Polygon Cruncher SDK
Polygon Cruncher SDK offers a complete 3D engine including a complete 3D scene graph. It includes:
- Polygon Cruncher optimization algorithm
- Reading and writing capabilities on most of 3D file formats including (Fbx, Cinema 4D, 3ds, lxo, collada, wavefront, vrml, sketchup...)
- Scene hierarchy
- UVs, vertex colors, normals information
- Materials information
- A set of powerful 3D features such mesh cleaning, confused point welding, mesh collapsing based on materials or anything else...
- Very compact in term of memory needs, it also allows memory allocation callbacks
- LOD generation for JT files through Siemens JT SDK. Check out here JT capabilities.
You can find more information about this capabilities here.
The SDK is available as a C++ library:
- for Windows with Visual Studio (2010 to 2017) in 64 bits.
- for MacOS with XCode.
- for Linux (Centos / gcc 4)
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.
SDK sampleDownload sample application
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.
You need to have DirectX9 setup on your computer in order to run this sample.
The sample load a default mesh and optimize it.
Load an object (O key)
You can load wavefront obj, directx or pOpt files.
If you load Obj file or DirectX file, the mesh is loaded and optimized. Then it is converted to a dynamic mesh. This demonstrates the left part of the below pipeline.
If you load a popt file, the sample loads a precomputed optimized mesh. There is no optimization step and the dynamic mesh is directly available. This demonstrates the right part of the below pipeline.
Save a pre-computed optimized mesh (S key)
This option optimize the loaded mesh and save the optimization to a popt file located in the mesh directory.
Example: if the mesh is furniture.x, then a furniture.popt is saved in furniture directory.
Once computed, you can load this file using O key. Just select the popt file.
This popt file saves the optimization as a dynamic mesh. When loaded it removed the heavy computation process step and allows the user to get the dynamic mesh directly with the appropriate optimization settings.
SDK Optimization Pipeline
Polygon Cruncher SDK pipeline
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 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:
- One or more UV texture channel.
- One or more VC vertex color channel.
- A specified normal channel.
- A selection information which give a control on the optimizable part of the geometry.
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.