mirror of
https://github.com/bloeys/assimp-go.git
synced 2025-12-29 08:28:20 +00:00
318 lines
9.9 KiB
Go
Executable File
318 lines
9.9 KiB
Go
Executable File
package asig
|
|
|
|
type aiReturn int32
|
|
|
|
const (
|
|
//Indicates that a function was successful
|
|
aiReturnSuccess = 0x0
|
|
|
|
//Indicates that a function failed
|
|
aiReturnFailure = -0x1
|
|
|
|
//Indicates that not enough memory was available to perform the requested operation
|
|
aiReturnOutofMemory = -0x3
|
|
)
|
|
|
|
type SceneFlag int32
|
|
|
|
const (
|
|
/**
|
|
* Specifies that the scene data structure that was imported is not complete.
|
|
* This flag bypasses some internal validations and allows the import
|
|
* of animation skeletons, material libraries or camera animation paths
|
|
* using Assimp. Most applications won't support such data.
|
|
*/
|
|
SceneFlagIncomplete SceneFlag = 1 << 0
|
|
|
|
/**
|
|
* This flag is set by the validation postprocess-step (PostProcessValidateDataStructure)
|
|
* if the validation is successful. In a validated scene you can be sure that
|
|
* any cross references in the data structure (e.g. vertex indices) are valid.
|
|
*/
|
|
SceneFlagValidated SceneFlag = 1 << 1
|
|
|
|
/**
|
|
* This flag is set by the validation postprocess-step (PostProcessValidateDataStructure)
|
|
* if the validation is successful but some issues have been found.
|
|
* This can for example mean that a texture that does not exist is referenced
|
|
* by a material or that the bone weights for a vertex don't sum to 1.0 ... .
|
|
* In most cases you should still be able to use the import. This flag could
|
|
* be useful for applications which don't capture Assimp's log output.
|
|
*/
|
|
SceneFlagValidationWarning SceneFlag = 1 << 2
|
|
|
|
/**
|
|
* This flag is currently only set by the PostProcessJoinIdenticalVertices step.
|
|
* It indicates that the vertices of the output meshes aren't in the internal
|
|
* verbose format anymore. In the verbose format all vertices are unique,
|
|
* no vertex is ever referenced by more than one face.
|
|
*/
|
|
SceneFlagNonVerboseFormat SceneFlag = 1 << 3
|
|
|
|
/**
|
|
* Denotes pure height-map terrain data. Pure terrains usually consist of quads,
|
|
* sometimes triangles, in a regular grid. The x,y coordinates of all vertex
|
|
* positions refer to the x,y coordinates on the terrain height map, the z-axis
|
|
* stores the elevation at a specific point.
|
|
*
|
|
* TER (Terragen) and HMP (3D Game Studio) are height map formats.
|
|
* @note Assimp is probably not the best choice for loading *huge* terrains -
|
|
* fully triangulated data takes extremely much free store and should be avoided
|
|
* as long as possible (typically you'll do the triangulation when you actually
|
|
* need to render it).
|
|
*/
|
|
SceneFlagTerrain SceneFlag = 1 << 4
|
|
|
|
/**
|
|
* Specifies that the scene data can be shared between structures. For example:
|
|
* one vertex in few faces. SceneFlagNonVerboseFormat can not be
|
|
* used for this because SceneFlagNonVerboseFormat has internal
|
|
* meaning about postprocessing steps.
|
|
*/
|
|
SceneFlagAllowShared SceneFlag = 1 << 5
|
|
)
|
|
|
|
//aiGetErrorString specifies the types of primitives that can be present in a mesh
|
|
type PrimitiveType int32
|
|
|
|
const (
|
|
PrimitiveTypePoint = 1 << 0
|
|
PrimitiveTypeLine = 1 << 1
|
|
PrimitiveTypeTriangle = 1 << 2
|
|
PrimitiveTypePolygon = 1 << 3
|
|
)
|
|
|
|
//MorphMethod specifies the Supported methods of mesh morphing
|
|
type MorphMethod int32
|
|
|
|
const (
|
|
//Interpolation between morph targets
|
|
MorphMethodVertexBlend = 0x1
|
|
//Normalized morphing between morph targets
|
|
MorphMethodMorphNormalized = 0x2
|
|
//Relative morphing between morph targets
|
|
MorphMethodMorphRelative = 0x3
|
|
)
|
|
|
|
//PostProcess defines the flags for all possible post processing steps.
|
|
type PostProcess int64
|
|
|
|
const (
|
|
PostProcessCalcTangentSpace PostProcess = 0x1
|
|
PostProcessJoinIdenticalVertices PostProcess = 0x2
|
|
PostProcessMakeLeftHanded PostProcess = 0x4
|
|
PostProcessTriangulate PostProcess = 0x8
|
|
PostProcessRemoveComponent PostProcess = 0x10
|
|
PostProcessGenNormals PostProcess = 0x20
|
|
PostProcessGenSmoothNormals PostProcess = 0x40
|
|
PostProcessSplitLargeMeshes PostProcess = 0x80
|
|
PostProcessPreTransformVertices PostProcess = 0x100
|
|
PostProcessLimitBoneWeights PostProcess = 0x200
|
|
PostProcessValidateDataStructure PostProcess = 0x400
|
|
PostProcessImproveCacheLocality PostProcess = 0x800
|
|
PostProcessRemoveRedundantMaterials PostProcess = 0x1000
|
|
PostProcessFixInfacingNormals PostProcess = 0x2000
|
|
PostProcessSortByPType PostProcess = 0x8000
|
|
PostProcessFindDegenerates PostProcess = 0x10000
|
|
PostProcessFindInvalidData PostProcess = 0x20000
|
|
PostProcessGenUVCoords PostProcess = 0x40000
|
|
PostProcessTransformUVCoords PostProcess = 0x80000
|
|
PostProcessFindInstances PostProcess = 0x100000
|
|
PostProcessOptimizeMeshes PostProcess = 0x200000
|
|
PostProcessOptimizeGraph PostProcess = 0x400000
|
|
PostProcessFlipUVs PostProcess = 0x800000
|
|
PostProcessFlipWindingOrder PostProcess = 0x1000000
|
|
PostProcessSplitByBoneCount PostProcess = 0x2000000
|
|
PostProcessDebone PostProcess = 0x4000000
|
|
PostProcessGlobalScale PostProcess = 0x8000000
|
|
PostProcessEmbedTextures PostProcess = 0x10000000
|
|
PostProcessForceGenNormals PostProcess = 0x20000000
|
|
PostProcessDropNormals PostProcess = 0x40000000
|
|
PostProcessGenBoundingBoxes PostProcess = 0x80000000
|
|
)
|
|
|
|
type TextureType int32
|
|
|
|
const (
|
|
|
|
/** Dummy value.
|
|
*
|
|
* No texture, but the value to be used as 'texture semantic'
|
|
* (MaterialProperty.Semantic) for all material properties
|
|
* *not* related to textures.
|
|
*/
|
|
TextureTypeNone TextureType = 0
|
|
|
|
/** The texture is combined with the result of the diffuse
|
|
* lighting equation.
|
|
*/
|
|
TextureTypeDiffuse TextureType = 1
|
|
|
|
/** The texture is combined with the result of the specular
|
|
* lighting equation.
|
|
*/
|
|
TextureTypeSpecular TextureType = 2
|
|
|
|
/** The texture is combined with the result of the ambient
|
|
* lighting equation.
|
|
*/
|
|
TextureTypeAmbient TextureType = 3
|
|
|
|
/** The texture is added to the result of the lighting
|
|
* calculation. It isn't influenced by incoming light.
|
|
*/
|
|
TextureTypeEmissive TextureType = 4
|
|
|
|
/** The texture is a height map.
|
|
*
|
|
* By convention, higher gray-scale values stand for
|
|
* higher elevations from the base height.
|
|
*/
|
|
TextureTypeHeight TextureType = 5
|
|
|
|
/** The texture is a (tangent space) normal-map.
|
|
*
|
|
* Agn, there are several conventions for tangent-space
|
|
* normal maps. Assimp does (intentionally) not
|
|
* distinguish here.
|
|
*/
|
|
TextureTypeNormal TextureType = 6
|
|
|
|
/** The texture defines the glossiness of the material.
|
|
*
|
|
* The glossiness is in fact the exponent of the specular
|
|
* (phong) lighting equation. Usually there is a conversion
|
|
* function defined to map the linear color values in the
|
|
* texture to a suitable exponent. Have fun.
|
|
*/
|
|
TextureTypeShininess TextureType = 7
|
|
|
|
/** The texture defines per-pixel opacity.
|
|
*
|
|
* Usually 'white' means opaque and 'black' means
|
|
* 'transparency'. Or quite the opposite. Have fun.
|
|
*/
|
|
TextureTypeOpacity TextureType = 8
|
|
|
|
/** Displacement texture
|
|
*
|
|
* The exact purpose and format is application-dependent.
|
|
* Higher color values stand for higher vertex displacements.
|
|
*/
|
|
TextureTypeDisplacement TextureType = 9
|
|
|
|
/** Lightmap texture (aka Ambient Occlusion)
|
|
*
|
|
* Both 'Lightmaps' and dedicated 'ambient occlusion maps' are
|
|
* covered by this material property. The texture contains a
|
|
* scaling value for the final color value of a pixel. Its
|
|
* intensity is not affected by incoming light.
|
|
*/
|
|
TextureTypeLightmap TextureType = 10
|
|
|
|
/** Reflection texture
|
|
*
|
|
* Contains the color of a perfect mirror reflection.
|
|
* Rarely used, almost never for real-time applications.
|
|
*/
|
|
TextureTypeReflection TextureType = 11
|
|
|
|
/** Unknown texture
|
|
* A texture reference that does not match any of the definitions
|
|
* above is considered to be 'unknown'. It is still imported,
|
|
* but is excluded from any further post-processing.
|
|
*/
|
|
TextureTypeUnknown TextureType = 18
|
|
)
|
|
|
|
/** PBR Materials
|
|
* PBR definitions from maya and other modelling packages now use this standard.
|
|
* This was originally introduced around 2012.
|
|
* Support for this is in game engines like Godot, Unreal or Unity3D.
|
|
* Modelling packages which use this are very common now.
|
|
*/
|
|
const (
|
|
TextureTypeBaseColor TextureType = 12
|
|
TextureTypeNormalCamera TextureType = 13
|
|
TextureTypeEmissionColor TextureType = 14
|
|
TextureTypeMetalness TextureType = 15
|
|
TextureTypeDiffuseRoughness TextureType = 16
|
|
TextureTypeAmbientOcclusion TextureType = 17
|
|
)
|
|
|
|
func (tp TextureType) String() string {
|
|
|
|
switch tp {
|
|
case TextureTypeNone:
|
|
return "None"
|
|
case TextureTypeDiffuse:
|
|
return "Diffuse"
|
|
case TextureTypeSpecular:
|
|
return "Specular"
|
|
case TextureTypeAmbient:
|
|
return "Ambient"
|
|
case TextureTypeAmbientOcclusion:
|
|
return "AmbientOcclusion"
|
|
case TextureTypeBaseColor:
|
|
return "BaseColor"
|
|
case TextureTypeDiffuseRoughness:
|
|
return "DiffuseRoughness"
|
|
case TextureTypeDisplacement:
|
|
return "Displacement"
|
|
case TextureTypeEmissionColor:
|
|
return "EmissionColor"
|
|
case TextureTypeEmissive:
|
|
return "Emissive"
|
|
case TextureTypeHeight:
|
|
return "Height"
|
|
case TextureTypeLightmap:
|
|
return "Lightmap"
|
|
case TextureTypeMetalness:
|
|
return "Metalness"
|
|
case TextureTypeNormal:
|
|
return "Normal"
|
|
case TextureTypeNormalCamera:
|
|
return "NormalCamera"
|
|
case TextureTypeOpacity:
|
|
return "Opacity"
|
|
case TextureTypeReflection:
|
|
return "Reflection"
|
|
case TextureTypeShininess:
|
|
return "Shininess"
|
|
case TextureTypeUnknown:
|
|
return "Unknown"
|
|
default:
|
|
return "Invalid"
|
|
}
|
|
}
|
|
|
|
type MatPropertyTypeInfo int32
|
|
|
|
const (
|
|
MatPropTypeInfoFloat32 MatPropertyTypeInfo = iota + 1
|
|
MatPropTypeInfoFloat64
|
|
MatPropTypeInfoString
|
|
MatPropTypeInfoInt32
|
|
|
|
//Simple binary buffer, content undefined. Not convertible to anything.
|
|
MatPropTypeInfoBuffer
|
|
)
|
|
|
|
func (mpti MatPropertyTypeInfo) String() string {
|
|
|
|
switch mpti {
|
|
case MatPropTypeInfoFloat32:
|
|
return "Float32"
|
|
case MatPropTypeInfoFloat64:
|
|
return "Float64"
|
|
case MatPropTypeInfoString:
|
|
return "String"
|
|
case MatPropTypeInfoInt32:
|
|
return "Int32"
|
|
case MatPropTypeInfoBuffer:
|
|
return "Buffer"
|
|
default:
|
|
return "Unknown"
|
|
}
|
|
}
|