- Target Platforms
- Windows XP
- Windows Vista
- Windows 7
- Hardware Acceleration
- Hardware accelerated via OpenGL
- Based on OpenGL 3.2 core profile (programmable pipeline/shaders)
- Using the new OpenGL context with core profile (no deprecated functions allowed)
- Supports all display resolutions
- Allows selection of different display refresh rates (Hz)
- Supports 32 bit color, 24 bit depth and 8 bit stencil buffers
- Double buffering for color buffer
- Rendering
- Using the OpenGL Shading Language (GLSL) for vertex manipulation,
light calculation and fragment rendering
- Fragment and vertex shader source loadable from disk/files
- Texturing
- Bilinear, bilinear mipmapped and trilinear mipmapped texture filtering
- 2x, 4x, 8x and 16x anisotropic texture filtering
- Multitexturing
- Smart and easy-to-handle texture system which avoids reloading of texture data
- Texture linking/unlinking to/from different 3D scenes
- Offscreen rendering (render-to-texture) using modern framebuffer objects (FBO)
capable to perform mipmapping, multisampling and fast blitting of FBO attachments.
Support for (multisampled) color and depth texture FBO attachments including
smart GLSL #ifdefs to use texelFetch on sampler2D or sampler2DMS
- Support for packed depth-stencil FBO texture attachments (shared buffer)
- Support for non-power-of-two (NPOT) framebuffer and texture dimensions
- Hardware accelerated mipmap generation
- Supports S3 Texture Compression (S3TC) methods DXT1, DXT3 and DXT5
- Compressed texture files (e.g. JPG) can be uncompressed to disk in order
to make following application starts faster
- Bump mapping using normal maps and TBN matrices. To generate the normal maps
from common RGB images, the "NVidia Normal Map Filter" plug-in for Adobe Photoshop
or the "Height Field to Normal Map" plug-in for Paint.NET could be used
|
- Scene Graph and Object Management
- Advanced object system which consists of a linear and a hierarchical (tree based)
scene and object representation
- The hierarchical representation allows fast recursive view frustum culling and
furnishs the base for rapid rendering and quick collision detection
- Object clipping against the view frustum by clipping each object's oriented bounding box
(OBB) generated by a fast gaussian point distribution algorithm. The OBB allows much more
accurate clipping because it fits better to the source object than an axis-aligned bounding
box (AABB). Each object holds an OBB which is the merge result of the children OBBs
If a node's OBB is outside the view frustum there is no need to perform further culling
tests on the children nodes. In this case the parent node and its complete subtree
is not further processed.
If an OBB was tested against one of the six view frustum planes and the result indicates
that the OBB lies on the positive side, the plane is deactivated for all the descendants
since they must also lie on the positive side due to the hierarchical representation.
This reduces the amount of OBB vs frustum plane tests and increases performance
- Light sources can be defined in the world to illuminate only a subtree of the scene graph
by placing the light sources at desired positions in the tree. Running the application in the
"developer mode" enables a (WinAPI based) tree view window besides the main window
which represents the scene graph and includes icons for geometric data, cameras, target
spot lights, point lights, directional lights, grouping dummy objects and particle systems.
Also informations about the render state (RS) and the collision handling (CH) are displayed
|
- Each object holds a local transformation matrix which represents its own local
position/rotation/scale and a world transformation matrix which represents its
position/rotation/scale in the world. In combination with the scene graph
manager this makes it possible to move/rotate/scale/delete whole worlds
and object groups by just changing the values of a single matrix and
calling the scene graph manager to recursively update the subtree.
This is automatically done by the smart scene graph manager who reduces the update
time for multiple changed objects by determining the minimal object group that has to
be updated. For example if geometric data has changed in a subtree of a parent node
but also geometric data of the parent has changed it would be a waste of performance
to first update the modified nodes in the subtree and then the parent node
- The smart scene graph manager is also responsible for receiving and evaluating the
current animation state for each object that is updated when recursively going
down the scene tree
- Using Vertex Buffer Objects (VBO) to store vertex, texture, normal and
face descriptor data in fast video memory
- Using Vertex Array Objects (VAO) to store the set of bindings between
vertex attributes and vertex data
- Smart and easy object loading and handling
- Fast front-to-back z-sorting on opaque objects with quicksort to exploit the depth buffer
- Easy object linking/unlinking to/from different unlimited scenes
- Easy state changes of objects during runtime (e.g. collision relevance, visibility)
- Recursive cloning of objects with only one function call
- Easy integration of special render functions (e.g. particle systems) into the scene graph
- Unlimited LOD object system reduces polygon count of faraway objects.
To generate the low polygon meshes NVidia's MeLODy tool is used which can
simplify objects/surfaces with color and texture using Quadric Error Metrics
based on Michael Garlands paper. MeLODy also creates high quality normal
maps that make a low-poly model look like a high-poly model
|
|
- Intersection Testing
- The hierarchical (tree based) scene representation allows fast recursive intersection tests
- Further each object owns a seperate OBB-tree which is automatically and recursively
generated during the loading process. Given a triangular mesh with corresponding
oriented bounding box, the mesh can be split into two submeshes. The algorithm
splits the mesh by a plane orthogonal to the longest axis of the OBB. This splitting
plane is calculated by using the median value of the projections of each face center
onto the longest axis as plane-center and the longest axis as plane-normal.
The faces are then partitioned based on the side on which their centers lie
- The final OBB-tree is among other things used to reduce the time required to test if a gun
shot (line segment) intersects a triangle of an enemie mesh with let's say 10.000 triangles.
If the gun shot intersects a root node of an OBB-tree he is further tested recursively
against the descendants in the OBB-tree until a test fails, a leaf node is reached
or a threshold (maximum tree depth/minimum triangles per leaf node) is exceeded.
So it is not necessary to test the gun shot for intersection against all of the 10k
triangles which would dramatically decrease performance. Instead the line segment
is only tested against a few triangles contained in some leaf nodes of the OBB-tree
- For collision detection purposes it is possible to make intersection tests between moving
OBBs, OBB-trees and triangles. Again the hierarchical (tree based) scene representation
allows fast recursive collision tests. Two OBB-trees are tested for intersection using
double recursion. Then (optional) intersection tests between the triangles in the
intersecting leaf nodes of both OBB-trees can be performed
- All tests can also be done with the terrain system and its hierarchical representation
- Animation Engine
- Character bone animations using object hierarchies
- Linear position interpolation
- Smooth hermite spline position interpolation with full support of the parameters bias,
tension and continuity (full compatible with the TCB Position controller available in
3dsmax/gmax and the 3DS format)
- Linear rotation interpolation using quaternion math
- Smooth bezier spline rotation interpolation using quaternion math with full
support of the parameters bias, tension and continuity (full compatible with
the TCB Rotation controller available in 3dsmax/gmax and the 3DS format)
- Particle System
- Comprehensive and easy to handle particle system
- Smart particle memory management with auto replace and resize
- Random particle textures possible
- Particle color fade out
- Particle morphing (size enlarge or reduce)
- Particle gravitation and path manipulation
- Origin and direction vector randomization in 3D
- Constant or random particle lifetime
- Dynamic speed control
- Particles can be rendered as billboards, with static face direction or with random rotation
- One and two sided particles for rotating particles (e.g. leaves)
- Pre initialization of particle positions possible
- Pre initialized particle positions can be saved twice to make it possible to transform
(rotate/move) the complete particle system. This is useful for special effects
like muzzle flashes which need to follow the current gun orientation
- Easy texture loading/deletion to/from particle slots
- Easy integration into object engine and z-sorting
- Realtime Shadows
- Realtime shadows that bend, stretch and wrap around other objects or the terrain
- Non-quadratic search algorithm finds face neighbours offline
- Linear search algorithm finds mesh silhouette (shadow volume)
- Special case where the eye position is inside a shadow volume is handled properly by using
the depth-fail algorithm (Carmack's Reverse) instead of the simpler depth-pass algorithm.
Therefor additional geometry for shadow volume capping is generated
- Shadow volumes are rendered as fast Vertex Buffer Objects (VBO)
- For static objects with a static light source (e.g. buildings), the shadow volume VBO
is calculated offline to eliminate the complete online shadow volume generation
- Shadow mask is rendered in one pass into the stencil buffer (using two-sided
stencil testing and stencil value wrap extensions)
- 3DS Loader
- Fast and entirely self-developed 3DS importer written in C++
- Processes for all objects, lights, point lights, spot lights and cameras
the full material, object and keyframer animation block
- Supports smoothing groups and optimizes vertex, texture and normal array data to
minimal array sizes to provide lowest video memory usage
- Mesh data check for vertices with bad #QNAN00 (not a number) values
- Mesh data check for vertices with corrupted values leading to #INF000 errors
- Mesh data check for isolated vertices
- Mesh data check for bad faces which have equal vertices including automatic repair
- 3DS object hierarchy used/combined with engine scene graph hierarchy
- 3DS scene can be loaded as subtree of existing nodes in the scene graph
- Homemade extension to allow loading of unlimited LOD geometry
- Homemade extension to allow loading of bump mapped objects with normal
and environment maps
- Anti-Aliasing
- Application controlled full scene anti-aliasing using hardware
accelerated High-Resolution-Anti-Aliasing (HRAA)
- Supported MSAA modes:
- 2x Samples 2 Taps
- 4x Samples 4 Taps
- 6x Samples 6 Taps
- 8x Samples 8 Taps
- If the number of samples is specified by the graphics driver control panel
the application will automatically use this sample count
- Lighting
- Phong shading (per-pixel/per-fragment lighting) with multiple light sources
- Parameters: (smoothed) vertex normals, material properties (ambient, diffuse, specular,
specular shininess, two-sided lighting), global/scene ambient light, light source type
(directional, positional, spot), light source distance and near/far attenuation
- Special Effects / Shader Effects
- Reflection, refraction and dispersion with GLSL
- God rays (Crepuscular rays) with GLSL
- Blur effects using texture mipmaps bias
- Radial blur
- Glow effects
- True reflections/mirror effects
- Particle based effects like fire, smoke, rain, snow or flying leaves
- Realistic lens flare effects using occlusion queries
- Utilizing the FMOD DSP Spectrum Analyzer for perfect camera
rumble or similar special effects synced to the audio beat
- 3D Sound
- Utilizing the high-end FMOD sound engine to produce full DOLBY 5.1 3D surround sound
- Font Rendering
- Internal font class
- Fast anti-aliased text rendering using OpenGL alpha testing
- Easy font style loading from different texture sets
- Leading
- Kerning
- Line breaks/text block rendering
- Image Formats
- Using the outstanding C++ library CxImage by Davide Pizzolato to
allow texture loading of popular and advanced image file formats
- Supported formats:
- JPG (JPEG - the most famous image format worldwide)
- JP2 (JPEG2000 - best compression format worldwide for photo-like images)
- PNG (best losless compression format with alpha channel)
- TGA, TIFF, BMP, GIF, PCX, ICO, WBMP, WMF, ZLIB, MNG, JBIG, PNM, PPM, PGM
- Homemade highspeed PCX decompression method
- Realtime Statistics
- Current time
- Frames per second (fps)
- Activated features (VBO, VSync, HRAA Samples, Anisotropic Filtering, ...)
- Cam position and view angle
- Rendered objects (opaque/transparent, smoothing groups, per-pixel-lightened)
- Rendered polygons (opaque/transparent)
- Performed culling tests (against FOV or a single view plane)
- Current textures online (loaded into system or GPU memory)
- Memory informations (current allocated memory, highest allocated memory)
- Active light sources
- Intersection tests (tested obbs/triangles, last intersection position/distance, ...)
- OpenGL renderer, vendor and version
- Camera System
- Unlimited easy to activate cameras
- Animations loadable from 3DS files
- Each camera can be controlled via mouse/keyboard (up/down/forward/strafe/mouse look)
- Rendering Modes
- Easy realtime switch between different scene visualization modes using F1-F12 keys:
- [texture]
- [texture + (object/merged) BoundingBox]
- [texture + vertex normals]
- [texture + (object/merged) BoundingBox + vertex normals]
- [wireframe]
- [wireframe + (object/merged) BoundingBox]
- [wireframe + vertex normals]
- [wireframe + (object/merged) BoundingBox + vertex normals]
- [linearized depth buffer]
The first screen shot below shows [wireframe] mode.
The second screen shot shows [wireframe + vertex normals] mode.
The third one shows [wireframe + (object) BoundingBox] mode.
On the last one the [linearized depth buffer] mode is shown.
The red axis system of each object shows its pivot point, the blue axis system shows the
object center and the thin red one shows the current object rotation. The white fat boxes
are the oriented bounding boxes used to clip each object against the view frustum planes
- Miscelleanous
- Support for V-sync (vertical synchronization) to avoid screen tearing
- Tidy windows configuration interface
- OpenGL clipplanes for particle based realtime fire/smoke/electro shock
effects and OpenGL scissor test for 2D related clipping purposes
- Skybox background rendering
- Internal gamma correction with adjustment interface
- Global material RGBA adjustment (brightness)
- Programming, Development and Design
- Programmed with Microsoft Visual Studio 2010 Ultimate in Visual C++ using all main
OOP techniques like inheritance, abstract classes, polymorphism, overloading,
references, templates and access levels
- Fastest code generated by the VC++ compiler with "Maximize Speed" optimizations,
deprecated warnings and buffer overflow security check
- Engine compiled into a static library to make it usable across different projects
- GMax by Autodesk is utilized which is a free 3D modeling and animation tool based on
Discreet's award-winning 3ds max. This powerful 3D editor is the best application out
there for professional 3D modelling and animation
|
- Memory management system and controlling prevents memory leaks
- Smart application controlling reduces internal CPU usage to nearly 0%
when the program is minimized or does not have the input focus
- Compiler warning level 3 is enabled and all warnings are dissolved
to ensure a clean compiler output with "0 warnings"
- The whole engine is seperated into over 67 class modules. Each class module consists
of a header (.h) and a source (.cpp) file to ensure clean and organized source code
- Optional nearly all of the rendering modules (e.g. terrain/lensflare/level/skybox)
can be controlled by XML script files. The XML parsing and DOM creation is done
using the Xerces C++ Parser from The Apache XML Project
|
|
