Polygon Cruncher SDK offers a complete 3D engine including a complete 3D scene graph. It includes:
The SDK is available as a C++ library:
The API calls are very easy to implement and you can integrate Polygon Cruncher powerful optimization features quickly to your application.
The application domain covers any 3D fields where LOD models are needed: video games, CAD, real time visualization, 3D modeling, 3D presentation...
Polygon Cruncher SDK provides a robust technology developed since 1999. It is used by several companies (Autodesk, Anark, Act-3D, FMC Konsberg, ka-ra...) in many different application contexts.
Mootools provides a close support during the integration phase making the integration fast and easy.
This sample application shows some features of the SDK under a DirectX 9 application. It is available for both x32 and x64 bits Windows platforms.
Load an object (O key)
Save a pre-computed optimized mesh (S key)
SDK Optimization Pipeline
The pipeline offers different approaches depending on your needs. The above schema shows two different approaches.
The left side exposes an optimization pipeline in which the user is associated to the optimization choice. He decides whether to keep textures or not, protect materials (...) and defines the most appropriate settings for optimizing its 3D assets. After optimization settings has been chosen and 3D simplification performed, a multi resolution mesh allows the user to choose the appropriate LOD (level of details) in real time for rendering the mesh. Polygon Cruncher software or ProOptimizer 3ds Max plugin is a good demonstration of such integration of the SDK.
The right side shows a different approach. In this case, the caller provides to the SDK a 3D mesh as well as precomputed optimization data. This data has been created previously using the most appropriate optimization settings for the mesh. With that information, the optimization step is removed and the SDK runs in real time: dynamic multi resolution mesh is generated immediately and the LOD can be adjusted in real time. This is the ideal schema when you want to provide a pre optimized 3D library, using the SDK in a game or in real time visualization context.
If you purchase the version of the SDK that includes the I/O capabilities, you wil be able to read most of the common 3D formats (Sketchup, Lightwave, Collada, Wavefront...). Once loaded you can optimize or convert this 3D assets to your own 3D formats. It is also possible to save your 3D assets to one of the supported 3D formats.
The implementation is straightfoward. The only thing to do is to convert your 3D structure to / from the SDK 3D structure.
The algorithm works with N-sided polygonal meshes. It returns triangular meshes with texture, vertex colors and normal maps, depending on the information provided.
Depending on your needs, you can transfer a single mesh or a whole scene to the optimizer. Each mesh may only contain the polygonal information or a more complex data set which can include:
You also define the optimization mode. All Polygon Cruncher optimization features are available through the API such the protect borders, exclude borders modes or the lock points, favor compact faces modes...
Once the conversion is performed, the optimizer SDK performs an initialization step. During that phase, a multiresolution mesh is generated giving the ability to optimize in real time in the following step.
Optimization loop and termination
After the initialization is performed, you usually gives the user a chance to select the appropriate optimization ratio through a slider and a visual feedback. As the initialization phase computes anything before, the process is very fast and you may provide a real time feedback. During that step, you only have to make the convertion from the 3D SDK structure to your own 3D structure.
You can also directly specify a predefined optimization ratio without any interaction if your application requires it.
As a result, you get your 3D mesh or your 3D scene optimized.
It is also possible to prepare neastly perfect optimization for your mesh then save the optimization data on your application side. You can then generate a multiresolution mesh directly, avoiding the initialization step. It possible to save full optimization data with all needed channels (textures, vertex colors, normals) and use only some channel afterward (ie textures).
Following that schema, the multiresolution mesh initialization and its use at the appropriate resolution is performed in real time and with the minimum memory requirements. The optimization ratio is adjustable as you want, just like it was described before. For example, you can use a low resolution when your object is far from the camera and a high resolution mesh when it is closed to it.