• Api Documentation
  • Source Code
Search Results for

    Show / Hide Table of Contents
    • SharpAssimp
      • Animation
      • AnimationBehaviour
      • AnimationInterpolation
      • AssimpContext
      • AssimpException
      • BlendMode
      • Bone
      • BoundingBox
      • Camera
      • CompileFlags
      • ConsoleLogStream
      • DefaultLogStream
      • EmbeddedTexture
      • ExcludeComponent
      • ExportDataBlob
      • ExportFormatDescription
      • Face
      • FileIOMode
      • FileIOSystem
      • FreeNativeDelegate
      • IMarshalable<Managed, Native>
      • INativeCustomMarshaler
      • IOStream
      • IOSystem
      • ImporterDescription
      • ImporterFeatureFlags
      • Light
      • LightSourceType
      • LogStream
      • LoggingCallback
      • Material
      • Material.PBRMaterialProperties
      • Material.ShaderMaterialProperties
      • MaterialProperty
      • Matrix3x3
      • MemoryHelper
      • Mesh
      • MeshAnimationAttachment
      • MeshAnimationChannel
      • MeshKey
      • MeshMorphAnimationChannel
      • MeshMorphKey
      • MeshMorphingMethod
      • MetaDataType
      • Metadata
      • Metadata.Entry
      • NativeCustomMarshalerAttribute
      • Node
      • NodeAnimationChannel
      • NodeCollection
      • Origin
      • PostProcessPreset
      • PostProcessSteps
      • PrimitiveType
      • PropertyType
      • QuaternionKey
      • Ray
      • ReturnCode
      • Scene
      • SceneFlags
      • ShadingMode
      • Texel
      • TextureFlags
      • TextureMapping
      • TextureOperation
      • TextureSlot
      • TextureType
      • TextureWrapMode
      • UVTransform
      • UVTransformFlags
      • VectorKey
      • VertexWeight
    • SharpAssimp.Configs
      • ACEvaluateSubdivisionConfig
      • ACSeparateBackfaceCullConfig
      • ASEReconstructNormalsConfig
      • AnimationAccuracyConfig
      • AppScaleConfig
      • BooleanPropertyConfig
      • ColladaIgnoreUpDirectionConfig
      • ColladaUseColladaNamesConfig
      • DeboneAllOrNoneConfig
      • DeboneThresholdConfig
      • ExportPointCloudsConfig
      • FBXConvertToMetersConfig
      • FBXImportAllGeometryLayersConfig
      • FBXImportAllMaterialsConfig
      • FBXImportAnimationsConfig
      • FBXImportCamerasConfig
      • FBXImportEmbeddedTexturesConfig
      • FBXImportEmbeddedTexturesLegacyNamingConfig
      • FBXImportLightsConfig
      • FBXImportMaterialsConfig
      • FBXOptimizeEmptyAnimationCurvesConfig
      • FBXPreservePivotsConfig
      • FBXStrictModeConfig
      • FavorSpeedConfig
      • FloatPropertyConfig
      • GlobalKeyFrameImportConfig
      • GlobalScaleConfig
      • IFCCylindricalTessellationConfig
      • IFCSkipSpaceRepresentationsConfig
      • IFCSmoothingAngleConfig
      • IFCUseCustomTriangulationConfig
      • IRRAnimationFrameRateConfig
      • IgnoreTextureCoordinatesConfig
      • IntegerPropertyConfig
      • KeepSceneHierarchyConfig
      • LWOImportOneLayerConfig
      • LWSAnimationEndConfig
      • LWSAnimationStartConfig
      • MD2KeyFrameImportConfig
      • MD3HandleMultiPartConfig
      • MD3KeyFrameImportConfig
      • MD3ShaderSourceConfig
      • MD3SkinNameConfig
      • MD5NoAnimationAutoLoadConfig
      • MDLColorMapConfig
      • MDLKeyFrameImportConfig
      • MaterialExcludeListConfig
      • MatrixPropertyConfig
      • MaxBoneCountConfig
      • MeasureTimeConfig
      • MeshTriangleLimitConfig
      • MeshVertexLimitConfig
      • MultithreadingConfig
      • NoSkeletonMeshesConfig
      • NodeExcludeListConfig
      • NormalSmoothingAngleConfig
      • NormalizeVertexComponentsConfig
      • OgreMaterialFileConfig
      • OgreTextureTypeFromFilenameConfig
      • PropertyConfig
      • RemoveComponentConfig
      • RemoveDegeneratePrimitivesCheckAreaConfig
      • RemoveDegeneratePrimitivesConfig
      • RemoveEmptyBonesConfig
      • RootTransformationConfig
      • SMDKeyFrameImportConfig
      • SmdLoadAnimationListConfig
      • SortByPrimitiveTypeConfig
      • StringPropertyConfig
      • TangentSmoothingAngleConfig
      • TangentTextureChannelIndexConfig
      • TerragenComputeTexCoordsConfig
      • TransformUVConfig
      • UnrealHandleFlagsConfig
      • UnrealKeyFrameImportConfig
      • VertexBoneWeightLimitConfig
      • VertexCacheSizeConfig
      • XFileUseDoublesConfig
    • SharpAssimp.Unmanaged
      • AiAnimMesh
      • AiAnimation
      • AiBone
      • AiCamera
      • AiConfigs
      • AiDefines
      • AiExportDataBlob
      • AiExportFormatDesc
      • AiFace
      • AiFile
      • AiFileCloseProc
      • AiFileFlushProc
      • AiFileIO
      • AiFileOpenProc
      • AiFileReadProc
      • AiFileSeek
      • AiFileTellProc
      • AiFileWriteProc
      • AiImporterDesc
      • AiLight
      • AiLogStream
      • AiLogStreamCallback
      • AiMatKeys
      • AiMaterial
      • AiMaterialProperty
      • AiMemoryInfo
      • AiMesh
      • AiMeshAnim
      • AiMeshColorArray
      • AiMeshMorphAnim
      • AiMeshMorphKey
      • AiMeshTextureCoordinateArray
      • AiMeshUVComponentArray
      • AiMetadata
      • AiMetadataEntry
      • AiNode
      • AiNodeAnim
      • AiScene
      • AiString
      • AiTexture
      • AssimpLibrary
      • Platform
      • UnmanagedFunctionNameAttribute
      • UnmanagedLibrary
      • UnmanagedLibraryResolver

    Enum PostProcessSteps

    Post processing flag options, specifying a number of steps that can be run on the data to either generate additional vertex data or optimize the imported data.

    Namespace: SharpAssimp
    Assembly: SharpAssimp.dll
    Syntax
    [Flags]
    public enum PostProcessSteps : uint

    Fields

    Name Description
    CalculateTangentSpace

    Calculates the tangents and binormals (bitangents) for the imported meshes.

    This does nothing if a mesh does not have normals. You might want this post processing step to be executed if you plan to use tangent space calculations such as normal mapping. There is a config setting AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE which allows you to specify a maximimum smoothing angle for the algorithm. However, usually you'll want to leave it at the default value.

    Debone

    Removes bones losslessly or according to some threshold. In some cases (e.g. formats that require it) exporters are faced to assign dummy bone weights to otherwise static meshes assigned to animated meshes. Full, weight-based skinning is expensive while animating nodes is extremely cheap, so this step is offered to clean up the data in that regard.

    Usage of the configuration AI_CONFIG_PP_DB_THRESHOLD to control the threshold and AI_CONFIG_PP_DB_ALL_OR_NONE if you want bones removed if and only if all bones within the scene qualify for removal.

    DropNormals

    Drops normals for all faces of all meshes. This is ignored if no normals are present. Face normals are shared between all points of a single face, so a single point can have multiple normals, which forces the library to duplicate vertices in some cases. JoinIdenticalVertices is senseless then. This process gives sense back to JoinIdenticalVertices.

    EmbedTextures

    A post processting step to embed textures. This will remove external data dependencies for textures. If a texture's file does not exist at the specified path (due, for instance, to an absolute path generate on another system), it will check if a file with the same name exists at the root folder of the imported model, and if so, embeds that.

    FindDegenerates

    This step searches all meshes for degenerated primitives and converts them to proper lines or points. A face is 'degenerated' if one or more of its points are identical.

    To have degenerated primitives removed, specify the FindDegenerates flag try one of the following procedures:

    This step also removes very small triangles with a surface area smaller than 10^-6. If you rely on having these small triangles, or notice holes in your model, set the property RemoveDegeneratePrimitivesCheckAreaConfig to false.

    Degenerated polygons are not necessarily evil and that's why they are not removed by default. There are several file formats which do not support lines or points where exporters bypass the format specification and write them as degenerated triangles instead.

    FindInstances

    Searches for duplicated meshes and replaces them with a reference to the first mesh.

    This is time consuming, so don't use it if you have no time. Its main purpose is to work around the limitation with some file formats that don't support instanced meshes, so exporters duplicate meshes.

    FindInvalidData

    This step searches all meshes for invalid data, such as zeroed normal vectors or invalid UV coordinates and removes or fixes them. This is intended to get rid of some common exporter rrors.

    This is especially useful for normals. If they are invalid, and the step recognizes this, they will be removed and can later be recomputed, e.g. by the GenerateSmoothNormals flag. The step will also remove meshes that are infinitely small and reduce animation tracks consisting of hundreds of redundant keys to a single key. The AI_CONFIG_PP_FID_ANIM_ACCURACY config property decides the accuracy of the check for duplicate animation tracks.

    FixInFacingNormals

    This step tries to determine which meshes have normal vectors that are facing inwards.

    The algorithm is simple but effective:

    The bounding box of all vertices and their normals are compared against the volume of the bounding box of all vertices without their normals. This works well for most objects, problems might occur with planar surfaces. However, the step tries to filter such cases. The step inverts all in-facing normals. Generally, it is recommended to enable this step, although the result is not always correct.

    FlipUVs

    Flips all UV coordinates along the y-axis and adjusts material settings/bitangents accordingly.

    FlipWindingOrder

    Flips face winding order from CCW (default) to CW.

    ForceGenerateNormals

    If the step to generate normals is set, it will not run if normals already exist. This flag will force that step to run even if normals are present.

    GenerateBoundingBoxes

    Generate bounding boxes for each mesh.

    GenerateNormals

    Generates normals for all faces of all meshes. It may not be specified together with GenerateSmoothNormals.

    This is ignored if normals are already there at the time where this flag is evaluated. Model importers try to load them from the source file, so they're usually already there. Face normals are shared between all points of a single face, so a single point can have multiple normals, which in other words, forces the library to duplicate vertices in some cases. This makes JoinIdenticalVertices senseless then.

    GenerateSmoothNormals

    Generates smooth normals for all vertices of all meshes. It may not be specified together with GenerateNormals.

    This is ignored if normals are already there at the time where this flag is evaluated. Model importers try to load them from the source file, so they're usually already there.

    The configuration option AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE allows you to specify an angle maximum for the normal smoothing algorithm. Normals exceeding this limit are not smoothed, resulting in a 'hard' seam between two faces. using a decent angle here (e.g. 80 degrees) results in a very good visual appearance.

    GenerateUVCoords

    This step converts non-UV mappings (such as spherical or cylindrical mapping) to proper texture coordinate channels.

    Most applications will support UV mapping only, so you will probably want to specify this step in every case. Note that Assimp is not always able to match the original mapping implementation of the 3D app which produced a model perfectly. It's always better to let the father app compute the UV channels, at least 3DS max, maya, blender, lightwave, modo, .... are able to achieve this.

    If this step is not requested, you'll need to process the MATKEY_MAPPING material property in order to display all assets properly.

    GlobalScale

    This step will perform a global scale of the model. Some importers provide a mechanism to define a scaling unit for the model, which this processing step can utilize. Use AI_CONFIG_GLOBAL_SCALE_FACTOR_KEY to setup the global scaling factor.

    ImproveCacheLocality

    Re-orders triangles for better vertex cache locality.

    This step tries to improve the ACMR (average post-transform vertex cache miss ratio) for all meshes. The implementation runs in O(n) time and is roughly based on the 'tipsify' algorithm.

    If you intend to render huge models in hardware, this step might be of interest for you. The AI_CONFIG_PP_ICL_PTCACHE_SIZE config setting can be used to fine tune the cache optimization.

    JoinIdenticalVertices

    Identifies and joins identical vertex data sets within all imported meshes.

    After this step is run, each mesh contains unique vertices, so a vertex may be used by multiple faces. You usually want to use this post processing step. If your application deals with indexed geometry, this step is compulsory or you'll just waste rendering time.

    If this flag is not specified, no vertices are referenced by more than one face and no index buffer is required for rendering.

    Unless the importer (like ply) had to split vertices. Then you need one regardless.

    LimitBoneWeights

    Limits the number of bones simultaneously affecting a single vertex to a maximum value.

    If any vertex is affected by more than that number of bones, the least important vertex weights are removed and the remaining vertex weights are re-normalized so that the weights still sum up to 1.

    The default bone weight limit is 4 and uses the AI_LMW_MAX_WEIGHTS config. If you intend to perform the skinning in hardware, this post processing step might be of interest for you.

    MakeLeftHanded

    Converts all imported data to a left handed coordinate space.

    By default the data is returned in a right-handed coordinate space, where +X points to the right, +Z towards the viewer, and +Y upwards.

    None

    No flags enabled.

    OptimizeGraph

    Optimizes scene hierarchy. Nodes with no animations, bones, lights, or cameras assigned are collapsed and joined.

    Node names can be lost during this step, you can specify names of nodes that should'nt be touched or modified with AI_CONFIG_PP_OG_EXCLUDE_LIST.

    Use this flag with caution. Most simple files will be collapsed to a single node, complex hierarchies are usually completely lost. That's not the right choice for editor environments, but probably a very effective optimization if you just want to get the model data, convert it to your own format and render it as fast as possible.

    This flag is designed to be used with OptimizeMeshes for best results.

    Scenes with thousands of extremely small meshes packed in deeply nested nodes exist for almost all file formats. Usage of this and OptimizeMeshes usually fixes them all and makes them renderable.

    OptimizeMeshes

    Attempts to reduce the number of meshes (and draw calls).

    This is recommended to be used together with OptimizeGraph and is fully compatible with both SplitLargeMeshes and SortByPrimitiveType.

    PreTransformVertices

    Removes the node graph and "bakes" (pre-transforms) all vertices with the local transformation matrices of their nodes. The output scene does still contain nodes, however, there is only a root node with children, each one referencing only one mesh. Each mesh referencing one material. For rendering, you can simply render all meshes in order, you don't need to pay attention to local transformations and the node hierarchy.

    Warning: Animations are removed during this step.

    RemoveComponent

    Removes some parts of the data structure (animations, materials, light sources, cameras, textures, vertex components).

    The components to be removed are specified in a separate configuration option, AI_CONFIG_PP_RVC_FLAGS. This is quite useful if you don't need all parts of the output structure. Especially vertex colors are rarely used today...calling this step to remove unrequired stuff from the pipeline as early as possible results in an increased performance and a better optimized output data structure.

    This step is also useful if you want to force Assimp to recompute normals or tangents. the corresponding steps don't recompute them if they're already there (loaded from the source asset). By using this step you can make sure they are NOT there.

    RemoveRedundantMaterials

    Searches for redundant/unreferenced materials and removes them.

    This is especially useful in combination with the PreTransformVertices and OptimizeMeshes flags. Both join small meshes with equal characteristics, but they can't do their work if two meshes have different materials. Because several material settings are always lost during Assimp's import filders and because many exporters don't check for redundant materials, huge models often have materials which are defined several times with exactly the same settings.

    Several material settings not contributing to the final appearance of a surface are ignored in all comparisons ... the material name is one of them. So, if you're passing additional information through the content pipeline (probably using *magic* material names), don't specify this flag. Alternatively, take a look at the AI_CONFIG_PP_RRM_EXCLUDE_LIST setting.

    SortByPrimitiveType

    This step splits meshes with more than one primitive type in homogeneous submeshes.

    This step is executed after triangulation and after it returns, just one bit is set in aiMesh:mPrimitiveTypes. This is especially useful for real-time rendering where point and line primitives are often ignored or rendered separately.

    You can use AI_CONFIG_PP_SBP_REMOVE option to specify which primitive types you need. This can be used to easily exclude lines and points, which are rarely used, from the import.

    SplitByBoneCount

    Splits meshes with many bones into submeshes so that each submesh has fewer or as many bones as a given limit.

    SplitLargeMeshes

    Splits large meshes into smaller submeshes.

    This is useful for realtime rendering where the number of triangles which can be maximally processed in a single draw call is usually limited by the video driver/hardware. The maximum vertex buffer is usually limited, too. Both requirements can be met with this step: you may specify both a triangle and a vertex limit for a single mesh.

    The split limits can be set through the AI_CONFIG_PP_SLM_VERTEX_LIMIT and AI_CONFIG_PP_SLM_TRIANGLE_LIMIT config settings. The default values are 1,000,000.

    Warning: This can be a time consuming task.

    TransformUVCoords

    Applies per-texture UV transformations and bakes them to stand-alone vtexture coordinate channels.

    UV Transformations are specified per-texture - see the MATKEY_UVTRANSFORM material key for more information. This step processes all textures with transformed input UV coordinates and generates new (pretransformed) UV channel transformations, so you will probably want to specify this step.

    UV transformations are usually implemented in realtime apps by transforming texture coordinates in a vertex shader stage with a 3x3 (homogenous) transformation matrix.

    Triangulate

    Triangulates all faces of all meshes.

    By default the imported mesh data might contain faces with more than three indices. For rendering you'll usually want all faces to be triangles. This post processing step splits up all higher faces to triangles. Line and point primitives are *not* modified. If you want 'triangles only' with no other kinds of primitives, try the following:

    1. Specify both Triangulate and SortByPrimitiveType.
    2. Ignore all point and line meshes when you process Assimp's output
    ValidateDataStructure

    Validates the imported scene data structure.

    This makes sure that all indices are valid, all animations and bones are linked correctly, all material references are correct, etc.

    It is recommended to capture Assimp's log output if you use this flag, so you can easily find out what's actually wrong if a file fails the validation. The validator is quite rude and will find *all* inconsistencies in the data structure. There are two types of failures:
    • Error: There's something wrong with the imported data. Further postprocessing is not possible and the data is not usable at all. The import fails.
    • Warning: There are some minor issues (e.g. 1000000 animation keyframes with the same time), but further postprocessing and use of the data structure is still safe. Warning details are written to the log file.
    • Edit this page
    • View Source
    In this article
    Back to top Copyright (c) 2012-2020 Nicholas Woodfield, (c) 2024 Salvage, (c) 2025 Jérémy Ansel