- Target Platforms
- Windows XP
- Windows Vista
- Windows 7
- Windows 8.X
- Windows 10
- Hardware Acceleration
- Hardware accelerated via OpenGL
- Based on OpenGL 1.X (fixed function pipeline)
- Using OpenGL extensions to access features from OpenGL 2.X
- Supporting all display resolutions and frequencies (Hz)
- Supports 32 bit color, 24 bit depth and 8 bit stencil buffers
- Double buffering
- Render targets
- Pixel buffers (pBuffers)
- Framebuffer objects (FBO) with multisampling and mipmapping support
- Packed depth-stencil FBO texture attachments (shared buffer for depth and stencil values)
- Support for non-power-of-two (NPOT) FBO dimensions
- Texturing
- Bilinear, bilinear mipmapped and trilinear mipmapped filtering
- 2x, 4x, 8x and 16x anisotropic filtering
- Multitexturing using texture combiner
- Smart texture management system
- Hardware accelerated mipmap generation
- Environment/sphere mapping
- Support for non-power-of-two (NPOT) texture dimensions
- Support for S3 Texture Compression (S3TC) methods DXT1, DXT3 and DXT5
- Compressed texture files (e.g. JPG) can be uncompressed to disk to make
the next application start faster
- DOT3 bump mapping using normal maps, normalization cube maps and TBN matrices
to convert light vectors from world to tangent space. 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
- Linear and hierarchical (tree based) representation of the scene/objects
- Hierarchical representation allows fast recursive view frustum culling and
furnishs the base for rapid collision/intersection tests and rendering
- For leaf objects, oriented bounding boxes (OBB) are calculated
- For parent objects the OBBs are constructed by merging the OBBs of the children
- The OBBs are used for view frustum culling. If an object's OBB is outside the view frustum
no further culling tests are wasted on the children. View frustum planes are individually deactivated for all the descendants of an object if its OBB lies on the positive plane side
- 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 "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 and a world transformation matrix which represent its local and
its world orientation. In combination with the scene graph manager this makes it possible to transform 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. The smart scene graph manager reduces the update time for multiple modified objects by determining the minimal object group that has to be updated
- Render data is stored in Vertex Buffer Objects (VBO) or optional in vertex arrays
- Front-to-back z-sorting on opaque objects to exploit the depth buffer
- Objects can be linked to groups to receive commands distributed to the group members
- Recursive deep cloning of objects with only one function call
- Easy integration of special render handlers (e.g. particle systems) into the scene graph
- Intersection Testing
- The hierarchical (tree based) scene representation allows fast recursive intersection tests
- Further each object owns a separate 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 reduces the time to test if a line segment (e.g. gun shot) intersects a
triangle of a mesh with possibly thousands of triangles
- 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
- Terrain System
- Advanced heightmap terrain generation system based on the paper Real-Time Generation
of Continuous Levels of Detail for Height Fields by Stefan Roettger. A very powerful terrain rendering approach which was also used in commercial game blockbusters like
Aquanox by Massive Development
- Allows rendering of very large terrains (e.g. 1.050.625 vertices or 2.097.152 triangles) at
very high frame rates with great surface approximation also on low-cost graphic cards
- Static or dynamic terrain lighting
- 4x Multitexturing with detail textures
- View frustum culling of the quadtree by culling qnode OBBs
- Smooth geomorphing eliminates popping between LODs
- Spherical and cubic volumetric fog regions
- Animation System
- Character bone animations using object hierarchies
- Linear and hermite spline interpolations fully compatible with the TCB position controller
in 3dsmax/gmax and the 3DS format
- Linear rotation interpolation with quaternion math
- Smooth bezier spline rotation interpolation with quaternion math fully compatible with
the TCB rotation controller in 3dsmax/gmax and the 3DS format
- Particle System
- Advanced particle system which can be rendered separately or as part of the scene graph
- Static or random texture selection
- Color (RGB) fading
- Alpha fading
- Dynamic resizing
- Gravitation and wind simulation
- Origin and direction vector randomization
- Constant or random particle lifetimes
- Dynamic speed control
- Billboards or rotating (two sided) quads
- Pre-initialization of particle positions possible
- Easy translation and rotation of complete particle system
- Easy texture loading into particle slots
- Lights and Shadows
- Standard OpenGL point lights, directional lights and spot lights
- Advanced per-pixel lighting using normal maps and texture combiner
- Material properties
- Support for static lighting with precalculated vertex colors
- Robust real-time stencil shadow volumes
- Fast algorithm to identify the mesh silhouette required for creating the shadow volume
- Using the depth-fail algorithm (Carmack's Reverse) to handle the special case where
the eye position is inside a shadow volume
- Shadow volumes are treated like normal objects and therefore rendered very fast
as Vertex Buffer Objects (VBO)
- For static objects with a static light source (e.g. buildings), the shadow volume
is calculated offline
- 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
- Support for normal maps, environment maps and self-illuminating maps
- Self-developed extension to allow loading of different LOD
- Anti-Aliasing
- Application controlled hardware accelerated High-Resolution-Anti-Aliasing (HRAA),
also known as Multisample Anti-Aliasing (MSAA)
- Supported sampling:
- 2x Samples 2 Taps
- 4x Samples 4 Taps
- 6x Samples 6 Taps
- 8x Samples 8 Taps
- Special Effects
- Utilizing the FMOD DSP Spectrum Analyzer for perfect camera
rumble or similar special effects synced to the audio beat
- High quality hardware accelerated radial blur with 256 and more layers
- Hardware accelerated blur using texture mipmaps and the texture mipmap bias extension
- Hardware accelerated glow effects
- True reflections/mirror effects
- Particle based effects like fire, smoke, rain, snow or flying leaves
- Alpha blending for flares, glow, gun shots and other lighting effects
- Lens flare effects with occlusion test and view dependent fading
- Realistic muzzle flash effects for 3D shooter
- Dazzling electro shock and laser/plasma gun effects
- Impact effects like particle dust and sparks with physical correct reflection vector
- 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
- Self-developed PCX decoding
- Realtime Statistics
- Current time
- Frames per second (fps)
- Activated features (VBO, VSync, MSAA samples, anisotropic filtering, ...)
- Cam position and view angle
- Rendered objects (opaque/transparent, smoothing groups, per-pixel-lightened)
- Rendered triangles (opaque/transparent)
- Performed culling tests (against FOV or a single view plane)
- Current textures in GPU memory
- Memory informations (current allocated memory, highest allocated memory)
- Active (OpenGL) 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 real-time switch between different visualizations using F1-F11 function keys.
Visualize wireframe, vertex normals and bounding boxes.
- The fat red axes visualize the object's pivot point and the blue axes the center.
The thin red axes visualize the object's current rotation. The white fat boxes are the oriented bounding boxes for culling against the view frustum
- Miscellaneous
- VSync (vertical synchronization) support to avoid screen tearing
- Tidy windows configuration interface
- OpenGL clip planes for particle based real-time fire/smoke/electro shock
effects and OpenGL scissor tests for 2D related clipping purposes
- Skybox background rendering
- Internal user interface for gamma correction
- Programming, Development and Design
- Programmed with Microsoft Visual Studio in Visual C++
- Compiled into a static library to make the engine 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.
- Smart application controlling reduces CPU usage to nearly 0%
when the program is minimized or does not have the input focus
- The whole engine consists of roughly 61 C++ source files
- 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
|
|