Following video shows how our editor application works:

Adidas Game Time (Sports Nation)





Augmented Reality – demo1





LuVision : CityEdit

RGL however has system where city-scape scene can be viewed from any position, from eye-level to kilometers in height, with very far visibility range.

To prepare your scene for such render, it is needed to prepare it in so-called “layered modeling”. Number of layers is not definite, and depends on the scene size and buildings (and other elements) density. More dense urban environments will need to have more layers than other types of city/town environments.

Basically, city-scape scene is divided into following layers:

Layer 0

• Each building is model with multiple LODs
• Each street light, furniture, tree or plant is a model with multiple LODs
• Each street & sidewalk segment is a model with multiple LODs
• Other elements of the scene, as models with multiple LODs

This is the most detailed layer, and it contains each scene element as stand-alone model (that can be instanced, in case of street lights, signs etc.) with multiple levels-of-detail per each model.

Layer 1

• Multiple buildings are combined (collapsed) into 1 model, that can have multiple LODs
• Multiple street lights, trees etc. are combined (collapsed) into 1 model….
• Other elements combined into 1 model…

This layer is less-detailed layer compared with Layer 0. The easiest way to create it is to use lowest level-of-detail of each scene element (building, street & sidewalk segment) and combine them into 1 model. All needed textures (ambient, diffuse, normals etc.) can be created based on the existing textures used in Layer 0, which saves a lot of time in texturing part of work.

Layer 2

• Multiple building groups are now combined into larger group, as 1 model only, that can have multiple LODs
• Multiple groups of street lights, trees etc. are combined (collapsed) into larger group, as 1 model….
• Other element groups…

This layer is less detailed than Layer 1. To create this layer, you can use same principle as for creating Layer 1. Use lowest level-of-detail of elements in Layer 1 and combine them into 1 model in Layer 2.

If your scene has just 40-50 blocks, 3 layers should be quite enough. However, if your scene is larger, then at least 1 more layer is needed.

This gives ability to user to go kilometers in altitude and observe entire city scene below, and seamlessly go back to eye-level and see all visual details when walking through the scene, without performance drop.

An example of Layer 2 ( building block model ):


Layer 2 will usually be visible from distance such as this one:

Layer 2 in this example, has 1 model with 1 LOD, and it contains only 2 meshes:

• Mesh of buildings with street & sidewalk
• Mesh of trees

(Following images are from 3dsmax viewport)


Click here to download RGL file of the example above.

Video #1
Following video shows Layer 2, as a reference how detailed it will appear when viewed from far.

Defining Layers
Following is an example how you can define which models will be included in which layer.

The easiest is to define Layer 2 first, by ‘cutting’ through middle of streets wherever possible, or cutting between neighbor large properties (yellow outlines). Then, within each Layer-2 block, cut out smaller pieces, preferably containing buildings of a same or similar type, to define Layer 1. At the end, Layer 0 contains each building as a model, and street & sidewalk segments.

(Click on the image above to show high-res version)

[add-on #1, 2009-07-29]

Sample Lot
Following is an example of entire city lot, from Layer0 to Layer2 (scroll to the bottom to download .rgl files of this example).
Let’s imagine that following is city lot that you need to create 3 layers for:

This lot is composed from very similar (assumed the same) building blocks, and few parking lot areas with some palm trees.

Let’s assume that we’ve defined Layer2 as ‘models of lots’ layer. This means that Layer2 will contain models (that can have multiple levels of detail) representing entire city lots, and not blocks or buildings. In this example, in Layer2 is only 1 model (we call it “Lot-A”) and it has only 1 level of detail (one RGL file). Layer2 is used when showing lots from greater distance, where details on the buildings and streets are too far to be visible.

In Layer1, we will then have ‘models of blocks within lots’, which also can have 1 or more levels of detail (depending on the need). In this example, since one block repeats in entire lot (rotated differently, but still the same), we need to create model of 1 block only:

Since we will also have this modeled in detail in Layer0, in this Layer1 we’ve decided to have only 1 level of detail for block model (one RGL file)

Now, in Layer0 will be models of each building, street or parking lot segment etc., in one or more levels of detail. In this sample, building block from Layer1 can be then decomposed into 1 building (all buildings in this block are the same), and 1 parking lot (area with palm trees).

Building model (named “Bld-A”) has 2 levels of detail (two RGL files), where LOD0 is basically equal in look & feel with building in Layer1 (same visual quality), while LOD1 is more detailed and is meant for close ups (viewer is able to move close to the building, walk around it etc.). Exterior walls use “RGL Standard” material to add “details” texture overlay, grass uses “RGL Relief” giving impression of grass streaks, asphalt surrounding the building has enough details to always look sharp from eye-level etc:

Similar technique is used for parking lot (named “Park-A”), just in this case with 3 levels of detail. Instead of having each palm tree as separate model, we’ve decided to “collapse” palm into parking lot model. Since parking lot doesn’t have much geometry (only flat asphalt and sidewalk), we can add more to it. This also keeps number of models lower (since palms are not models on their own) which gives better performance:

This example covers the basic workflow of Layers creation. To download RGL files from this example, click here.

Sometimes artist will have to manually adjust normals map, especially if normals map is created based on diffuse map (RGB) using nVIDIA’s Photoshop Plugin (or other tool). Software that creates normals map usually treats provided base image as a form of height map. Thus bumps that are created may not be perfectly accurate, if image contained shadows & highlights (from for example direct sunlight).

It is advised to adjust base image first, so it doesn’t contain shadows or highlights (or try to minimize them), before using software to generate normals from it.

In case of a building texture, bumps are needed for bricks or concrete walls, but should not appear on windows. In this case, artist should alter normals map by setting windows pixels to [128,128,255] color manually (Red = 128, Green = 128, Blue = 255). As explained in video above, RGB[128,128,255] represents no-alteration of surface smoothing normal. This will give no-bumps effect on the window pixels.

Importer uses MaxScript to do so, giving compatibility with all future versions of 3D Studio Max.

It is also useful tool to exchange files between different 3Dsmax versions.

Click on the “Import” button & select RGL file you want to import. It will first attempt to load file content into memory. If success, will ask you for output folder to extract textures.

You may choose to cancel output textures folder, in which case later you will have to either manually set texture paths in each material (very labor-work) or you can use RGLTools “Set Texture Paths” to set it up.

After extracting textures, it will build geometry using run-time generated maxscript, per each object. It will also create proper 3dsmax material and set up textures in proper slots.

At the end, it will show import report, which will have listed among other information, errors, if any occurred.

You can also review MaxScript Listener (F11) to check for errors.

Video #1
Demonstration of Import function

]]> http://www.visionmax.com.hk/blog/?feed=rss2&p=395 0 http://www.visionmax.com.hk/blog/?p=370#utm_source=feed&utm_medium=feed&utm_campaign=feed http://www.visionmax.com.hk/blog/?p=370#comments Fri, 26 Jun 2009 09:15:22 +0000 Sinisa http://www.visionmax.com.hk/blog/?p=370 To create cubic maps for RGL, it has to be done with 1 RGB texture (no Alpha), size ratio 2:1, and with power-of-two size. Following is scheme how you should place & orient cube sides within this 1 texture:

Texture name MUST contain #CUBE substring, for example “sample_reflection_#CUBE.tga”.

RGL will detect from texture name, that this is a cube map, and will properly extract all 6 sides into cubic texture.

How to easily render cube map sides in 3D Studio Max

First, create one sphere, with inverted normals (triangles facing inside, and not outside) and set it’s parameters to:

• Backface Cull ON
• Receive Shadows OFF
• Cast Shadows OFF
• Apply Atmospherics OFF

Now, create material that will simulate sky color. In this sample we’ve just added vertical gradient, but you can use high-res sky images, with clouds and distant scenery. Make material be 100% Self-Illuminated, and that has no Specular or Glossiness. Goal is to have this sphere rendered without any influence of light or shadows.

After skydome is ready, place your 3D scene inside, setup the lighting (sky light, sun light, local lights), materials etc. At the end, create one small cube, with centered pivot, and place it in the position from which you want to render 360 image (cube map), and set all parameters for the cube same as for sky dome object (no shadow cast / receive etc.), and also, set it to be invisible to camera and invisible to reflection/refraction. This cube will be used just to define position of 360 render, and should not influence the scene in any way.

Prepare new material in material editor. It does not need to be assigned to any object. It is just used to render cube map. Add “Reflect/Refract” map type to any texture slot you want. In this example, we picked Diffuse but slot choice is irrelevant:

Now setup Reflect/Refract map you’ve just added:

• Size: for use in RGL, Size parameter should always be power-of-two (for example 1024). For other usage (such as 3D flash), use any size you like.
• From File: ON
• To File: Set output path and base filename for cube map sides.

Now you are ready to render cube map. Choose “Pick Object and Render Maps” and then click on the cube you have previously added to define position of 360 renderer:

3Dsmax will start rendering 6 images, UP, DOWN,LEFT,RIGHT,FRONT and BACK, using current rendering settings and currently active renderer. You can choose to use V-Ray or any other rendering engine to produce high-quality cube maps. Rendered result of the above sample looks like this:

]]> http://www.visionmax.com.hk/blog/?feed=rss2&p=370 0 http://www.visionmax.com.hk/blog/?p=364#utm_source=feed&utm_medium=feed&utm_campaign=feed http://www.visionmax.com.hk/blog/?p=364#comments Fri, 26 Jun 2009 09:05:08 +0000 Sinisa http://www.visionmax.com.hk/blog/?p=364

Specs:

• Use 3dsmax standard material
• Add |REL|ReliefDepthFactor|MaxReliefVisibleDistance at the end of material name (eg. mymaterial|REL|3.5|80.0)
• Ambient slot: RGB ambient map in mapping channel 2
• Diffuse slot: RGBA diffuse & specular map in mapping channel 1
• Bump slot: RGBA normals map + height map (Alpha) in mapping channel 1

Behavior:

• Ambient map: 50% gray has no effect. Darker than 50% will darken the surface, lighter than 50% will lighten the surface
• Diffuse & Specular map: RGB channel defines base surfacecolor. Alpha channel, for total black causes 100% transparent surface. Other values (lighter than total black) define surface specular level.
• Normals map: RGB normalized values, create bump effect on the surface. Use nVIDIA Photoshop plugin (or other software for creating normalized RGB maps) to create proper normal maps. Alpha channel is used as height map, for relief paralax calculation.

Video #1
Demonstration of relief “paralax” shader

• Use 3dsmax standard material
• Add |TGL|ReflectionIntensity at the end of material name (eg. mymaterial|TGL|2.0)
• Ambient slot: RGB ambient map in mapping channel 2
• Diffuse slot: RGBA diffuse & specular map in mapping channel 1
• Reflection slot: RGB cube map (mapping channel ignored, shader calculates reflection vector)
• Bump slot: RGB normals map in mapping channel 1

Behavior:

• Ambient map: 50% gray has no effect. Darken than 50% or lighter than 50% will give more or less reflectivity (if fragment is less accessible to the light, reflection pixel will be less visible.
• Diffuse & Specular map: ThinGlass is always transparent 100%. Thus RGB channel defines base surfacecolor that is slightly visible in transitions between reflection fragment and totally transparent fragment. Alpha channel defines specularity only, which increases reflectivness of a fragment (totally black will cause no visible reflection).
• Cube reflection map: RGB value combined with ReflectionIntensity, specularity from Alpha channel (less specular fragments will have less reflection).
• Normals map: RGB normalized values, create bump effect on the surface. Will cause relfections to appear distorted. Use nVIDIA Photoshop plugin (or other software for creating normalized RGB maps) to create proper normal maps.

Video #1
Demonstration of thin-glass effect

Specs:

• Use 3dsmax standard material
• Add |CRF|ReflectionIntensity at the end of material name (eg. mymaterial|CRF|2.0)
• Ambient slot: RGB ambient map in mapping channel 2
• Diffuse slot: RGBA diffuse & specular map in mapping channel 1
• Reflection slot: RGB cube map (mapping channel ignored, shader calculates reflection vector)
• Bump slot: RGB normals map in mapping channel 1

Behavior:

• Ambient map: 50% gray has no effect. Darker than 50% will darken the surface, lighter than 50% will lighten the surface
• Diffuse & Specular map: RGB channel defines base surfacecolor. Alpha channel, for total black causes 100% transparent surface. Other values (lighter than total black) define surface specular level.
• Cube reflection map: RGB value combined with ReflectionIntensity, specularity from Alpha channel (less specular fragments will have less reflection).
• Normals map: RGB normalized values, create bump effect on the surface. Use nVIDIA Photoshop plugin (or other software for creating normalized RGB maps) to create proper normal maps.

Video #1
Demonstration of cubic-reflection effect

• Use 3dsmax standard material
• Add |DIFF at the end of material name (eg. mymaterial|DIFF)
• Diffuse slot: RGBA diffuse & 0-1 Alpha map in mapping channel 1

Behavior:

• Diffuse & 0-1Alpha map: RGB channel defines base surface color. Alpha channel, for total black causes 100% transparent pixel. Other values (lighter than total black) will be fully opaque.
• Can cast shadow, but cannot receive shadow.
• Can be used for area markers, info billboards, or other non-3D objects.

Example texture: