selinux24 / skirmish Goto Github PK

Cached animations

Different clips and keyframes for each instance of a model

See GPU Gems 3

Search nVidia Developer Samples

Consider using SpriteTextRenderer

The actual curve implementation is a mess

Dynamic: OBB or SPH

Picking is being done against the entire list of triangles of a model. It is a bad idea for the terrain class.

it is necessary to organize the list of triangles in a partition like a quadtree or an octree for collision tests

Skydom must render always first

Smoke

LOD-level model

When rendenring sky domes with fogging enabled, the fog pops at the far plane distance, because fog color is constant.

Change the order of visible lights (4) to render nearest first

Modify the geometry on the GPU using heightmaps to add realism to objects

• Pre-processing of scenarios using QuadTrees / OcTrees
• Load / Pre-processing of grids for Path Finding over terrain geometry

Comment:

Since you now have split up the mesh, you can perform LOD and culling techniques on it to skip rendering hidden chunks.

View distance is where you start. You would only render chunks within a given distance, for example the view distance of your camera. The lower the view distance, the more performance you get since fewer chunks of the terrain must be drawn.

Frustum culling is a common technique to only render meshes that intersect with the camera's view frustum. This will most likely give you the largest performance gain.

Experiment with the chunk size and view distance to get best results. Chunk size is a tradeoff between accurate culling versus easy computation. To further optimize, you could take a look at these more advanced optimizations.

Occlusion culling can be done by rendering the meshes on the CPU at very low resolution. This allows you to early detect meshes hidden behind other ones. They don't must be sent to the GPU, so you save a lot of vertex shader executions which otherwise would have been performed before rejecting the triangles.

Level of detail means that you calculate lower resolution meshes of your chunks. Based on distance to camera, you choose one of the meshes to draw. That allows you to reduce the number of vertices since chunks far away don't need so much detail. This approach plays well with octrees because you could merge multiple cubes into one low resolution mesh when being far away from the camera. However, it is non trivial to seamlessly merge the edges between two chunks of a different resolution.

Generate from the begining a static shadow map (inmutable) for static geometry

Separate moving objects to another shadow map, and update it every frame only with these objects

In the example of NVIDIA Skinned Instancing, the load of resources it is done through compressed files.

Explosions

The objects are too dark

The illuminated faces are displayed in color less vivid than those against the light

Possibly the normalization of normal used to calculate the inclination of light are being made in the wrong place (see examples of DX11)

Use UVAtlas to load all textures of a model in a single big texture

Billboards and fog isn't work well

There was an error in the volume calculation

See cone of spot lights in heightmap sample

Check the camera. Review the allocation of matrices in the shaders. The transposition may be the problem

Pass a transform matrix to apply to the whole file at load time

• More than a ground texture by using masks
• Combine mask texturing with slope based texturing (slope rendering)

Fix the holes in medium level of detail. Whole patches were lost when moving the camera.

Error applying initial transformation matrix models with animation

The initial transformation matrix is applied properly to geometry, position, normal, tangent, but the animation produces strange effects.

Implement resource loading in separate threads and navigation between scenes

Error case

Ray {Position:X:-59,95468 Y:1000 Z:-59,95468 Direction:X:0 Y:-1 Z:0}

Tri {Vertex 1 X:-58,68813 Y:9,74461E-07 Z:-58,68813; Vertex 2 X:-58,68813 Y:0 Z:-61,77698; Vertex 3 X:-61,77698 Y:0 Z:-61,77698;}
Pos {X:-59,95468 Y:-0,0001220703 Z:-59,95468}

Tri {Vertex 1 X:-61,77698 Y:0 Z:-58,68813; Vertex 2 X:-58,68813 Y:9,74461E-07 Z:-58,68813; Vertex 3 X:-61,77698 Y:0 Z:-61,77698;}
Pos {X:-59,95468 Y:0 Z:-59,95468}

X:-58,68813 Y:9,74461E-07 Z:-58,68813; Vertex 1
X:-58,68813 Y:9,74461E-07 Z:-58,68813; Vertex 2

X:-58,68813 Y:0 Z:-61,77698; Vertex 2
X:-61,77698 Y:0 Z:-58,68813; Vertex 1

X:-61,77698 Y:0 Z:-61,77698; Vertex 3
X:-61,77698 Y:0 Z:-61,77698; Vertex 3

Random rest positions (loop and clip auto change)

Movement to stopped and vice versa transitions (from rest to connection point, loop, and connection point to rest)

Capable to attach objects by bone name (weapons, items, backpacks...)

Review

• Update component for Foliage Patchs use
• Renderize Foliage from farthest to closest (transparency)
• Generate random positions instead of pre-computed

Separate the mouse and keyboard input from the main thread

The text is not displayed correctly in all graphics cards (in fact, only seen in laptop)

Self explanatory

Investigate the use of rects for light writting instead of bounding volumes.

Implement the progress bar control for 2D and 3D

View Rastertek tutorials

Effects were deprecated. Use shaders directly

From a model generated in Blender, perform a geometry partition that allows fast rendering and multi-threading patch loading

This partitioning process must be configurable based on:

• Maximum size of the partition or maximum number of partitions
• Heights (Quadtree / Octree)

Reflection in open environments with other objects

Dust

Use alpha mapping with tree1 and tree2 models

Adds some wind in folliage

Use a shader macro to initialize maximum number of things in shader:

Max sopt lights
Max point lights
Max bones per skeleton
...

Indicator to select only facing triangles in picking

XACT

From a model generated using Blender and node partitioned, generate N distinct resolution models:

• High: N triangles
• Medium: N/2 triangles
• Low: N/4 triangles
• Ultra low: N/8 triangles

Article:

Since you now have split up the mesh, you can perform LOD and culling techniques on it to skip rendering hidden chunks.

View distance is where you start. You would only render chunks within a given distance, for example the view distance of your camera. The lower the view distance, the more performance you get since fewer chunks of the terrain must be drawn.

Frustum culling is a common technique to only render meshes that intersect with the camera's view frustum. This will most likely give you the largest performance gain.

Experiment with the chunk size and view distance to get best results. Chunk size is a tradeoff between accurate culling versus easy computation. To further optimize, you could take a look at these more advanced optimizations.

Occlusion culling can be done by rendering the meshes on the CPU at very low resolution. This allows you to early detect meshes hidden behind other ones. They don't must be sent to the GPU, so you save a lot of vertex shader executions which otherwise would have been performed before rejecting the triangles.

Level of detail means that you calculate lower resolution meshes of your chunks. Based on distance to camera, you choose one of the meshes to draw. That allows you to reduce the number of vertices since chunks far away don't need so much detail. This approach plays well with octrees because you could merge multiple cubes into one low resolution mesh when being far away from the camera. However, it is non trivial to seamlessly merge the edges between two chunks of a different resolution.

Review Shaders. Is normalizing normal once per pixel (the pixel shader) instead of once per vertex (in the Vertex Shader)

How to load a navigation mesh chunk by chunk?

Modify the planting algorithm to use some kind of map in combination with the actual random generation

Maybe using the terrain alpha map

Check this:

Grouping each model mesh according to its material and vertex type.

This improves performance because fewer calls to the Draw API were made, but calculated volumes are larger and less efficient, because of containing more similar geometry.

Investigate algorithms for efficient ambient lighting