VGFXOpenGL v1

Introduction

Developed in 2003, VGFXOpenGL (Venom Graphics OpenGL) version 1.0 is an in-house, hardware-accelerated 3D engine. Built on OpenGL 1.X, it takes full advantage of the fixed-function pipeline.

Technical Features

Target Platforms

Windows XP, Vista, 7, 8.X, 10, 11

Hardware Acceleration

Hardware-accelerated through the OpenGL 1.X fixed-function pipeline
Using extensions to access features from OpenGL 2.X
Supports all display resolutions and refresh rates (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 decompressed and stored on disk to speed up subsequent application startups
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 utilized

Scene Graph and Object Management

Linear and hierarchical (tree-based) representation of the scene/objects
The hierarchical representation enables fast recursive view frustum culling and serves as the foundation for efficient collision/intersection tests and rendering
For leaf objects, oriented bounding boxes (OBBs) are calculated
For parent objects, OBBs are constructed by merging the OBBs of their child objects
OBBs are utilized for view frustum culling. If an object’s OBB lies outside the view frustum, no further culling tests are performed on its child objects. View frustum planes are individually deactivated for all descendants of an object if its OBB lies on the positive side of the plane
Light sources can be defined in the world to illuminate only a subtree of the scene graph. This is achieved by placing light sources at desired positions within the tree. In “developer mode,” a (WinAPI-based) tree view window is displayed alongside the main window. This view represents the scene graph and includes icons for geometric data, cameras, target spotlights, point lights, directional lights, grouping dummy objects, and particle systems. Additionally, information about the render state (RS) and collision handling (CH) is displayed

Each object holds both a local and a world transformation matrix, which represent its local and global orientations. In combination with the scene graph manager, this allows entire worlds or object groups to be transformed simply by modifying the values of a single matrix and calling the scene graph manager to recursively update the subtree. The intelligent scene graph manager optimizes update times by determining the minimal object group that requires updating
Render data is stored in Vertex Buffer Objects (VBOs) or optionally in vertex arrays
Front-to-back z-sorting is performed on opaque objects to efficiently utilize the depth buffer
Objects can be linked into groups to receive commands distributed among all group members
Recursive deep cloning of objects is achieved with a single function call
Special render handlers (e.g., particle systems) can be easily integrated into the scene graph

Intersection Testing

The hierarchical, tree-based scene representation enables efficient recursive intersection tests
Each object includes a separate OBB-tree, which is automatically and recursively generated during the loading process. For a given triangular mesh with an associated oriented bounding box, the mesh can be divided into two submeshes. The algorithm splits the mesh using a plane orthogonal to the longest axis of the OBB. This splitting plane is determined by calculating the median value of the projections of each face center onto the longest axis, with the median as the plane’s center and the longest axis as the plane’s normal. The faces are then partitioned based on the side of the plane on which their centers lie

The resulting OBB-tree significantly reduces the computation time required to test whether a line segment (e.g., a gunshot) intersects a triangle in a mesh containing potentially thousands of triangles