Skip to main content

Asset Guidelines

info

This page is legacy content (RapidCompact) and might be outdated soon. Please refer to our new RapidPipeline Asset Guidelines for most up to date content - Coming Soon.

Introduction

As a 3D Data Optimization Solution, RapidCompact relies on clean and functional input data. This applies mostly to Materials & Shading, but also to a certain extend to Texture Mapping and Geometry data.

RapidCompact is not a only a LOD Generation tool, but instead a 3D Data Simplifier. It is capable of preserving and simplifying PBR material information in addition to simplifying meshes, node structures and input textures as well as baking material information from input such as vertex/material colors and mesh/texture data. Therefore properly set-up input data is key for a smooth optimization process.

Left: Unoptimized source data , Right: Optimized with RapidCompact using Atlas Baking (rebaking) methodLeft: Unoptimized source data , Right: Optimized with RapidCompact using Atlas Baking (rebaking) method

Here are some good rules of thumb of verifying the integrity of your input data:

  • Can the asset be loaded into DCC tools such as Blender?
  • Does the rendering result look correct?
  • Does it consist of polygonal data?
  • Are textures and materials correctly assigned?
  • Does the file contains one asset or multiple assets*? The latter should be avoided
  • In case of 3D scanning. Is the pointcloud data already converted into a mesh?
  • Are the mesh normals pointing in the right direction? (RapidCompact can handle outliers)
  • Does the input dataset make heavy use of procedural generated materials & nodes? (see Material Support section below)

Asset definition: Coherent dataset which is set-up for deployment or further optimization, this can be one mesh, multiple meshes or a whole scene.

We also recommend some general guidelines for creating or converting to real-time assets:

3D Data Types & Formats

Supported 3D formats:

FormatInput (Upload)Output (Download)
GLTF/GLB .gltf .glbyesyes
VRM .vrmyesyes (.vrm input data required)
USDZ .usdzyesyes
USD/USDA/USDC .usd .usda .usdcyesyes
FBX .fbx .FBX**yesyes
OBJ .objyesyes
PLY .plyyesyes
STL .stlyesyes
STEP .stp .step*yesno
IGES .igs .iges*yesno
3D Studio Max .maxDCC ImporterDCC Importer

* Currently not available in Free Plan
** Material support limitations apply, see material section below

Supported texture formats (requires reference to or embed in 3D format):

FormatInput (with 3D Format)Output (with 3D Format)
JPEG .jpgyesyes
PNG .pngyesyes
TGA .tgayesno
KTX2 .ktxyesyes

Other supported formats:

FormatUpload (Web Platform)Download (Web Platform)
ZIP .zipyesyes

Note: RapidCompact's ZIP importer only supports single 3D file in root folder , sub-directories containing textures are supported as long as referenced in 3D file.

Supported 3D Features

FeatureInput (Upload)Output (Download)Preserved during Optimization?
Rigid Animationlimited***limited***yes
Skinned Animationlimited***limited***yes
Morph Targets (Blend Shapes)limited**limited**limited**
Scene Lightslimited*limited*limited*
Cameraslimited****limited****no

* Currently the following scene light is supported (glTF only): KHR_lights_punctual
** Currently morph target support is limited to .gltf for import and export
*** Currently we do not read any animation data from USD(Z) files in the input and do not write any animation into .fbx files in the output (see table below for further information)
**** .glTF and some .fbx cameras only

Animation data is supported for the following file formats:

File formatInputOutput
.fbxyesno
.gltf / .glbyesyes
.usdnoyes

glTF extensions (for material extension please see the section below)

ExtensionSupport
KHR_draco_mesh_compressionyes
KHR__lights_punctualyes
KHR_mesh_quantizationlimited*
KHR_texture_basisuyes
KHR_texture_transformyes
KHR_xmp_json_ldno
EXT_texture_webpyes
Other EXT or vendor specific extensionsno

* Import only

USD(Z) Feature Support (Status: Q1 2024)

  • Recognized file containers: usd, usda, usdc, usdz
  • Profiles: arkit, omniverse, generic
  • Stage settings:
    • metersPerUnit
    • Up axis ➝ handling of Z up
  • Nodes:
    • Trafos
    • Meshes
    • Can filter for purpose (render, proxy, guide)
  • Mesh:
    • UsdGeomMesh
      • Triangles. Can triangulate quads and polys.
      • Positions, normals, UVs
    • GeomSubsets (except if the mesh contains polygons)
  • Material:
    • Textures: UVTextures from files
      • texture trafos (UsdTransform2d)
    • PreviewSurface
      • diffuseColor, opacity
      • opacityThreshold
      • metallic, roughness
      • emissiveColor
      • normal
      • occlusion
      • clearcoat, clearcoatRoughness
      • ior
      • displacement
    • Adobe Standard Material (currently only if the input contains ASM)
    • Conversion of mesh sidedness to material sidedness (import) or the other way around (export).

Limited support for:

  • Node instancing
  • Animation

Material Support

In general RapidCompact supports the following material properties:

Material PropertyImport (Upload)Export (Download)
Material Colorsyesyes
Vertex Colorsyesno
Materials using Texture Maps (PBR)yesyes
Materials using repeating UVs & tiled Texturesyesyes
Materials using procedural nodesDCC Importerno
Materials using render-specific shading nodes (eg. V-Ray)DCC Importerno

RapidCompact supports PBR Material systems such as the one supported by glTF 2.0, physical material for 3D Studio Max or Stingray PBS for Maya.

This means that all glTF/glb datasets exported by any DCC tool will work flawlessly with RapidCompact (if no custom extensions are used).

However the most commonly used exchange format is FBX. In the following we listed the most commonly used shader/material systems and the most common format these are saved in as well as the RapidCompact support for those:

MaterialSupportOrigin Software/EntitySupported Format
glTF PBRyesglTF/Khronos Group.glTF/.glb
USD Preview SurfaceyesPixar.usd, .usda, .usdc, .usdz
Adobe Standard MaterialyesAdobe.usd, .usda, .usdc, .usdz
Physical MaterialyesAutodesk 3ds Max.fbx
PBR Material (Metal/Rough)yesAutodesk 3ds Max.fbx
Standard MateriallimitedAutodesk 3ds Max.fbx
Stingray PBS (Autodesk Maya)yesAutodesk Maya.fbx
VRayDCC ImporterChaos Group.max
CoronanoChaos GroupN/A
ArnoldnoAutodeskN/A
Principled BSDF (Blender)limited.fbx

glTF Material Extensions

Material ExtensionSupport
KHR_materials_unlityes
KHR_materials_clearcoatyes
KHR_materials_sheenyes
KHR_materials_specularyes
KHR_materials_transmissionyes
KHR_materials_volumeyes
KHR_materials_ioryes
KHR_materials_iridescenceyes
KHR_materials_emission_strengthno
KHR_materials_anisotropyno
KHR_materials_variantsno

Adobe Standard Material Support (Status: Q1 2024)

Supported ASM Propertyconverted glTF PBR PropertyNotes
Base ColorBase Color
RoughnessRoughness
MetallicMetallic
OpacityOpacityAlpha Component in glTF Base Color.
Specular LevelSpecularKHR_materials_specularNo direct conversion - current results may not be accurate
Specular Edge ColorSpecular Color
NormalNormal map
Normal ScaleNormal map scale
Combine Normal and HeightN/ANo conversion possible
HeightN/ANo conversion possible
Height ScaleN/ANo conversion possible
Height LevelN/ANo conversion possible
AnisotropyNot yet supportedNeeds KHR_materials_anisotropy
Anisotropy AngleNot yet supportedNeeds KHR_materials_anisotropy
EmissionNot yet supportedNeeds KHR_materials_emissive_strength
Emission ColorEmissive
Sheen OpacityN/ANo conversion possible
Sheen ColorSheen ColorNeeds validation on compatibility
Sheen RoughnessSheen Roughness
TranslucencyTransmissionUses KHR_materials_transmissionIn glTF, Base Color tints translucent materials. This is not the case in ASM. Translucent materials may look different. 
IORIORUses KHR_materials_ior
DispersionNot yet supportedNeeds KHR_materials_dispersionNeeds validation on compatibility
Absorption ColorAttenuation ColorIn glTF, Attenuation Color cannot be a texture. If Absorption Color is present, it is currently ignored in the conversion
Absorption DistanceAttenuation Distance
Scattening ColorN/ANo conversion possible
Scattening DistanceN/ANo conversion possible
Scattering Distance ScaleN/ANo conversion possible
Red ShiftN/ANo conversion possible
Rayleigh ScatteringN/ANo conversion possible
Coat OpacityClearcoat
Coat ColorN/ANo conversion possible
Coat RoughnessClearcoat Roughness
Coat IORN/ANo conversion possible
Coat Specular LevelN/ANo conversion possible
Coat NormalClearcoat normal map
Coat Normal ScaleClearcoat normal map scale
Ambient OcclusionOcclusion
Volume ThicknessThickness (texture)
Volume Thickness ScaleThickness (factor)In ASM, Thickness Scale seems to apply only to the thickness texture. In glTF, Thickness factor defines a constant thickness.
Thin WalledN/ANo conversionNot part of the ASM Material Model 4.0

When loading ASM (and USDPreviewSurface) materials from USD, if opacity is present and different from 1.0, the material is set to Alpha Blending or Alpha Masking - if opacityThreshold > 0.0 or opacityThreshold == 0.0, respectively

OBJ .mtl syntax

A very commonly used, yet very much aged, exchange format is obj. RapidCompact only supports loading textures with an .obj file if these are properly referenced in a .mtl file (this file will be written out by default with any .obj file from most DCCs).

As the PBR material standard is not streamlined with .obj and .mtl files, we recommend using the following syntax, in order to make RapidCompact find the respective texture files:

TextureSingle ValueMap Inputexample
basecolorKdmap_Kdmap_kd material0_albedo.jpg
normal/normnorm material0_normal.png
occlusion/occlusionocclusion material0_occlusion.jpg
metallicPmmap_Pmmap_Pm material0_metallic.jpg
roughnessPrmap_Prmap_Pr material0_roughness.jpg
emissionKemap_kemap_Ke material0_emission.jpg

DCC Tool Export Guidelines

The following section introduces best practises for exporting data from various DCC tools. As the tools can be quite different in usability, use-case and functionality we will go into detail with each tool and highlight the steps for creating valid input data for further processing and optimization towards real-time content.

Autodesk 3ds Max

For the best possible outcome we recommend using the editable poly surface modifier for all 3D data. Subdivide and other modifiers operating and/or altering the meshes raw geometry data as well as render-specific modifiers (eg. VrayDisplacementMod etc.) should be merged with the editable poly if they are supported or get ignored if they are not supported.

Concerning materials there are similar roadblocks when going from offline-render-specific material systems (see section above) to real-time representations. Thus we would recommend using the 3D Studio Max Scene Converter feature:

Left: Rendering->Scene Converter; Right: Select the material/render model the scene was initially set-up with, to convert it to physical material Left: Rendering->Scene Converter; Right: Select the material/render model the scene was initially set-up with, to convert it to physical material

For exporting the data we recommend using fbx 2020 with the embed media option checked. The resulting fbx are then supported by RapidCompact.

Alternatively tools such as the Babylon glTF Exporter can be used (It's the same approach but uses glTF as export format).

Autodesk Maya

The recommended export steps for Autodesk Maya are the following:

  • Stingray PBS Materials
  • Export fbx 2020 with embed media option (similar to 3ds Max export settings above)

Stingray PBS Material can be found in the Hypershade EditorStingray PBS Material can be found in the Hypershade Editor

Blender

As stated in “4. Material Support” Principled BSDF shader’s supported channels are:

Base Color / Metallic / Roughness / Normal / Ambient Occlusion / Emission

If exported as glb/glTF the properties of those channels will be readable in Rapid Compact.

With other supported file formats please make sure there are textures connected to and exported with the PBR supported channels.

Supported channels highlighted in greenSupported channels highlighted in green

Modo

Materials that support the PBR model in Modo are the Principled Shader, gltF Material, Unity Material & Unreal Materials.

The Modo PBR Loader can help with importing PBR textures into Modo within your texturing workflow.

Left: PBR loader can be found in Texture/PBR;  Right: Materials with supported texturesLeft: PBR loader can be found in Texture/PBR; Right: Materials with supported textures

CLO 3D

If the starting point of the 3D workflow is in 3D apparel software such as CLO 3D we recommend the following export settings:

  • .glTF/.glb format
  • Object options "Thin" and "Single Object" have to be ticked
  • File settings: "Save Colorway" + "Maintain Individual Texture Image Coordinates"

Left: Navigation inside CLO 3D to glTF/GLB export; Right: Recommended GLB export settingsLeft: Navigation inside CLO 3D to glTF/GLB export; Right: Recommended GLB export settings

For further export options see the CLO 3D Export Options Documentation.

VStitcher [Browzwear]

  • Avatar: do not include it

  • Geometry: Include Garment outside Scale: x1

  • Textures: Baked Textures in PNG (DPI depends on needs)

  • UV: Single UV for all Pieces (Square)

  • glTF Settings: Alpha Mode: Blend PBR Model: Metallic/Roughness

  • Advanced Settings: Not needed

  • Colorways: Select All (or select the ones you need)

vstitcher

Game Engine Import Guidelines

Often, assets optimized with RapidCompact are not directly deployed on the web or in app-less (AR) functionalities, but are also being used in Game Engines and other platforms building real-time interactive experiences.

In this section we highlight general best practises of getting the optimized data into Editors such as Unreal and Unity 3D.

Unreal Engine 5

With Unreal Engine 5, we recommend utilizing the glTF/glb formats for export from RapidCompact and import into the engine. Please find the official section in the Unreal Engine 5 Documentation here: https://docs.unrealengine.com/5.3/en-US/importing-gltf-files-into-unreal-engine/

Fixing issues with tangent computation after glTF import in Unreal Engine 5.1.1, 5.2.1 and 5.3.x:

Usually RapidCompact saves computed tangents and normal information within a glTF or glb file. However, some tools and game engine recalculate normals and tangents on import. This is usually a good idea and in general a very default operation.

However, in case of RapidCompact optimized models this can lead to artifacts similar to "UV-seam" issues, especially if a tangent boarder is running over a large surface.

In order to avoid this, during glTF import within the Static Meshes section, we recommend to not check the following settings, as seen below:

  • Recompute Normals
  • Recompute Tangents
  • Compute Weighted Normals

UE5 Pipeline Configuration

Unreal Engine 4 [outdated]

For Unreal Engine we recommend the following import options:

  • Import .glb files (advantage: PBR materials are automatically set-up, assets are matching RapidCompact Output)
  • Scale factor should be 100 by default (coming from meters in glTF/glb going to centimeters in unreal)
  • The flip from Y-Up to Z-Up is handeled automatically when importing gltf/glb

Unreal Engine glTF Import Options, generate Lightmap UVs is recommended
Unreal Engine glTF Import Options, generate Lightmap UVs is recommended

By default unreal engine imports gltf normal maps without flagging them as those leading to visual errors.

Solution:

  1. Set the map in the texture editor's compression settings to Normalmap and flip the green channel.
  2. Go into the respective materials fixing the map channel of the normal map node to "Normal" and hook up the normal map node directly into the normal slot of the material, ignore the shader network which was set-up in the first place.

Correct Material set-up for glTF normal maps as described above (subject to change depending on unreal improvements).

Correct Material set-up for glTF normal maps as described above (subject to change depending on unreal improvements).

Left: FlightHelmet asset from glTF with wrong normals; Right: After applying the steps above Left: FlightHelmet asset from glTF with wrong normals; Right: After applying the steps above

As you will realise with multi-part assets (such as unoptimized data, complex multi mesh node objects or assets with opacque vs transparent materials and nodes) these have to be combined into a single in-game "actor". In Unreal this works a bit different compared to the "prefab" system in Unity (see section below).

To merge parts of multi-part assets into a single actor use the following guidelines:

  1. Put the parts into the scene, zero their translations so they are in the origin of the scene. Select all parts which should be merged.
  2. Go to Window -> Developer Tools -> Merge Actors
  3. Accept (usually default settings are reasonable) and save into a new directory
  4. Delete the original assets in the scene
  5. New merged actor can be placed (settings, materials & LODs should be merged as well)

Left: Merge Actors Setting; Right: Select actors to merge Left: Merge Actors Setting; Right: Select actors to merge

Unity 3D

Similar to the workflow with unreal we would recommend using the .glTF/.glb format for importing your assets from RapidCompact. OBJ is possible too, but forces the recreation of materials, texture import and assignments inside Unity.

Other than Unreal, Unity 3D has no official glTF support and thus relies on plugins/packages by the developer community.

There are alot of glTF importers for Unity out there.

We would recommend glTFast as we have a very positive experience with the developers and the tool itself. The following features come with this import tool:

  • Runtime import
  • Fast and small footprint JSON parsing
  • Multi-threading via C# job system
  • Editor import
  • Core glTF features
  • Full list here

Simply install the package of your choice and start importing glTF/glb files.

3D Scan Guidelines

RapidCompact is especially efficient in simplifying 3D scanned data due to the strong research background of DGG in this area. Whichever scan method or software is used, the following points should communicate some important guidelines:

  • Please calculate mesh/ tesselate before exporting. No point clouds, only mesh data
  • If exported in PLY format make sure the vertex colors are correctly exported
  • If exported in OBJ format make sure the .mtl file is correctly exported and later part of the (zipped) upload data
  • Please take the upload limit of RapidCompact (free plan 500MB) into account when exporting data