v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' into MalcolmTyrrell/jsonSchemaSupport

pull/4111/head
Kim Kulling 2021-10-28 13:38:41 +02:00 committed by GitHub
parent 5a1bcc6aa5 817fbed8c2
commit 8c0b869998
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
76 changed files with 376 additions and 254 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
code/AssetLib/3DS/3DSHelper.h
View File

@ -259,7 +259,7 @@ namespace Discreet3DS {
// Specifies the file name of a texture
CHUNK_MAPFILE = 0xA300,
// Specifies whether a materail requires two-sided rendering
// Specifies whether a material requires two-sided rendering
CHUNK_MAT_TWO_SIDE = 0xA081,
// ********************************************************************

6
code/AssetLib/3MF/D3MFExporter.h
View File

@ -101,9 +101,11 @@ private:
std::vector<OpcPackageRelationship*> mRelations;
};
#endif // ASSIMP_BUILD_NO_3MF_EXPORTER
#endif // ASSIMP_BUILD_NO_EXPORT
} // Namespace D3MF
} // Namespace Assimp
#endif // ASSIMP_BUILD_NO_3MF_EXPORTER
#endif // ASSIMP_BUILD_NO_EXPORT

1
code/AssetLib/3MF/XmlSerializer.cpp
View File

@ -159,7 +159,6 @@ bool parseColor(const char *color, aiColor4D &diffuse) {
return false;
}
//const char *buf(color);
if ('#' != color[0]) {
return false;
}

2
code/AssetLib/AMF/AMFImporter_Postprocess.cpp
View File

@ -690,7 +690,7 @@ void AMFImporter::Postprocess_BuildConstellation(AMFConstellation &pConstellatio
if (ne->Type == AMFNodeElementBase::ENET_Metadata) continue;
if (ne->Type != AMFNodeElementBase::ENET_Instance) throw DeadlyImportError("Only <instance> nodes can be in <constellation>.");
// create alias for conveniance
// create alias for convenience
AMFInstance &als = *((AMFInstance *)ne);
// find referenced object
if (!Find_ConvertedNode(als.ObjectID, nodeArray, &found_node)) Throw_ID_NotFound(als.ObjectID);

2
code/AssetLib/ASE/ASELoader.cpp
View File

@ -681,7 +681,7 @@ void ASEImporter::BuildNodes(std::vector<BaseNode *> &nodes) {
}
}
// Are there ane orphaned nodes?
// Are there any orphaned nodes?
if (!aiList.empty()) {
std::vector<aiNode *> apcNodes;
apcNodes.reserve(aiList.size() + pcScene->mRootNode->mNumChildren);

4
code/AssetLib/Assbin/AssbinExporter.h
View File

@ -48,11 +48,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/defs.h>
#ifndef ASSIMP_BUILD_NO_EXPORT
// nothing really needed here - reserved for future use like properties
namespace Assimp {
void ASSIMP_API ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/);
}
#endif
#endif // AI_ASSBINEXPORTER_H_INC

23
code/AssetLib/Assbin/AssbinFileWriter.cpp
View File

@ -43,13 +43,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "AssbinFileWriter.h"
#include "Common/assbin_chunks.h"
#include "PostProcessing/ProcessHelper.h"
#include <assimp/Exceptional.h>
#include <assimp/version.h>
#include <assimp/Exporter.hpp>
#include <assimp/IOStream.hpp>
#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
@ -58,7 +56,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "../contrib/zlib/zlib.h"
#endif
#include <time.h>
#include <ctime>
#if _MSC_VER
#pragma warning(push)
@ -277,7 +275,7 @@ public:
// empty
}
virtual ~AssbinChunkWriter() {
~AssbinChunkWriter() override {
if (container) {
container->Write(&magic, sizeof(uint32_t), 1);
container->Write(&cursor, sizeof(uint32_t), 1);
@ -288,26 +286,27 @@ public:
void *GetBufferPointer() { return buffer; }
// -------------------------------------------------------------------
virtual size_t Read(void * /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) {
size_t Read(void * /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) override {
return 0;
}
virtual aiReturn Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/) {
aiReturn Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/) override {
return aiReturn_FAILURE;
}
virtual size_t Tell() const {
size_t Tell() const override {
return cursor;
}
virtual void Flush() {
void Flush() override {
// not implemented
}
virtual size_t FileSize() const {
size_t FileSize() const override {
return cursor;
}
// -------------------------------------------------------------------
virtual size_t Write(const void *pvBuffer, size_t pSize, size_t pCount) {
size_t Write(const void *pvBuffer, size_t pSize, size_t pCount) override {
pSize *= pCount;
if (cursor + pSize > cur_size) {
Grow(cursor + pSize);

2
code/AssetLib/Assbin/AssbinLoader.cpp
View File

@ -406,7 +406,7 @@ void AssbinImporter::ReadBinaryMesh(IOStream *stream, aiMesh *mesh) {
f.mIndices = new unsigned int[f.mNumIndices];
for (unsigned int a = 0; a < f.mNumIndices; ++a) {
// Check if unsigned short ( 16 bit ) are big enought for the indices
// Check if unsigned short ( 16 bit ) are big enough for the indices
if (fitsIntoUI16(mesh->mNumVertices)) {
f.mIndices[a] = Read<uint16_t>(stream);
} else {

2
code/AssetLib/Assxml/AssxmlFileWriter.cpp
View File

@ -168,7 +168,7 @@ static void WriteNode(const aiNode *node, IOStream *io, unsigned int depth) {
}
// -----------------------------------------------------------------------------------
// Some chuncks of text will need to be encoded for XML
// Some chunks of text will need to be encoded for XML
// http://stackoverflow.com/questions/5665231/most-efficient-way-to-escape-xml-html-in-c-string#5665377
static std::string encodeXML(const std::string &data) {
std::string buffer;

2
code/AssetLib/BVH/BVHLoader.cpp
View File

@ -178,7 +178,7 @@ void BVHLoader::ReadHierarchy(aiScene *pScene) {
}
// ------------------------------------------------------------------------------------------------
// Reads a node and recursively its childs and returns the created node;
// Reads a node and recursively its children and returns the created node;
aiNode *BVHLoader::ReadNode() {
// first token is name
std::string nodeName = GetNextToken();

2
code/AssetLib/BVH/BVHLoader.h
View File

@ -112,7 +112,7 @@ protected:
/** Reads the hierarchy */
void ReadHierarchy(aiScene *pScene);
/** Reads a node and recursively its childs and returns the created node. */
/** Reads a node and recursively its children and returns the created node. */
aiNode *ReadNode();
/** Reads an end node and returns the created node. */

2
code/AssetLib/Blender/BlenderDNA.h
View File

@ -476,7 +476,7 @@ public:
* in BlenderScene.cpp and is machine-generated.
* Converters are used to quickly handle objects whose
* exact data type is a runtime-property and not yet
* known at compile time (consier Object::data).*/
* known at compile time (consider Object::data).*/
void RegisterConverters();
// --------------------------------------------------------

6
code/AssetLib/COB/COBLoader.cpp
View File

@ -586,7 +586,7 @@ void COBImporter::ReadUnit_Ascii(Scene &out, LineSplitter &splitter, const Chunk
return;
}
// parent chunks preceede their childs, so we should have the
// parent chunks preceede their children, so we should have the
// corresponding chunk already.
for (std::shared_ptr<Node> &nd : out.nodes) {
if (nd->id == nfo.parent_id) {
@ -668,7 +668,7 @@ void COBImporter::ReadCame_Ascii(Scene &out, LineSplitter &splitter, const Chunk
ReadBasicNodeInfo_Ascii(msh, ++splitter, nfo);
// skip the next line, we don't know this differenciation between a
// skip the next line, we don't know this differentiation between a
// standard camera and a panoramic camera.
++splitter;
}
@ -1169,7 +1169,7 @@ void COBImporter::ReadUnit_Binary(COB::Scene &out, StreamReaderLE &reader, const
const chunk_guard cn(nfo, reader);
// parent chunks preceede their childs, so we should have the
// parent chunks preceede their children, so we should have the
// corresponding chunk already.
for (std::shared_ptr<Node> &nd : out.nodes) {
if (nd->id == nfo.parent_id) {

2
code/AssetLib/FBX/FBXConverter.cpp
View File

@ -1595,7 +1595,7 @@ void FBXConverter::ConvertCluster(std::vector<aiBone *> &local_mesh_bones, const
bone_map.insert(std::pair<const std::string, aiBone *>(deformer_name, bone));
}
ASSIMP_LOG_DEBUG("bone research: Indicies size: ", out_indices.size());
ASSIMP_LOG_DEBUG("bone research: Indices size: ", out_indices.size());
// lookup must be populated in case something goes wrong
// this also allocates bones to mesh instance outside

2
code/AssetLib/FBX/FBXDocument.h
View File

@ -693,7 +693,7 @@ private:
typedef std::vector<int64_t> KeyTimeList;
typedef std::vector<float> KeyValueList;
/** Represents a FBX animation curve (i.e. a 1-dimensional set of keyframes and values therefor) */
/** Represents a FBX animation curve (i.e. a 1-dimensional set of keyframes and values therefore) */
class AnimationCurve : public Object {
public:
AnimationCurve(uint64_t id, const Element& element, const std::string& name, const Document& doc);

4
code/AssetLib/FBX/FBXExporter.cpp
View File

@ -1709,7 +1709,7 @@ void FBXExporter::WriteObjects ()
//p.AddP70string("UVSet", ""); // TODO: how should this work?
p.AddP70bool("UseMaterial", 1);
tnode.AddChild(p);
// can't easily detrmine which texture path will be correct,
// can't easily determine which texture path will be correct,
// so just store what we have in every field.
// these being incorrect is a common problem with FBX anyway.
tnode.AddChild("FileName", texture_path);
@ -1915,7 +1915,7 @@ void FBXExporter::WriteObjects ()
// mark all parent nodes as skeleton as well,
// up until we find the root node,
// or else the node containing the mesh,
// or else the parent of a node containig the mesh.
// or else the parent of a node containing the mesh.
for (
const aiNode* parent = n->mParent;
parent && parent != mScene->mRootNode;

2
code/AssetLib/Irr/IRRLoader.cpp
View File

@ -132,7 +132,7 @@ void IRRImporter::SetupProperties(const Importer *pImp) {
}
// ------------------------------------------------------------------------------------------------
// Build a mesh tha consists of a single squad (a side of a skybox)
// Build a mesh that consists of a single squad (a side of a skybox)
aiMesh *IRRImporter::BuildSingleQuadMesh(const SkyboxVertex &v1,
const SkyboxVertex &v2,
const SkyboxVertex &v3,

2
code/AssetLib/M3D/M3DExporter.cpp
View File

@ -76,7 +76,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* Currently supports static meshes, vertex colors, materials, textures
*
* For animation, it would require the following conversions:
* - aiNode (bones) -> m3d_t.bone (with parent id, position vector and oriantation quaternion)
* - aiNode (bones) -> m3d_t.bone (with parent id, position vector and orientation quaternion)
* - aiMesh.aiBone -> m3d_t.skin (per vertex, with bone id, weight pairs)
* - aiAnimation -> m3d_action (frame with timestamp and list of bone id, position, orientation
* triplets, instead of per bone timestamp + lists)

6
code/AssetLib/M3D/M3DImporter.cpp
View File

@ -296,7 +296,7 @@ void M3DImporter::importMaterials(const M3DWrapper &m3d) {
}
// texture map properties
if (m->prop[j].type >= 128 && aiTxProps[k].pKey &&
// extra check, should never happen, do we have the refered texture?
// extra check, should never happen, do we have the referred texture?
m->prop[j].value.textureid < m3d->numtexture &&
m3d->texture[m->prop[j].value.textureid].name) {
name.Set(std::string(std::string(m3d->texture[m->prop[j].value.textureid].name) + ".png"));
@ -474,7 +474,7 @@ void M3DImporter::importMeshes(const M3DWrapper &m3d) {
mScene->mMeshes = new aiMesh *[mScene->mNumMeshes];
std::copy(meshes->begin(), meshes->end(), mScene->mMeshes);
// create mesh indeces in root node
// create mesh indices in root node
mScene->mRootNode->mNumMeshes = static_cast<unsigned int>(meshes->size());
mScene->mRootNode->mMeshes = new unsigned int[meshes->size()];
for (i = 0; i < meshes->size(); i++) {
@ -688,7 +688,7 @@ void M3DImporter::calculateOffsetMatrix(aiNode *pNode, aiMatrix4x4 *m) {
// ------------------------------------------------------------------------------------------------
// because M3D has a global mesh, global vertex ids and stores materialid on the face, we need
// temporary lists to collect data for an aiMesh, which requires local arrays and local indeces
// temporary lists to collect data for an aiMesh, which requires local arrays and local indices
// this function fills up an aiMesh with those temporary lists
void M3DImporter::populateMesh(const M3DWrapper &m3d, aiMesh *pMesh, std::vector<aiFace> *faces, std::vector<aiVector3D> *vertices,
std::vector<aiVector3D> *normals, std::vector<aiVector3D> *texcoords, std::vector<aiColor4D> *colors,

10
code/AssetLib/M3D/m3d.h
View File

@ -59,7 +59,7 @@ extern "C" {
#ifndef M3D_DOUBLE
typedef float M3D_FLOAT;
#ifndef M3D_EPSILON
/* carefully choosen for IEEE 754 don't change */
/* carefully chosen for IEEE 754 don't change */
#define M3D_EPSILON ((M3D_FLOAT)1e-7)
#endif
#else
@ -121,7 +121,7 @@ typedef uint16_t M3D_INDEX;
* TMAP texture map chunk (optional)
* VRTS vertex data chunk (optional if it's a material library)
* BONE bind-pose skeleton, bone hierarchy chunk (optional)
* n x m3db_t contains propably more, but at least one bone
* n x m3db_t contains probably more, but at least one bone
* n x m3ds_t skin group records
* MTRL* material chunk(s), can be more (optional)
* n x m3dp_t each material contains propapbly more, but at least one property
@ -1109,7 +1109,7 @@ void _m3d_inv(M3D_FLOAT *m) {
r[15] = det * (m[0] * (m[5] * m[10] - m[6] * m[9]) + m[1] * (m[6] * m[8] - m[4] * m[10]) + m[2] * (m[4] * m[9] - m[5] * m[8]));
memcpy(m, &r, sizeof(r));
}
/* compose a coloumn major 4 x 4 matrix from vec3 position and vec4 orientation/rotation quaternion */
/* compose a column major 4 x 4 matrix from vec3 position and vec4 orientation/rotation quaternion */
void _m3d_mat(M3D_FLOAT *r, m3dv_t *p, m3dv_t *q) {
if (q->x == (M3D_FLOAT)0.0 && q->y == (M3D_FLOAT)0.0 && q->z >= (M3D_FLOAT)0.7071065 && q->z <= (M3D_FLOAT)0.7071075 &&
q->w == (M3D_FLOAT)0.0) {
@ -4033,7 +4033,7 @@ unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size
out[len] = 0;
} else
{
/* stricly only use LF (newline) in binary */
/* strictly only use LF (newline) in binary */
sd = _m3d_safestr(model->desc, 3);
if (!sd) goto memerr;
/* header */
@ -4608,7 +4608,7 @@ unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size
h = (m3dhdr_t *)z;
}
}
/* add file header at the begining */
/* add file header at the beginning */
len += 8;
out = (unsigned char *)M3D_MALLOC(len);
if (!out) goto memerr;

2
code/AssetLib/MD3/MD3FileData.h
View File

@ -271,7 +271,7 @@ inline void LatLngNormalToVec3(uint16_t p_iNormal, ai_real* p_afOut)
// -------------------------------------------------------------------------------
/** @brief Pack a Q3 normal into 16bit latitute/longitude representation
/** @brief Pack a Q3 normal into 16bit latitude/longitude representation
* @param p_vIn Input vector
* @param p_iOut Output normal
*

2
code/AssetLib/MD5/MD5Parser.cpp
View File

@ -59,7 +59,7 @@ using namespace Assimp;
using namespace Assimp::MD5;
// ------------------------------------------------------------------------------------------------
// Parse the segment structure fo a MD5 file
// Parse the segment structure for an MD5 file
MD5Parser::MD5Parser(char *_buffer, unsigned int _fileSize) {
ai_assert(nullptr != _buffer);
ai_assert(0 != _fileSize);

4
code/AssetLib/MDL/MDLMaterialLoader.cpp
View File

@ -387,7 +387,7 @@ void MDLImporter::CreateTexture_3DGS_MDL5(const unsigned char *szData,
// this should not occur - at least the docs say it shouldn't.
// however, one can easily try out what MED does if you have
// a model with a DDS texture and export it to MDL5 ...
// yeah, it embedds the DDS file.
// yeah, it embeds the DDS file.
if (6 == iType) {
// this is a compressed texture in DDS format
*piSkip = pcNew->mWidth;
@ -524,7 +524,7 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
}
// sometimes there are MDL7 files which have a monochrome
// texture instead of material colors ... posssible they have
// texture instead of material colors ... possible they have
// been converted to MDL7 from other formats, such as MDL5
aiColor4D clrTexture;
if (pcNew)

4
code/AssetLib/MMD/MMDPmdParser.h
View File

@ -195,7 +195,7 @@ namespace pmd
public:
uint16_t ik_bone_index;
uint16_t target_bone_index;
uint16_t interations;
uint16_t iterations;
float angle_limit;
std::vector<uint16_t> ik_child_bone_index;
@ -205,7 +205,7 @@ namespace pmd
stream->read((char *) &target_bone_index, sizeof(uint16_t));
uint8_t ik_chain_length;
stream->read((char*) &ik_chain_length, sizeof(uint8_t));
stream->read((char *) &interations, sizeof(uint16_t));
stream->read((char *) &iterations, sizeof(uint16_t));
stream->read((char *) &angle_limit, sizeof(float));
ik_child_bone_index.resize(ik_chain_length);
for (int i = 0; i < ik_chain_length; i++)

2
code/AssetLib/MMD/MMDVmdParser.h
View File

@ -358,7 +358,7 @@ namespace vmd
light_frames[i].Write(stream);
}
// self shadow datas
// self shadow data
const int self_shadow_num = 0;
stream->write(reinterpret_cast<const char*>(&self_shadow_num), sizeof(int));

2
code/AssetLib/OFF/OFFLoader.cpp
View File

@ -233,7 +233,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
sz = fast_atoreal_move<ai_real>(sz, *vec[dim]);
}
// if has homogenous coordinate, divide others by this one
// if has homogeneous coordinate, divide others by this one
if (hasHomogenous) {
SkipSpaces(&sz);
ai_real w = 1.;

2
code/AssetLib/Obj/ObjFileData.h
View File

@ -233,7 +233,7 @@ struct Mesh {
// ------------------------------------------------------------------------------------------------
//! \struct Model
//! \brief Data structure to store all obj-specific model datas
//! \brief Data structure to store all obj-specific model data
// ------------------------------------------------------------------------------------------------
struct Model {
using GroupMap = std::map<std::string, std::vector<unsigned int> *>;

2
code/AssetLib/Ogre/OgreStructs.h
View File

@ -555,7 +555,7 @@ public:
should be 0 after this reset. */
void Reset();
/// Covert to Assimp mesh.
/// Convert to Assimp mesh.
aiMesh *ConvertToAssimpMesh(Mesh *parent);
/// Vertex data.

4
code/AssetLib/OpenGEX/OpenGEXImporter.cpp
View File

@ -351,8 +351,8 @@ void OpenGEXImporter::handleNodes(DDLNode *node, aiScene *pScene) {
return;
}
DDLNode::DllNodeList childs = node->getChildNodeList();
for (DDLNode::DllNodeList::iterator it = childs.begin(); it != childs.end(); ++it) {
DDLNode::DllNodeList children = node->getChildNodeList();
for (DDLNode::DllNodeList::iterator it = children.begin(); it != children.end(); ++it) {
Grammar::TokenType tokenType(Grammar::matchTokenType((*it)->getType().c_str()));
switch (tokenType) {
case Grammar::MetricToken:

2
code/AssetLib/Q3BSP/Q3BSPFileData.h
View File

@ -95,7 +95,7 @@ struct sQ3BSPVertex {
vec3f vPosition; ///< Position of vertex
vec2f vTexCoord; ///< (u,v) Texturecoordinate of detailtexture
vec2f vLightmap; ///< (u,v) Texturecoordinate of lightmap
vec3f vNormal; ///< vertex normale
vec3f vNormal; ///< vertex normal
unsigned char bColor[ 4 ]; ///< Color in RGBA
};

2
code/AssetLib/SMD/SMDLoader.cpp
View File

@ -868,7 +868,7 @@ void SMDImporter::ParseNodeInfo(const char* szCurrent, const char** szCurrentOut
bool bQuota = true;
if ('\"' != *szCurrent) {
LogWarning("Bone name is expcted to be enclosed in "
LogWarning("Bone name is expected to be enclosed in "
"double quotation marks. ");
bQuota = false;
} else {

2
code/AssetLib/X/XFileImporter.cpp
View File

@ -219,7 +219,7 @@ aiNode* XFileImporter::CreateNodes( aiScene* pScene, aiNode* pParent, const XFil
// convert meshes from the source node
CreateMeshes( pScene, node, pNode->mMeshes);
// handle childs
// handle children
if( !pNode->mChildren.empty() ) {
node->mNumChildren = (unsigned int)pNode->mChildren.size();
node->mChildren = new aiNode* [node->mNumChildren];

6
code/AssetLib/X3D/X3DExporter.cpp
View File

@ -279,7 +279,7 @@ void X3DExporter::Export_Mesh(const size_t pIdxMesh, const size_t pTabLevel) {
const char *NodeName_Shape = "Shape";
list<SAttribute> attr_list;
aiMesh &mesh = *mScene->mMeshes[pIdxMesh]; // create alias for conveniance.
aiMesh &mesh = *mScene->mMeshes[pIdxMesh]; // create alias for convenience.
// Check if mesh already defined early.
if (mDEF_Map_Mesh.find(pIdxMesh) != mDEF_Map_Mesh.end()) {
@ -375,7 +375,7 @@ void X3DExporter::Export_Material(const size_t pIdxMaterial, const size_t pTabLe
const char *NodeName_A = "Appearance";
list<SAttribute> attr_list;
aiMaterial &material = *mScene->mMaterials[pIdxMaterial]; // create alias for conveniance.
aiMaterial &material = *mScene->mMaterials[pIdxMaterial]; // create alias for convenience.
// Check if material already defined early.
if (mDEF_Map_Material.find(pIdxMaterial) != mDEF_Map_Material.end()) {
@ -586,7 +586,7 @@ bool X3DExporter::CheckAndExport_Light(const aiNode &pNode, const size_t pTabLev
if (!found) return false;
// Light source is found.
const aiLight &light = *mScene->mLights[idx_light]; // Alias for conveniance.
const aiLight &light = *mScene->mLights[idx_light]; // Alias for convenience.
aiMatrix4x4 trafo_mat = Matrix_GlobalToCurrent(pNode).Inverse();

28
code/AssetLib/glTF2/glTF2Asset.h
View File

@ -49,6 +49,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* KHR_materials_sheen full
* KHR_materials_clearcoat full
* KHR_materials_transmission full
* KHR_materials_volume full
* KHR_materials_ior full
*/
#ifndef GLTF2ASSET_H_INC
#define GLTF2ASSET_H_INC
@ -714,6 +716,7 @@ const vec3 defaultEmissiveFactor = { 0, 0, 0 };
const vec4 defaultDiffuseFactor = { 1, 1, 1, 1 };
const vec3 defaultSpecularFactor = { 1, 1, 1 };
const vec3 defaultSheenFactor = { 0, 0, 0 };
const vec3 defaultAttenuationColor = { 1, 1, 1 };
struct TextureInfo {
Ref<Texture> texture;
@ -778,6 +781,23 @@ struct MaterialTransmission {
float transmissionFactor = 0.f;
};
struct MaterialVolume {
float thicknessFactor = 0.f;
TextureInfo thicknessTexture;
float attenuationDistance = 0.f;
vec3 attenuationColor;
MaterialVolume() { SetDefaults(); }
void SetDefaults();
};
struct MaterialIOR {
float ior = 0.f;
MaterialIOR() { SetDefaults(); }
void SetDefaults();
};
//! The material appearance of a primitive.
struct Material : public Object {
//PBR metallic roughness properties
@ -804,6 +824,12 @@ struct Material : public Object {
//extension: KHR_materials_transmission
Nullable<MaterialTransmission> materialTransmission;
//extension: KHR_materials_volume
Nullable<MaterialVolume> materialVolume;
//extension: KHR_materials_ior
Nullable<MaterialIOR> materialIOR;
//extension: KHR_materials_unlit
bool unlit;
@ -1093,6 +1119,8 @@ public:
bool KHR_materials_sheen;
bool KHR_materials_clearcoat;
bool KHR_materials_transmission;
bool KHR_materials_volume;
bool KHR_materials_ior;
bool KHR_draco_mesh_compression;
bool FB_ngon_encoding;
bool KHR_texture_basisu;

37
code/AssetLib/glTF2/glTF2Asset.inl
View File

@ -1215,6 +1215,29 @@ inline void Material::Read(Value &material, Asset &r) {
}
}
if (r.extensionsUsed.KHR_materials_volume) {
if (Value *curMaterialVolume = FindObject(*extensions, "KHR_materials_volume")) {
MaterialVolume volume;
ReadMember(*curMaterialVolume, "thicknessFactor", volume.thicknessFactor);
ReadTextureProperty(r, *curMaterialVolume, "thicknessTexture", volume.thicknessTexture);
ReadMember(*curMaterialVolume, "attenuationDistance", volume.attenuationDistance);
ReadMember(*curMaterialVolume, "attenuationColor", volume.attenuationColor);
this->materialVolume = Nullable<MaterialVolume>(volume);
}
}
if (r.extensionsUsed.KHR_materials_ior) {
if (Value *curMaterialIOR = FindObject(*extensions, "KHR_materials_ior")) {
MaterialIOR ior;
ReadMember(*curMaterialIOR, "ior", ior.ior);
this->materialIOR = Nullable<MaterialIOR>(ior);
}
}
unlit = nullptr != FindObject(*extensions, "KHR_materials_unlit");
}
}
@ -1260,6 +1283,18 @@ inline void MaterialSheen::SetDefaults() {
sheenRoughnessFactor = 0.f;
}
inline void MaterialVolume::SetDefaults() {
//KHR_materials_volume properties
thicknessFactor = 0.f;
attenuationDistance = INFINITY;
SetVector(attenuationColor, defaultAttenuationColor);
}
inline void MaterialIOR::SetDefaults() {
//KHR_materials_ior properties
ior = 1.5f;
}
namespace {
template <int N>
@ -1975,6 +2010,8 @@ inline void Asset::ReadExtensionsUsed(Document &doc) {
CHECK_EXT(KHR_materials_sheen);
CHECK_EXT(KHR_materials_clearcoat);
CHECK_EXT(KHR_materials_transmission);
CHECK_EXT(KHR_materials_volume);
CHECK_EXT(KHR_materials_ior);
CHECK_EXT(KHR_draco_mesh_compression);
CHECK_EXT(KHR_texture_basisu);

2
code/AssetLib/glTF2/glTF2AssetWriter.h
View File

@ -49,6 +49,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* KHR_materials_sheen: full
* KHR_materials_clearcoat: full
* KHR_materials_transmission: full
* KHR_materials_volume: full
* KHR_materials_ior: full
*/
#ifndef GLTF2ASSETWRITER_H_INC
#define GLTF2ASSETWRITER_H_INC

44
code/AssetLib/glTF2/glTF2AssetWriter.inl
View File

@ -474,6 +474,42 @@ namespace glTF2 {
}
}
if (m.materialVolume.isPresent) {
Value materialVolume(rapidjson::Type::kObjectType);
MaterialVolume &volume = m.materialVolume.value;
if (volume.thicknessFactor != 0.f) {
WriteFloat(materialVolume, volume.thicknessFactor, "thicknessFactor", w.mAl);
}
WriteTex(materialVolume, volume.thicknessTexture, "thicknessTexture", w.mAl);
if (volume.attenuationDistance != INFINITY) {
WriteFloat(materialVolume, volume.attenuationDistance, "attenuationDistance", w.mAl);
}
WriteVec(materialVolume, volume.attenuationColor, "attenuationColor", defaultAttenuationColor, w.mAl);
if (!materialVolume.ObjectEmpty()) {
exts.AddMember("KHR_materials_volume", materialVolume, w.mAl);
}
}
if (m.materialIOR.isPresent) {
Value materialIOR(rapidjson::Type::kObjectType);
MaterialIOR &ior = m.materialIOR.value;
if (ior.ior != 1.5f) {
WriteFloat(materialIOR, ior.ior, "ior", w.mAl);
}
if (!materialIOR.ObjectEmpty()) {
exts.AddMember("KHR_materials_ior", materialIOR, w.mAl);
}
}
if (!exts.ObjectEmpty()) {
obj.AddMember("extensions", exts, w.mAl);
}
@ -890,6 +926,14 @@ namespace glTF2 {
exts.PushBack(StringRef("KHR_materials_transmission"), mAl);
}
if (this->mAsset.extensionsUsed.KHR_materials_volume) {
exts.PushBack(StringRef("KHR_materials_volume"), mAl);
}
if (this->mAsset.extensionsUsed.KHR_materials_ior) {
exts.PushBack(StringRef("KHR_materials_ior"), mAl);
}
if (this->mAsset.extensionsUsed.FB_ngon_encoding) {
exts.PushBack(StringRef("FB_ngon_encoding"), mAl);
}

28
code/AssetLib/glTF2/glTF2Exporter.cpp
View File

@ -704,6 +704,22 @@ bool glTF2Exporter::GetMatTransmission(const aiMaterial &mat, glTF2::MaterialTra
return result || transmission.transmissionTexture.texture;
}
bool glTF2Exporter::GetMatVolume(const aiMaterial &mat, glTF2::MaterialVolume &volume) {
bool result = mat.Get(AI_MATKEY_VOLUME_THICKNESS_FACTOR, volume.thicknessFactor) != aiReturn_SUCCESS;
GetMatTex(mat, volume.thicknessTexture, AI_MATKEY_VOLUME_THICKNESS_TEXTURE);
result = result || mat.Get(AI_MATKEY_VOLUME_ATTENUATION_DISTANCE, volume.attenuationDistance);
result = result || GetMatColor(mat, volume.attenuationColor, AI_MATKEY_VOLUME_ATTENUATION_COLOR) != aiReturn_SUCCESS;
// Valid if any of these properties are available
return result || volume.thicknessTexture.texture;
}
bool glTF2Exporter::GetMatIOR(const aiMaterial &mat, glTF2::MaterialIOR &ior) {
return mat.Get(AI_MATKEY_REFRACTI, ior.ior) == aiReturn_SUCCESS;
}
void glTF2Exporter::ExportMaterials() {
aiString aiName;
for (unsigned int i = 0; i < mScene->mNumMaterials; ++i) {
@ -824,6 +840,18 @@ void glTF2Exporter::ExportMaterials() {
mAsset->extensionsUsed.KHR_materials_transmission = true;
m->materialTransmission = Nullable<MaterialTransmission>(transmission);
}
MaterialVolume volume;
if (GetMatVolume(mat, volume)) {
mAsset->extensionsUsed.KHR_materials_volume = true;
m->materialVolume = Nullable<MaterialVolume>(volume);
}
MaterialIOR ior;
if (GetMatIOR(mat, ior)) {
mAsset->extensionsUsed.KHR_materials_ior = true;
m->materialIOR = Nullable<MaterialIOR>(ior);
}
}
}
}

4
code/AssetLib/glTF2/glTF2Exporter.h
View File

@ -77,6 +77,8 @@ struct PbrSpecularGlossiness;
struct MaterialSheen;
struct MaterialClearcoat;
struct MaterialTransmission;
struct MaterialVolume;
struct MaterialIOR;
// Vec/matrix types, as raw float arrays
typedef float(vec2)[2];
@ -114,6 +116,8 @@ protected:
bool GetMatSheen(const aiMaterial &mat, glTF2::MaterialSheen &sheen);
bool GetMatClearcoat(const aiMaterial &mat, glTF2::MaterialClearcoat &clearcoat);
bool GetMatTransmission(const aiMaterial &mat, glTF2::MaterialTransmission &transmission);
bool GetMatVolume(const aiMaterial &mat, glTF2::MaterialVolume &volume);
bool GetMatIOR(const aiMaterial &mat, glTF2::MaterialIOR &ior);
void ExportMetadata();
void ExportMaterials();
void ExportMeshes();

19
code/AssetLib/glTF2/glTF2Importer.cpp
View File

@ -309,7 +309,7 @@ static aiMaterial *ImportMaterial(std::vector<int> &embeddedTexIdxs, Asset &r, M
if (mat.materialSheen.isPresent) {
MaterialSheen &sheen = mat.materialSheen.value;
// Default value {0,0,0} disables Sheen
if (sheen.sheenColorFactor != defaultSheenFactor) {
if (std::memcmp(sheen.sheenColorFactor, defaultSheenFactor, sizeof(glTFCommon::vec3)) != 0) {
SetMaterialColorProperty(r, sheen.sheenColorFactor, aimat, AI_MATKEY_SHEEN_COLOR_FACTOR);
aimat->AddProperty(&sheen.sheenRoughnessFactor, 1, AI_MATKEY_SHEEN_ROUGHNESS_FACTOR);
SetMaterialTextureProperty(embeddedTexIdxs, r, sheen.sheenColorTexture, aimat, AI_MATKEY_SHEEN_COLOR_TEXTURE);
@ -338,6 +338,23 @@ static aiMaterial *ImportMaterial(std::vector<int> &embeddedTexIdxs, Asset &r, M
SetMaterialTextureProperty(embeddedTexIdxs, r, transmission.transmissionTexture, aimat, AI_MATKEY_TRANSMISSION_TEXTURE);
}
// KHR_materials_volume
if (mat.materialVolume.isPresent) {
MaterialVolume &volume = mat.materialVolume.value;
aimat->AddProperty(&volume.thicknessFactor, 1, AI_MATKEY_VOLUME_THICKNESS_FACTOR);
SetMaterialTextureProperty(embeddedTexIdxs, r, volume.thicknessTexture, aimat, AI_MATKEY_VOLUME_THICKNESS_TEXTURE);
aimat->AddProperty(&volume.attenuationDistance, 1, AI_MATKEY_VOLUME_ATTENUATION_DISTANCE);
SetMaterialColorProperty(r, volume.attenuationColor, aimat, AI_MATKEY_VOLUME_ATTENUATION_COLOR);
}
// KHR_materials_ior
if (mat.materialIOR.isPresent) {
MaterialIOR &ior = mat.materialIOR.value;
aimat->AddProperty(&ior.ior, 1, AI_MATKEY_REFRACTI);
}
return aimat;
} catch (...) {
delete aimat;

2
code/Common/BaseImporter.cpp
View File

@ -207,7 +207,7 @@ void BaseImporter::GetExtensionList(std::set<std::string> &extensions) {
if (!r) {
continue;
}
// We need to make sure that we didn't accidentially identify the end of another token as our token,
// We need to make sure that we didn't accidentally identify the end of another token as our token,
// e.g. in a previous version the "gltf " present in some gltf files was detected as "f "
if (noAlphaBeforeTokens && (r != buffer && isalpha(static_cast<unsigned char>(r[-1])))) {
continue;

1
code/Common/ImporterRegistry.cpp
View File

@ -46,6 +46,7 @@ directly (unless you are adding new loaders), instead use the
corresponding preprocessor flag to selectively disable formats.
*/
#include <assimp/anim.h>
#include <assimp/BaseImporter.h>
#include <vector>
#include <cstdlib>

4
code/Common/SGSpatialSort.cpp
View File

@ -52,7 +52,7 @@ using namespace Assimp;
// ------------------------------------------------------------------------------------------------
SGSpatialSort::SGSpatialSort()
{
// define the reference plane. We choose some arbitrary vector away from all basic axises
// define the reference plane. We choose some arbitrary vector away from all basic axes
// in the hope that no model spreads all its vertices along this plane.
mPlaneNormal.Set( 0.8523f, 0.34321f, 0.5736f);
mPlaneNormal.Normalize();
@ -121,7 +121,7 @@ void SGSpatialSort::FindPositions( const aiVector3D& pPosition,
index++;
// Mow start iterating from there until the first position lays outside of the distance range.
// Add all positions inside the distance range within the given radius to the result aray
// Add all positions inside the distance range within the given radius to the result array
float squareEpsilon = pRadius * pRadius;
std::vector<Entry>::const_iterator it = mPositions.begin() + index;

42
code/Common/SpatialSort.cpp
View File

@ -55,17 +55,19 @@ const aiVector3D PlaneInit(0.8523f, 0.34321f, 0.5736f);
// ------------------------------------------------------------------------------------------------
// Constructs a spatially sorted representation from the given position array.
// define the reference plane. We choose some arbitrary vector away from all basic axises
// define the reference plane. We choose some arbitrary vector away from all basic axes
// in the hope that no model spreads all its vertices along this plane.
SpatialSort::SpatialSort(const aiVector3D *pPositions, unsigned int pNumPositions, unsigned int pElementOffset) :
mPlaneNormal(PlaneInit) {
mPlaneNormal(PlaneInit),
mFinalized(false) {
mPlaneNormal.Normalize();
Fill(pPositions, pNumPositions, pElementOffset);
}
// ------------------------------------------------------------------------------------------------
SpatialSort::SpatialSort() :
mPlaneNormal(PlaneInit) {
mPlaneNormal(PlaneInit),
mFinalized(false) {
mPlaneNormal.Normalize();
}
@ -80,28 +82,41 @@ void SpatialSort::Fill(const aiVector3D *pPositions, unsigned int pNumPositions,
unsigned int pElementOffset,
bool pFinalize /*= true */) {
mPositions.clear();
mFinalized = false;
Append(pPositions, pNumPositions, pElementOffset, pFinalize);
mFinalized = pFinalize;
}
// ------------------------------------------------------------------------------------------------
ai_real SpatialSort::CalculateDistance(const aiVector3D &pPosition) const {
return (pPosition - mCentroid) * mPlaneNormal;
}
// ------------------------------------------------------------------------------------------------
void SpatialSort::Finalize() {
const ai_real scale = 1.0f / mPositions.size();
for (unsigned int i = 0; i < mPositions.size(); i++) {
mCentroid += scale * mPositions[i].mPosition;
}
for (unsigned int i = 0; i < mPositions.size(); i++) {
mPositions[i].mDistance = CalculateDistance(mPositions[i].mPosition);
}
std::sort(mPositions.begin(), mPositions.end());
mFinalized = true;
}
// ------------------------------------------------------------------------------------------------
void SpatialSort::Append(const aiVector3D *pPositions, unsigned int pNumPositions,
unsigned int pElementOffset,
bool pFinalize /*= true */) {
ai_assert(!mFinalized && "You cannot add positions to the SpatialSort object after it has been finalized.");
// store references to all given positions along with their distance to the reference plane
const size_t initial = mPositions.size();
mPositions.reserve(initial + (pFinalize ? pNumPositions : pNumPositions * 2));
mPositions.reserve(initial + pNumPositions);
for (unsigned int a = 0; a < pNumPositions; a++) {
const char *tempPointer = reinterpret_cast<const char *>(pPositions);
const aiVector3D *vec = reinterpret_cast<const aiVector3D *>(tempPointer + a * pElementOffset);
// store position by index and distance
ai_real distance = *vec * mPlaneNormal;
mPositions.push_back(Entry(static_cast<unsigned int>(a + initial), *vec, distance));
mPositions.push_back(Entry(static_cast<unsigned int>(a + initial), *vec));
}
if (pFinalize) {
@ -114,7 +129,8 @@ void SpatialSort::Append(const aiVector3D *pPositions, unsigned int pNumPosition
// Returns an iterator for all positions close to the given position.
void SpatialSort::FindPositions(const aiVector3D &pPosition,
ai_real pRadius, std::vector<unsigned int> &poResults) const {
const ai_real dist = pPosition * mPlaneNormal;
ai_assert(mFinalized && "The SpatialSort object must be finalized before FindPositions can be called.");
const ai_real dist = CalculateDistance(pPosition);
const ai_real minDist = dist - pRadius, maxDist = dist + pRadius;
// clear the array
@ -148,7 +164,7 @@ void SpatialSort::FindPositions(const aiVector3D &pPosition,
index++;
// Mow start iterating from there until the first position lays outside of the distance range.
// Add all positions inside the distance range within the given radius to the result aray
// Add all positions inside the distance range within the given radius to the result array
std::vector<Entry>::const_iterator it = mPositions.begin() + index;
const ai_real pSquared = pRadius * pRadius;
while (it->mDistance < maxDist) {
@ -229,6 +245,7 @@ BinFloat ToBinary(const ai_real &pValue) {
// Fills an array with indices of all positions identical to the given position. In opposite to
// FindPositions(), not an epsilon is used but a (very low) tolerance of four floating-point units.
void SpatialSort::FindIdenticalPositions(const aiVector3D &pPosition, std::vector<unsigned int> &poResults) const {
ai_assert(mFinalized && "The SpatialSort object must be finalized before FindIdenticalPositions can be called.");
// Epsilons have a huge disadvantage: they are of constant precision, while floating-point
// values are of log2 precision. If you apply e=0.01 to 100, the epsilon is rather small, but
// if you apply it to 0.001, it is enormous.
@ -254,7 +271,7 @@ void SpatialSort::FindIdenticalPositions(const aiVector3D &pPosition, std::vecto
// Convert the plane distance to its signed integer representation so the ULPs tolerance can be
// applied. For some reason, VC won't optimize two calls of the bit pattern conversion.
const BinFloat minDistBinary = ToBinary(pPosition * mPlaneNormal) - distanceToleranceInULPs;
const BinFloat minDistBinary = ToBinary(CalculateDistance(pPosition)) - distanceToleranceInULPs;
const BinFloat maxDistBinary = minDistBinary + 2 * distanceToleranceInULPs;
// clear the array in this strange fashion because a simple clear() would also deallocate
@ -297,13 +314,14 @@ void SpatialSort::FindIdenticalPositions(const aiVector3D &pPosition, std::vecto
// ------------------------------------------------------------------------------------------------
unsigned int SpatialSort::GenerateMappingTable(std::vector<unsigned int> &fill, ai_real pRadius) const {
ai_assert(mFinalized && "The SpatialSort object must be finalized before GenerateMappingTable can be called.");
fill.resize(mPositions.size(), UINT_MAX);
ai_real dist, maxDist;
unsigned int t = 0;
const ai_real pSquared = pRadius * pRadius;
for (size_t i = 0; i < mPositions.size();) {
dist = mPositions[i].mPosition * mPlaneNormal;
dist = (mPositions[i].mPosition - mCentroid) * mPlaneNormal;
maxDist = dist + pRadius;
fill[mPositions[i].mIndex] = t;

2
code/Pbrt/PbrtExporter.cpp
View File

@ -614,7 +614,7 @@ void PbrtExporter::WriteMaterial(int m) {
eta != 1);
mOutput << "# - Constants: diffuse " << constantDiffuse << " specular " << constantSpecular <<
" transprency " << constantTransparency << " opacity " << constantOpacity <<
" transparency " << constantTransparency << " opacity " << constantOpacity <<
" shininess " << constantShininess << " shininess strength " << constantShininessStrength <<
" eta " << constantEta << "\n";

2
code/PostProcessing/RemoveVCProcess.cpp
View File

@ -67,7 +67,7 @@ bool RemoveVCProcess::IsActive(unsigned int pFlags) const {
}
// ------------------------------------------------------------------------------------------------
// Small helper function to delete all elements in a T** aray using delete
// Small helper function to delete all elements in a T** array using delete
template <typename T>
inline void ArrayDelete(T **&in, unsigned int &num) {
for (unsigned int i = 0; i < num; ++i)

2
code/PostProcessing/ScaleProcess.cpp
View File

@ -118,7 +118,7 @@ void ScaleProcess::Execute( aiScene* pScene ) {
{
aiMesh *mesh = pScene->mMeshes[meshID];
// Reconstruct mesh vertexes to the new unit system
// Reconstruct mesh vertices to the new unit system
for( unsigned int vertexID = 0; vertexID < mesh->mNumVertices; vertexID++)
{
aiVector3D& vertex = mesh->mVertices[vertexID];

2
code/PostProcessing/SplitLargeMeshes.cpp
View File

@ -129,7 +129,7 @@ void SplitLargeMeshesProcess_Triangle::UpdateNode(aiNode* pcNode,
pcNode->mMeshes[b] = aiEntries[b];
}
// recusively update all other nodes
// recursively update all other nodes
for (unsigned int i = 0; i < pcNode->mNumChildren;++i) {
UpdateNode ( pcNode->mChildren[i], avList );
}

2
code/PostProcessing/TextureTransform.cpp
View File

@ -539,7 +539,7 @@ void TextureTransformStep::Execute( aiScene* pScene)
m5.a3 += trl.x; m5.b3 += trl.y;
matrix = m2 * m4 * matrix * m3 * m5;
for (src = dest; src != end; ++src) { /* manual homogenious divide */
for (src = dest; src != end; ++src) { /* manual homogeneous divide */
src->z = 1.f;
*src = matrix * *src;
src->x /= src->z;

139
contrib/irrXML/fast_atof.h
View File

@ -1,139 +0,0 @@
// Copyright (C) 2002-2005 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine" and the "irrXML" project.
// For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
#ifndef __FAST_A_TO_F_H_INCLUDED__
#define __FAST_A_TO_F_H_INCLUDED__
#include <stdlib.h>
#include <math.h>
namespace irr
{
namespace core
{
const float fast_atof_table[] = {
0.f,
0.1f,
0.01f,
0.001f,
0.0001f,
0.00001f,
0.000001f,
0.0000001f,
0.00000001f,
0.000000001f,
0.0000000001f,
0.00000000001f,
0.000000000001f,
0.0000000000001f,
0.00000000000001f,
0.000000000000001f
};
//! Provides a fast function for converting a string into a float,
//! about 6 times faster than atof in win32.
// If you find any bugs, please send them to me, niko (at) irrlicht3d.org.
inline char* fast_atof_move(char* c, float& out)
{
bool inv = false;
char *t;
float f;
if (*c=='-')
{
c++;
inv = true;
}
f = (float)strtol(c, &t, 10);
c = t;
if (*c == '.')
{
c++;
float pl = (float)strtol(c, &t, 10);
pl *= fast_atof_table[t-c];
f += pl;
c = t;
if (*c == 'e')
{
++c;
float exp = (float)strtol(c, &t, 10);
f *= (float)pow(10.0f, exp);
c = t;
}
}
if (inv)
f *= -1.0f;
out = f;
return c;
}
//! Provides a fast function for converting a string into a float,
//! about 6 times faster than atof in win32.
// If you find any bugs, please send them to me, niko (at) irrlicht3d.org.
inline const char* fast_atof_move_const(const char* c, float& out)
{
bool inv = false;
char *t;
float f;
if (*c=='-')
{
c++;
inv = true;
}
f = (float)strtol(c, &t, 10);
c = t;
if (*c == '.')
{
c++;
float pl = (float)strtol(c, &t, 10);
pl *= fast_atof_table[t-c];
f += pl;
c = t;
if (*c == 'e')
{
++c;
f32 exp = (f32)strtol(c, &t, 10);
f *= (f32)powf(10.0f, exp);
c = t;
}
}
if (inv)
f *= -1.0f;
out = f;
return c;
}
inline float fast_atof(const char* c)
{
float ret;
fast_atof_move_const(c, ret);
return ret;
}
} // end namespace core
}// end namespace irr
#endif

10
doc/dox.h
View File

@ -85,7 +85,7 @@ as long as you retain the license information and take own responsibility for wh
the LICENSE file.
You can find test models for almost all formats in the <assimp_root>/test/models directory. Beware, they're *free*,
but not all of them are *open-source*. If there's an accompagning '<file>\source.txt' file don't forget to read it.
but not all of them are *open-source*. If there's an accompanying '<file>\source.txt' file don't forget to read it.
@section main_install Installation
@ -687,7 +687,7 @@ There are two cases:
format such as DDS or PNG. The term "compressed" does not mean that the texture data must
actually be compressed, however the texture was found in the model file as if it was stored in a
separate file on the harddisk. Appropriate decoders (such as libjpeg, libpng, D3DX, DevIL) are
required to load theses textures. aiTexture::mWidth specifies the size of the texture data in
required to load these textures. aiTexture::mWidth specifies the size of the texture data in
bytes, aiTexture::pcData is a pointer to the raw image data and aiTexture::achFormatHint is
either zeroed or contains the most common file extension of the embedded texture's format. This
value is only set if assimp is able to determine the file format.
@ -1181,7 +1181,7 @@ You can get assigned shader sources by using the following material keys:
<li>AI_MATKEY_SHADER_VERTEX</li> Assigned vertex shader code stored as a string.
<li>AI_MATKEY_SHADER_FRAGMENT</li> Assigned fragment shader code stored as a string.
<li>AI_MATKEY_SHADER_GEO</li> Assigned geometry shader code stored as a string.
<li>AI_MATKEY_SHADER_TESSELATION</li> Assigned tesselation shader code stored as a string.
<li>AI_MATKEY_SHADER_TESSELATION</li> Assigned tessellation shader code stored as a string.
<li>AI_MATKEY_SHADER_PRIMITIVE</li> Assigned primitive shader code stored as a string.
<li>AI_MATKEY_SHADER_COMPUTE</li> Assigned compute shader code stored as a string.
@ -1359,7 +1359,7 @@ When filing bugs on the Blender loader, always give the Blender version (or, eve
This section contains implementation notes on the IFC-STEP importer.
@subsection ifc_overview Overview
The library provides a partial implementation of the IFC2x3 industry standard for automatized exchange of CAE/architectural
The library provides a partial implementation of the IFC2x3 industry standard for automated exchange of CAE/architectural
data sets. See http://en.wikipedia.org/wiki/Industry_Foundation_Classes for more information on the format. We aim
at getting as much 3D data out of the files as possible.
@ -1503,7 +1503,7 @@ like Windows and Linux ( 32 bit and 64 bit ).
</li>
<li>
Provide some _free_ test models in <tt>&lt;root&gt;/test/models/&lt;FormatName&gt;/</tt> and credit their authors.
Test files for a file format shouldn't be too large (<i>~500 KiB in total</i>), and not too repetive. Try to cover all format features with test data.
Test files for a file format shouldn't be too large (<i>~500 KiB in total</i>), and not too repetitive. Try to cover all format features with test data.
</li>
<li>
Done! Please, share your loader that everyone can profit from it!

2
include/assimp/ByteSwapper.h
View File

@ -40,7 +40,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------
*/
/** @file Helper class tp perform various byte oder swappings
/** @file Helper class tp perform various byte order swappings
(e.g. little to big endian) */
#pragma once
#ifndef AI_BYTESWAPPER_H_INC

2
include/assimp/LogAux.h
View File

@ -56,7 +56,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
namespace Assimp {
/// @brief Logger class, which will exten the class by log-functions.
/// @brief Logger class, which will extend the class by log-functions.
/// @tparam TDeriving
template<class TDeriving>
class LogFunctions {

2
include/assimp/MemoryIOWrapper.h
View File

@ -41,7 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/** @file MemoryIOWrapper.h
* Handy IOStream/IOSystem implemetation to read directly from a memory buffer */
* Handy IOStream/IOSystem implementation to read directly from a memory buffer */
#pragma once
#ifndef AI_MEMORYIOSTREAM_H_INC
#define AI_MEMORYIOSTREAM_H_INC

27
include/assimp/SpatialSort.h
View File

@ -51,6 +51,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/types.h>
#include <vector>
#include <limits>
namespace Assimp {
@ -142,24 +143,35 @@ public:
ai_real pRadius) const;
protected:
/** Normal of the sorting plane, normalized. The center is always at (0, 0, 0) */
/** Return the distance to the sorting plane. */
ai_real CalculateDistance(const aiVector3D &pPosition) const;
protected:
/** Normal of the sorting plane, normalized.
*/
aiVector3D mPlaneNormal;
/** The centroid of the positions, which is used as a point on the sorting plane
* when calculating distance. This value is calculated in Finalize.
*/
aiVector3D mCentroid;
/** An entry in a spatially sorted position array. Consists of a vertex index,
* its position and its pre-calculated distance from the reference plane */
struct Entry {
unsigned int mIndex; ///< The vertex referred by this entry
aiVector3D mPosition; ///< Position
ai_real mDistance; ///< Distance of this vertex to the sorting plane
/// Distance of this vertex to the sorting plane. This is set by Finalize.
ai_real mDistance;
Entry() AI_NO_EXCEPT
: mIndex(999999999),
: mIndex(std::numeric_limits<unsigned int>::max()),
mPosition(),
mDistance(99999.) {
mDistance(std::numeric_limits<ai_real>::max()) {
// empty
}
Entry(unsigned int pIndex, const aiVector3D &pPosition, ai_real pDistance) :
mIndex(pIndex), mPosition(pPosition), mDistance(pDistance) {
Entry(unsigned int pIndex, const aiVector3D &pPosition) :
mIndex(pIndex), mPosition(pPosition), mDistance(std::numeric_limits<ai_real>::max()) {
// empty
}
@ -168,6 +180,9 @@ protected:
// all positions, sorted by distance to the sorting plane
std::vector<Entry> mPositions;
/// false until the Finalize method is called.
bool mFinalized;
};
} // end of namespace Assimp

2
include/assimp/StreamReader.h
View File

@ -207,7 +207,7 @@ public:
// ---------------------------------------------------------------------
/** Set current file pointer (Get it from #GetPtr). This is if you
* prefer to do pointer arithmetics on your own or want to copy
* prefer to do pointer arithmetic on your own or want to copy
* large chunks of data at once.
* @param p The new pointer, which is validated against the size
* limit and buffer boundaries. */

6
include/assimp/Vertex.h
View File

@ -93,7 +93,7 @@ namespace Assimp {
// ------------------------------------------------------------------------------------------------
/** Intermediate description a vertex with all possible components. Defines a full set of
* operators, so you may use such a 'Vertex' in basic arithmetics. All operators are applied
* operators, so you may use such a 'Vertex' in basic arithmetic. All operators are applied
* to *all* vertex components equally. This is useful for stuff like interpolation
* or subdivision, but won't work if special handling is required for some vertex components. */
// ------------------------------------------------------------------------------------------------
@ -222,7 +222,7 @@ private:
}
// ----------------------------------------------------------------------------
/** This time binary arithmetics of v0 with a floating-point number */
/** This time binary arithmetic of v0 with a floating-point number */
template <template <typename, typename, typename> class op> static Vertex BinaryOp(const Vertex& v0, ai_real f) {
// this is a heavy task for the compiler to optimize ... *pray*
@ -242,7 +242,7 @@ private:
}
// ----------------------------------------------------------------------------
/** This time binary arithmetics of v0 with a floating-point number */
/** This time binary arithmetic of v0 with a floating-point number */
template <template <typename, typename, typename> class op> static Vertex BinaryOp(ai_real f, const Vertex& v0) {
// this is a heavy task for the compiler to optimize ... *pray*

2
include/assimp/cexport.h
View File

@ -112,7 +112,7 @@ ASSIMP_API void aiReleaseExportFormatDescription(const C_STRUCT aiExportFormatDe
* export them again. Since the scene returned by the various importer functions
* is const, a modifiable copy is needed.
* @param pIn Valid scene to be copied
* @param pOut Receives a modifyable copy of the scene. Use aiFreeScene() to
* @param pOut Receives a modifiable copy of the scene. Use aiFreeScene() to
* delete it again.
*/
ASSIMP_API void aiCopyScene(const C_STRUCT aiScene *pIn,

13
include/assimp/material.h
View File

@ -1028,6 +1028,19 @@ extern "C" {
// Multiplied by AI_MATKEY_TRANSMISSION_FACTOR
#define AI_MATKEY_TRANSMISSION_TEXTURE aiTextureType_TRANSMISSION, 0
// Volume
// ------------
// https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_volume
// The thickness of the volume beneath the surface. If the value is 0 the material is thin-walled. Otherwise the material is a volume boundary.
#define AI_MATKEY_VOLUME_THICKNESS_FACTOR "$mat.volume.thicknessFactor", 0, 0
// Texture that defines the thickness.
// Multiplied by AI_MATKEY_THICKNESS_FACTOR
#define AI_MATKEY_VOLUME_THICKNESS_TEXTURE aiTextureType_TRANSMISSION, 1
// Density of the medium given as the average distance that light travels in the medium before interacting with a particle.
#define AI_MATKEY_VOLUME_ATTENUATION_DISTANCE "$mat.volume.attenuationDistance", 0, 0
// The color that white light turns into due to absorption when reaching the attenuation distance.
#define AI_MATKEY_VOLUME_ATTENUATION_COLOR "$mat.volume.attenuationColor", 0, 0
// Emissive
// --------
#define AI_MATKEY_USE_EMISSIVE_MAP "$mat.useEmissiveMap", 0, 0

2
include/assimp/postprocess.h
View File

@ -440,7 +440,7 @@ enum aiPostProcessSteps
*
* @note UV transformations are usually implemented in real-time apps by
* transforming texture coordinates at vertex shader stage with a 3x3
* (homogenous) transformation matrix.
* (homogeneous) transformation matrix.
*/
aiProcess_TransformUVCoords = 0x80000,

2
samples/SimpleAssimpViewX/MyDocument.h
View File

@ -40,7 +40,7 @@
NSMutableArray* modelMeshes;
BOOL builtBuffers;
NSMutableDictionary* textureDictionary; // Array of Dicionaries that map image filenames to textureIds
NSMutableDictionary* textureDictionary; // Array of Dictionaries that map image filenames to textureIds
}
@property (retain) IBOutlet NSView* _view;

2
samples/SimpleOpenGL/Sample_SimpleOpenGL.c
View File

@ -361,7 +361,7 @@ int main(int argc, char **argv)
C_STRUCT aiLogStream stream;
if (argc < 2) {
print_error("No input model file specifed.");
print_error("No input model file specified.");
print_run_command(COMMAND_USAGE);
return EXIT_FAILURE;
}

2
samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp
View File

@ -129,7 +129,7 @@ int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/,
LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc);
if (!argv) {
MessageBox(nullptr,
TEXT("An error occured while reading command line arguments."),
TEXT("An error occurred while reading command line arguments."),
TEXT("Error!"),
MB_ICONERROR | MB_OK);
return EXIT_FAILURE;

2
samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/src/model_loading.cpp
View File

@ -667,7 +667,7 @@ BOOL CreateGLWindow(const char* title, int width, int height, int bits, bool ful
dwStyle=WS_OVERLAPPEDWINDOW; // Windows style
}
AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requestes Size
AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size
if (nullptr == (g_hWnd=CreateWindowEx(dwExStyle, // Extended Style For The Window
TEXT("OpenGL"), // Class Name

36
test/unit/Common/utSpatialSort.cpp
View File

@ -82,3 +82,39 @@ TEST_F(utSpatialSort, findPositionsTest) {
sSort.FindPositions(vecs[0], 0.01f, indices);
EXPECT_EQ(1u, indices.size());
}
TEST_F(utSpatialSort, highlyDisplacedPositionsTest) {
// Make a cube of positions, and then query it using the SpatialSort object.
constexpr unsigned int verticesPerAxis = 10;
constexpr ai_real step = 0.001f;
// Note the large constant offset here.
constexpr ai_real offset = 5000.0f - (0.5f * verticesPerAxis * step);
constexpr unsigned int totalNumPositions = verticesPerAxis * verticesPerAxis * verticesPerAxis;
aiVector3D* positions = new aiVector3D[totalNumPositions];
for (unsigned int x = 0; x < verticesPerAxis; ++x) {
for (unsigned int y = 0; y < verticesPerAxis; ++y) {
for (unsigned int z = 0; z < verticesPerAxis; ++z) {
const unsigned int index = (x * verticesPerAxis * verticesPerAxis) + (y * verticesPerAxis) + z;
positions[index] = aiVector3D(offset + (x * step), offset + (y * step), offset + (z * step));
}
}
}
SpatialSort sSort;
sSort.Fill(positions, totalNumPositions, sizeof(aiVector3D));
// Enough to find a point and its 6 immediate neighbors, but not any other point.
const ai_real epsilon = 1.1f * step;
std::vector<unsigned int> indices;
// Iterate through the _interior_ points of the cube.
for (unsigned int x = 1; x < verticesPerAxis - 1; ++x) {
for (unsigned int y = 1; y < verticesPerAxis - 1; ++y) {
for (unsigned int z = 1; z < verticesPerAxis - 1; ++z) {
const unsigned int index = (x * verticesPerAxis * verticesPerAxis) + (y * verticesPerAxis) + z;
sSort.FindPositions(positions[index], epsilon, indices);
ASSERT_EQ(7u, indices.size());
}
}
}
delete[] positions;
}

2
test/unit/ImportExport/MDL/utMDLImporter_HL1_Nodes.cpp
View File

@ -391,7 +391,7 @@ public:
// Unapply the transformation using the offset matrix.
aiMatrix4x4 unapplied_transform = scene_mesh_bone->mOffsetMatrix * transform;
// Ensure that we have, approximatively, the identity matrix.
// Ensure that we have, approximately, the identity matrix.
expect_equal_matrices(identity_matrix, unapplied_transform, TOLERANCE);
}
}

4
test/unit/ImportExport/utExporter.cpp
View File

@ -45,6 +45,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
#ifndef ASSIMP_BUILD_NO_EXPORT
class TestProgressHandler : public ProgressHandler {
public:
TestProgressHandler() :
@ -101,3 +103,5 @@ TEST_F(ExporterTest, ExporterIdTest) {
const aiExportFormatDesc *desc = exporter.GetExportFormatDescription(exportFormatCount);
EXPECT_EQ(nullptr, desc) << "More exporters than claimed";
}
#endif

4
test/unit/utColladaImportExport.cpp
View File

@ -233,6 +233,8 @@ unsigned int GetMeshUseCount(const aiNode *rootNode) {
return result;
}
#ifndef ASSIMP_BUILD_NO_EXPORT
TEST_F(utColladaImportExport, exportRootNodeMeshTest) {
Assimp::Importer importer;
Assimp::Exporter exporter;
@ -342,6 +344,8 @@ TEST_F(utColladaImportExport, exporterUniqueIdsTest) {
ImportAsNames(outFileNamed, scene);
}
#endif
class utColladaZaeImportExport : public AbstractImportExportBase {
public:
virtual bool importerTest() final {

2
test/unit/utTriangulate.cpp
View File

@ -132,6 +132,6 @@ TEST_F(TriangulateProcessTest, testTriangulation) {
}
}
// we should have no valid normal vectors now necause we aren't a pure polygon mesh
// we should have no valid normal vectors now because we aren't a pure polygon mesh
EXPECT_TRUE(pcMesh->mNormals == NULL);
}

2
tools/assimp_cmd/Info.cpp
View File

@ -313,7 +313,7 @@ int Assimp_Info (const char* const* params, unsigned int num) {
// Verbose and silent at the same time are not allowed
if ( verbose && silent ) {
printf("assimp info: Invalid arguments, verbose and silent at the same time are forbitten. ");
printf("assimp info: Invalid arguments, verbose and silent at the same time are forbidden. ");
return AssimpCmdInfoError::InvalidCombinaisonOfArguments;
}

8
tools/assimp_cmd/WriteDump.cpp
View File

@ -66,6 +66,8 @@ const char *AICMD_MSG_DUMP_HELP =
FILE *out = nullptr;
bool shortened = false;
#ifndef ASSIMP_BUILD_NO_EXPORT
// -----------------------------------------------------------------------------------
int Assimp_Dump(const char *const *params, unsigned int num) {
const char *fail = "assimp dump: Invalid number of arguments. "
@ -162,3 +164,9 @@ int Assimp_Dump(const char *const *params, unsigned int num) {
printf("assimp dump: Wrote output dump %s\n", cur_out.c_str());
return AssimpCmdError::Success;
}
#else
int Assimp_Dump(const char *const *, unsigned int ) {
printf("assimp dump: Export disabled.\n");
return AssimpCmdError::UnrecognizedCommand;
}
#endif

4
tools/assimp_view/Display.cpp
View File

@ -90,7 +90,7 @@ D3DXVECTOR4 g_aclNormalColors[14] =
//-------------------------------------------------------------------------------
// Recursivly count the number of nodes in an asset's node graph
// Recursively count the number of nodes in an asset's node graph
// Used by LoadAsset()
//-------------------------------------------------------------------------------
void GetNodeCount(aiNode* pcNode, unsigned int* piCnt)
@ -1535,7 +1535,7 @@ int CDisplay::RenderStereoView(const aiMatrix4x4& m)
// (move back to the original position)
g_sCamera.vPos -= g_sCamera.vRight * 0.03f;
// reenable all channels
// re-enable all channels
g_piDevice->SetRenderState(D3DRS_COLORWRITEENABLE,
D3DCOLORWRITEENABLE_RED |
D3DCOLORWRITEENABLE_GREEN |

2
tools/assimp_view/Material.cpp
View File

@ -1483,7 +1483,7 @@ int CMaterialManager::EndMaterial (AssetHelper::MeshHelper* pcMesh)
pcMesh->piEffect->EndPass();
pcMesh->piEffect->End();
// reenable culling if necessary
// re-enable culling if necessary
if (pcMesh->twosided && g_sOptions.bCulling) {
g_piDevice->SetRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
}

4
tools/assimp_view/MessageProc.cpp
View File

@ -116,7 +116,7 @@ void MakeFileAssociations() {
RegSetValueEx(hRegistry,"",0,REG_SZ,(const BYTE*)szTemp,(DWORD)strlen(szTemp)+1);
RegCloseKey(hRegistry);
CLogDisplay::Instance().AddEntry("[OK] File assocations have been registered",
CLogDisplay::Instance().AddEntry("[OK] File associations have been registered",
D3DCOLOR_ARGB(0xFF,0,0xFF,0));
CLogDisplay::Instance().AddEntry(tmp.data,D3DCOLOR_ARGB(0xFF,0,0xFF,0));
@ -1508,7 +1508,7 @@ INT_PTR CALLBACK MessageProc(HWND hwndDlg,UINT uMsg, WPARAM wParam,LPARAM lParam
sRect.right -= sRect.left;
sRect.bottom -= sRect.top;
// if the mouse klick was inside the viewer panel
// if the mouse click was inside the viewer panel
// give the focus to it
if (xPos > 0 && xPos < sRect.right && yPos > 0 && yPos < sRect.bottom)
{

2
tools/assimp_view/SceneAnimator.h
View File

@ -125,7 +125,7 @@ public:
// ----------------------------------------------------------------------------
/** Calculates the node transformations for the scene. Call this to get
* uptodate results before calling one of the getters.
* up-to-date results before calling one of the getters.
* @param pTime Current time. Can be an arbitrary range.
*/
void Calculate(double pTime);

2
tools/assimp_view/assimp_view.cpp
View File

@ -489,7 +489,7 @@ int CreateAssetData() {
nidx = 3;
break;
default:
CLogWindow::Instance().WriteLine("Unknown primitiv type");
CLogWindow::Instance().WriteLine("Unknown primitive type");
break;
};