summaryrefslogtreecommitdiff
path: root/libs/assimp/code/AssetLib/MD3
diff options
context:
space:
mode:
authorsanine <sanine.not@pm.me>2023-02-12 23:53:22 -0600
committersanine <sanine.not@pm.me>2023-02-12 23:53:22 -0600
commitf1fe73d1909a2448a004a88362a1a532d0d4f7c3 (patch)
treeab37ae3837e2f858de2932bcee9f26e69fab3db1 /libs/assimp/code/AssetLib/MD3
parentf567ea1e2798fd3156a416e61f083ea3e6b95719 (diff)
switch to tinyobj and nanovg from assimp and cairo
Diffstat (limited to 'libs/assimp/code/AssetLib/MD3')
-rw-r--r--libs/assimp/code/AssetLib/MD3/MD3FileData.h314
-rw-r--r--libs/assimp/code/AssetLib/MD3/MD3Loader.cpp1060
-rw-r--r--libs/assimp/code/AssetLib/MD3/MD3Loader.h314
3 files changed, 0 insertions, 1688 deletions
diff --git a/libs/assimp/code/AssetLib/MD3/MD3FileData.h b/libs/assimp/code/AssetLib/MD3/MD3FileData.h
deleted file mode 100644
index 01475e6..0000000
--- a/libs/assimp/code/AssetLib/MD3/MD3FileData.h
+++ /dev/null
@@ -1,314 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2022, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
- copyright notice, this list of conditions and the
- following disclaimer.
-
-* Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the
- following disclaimer in the documentation and/or other
- materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
- contributors may be used to endorse or promote products
- derived from this software without specific prior
- written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Md3FileData.h
- *
- * @brief Defines helper data structures for importing MD3 files.
- * http://linux.ucla.edu/~phaethon/q3/formats/md3format.html
- */
-#ifndef AI_MD3FILEHELPER_H_INC
-#define AI_MD3FILEHELPER_H_INC
-
-#include <string>
-#include <vector>
-#include <sstream>
-#include <stdint.h>
-
-#include <assimp/types.h>
-#include <assimp/mesh.h>
-#include <assimp/anim.h>
-
-#include <assimp/Compiler/pushpack1.h>
-
-namespace Assimp {
-namespace MD3 {
-
-// to make it easier for us, we test the magic word against both "endianesses"
-#define AI_MD3_MAGIC_NUMBER_BE AI_MAKE_MAGIC("IDP3")
-#define AI_MD3_MAGIC_NUMBER_LE AI_MAKE_MAGIC("3PDI")
-
-// common limitations
-#define AI_MD3_VERSION 15
-#define AI_MD3_MAXQPATH 64
-#define AI_MD3_MAXFRAME 16
-#define AI_MD3_MAX_FRAMES 1024
-#define AI_MD3_MAX_TAGS 16
-#define AI_MD3_MAX_SURFACES 32
-#define AI_MD3_MAX_SHADERS 256
-#define AI_MD3_MAX_VERTS 4096
-#define AI_MD3_MAX_TRIANGLES 8192
-
-// master scale factor for all vertices in a MD3 model
-#define AI_MD3_XYZ_SCALE (1.0f/64.0f)
-
-// -------------------------------------------------------------------------------
-/** @brief Data structure for the MD3 main header
- */
-struct Header
-{
- //! magic number
- uint32_t IDENT;
-
- //! file format version
- uint32_t VERSION;
-
- //! original name in .pak archive
- char NAME[ AI_MD3_MAXQPATH ];
-
- //! unknown
- int32_t FLAGS;
-
- //! number of frames in the file
- uint32_t NUM_FRAMES;
-
- //! number of tags in the file
- uint32_t NUM_TAGS;
-
- //! number of surfaces in the file
- uint32_t NUM_SURFACES;
-
- //! number of skins in the file
- uint32_t NUM_SKINS;
-
- //! offset of the first frame
- uint32_t OFS_FRAMES;
-
- //! offset of the first tag
- uint32_t OFS_TAGS;
-
- //! offset of the first surface
- uint32_t OFS_SURFACES;
-
- //! end of file
- uint32_t OFS_EOF;
-} PACK_STRUCT;
-
-
-// -------------------------------------------------------------------------------
-/** @brief Data structure for the frame header
- */
-struct Frame
-{
- //! minimum bounds
- aiVector3D min;
-
- //! maximum bounds
- aiVector3D max;
-
- //! local origin for this frame
- aiVector3D origin;
-
- //! radius of bounding sphere
- ai_real radius;
-
- //! name of frame
- char name[ AI_MD3_MAXFRAME ];
-
-} /* PACK_STRUCT */;
-
-
-// -------------------------------------------------------------------------------
-/**
- * @brief Data structure for the tag header
- */
-struct Tag {
- //! name of the tag
- char NAME[ AI_MD3_MAXQPATH ];
-
- //! Local tag origin and orientation
- aiVector3D origin;
- ai_real orientation[3][3];
-
-} /* PACK_STRUCT */;
-
-
-// -------------------------------------------------------------------------------
-/** @brief Data structure for the surface header
- */
-struct Surface {
- //! magic number
- int32_t IDENT;
-
- //! original name of the surface
- char NAME[ AI_MD3_MAXQPATH ];
-
- //! unknown
- int32_t FLAGS;
-
- //! number of frames in the surface
- uint32_t NUM_FRAMES;
-
- //! number of shaders in the surface
- uint32_t NUM_SHADER;
-
- //! number of vertices in the surface
- uint32_t NUM_VERTICES;
-
- //! number of triangles in the surface
- uint32_t NUM_TRIANGLES;
-
- //! offset to the triangle data
- uint32_t OFS_TRIANGLES;
-
- //! offset to the shader data
- uint32_t OFS_SHADERS;
-
- //! offset to the texture coordinate data
- uint32_t OFS_ST;
-
- //! offset to the vertex/normal data
- uint32_t OFS_XYZNORMAL;
-
- //! offset to the end of the Surface object
- int32_t OFS_END;
-} /*PACK_STRUCT*/;
-
-// -------------------------------------------------------------------------------
-/** @brief Data structure for a shader defined in there
- */
-struct Shader {
- //! filename of the shader
- char NAME[ AI_MD3_MAXQPATH ];
-
- //! index of the shader
- uint32_t SHADER_INDEX;
-} /*PACK_STRUCT*/;
-
-
-// -------------------------------------------------------------------------------
-/** @brief Data structure for a triangle
- */
-struct Triangle
-{
- //! triangle indices
- uint32_t INDEXES[3];
-} /*PACK_STRUCT*/;
-
-
-// -------------------------------------------------------------------------------
-/** @brief Data structure for an UV coord
- */
-struct TexCoord
-{
- //! UV coordinates
- ai_real U,V;
-} /*PACK_STRUCT*/;
-
-
-// -------------------------------------------------------------------------------
-/** @brief Data structure for a vertex
- */
-struct Vertex
-{
- //! X/Y/Z coordinates
- int16_t X,Y,Z;
-
- //! encoded normal vector
- uint16_t NORMAL;
-} /*PACK_STRUCT*/;
-
-#include <assimp/Compiler/poppack1.h>
-
-// -------------------------------------------------------------------------------
-/** @brief Unpack a Q3 16 bit vector to its full float3 representation
- *
- * @param p_iNormal Input normal vector in latitude/longitude form
- * @param p_afOut Pointer to an array of three floats to receive the result
- *
- * @note This has been taken from q3 source (misc_model.c)
- */
-inline void LatLngNormalToVec3(uint16_t p_iNormal, ai_real* p_afOut)
-{
- ai_real lat = (ai_real)(( p_iNormal >> 8u ) & 0xff);
- ai_real lng = (ai_real)(( p_iNormal & 0xff ));
- const ai_real invVal( ai_real( 1.0 ) / ai_real( 128.0 ) );
- lat *= ai_real( 3.141926 ) * invVal;
- lng *= ai_real( 3.141926 ) * invVal;
-
- p_afOut[ 0 ] = std::cos(lat) * std::sin(lng);
- p_afOut[ 1 ] = std::sin(lat) * std::sin(lng);
- p_afOut[ 2 ] = std::cos(lng);
-}
-
-
-// -------------------------------------------------------------------------------
-/** @brief Pack a Q3 normal into 16bit latitude/longitude representation
- * @param p_vIn Input vector
- * @param p_iOut Output normal
- *
- * @note This has been taken from q3 source (mathlib.c)
- */
-inline void Vec3NormalToLatLng( const aiVector3D& p_vIn, uint16_t& p_iOut )
-{
- // check for singularities
- if ( 0.0f == p_vIn[0] && 0.0f == p_vIn[1] )
- {
- if ( p_vIn[2] > 0.0f )
- {
- ((unsigned char*)&p_iOut)[0] = 0;
- ((unsigned char*)&p_iOut)[1] = 0; // lat = 0, long = 0
- }
- else
- {
- ((unsigned char*)&p_iOut)[0] = 128;
- ((unsigned char*)&p_iOut)[1] = 0; // lat = 0, long = 128
- }
- }
- else
- {
- int a, b;
-
- a = int(57.2957795f * ( std::atan2( p_vIn[1], p_vIn[0] ) ) * (255.0f / 360.0f ));
- a &= 0xff;
-
- b = int(57.2957795f * ( std::acos( p_vIn[2] ) ) * ( 255.0f / 360.0f ));
- b &= 0xff;
-
- ((unsigned char*)&p_iOut)[0] = (unsigned char) b; // longitude
- ((unsigned char*)&p_iOut)[1] = (unsigned char) a; // latitude
- }
-}
-
-} // Namespace MD3
-} // Namespace Assimp
-
-#endif // !! AI_MD3FILEHELPER_H_INC
diff --git a/libs/assimp/code/AssetLib/MD3/MD3Loader.cpp b/libs/assimp/code/AssetLib/MD3/MD3Loader.cpp
deleted file mode 100644
index 6120bd8..0000000
--- a/libs/assimp/code/AssetLib/MD3/MD3Loader.cpp
+++ /dev/null
@@ -1,1060 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2022, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
- copyright notice, this list of conditions and the
- following disclaimer.
-
-* Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the
- following disclaimer in the documentation and/or other
- materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
- contributors may be used to endorse or promote products
- derived from this software without specific prior
- written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file MD3Loader.cpp
- * @brief Implementation of the MD3 importer class
- *
- * Sources:
- * http://www.gamers.org/dEngine/quake3/UQ3S
- * http://linux.ucla.edu/~phaethon/q3/formats/md3format.html
- * http://www.heppler.com/shader/shader/
- */
-
-#ifndef ASSIMP_BUILD_NO_MD3_IMPORTER
-
-#include "AssetLib/MD3/MD3Loader.h"
-#include "Common/Importer.h"
-
-#include <assimp/GenericProperty.h>
-#include <assimp/ParsingUtils.h>
-#include <assimp/RemoveComments.h>
-#include <assimp/SceneCombiner.h>
-#include <assimp/importerdesc.h>
-#include <assimp/material.h>
-#include <assimp/scene.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/IOSystem.hpp>
-
-#include <cctype>
-#include <memory>
-
-using namespace Assimp;
-
-static const aiImporterDesc desc = {
- "Quake III Mesh Importer",
- "",
- "",
- "",
- aiImporterFlags_SupportBinaryFlavour,
- 0,
- 0,
- 0,
- 0,
- "md3"
-};
-
-// ------------------------------------------------------------------------------------------------
-// Convert a Q3 shader blend function to the appropriate enum value
-Q3Shader::BlendFunc StringToBlendFunc(const std::string &m) {
- if (m == "GL_ONE") {
- return Q3Shader::BLEND_GL_ONE;
- }
- if (m == "GL_ZERO") {
- return Q3Shader::BLEND_GL_ZERO;
- }
- if (m == "GL_SRC_ALPHA") {
- return Q3Shader::BLEND_GL_SRC_ALPHA;
- }
- if (m == "GL_ONE_MINUS_SRC_ALPHA") {
- return Q3Shader::BLEND_GL_ONE_MINUS_SRC_ALPHA;
- }
- if (m == "GL_ONE_MINUS_DST_COLOR") {
- return Q3Shader::BLEND_GL_ONE_MINUS_DST_COLOR;
- }
- ASSIMP_LOG_ERROR("Q3Shader: Unknown blend function: ", m);
- return Q3Shader::BLEND_NONE;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Load a Quake 3 shader
-bool Q3Shader::LoadShader(ShaderData &fill, const std::string &pFile, IOSystem *io) {
- std::unique_ptr<IOStream> file(io->Open(pFile, "rt"));
- if (!file.get())
- return false; // if we can't access the file, don't worry and return
-
- ASSIMP_LOG_INFO("Loading Quake3 shader file ", pFile);
-
- // read file in memory
- const size_t s = file->FileSize();
- std::vector<char> _buff(s + 1);
- file->Read(&_buff[0], s, 1);
- _buff[s] = 0;
-
- // remove comments from it (C++ style)
- CommentRemover::RemoveLineComments("//", &_buff[0]);
- const char *buff = &_buff[0];
-
- Q3Shader::ShaderDataBlock *curData = nullptr;
- Q3Shader::ShaderMapBlock *curMap = nullptr;
-
- // read line per line
- for (; SkipSpacesAndLineEnd(&buff); SkipLine(&buff)) {
-
- if (*buff == '{') {
- ++buff;
-
- // append to last section, if any
- if (!curData) {
- ASSIMP_LOG_ERROR("Q3Shader: Unexpected shader section token \'{\'");
- return true; // still no failure, the file is there
- }
-
- // read this data section
- for (; SkipSpacesAndLineEnd(&buff); SkipLine(&buff)) {
- if (*buff == '{') {
- ++buff;
- // add new map section
- curData->maps.push_back(Q3Shader::ShaderMapBlock());
- curMap = &curData->maps.back();
-
- for (; SkipSpacesAndLineEnd(&buff); SkipLine(&buff)) {
- // 'map' - Specifies texture file name
- if (TokenMatchI(buff, "map", 3) || TokenMatchI(buff, "clampmap", 8)) {
- curMap->name = GetNextToken(buff);
- }
- // 'blendfunc' - Alpha blending mode
- else if (TokenMatchI(buff, "blendfunc", 9)) {
- const std::string blend_src = GetNextToken(buff);
- if (blend_src == "add") {
- curMap->blend_src = Q3Shader::BLEND_GL_ONE;
- curMap->blend_dest = Q3Shader::BLEND_GL_ONE;
- } else if (blend_src == "filter") {
- curMap->blend_src = Q3Shader::BLEND_GL_DST_COLOR;
- curMap->blend_dest = Q3Shader::BLEND_GL_ZERO;
- } else if (blend_src == "blend") {
- curMap->blend_src = Q3Shader::BLEND_GL_SRC_ALPHA;
- curMap->blend_dest = Q3Shader::BLEND_GL_ONE_MINUS_SRC_ALPHA;
- } else {
- curMap->blend_src = StringToBlendFunc(blend_src);
- curMap->blend_dest = StringToBlendFunc(GetNextToken(buff));
- }
- }
- // 'alphafunc' - Alpha testing mode
- else if (TokenMatchI(buff, "alphafunc", 9)) {
- const std::string at = GetNextToken(buff);
- if (at == "GT0") {
- curMap->alpha_test = Q3Shader::AT_GT0;
- } else if (at == "LT128") {
- curMap->alpha_test = Q3Shader::AT_LT128;
- } else if (at == "GE128") {
- curMap->alpha_test = Q3Shader::AT_GE128;
- }
- } else if (*buff == '}') {
- ++buff;
- // close this map section
- curMap = nullptr;
- break;
- }
- }
-
- } else if (*buff == '}') {
- ++buff;
- curData = nullptr;
- break;
- }
-
- // 'cull' specifies culling behaviour for the model
- else if (TokenMatchI(buff, "cull", 4)) {
- SkipSpaces(&buff);
- if (!ASSIMP_strincmp(buff, "back", 4)) { // render face's backside, does not function in Q3 engine (bug)
- curData->cull = Q3Shader::CULL_CCW;
- } else if (!ASSIMP_strincmp(buff, "front", 5)) { // is not valid keyword in Q3, but occurs in shaders
- curData->cull = Q3Shader::CULL_CW;
- } else if (!ASSIMP_strincmp(buff, "none", 4) || !ASSIMP_strincmp(buff, "twosided", 8) || !ASSIMP_strincmp(buff, "disable", 7)) {
- curData->cull = Q3Shader::CULL_NONE;
- } else {
- ASSIMP_LOG_ERROR("Q3Shader: Unrecognized cull mode");
- }
- }
- }
- } else {
- // add new section
- fill.blocks.push_back(Q3Shader::ShaderDataBlock());
- curData = &fill.blocks.back();
-
- // get the name of this section
- curData->name = GetNextToken(buff);
- }
- }
- return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Load a Quake 3 skin
-bool Q3Shader::LoadSkin(SkinData &fill, const std::string &pFile, IOSystem *io) {
- std::unique_ptr<IOStream> file(io->Open(pFile, "rt"));
- if (!file.get())
- return false; // if we can't access the file, don't worry and return
-
- ASSIMP_LOG_INFO("Loading Quake3 skin file ", pFile);
-
- // read file in memory
- const size_t s = file->FileSize();
- std::vector<char> _buff(s + 1);
- const char *buff = &_buff[0];
- file->Read(&_buff[0], s, 1);
- _buff[s] = 0;
-
- // remove commas
- std::replace(_buff.begin(), _buff.end(), ',', ' ');
-
- // read token by token and fill output table
- for (; *buff;) {
- SkipSpacesAndLineEnd(&buff);
-
- // get first identifier
- std::string ss = GetNextToken(buff);
-
- // ignore tokens starting with tag_
- if (!::strncmp(&ss[0], "tag_", std::min((size_t)4, ss.length())))
- continue;
-
- fill.textures.push_back(SkinData::TextureEntry());
- SkinData::TextureEntry &entry = fill.textures.back();
-
- entry.first = ss;
- entry.second = GetNextToken(buff);
- }
- return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Convert Q3Shader to material
-void Q3Shader::ConvertShaderToMaterial(aiMaterial *out, const ShaderDataBlock &shader) {
- ai_assert(nullptr != out);
-
- /* IMPORTANT: This is not a real conversion. Actually we're just guessing and
- * hacking around to build an aiMaterial that looks nearly equal to the
- * original Quake 3 shader. We're missing some important features like
- * animatable material properties in our material system, but at least
- * multiple textures should be handled correctly.
- */
-
- // Two-sided material?
- if (shader.cull == Q3Shader::CULL_NONE) {
- const int twosided = 1;
- out->AddProperty(&twosided, 1, AI_MATKEY_TWOSIDED);
- }
-
- unsigned int cur_emissive = 0, cur_diffuse = 0, cur_lm = 0;
-
- // Iterate through all textures
- for (std::list<Q3Shader::ShaderMapBlock>::const_iterator it = shader.maps.begin(); it != shader.maps.end(); ++it) {
-
- // CONVERSION BEHAVIOUR:
- //
- //
- // If the texture is additive
- // - if it is the first texture, assume additive blending for the whole material
- // - otherwise register it as emissive texture.
- //
- // If the texture is using standard blend (or if the blend mode is unknown)
- // - if first texture: assume default blending for material
- // - in any case: set it as diffuse texture
- //
- // If the texture is using 'filter' blending
- // - take as lightmap
- //
- // Textures with alpha funcs
- // - aiTextureFlags_UseAlpha is set (otherwise aiTextureFlags_NoAlpha is explicitly set)
- aiString s((*it).name);
- aiTextureType type;
- unsigned int index;
-
- if ((*it).blend_src == Q3Shader::BLEND_GL_ONE && (*it).blend_dest == Q3Shader::BLEND_GL_ONE) {
- if (it == shader.maps.begin()) {
- const int additive = aiBlendMode_Additive;
- out->AddProperty(&additive, 1, AI_MATKEY_BLEND_FUNC);
-
- index = cur_diffuse++;
- type = aiTextureType_DIFFUSE;
- } else {
- index = cur_emissive++;
- type = aiTextureType_EMISSIVE;
- }
- } else if ((*it).blend_src == Q3Shader::BLEND_GL_DST_COLOR && (*it).blend_dest == Q3Shader::BLEND_GL_ZERO) {
- index = cur_lm++;
- type = aiTextureType_LIGHTMAP;
- } else {
- const int blend = aiBlendMode_Default;
- out->AddProperty(&blend, 1, AI_MATKEY_BLEND_FUNC);
-
- index = cur_diffuse++;
- type = aiTextureType_DIFFUSE;
- }
-
- // setup texture
- out->AddProperty(&s, AI_MATKEY_TEXTURE(type, index));
-
- // setup texture flags
- const int use_alpha = ((*it).alpha_test != Q3Shader::AT_NONE ? aiTextureFlags_UseAlpha : aiTextureFlags_IgnoreAlpha);
- out->AddProperty(&use_alpha, 1, AI_MATKEY_TEXFLAGS(type, index));
- }
- // If at least one emissive texture was set, set the emissive base color to 1 to ensure
- // the texture is actually displayed.
- if (0 != cur_emissive) {
- aiColor3D one(1.f, 1.f, 1.f);
- out->AddProperty(&one, 1, AI_MATKEY_COLOR_EMISSIVE);
- }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-MD3Importer::MD3Importer() :
- configFrameID(0), configHandleMP(true), configSpeedFlag(), pcHeader(), mBuffer(), fileSize(), mScene(), mIOHandler() {}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-MD3Importer::~MD3Importer() {}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the class can handle the format of the given file.
-bool MD3Importer::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
- static const uint32_t tokens[] = { AI_MD3_MAGIC_NUMBER_LE };
- return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
-}
-
-// ------------------------------------------------------------------------------------------------
-void MD3Importer::ValidateHeaderOffsets() {
- // Check magic number
- if (pcHeader->IDENT != AI_MD3_MAGIC_NUMBER_BE &&
- pcHeader->IDENT != AI_MD3_MAGIC_NUMBER_LE)
- throw DeadlyImportError("Invalid MD3 file: Magic bytes not found");
-
- // Check file format version
- if (pcHeader->VERSION > 15)
- ASSIMP_LOG_WARN("Unsupported MD3 file version. Continuing happily ...");
-
- // Check some offset values whether they are valid
- if (!pcHeader->NUM_SURFACES)
- throw DeadlyImportError("Invalid md3 file: NUM_SURFACES is 0");
-
- if (pcHeader->OFS_FRAMES >= fileSize || pcHeader->OFS_SURFACES >= fileSize ||
- pcHeader->OFS_EOF > fileSize) {
- throw DeadlyImportError("Invalid MD3 header: some offsets are outside the file");
- }
-
- if (pcHeader->NUM_SURFACES > AI_MAX_ALLOC(MD3::Surface)) {
- throw DeadlyImportError("Invalid MD3 header: too many surfaces, would overflow");
- }
-
- if (pcHeader->OFS_SURFACES + pcHeader->NUM_SURFACES * sizeof(MD3::Surface) >= fileSize) {
- throw DeadlyImportError("Invalid MD3 header: some surfaces are outside the file");
- }
-
- if (pcHeader->NUM_FRAMES <= configFrameID)
- throw DeadlyImportError("The requested frame is not existing the file");
-}
-
-// ------------------------------------------------------------------------------------------------
-void MD3Importer::ValidateSurfaceHeaderOffsets(const MD3::Surface *pcSurf) {
- // Calculate the relative offset of the surface
- const int32_t ofs = int32_t((const unsigned char *)pcSurf - this->mBuffer);
-
- // Check whether all data chunks are inside the valid range
- if (pcSurf->OFS_TRIANGLES + ofs + pcSurf->NUM_TRIANGLES * sizeof(MD3::Triangle) > fileSize ||
- pcSurf->OFS_SHADERS + ofs + pcSurf->NUM_SHADER * sizeof(MD3::Shader) > fileSize ||
- pcSurf->OFS_ST + ofs + pcSurf->NUM_VERTICES * sizeof(MD3::TexCoord) > fileSize ||
- pcSurf->OFS_XYZNORMAL + ofs + pcSurf->NUM_VERTICES * sizeof(MD3::Vertex) > fileSize) {
-
- throw DeadlyImportError("Invalid MD3 surface header: some offsets are outside the file");
- }
-
- // Check whether all requirements for Q3 files are met. We don't
- // care, but probably someone does.
- if (pcSurf->NUM_TRIANGLES > AI_MD3_MAX_TRIANGLES) {
- ASSIMP_LOG_WARN("MD3: Quake III triangle limit exceeded");
- }
-
- if (pcSurf->NUM_SHADER > AI_MD3_MAX_SHADERS) {
- ASSIMP_LOG_WARN("MD3: Quake III shader limit exceeded");
- }
-
- if (pcSurf->NUM_VERTICES > AI_MD3_MAX_VERTS) {
- ASSIMP_LOG_WARN("MD3: Quake III vertex limit exceeded");
- }
-
- if (pcSurf->NUM_FRAMES > AI_MD3_MAX_FRAMES) {
- ASSIMP_LOG_WARN("MD3: Quake III frame limit exceeded");
- }
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiImporterDesc *MD3Importer::GetInfo() const {
- return &desc;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Setup configuration properties
-void MD3Importer::SetupProperties(const Importer *pImp) {
- // The
- // AI_CONFIG_IMPORT_MD3_KEYFRAME option overrides the
- // AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option.
- configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD3_KEYFRAME, -1);
- if (static_cast<unsigned int>(-1) == configFrameID) {
- configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME, 0);
- }
-
- // AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART
- configHandleMP = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART, 1));
-
- // AI_CONFIG_IMPORT_MD3_SKIN_NAME
- configSkinFile = (pImp->GetPropertyString(AI_CONFIG_IMPORT_MD3_SKIN_NAME, "default"));
-
- // AI_CONFIG_IMPORT_MD3_LOAD_SHADERS
- configLoadShaders = (pImp->GetPropertyBool(AI_CONFIG_IMPORT_MD3_LOAD_SHADERS, true));
-
- // AI_CONFIG_IMPORT_MD3_SHADER_SRC
- configShaderFile = (pImp->GetPropertyString(AI_CONFIG_IMPORT_MD3_SHADER_SRC, ""));
-
- // AI_CONFIG_FAVOUR_SPEED
- configSpeedFlag = (0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED, 0));
-}
-
-// ------------------------------------------------------------------------------------------------
-// Try to read the skin for a MD3 file
-void MD3Importer::ReadSkin(Q3Shader::SkinData &fill) const {
- // skip any postfixes (e.g. lower_1.md3)
- std::string::size_type s = filename.find_last_of('_');
- if (s == std::string::npos) {
- s = filename.find_last_of('.');
- if (s == std::string::npos) {
- s = filename.size();
- }
- }
- ai_assert(s != std::string::npos);
-
- const std::string skin_file = path + filename.substr(0, s) + "_" + configSkinFile + ".skin";
- Q3Shader::LoadSkin(fill, skin_file, mIOHandler);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Try to read the shader for a MD3 file
-void MD3Importer::ReadShader(Q3Shader::ShaderData &fill) const {
- // Determine Q3 model name from given path
- const std::string::size_type s = path.find_last_of("\\/", path.length() - 2);
- const std::string model_file = path.substr(s + 1, path.length() - (s + 2));
-
- // If no specific dir or file is given, use our default search behaviour
- if (!configShaderFile.length()) {
- const char sep = mIOHandler->getOsSeparator();
- if (!Q3Shader::LoadShader(fill, path + ".." + sep + ".." + sep + ".." + sep + "scripts" + sep + model_file + ".shader", mIOHandler)) {
- Q3Shader::LoadShader(fill, path + ".." + sep + ".." + sep + ".." + sep + "scripts" + sep + filename + ".shader", mIOHandler);
- }
- } else {
- // If the given string specifies a file, load this file.
- // Otherwise it's a directory.
- const std::string::size_type st = configShaderFile.find_last_of('.');
- if (st == std::string::npos) {
-
- if (!Q3Shader::LoadShader(fill, configShaderFile + model_file + ".shader", mIOHandler)) {
- Q3Shader::LoadShader(fill, configShaderFile + filename + ".shader", mIOHandler);
- }
- } else {
- Q3Shader::LoadShader(fill, configShaderFile, mIOHandler);
- }
- }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Tiny helper to remove a single node from its parent' list
-void RemoveSingleNodeFromList(aiNode *nd) {
- if (!nd || nd->mNumChildren || !nd->mParent) return;
- aiNode *par = nd->mParent;
- for (unsigned int i = 0; i < par->mNumChildren; ++i) {
- if (par->mChildren[i] == nd) {
- --par->mNumChildren;
- for (; i < par->mNumChildren; ++i) {
- par->mChildren[i] = par->mChildren[i + 1];
- }
- delete nd;
- break;
- }
- }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Read a multi-part Q3 player model
-bool MD3Importer::ReadMultipartFile() {
- // check whether the file name contains a common postfix, e.g lower_2.md3
- std::string::size_type s = filename.find_last_of('_'), t = filename.find_last_of('.');
-
- if (t == std::string::npos)
- t = filename.size();
- if (s == std::string::npos)
- s = t;
-
- const std::string mod_filename = filename.substr(0, s);
- const std::string suffix = filename.substr(s, t - s);
-
- if (mod_filename == "lower" || mod_filename == "upper" || mod_filename == "head") {
- const std::string lower = path + "lower" + suffix + ".md3";
- const std::string upper = path + "upper" + suffix + ".md3";
- const std::string head = path + "head" + suffix + ".md3";
-
- aiScene *scene_upper = nullptr;
- aiScene *scene_lower = nullptr;
- aiScene *scene_head = nullptr;
- std::string failure;
-
- aiNode *tag_torso, *tag_head;
- std::vector<AttachmentInfo> attach;
-
- ASSIMP_LOG_INFO("Multi part MD3 player model: lower, upper and head parts are joined");
-
- // ensure we won't try to load ourselves recursively
- BatchLoader::PropertyMap props;
- SetGenericProperty(props.ints, AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART, 0);
-
- // now read these three files
- BatchLoader batch(mIOHandler);
- const unsigned int _lower = batch.AddLoadRequest(lower, 0, &props);
- const unsigned int _upper = batch.AddLoadRequest(upper, 0, &props);
- const unsigned int _head = batch.AddLoadRequest(head, 0, &props);
- batch.LoadAll();
-
- // now construct a dummy scene to place these three parts in
- aiScene *master = new aiScene();
- aiNode *nd = master->mRootNode = new aiNode();
- nd->mName.Set("<MD3_Player>");
-
- // ... and get them. We need all of them.
- scene_lower = batch.GetImport(_lower);
- if (!scene_lower) {
- ASSIMP_LOG_ERROR("M3D: Failed to read multi part model, lower.md3 fails to load");
- failure = "lower";
- goto error_cleanup;
- }
-
- scene_upper = batch.GetImport(_upper);
- if (!scene_upper) {
- ASSIMP_LOG_ERROR("M3D: Failed to read multi part model, upper.md3 fails to load");
- failure = "upper";
- goto error_cleanup;
- }
-
- scene_head = batch.GetImport(_head);
- if (!scene_head) {
- ASSIMP_LOG_ERROR("M3D: Failed to read multi part model, head.md3 fails to load");
- failure = "head";
- goto error_cleanup;
- }
-
- // build attachment infos. search for typical Q3 tags
-
- // original root
- scene_lower->mRootNode->mName.Set("lower");
- attach.push_back(AttachmentInfo(scene_lower, nd));
-
- // tag_torso
- tag_torso = scene_lower->mRootNode->FindNode("tag_torso");
- if (!tag_torso) {
- ASSIMP_LOG_ERROR("M3D: Failed to find attachment tag for multi part model: tag_torso expected");
- goto error_cleanup;
- }
- scene_upper->mRootNode->mName.Set("upper");
- attach.push_back(AttachmentInfo(scene_upper, tag_torso));
-
- // tag_head
- tag_head = scene_upper->mRootNode->FindNode("tag_head");
- if (!tag_head) {
- ASSIMP_LOG_ERROR("M3D: Failed to find attachment tag for multi part model: tag_head expected");
- goto error_cleanup;
- }
- scene_head->mRootNode->mName.Set("head");
- attach.push_back(AttachmentInfo(scene_head, tag_head));
-
- // Remove tag_head and tag_torso from all other model parts ...
- // this ensures (together with AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY)
- // that tag_torso/tag_head is also the name of the (unique) output node
- RemoveSingleNodeFromList(scene_upper->mRootNode->FindNode("tag_torso"));
- RemoveSingleNodeFromList(scene_head->mRootNode->FindNode("tag_head"));
-
- // Undo the rotations which we applied to the coordinate systems. We're
- // working in global Quake space here
- scene_head->mRootNode->mTransformation = aiMatrix4x4();
- scene_lower->mRootNode->mTransformation = aiMatrix4x4();
- scene_upper->mRootNode->mTransformation = aiMatrix4x4();
-
- // and merge the scenes
- SceneCombiner::MergeScenes(&mScene, master, attach,
- AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES |
- AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES |
- AI_INT_MERGE_SCENE_RESOLVE_CROSS_ATTACHMENTS |
- (!configSpeedFlag ? AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY : 0));
-
- // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
- mScene->mRootNode->mTransformation = aiMatrix4x4(1.f, 0.f, 0.f, 0.f,
- 0.f, 0.f, 1.f, 0.f, 0.f, -1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f);
-
- return true;
-
- error_cleanup:
- delete scene_upper;
- delete scene_lower;
- delete scene_head;
- delete master;
-
- if (failure == mod_filename) {
- throw DeadlyImportError("MD3: failure to read multipart host file");
- }
- }
- return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Convert a MD3 path to a proper value
-void MD3Importer::ConvertPath(const char *texture_name, const char *header_name, std::string &out) const {
- // If the MD3's internal path itself and the given path are using
- // the same directory, remove it completely to get right output paths.
- const char *end1 = ::strrchr(header_name, '\\');
- if (!end1) end1 = ::strrchr(header_name, '/');
-
- const char *end2 = ::strrchr(texture_name, '\\');
- if (!end2) end2 = ::strrchr(texture_name, '/');
-
- // HACK: If the paths starts with "models", ignore the
- // next two hierarchy levels, it specifies just the model name.
- // Ignored by Q3, it might be not equal to the real model location.
- if (end2) {
-
- size_t len2;
- const size_t len1 = (size_t)(end1 - header_name);
- if (!ASSIMP_strincmp(texture_name, "models", 6) && (texture_name[6] == '/' || texture_name[6] == '\\')) {
- len2 = 6; // ignore the seventh - could be slash or backslash
-
- if (!header_name[0]) {
- // Use the file name only
- out = end2 + 1;
- return;
- }
- } else
- len2 = std::min(len1, (size_t)(end2 - texture_name));
- if (!ASSIMP_strincmp(texture_name, header_name, static_cast<unsigned int>(len2))) {
- // Use the file name only
- out = end2 + 1;
- return;
- }
- }
- // Use the full path
- out = texture_name;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Imports the given file into the given scene structure.
-void MD3Importer::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
- mFile = pFile;
- mScene = pScene;
- mIOHandler = pIOHandler;
-
- // get base path and file name
- // todo ... move to PathConverter
- std::string::size_type s = mFile.find_last_of("/\\");
- if (s == std::string::npos) {
- s = 0;
- } else {
- ++s;
- }
- filename = mFile.substr(s), path = mFile.substr(0, s);
- for (std::string::iterator it = filename.begin(); it != filename.end(); ++it) {
- *it = static_cast<char>(tolower(static_cast<unsigned char>(*it)));
- }
-
- // Load multi-part model file, if necessary
- if (configHandleMP) {
- if (ReadMultipartFile())
- return;
- }
-
- std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));
-
- // Check whether we can read from the file
- if (file.get() == nullptr) {
- throw DeadlyImportError("Failed to open MD3 file ", pFile, ".");
- }
-
- // Check whether the md3 file is large enough to contain the header
- fileSize = (unsigned int)file->FileSize();
- if (fileSize < sizeof(MD3::Header))
- throw DeadlyImportError("MD3 File is too small.");
-
- // Allocate storage and copy the contents of the file to a memory buffer
- std::vector<unsigned char> mBuffer2(fileSize);
- file->Read(&mBuffer2[0], 1, fileSize);
- mBuffer = &mBuffer2[0];
-
- pcHeader = (BE_NCONST MD3::Header *)mBuffer;
-
- // Ensure correct endianness
-#ifdef AI_BUILD_BIG_ENDIAN
-
- AI_SWAP4(pcHeader->VERSION);
- AI_SWAP4(pcHeader->FLAGS);
- AI_SWAP4(pcHeader->IDENT);
- AI_SWAP4(pcHeader->NUM_FRAMES);
- AI_SWAP4(pcHeader->NUM_SKINS);
- AI_SWAP4(pcHeader->NUM_SURFACES);
- AI_SWAP4(pcHeader->NUM_TAGS);
- AI_SWAP4(pcHeader->OFS_EOF);
- AI_SWAP4(pcHeader->OFS_FRAMES);
- AI_SWAP4(pcHeader->OFS_SURFACES);
- AI_SWAP4(pcHeader->OFS_TAGS);
-
-#endif
-
- // Validate the file header
- ValidateHeaderOffsets();
-
- // Navigate to the list of surfaces
- BE_NCONST MD3::Surface *pcSurfaces = (BE_NCONST MD3::Surface *)(mBuffer + pcHeader->OFS_SURFACES);
-
- // Navigate to the list of tags
- BE_NCONST MD3::Tag *pcTags = (BE_NCONST MD3::Tag *)(mBuffer + pcHeader->OFS_TAGS);
-
- // Allocate output storage
- pScene->mNumMeshes = pcHeader->NUM_SURFACES;
- if (pcHeader->NUM_SURFACES == 0) {
- throw DeadlyImportError("MD3: No surfaces");
- } else if (pcHeader->NUM_SURFACES > AI_MAX_ALLOC(aiMesh)) {
- // We allocate pointers but check against the size of aiMesh
- // since those pointers will eventually have to point to real objects
- throw DeadlyImportError("MD3: Too many surfaces, would run out of memory");
- }
- pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
-
- pScene->mNumMaterials = pcHeader->NUM_SURFACES;
- pScene->mMaterials = new aiMaterial *[pScene->mNumMeshes];
-
- // Set arrays to zero to ensue proper destruction if an exception is raised
- ::memset(pScene->mMeshes, 0, pScene->mNumMeshes * sizeof(aiMesh *));
- ::memset(pScene->mMaterials, 0, pScene->mNumMaterials * sizeof(aiMaterial *));
-
- // Now read possible skins from .skin file
- Q3Shader::SkinData skins;
- ReadSkin(skins);
-
- // And check whether we can locate a shader file for this model
- Q3Shader::ShaderData shaders;
- if (configLoadShaders){
- ReadShader(shaders);
- }
-
- // Adjust all texture paths in the shader
- const char *header_name = pcHeader->NAME;
- if (!shaders.blocks.empty()) {
- for (std::list<Q3Shader::ShaderDataBlock>::iterator dit = shaders.blocks.begin(); dit != shaders.blocks.end(); ++dit) {
- ConvertPath((*dit).name.c_str(), header_name, (*dit).name);
-
- for (std::list<Q3Shader::ShaderMapBlock>::iterator mit = (*dit).maps.begin(); mit != (*dit).maps.end(); ++mit) {
- ConvertPath((*mit).name.c_str(), header_name, (*mit).name);
- }
- }
- }
-
- // Read all surfaces from the file
- unsigned int iNum = pcHeader->NUM_SURFACES;
- unsigned int iNumMaterials = 0;
- while (iNum-- > 0) {
-
- // Ensure correct endianness
-#ifdef AI_BUILD_BIG_ENDIAN
-
- AI_SWAP4(pcSurfaces->FLAGS);
- AI_SWAP4(pcSurfaces->IDENT);
- AI_SWAP4(pcSurfaces->NUM_FRAMES);
- AI_SWAP4(pcSurfaces->NUM_SHADER);
- AI_SWAP4(pcSurfaces->NUM_TRIANGLES);
- AI_SWAP4(pcSurfaces->NUM_VERTICES);
- AI_SWAP4(pcSurfaces->OFS_END);
- AI_SWAP4(pcSurfaces->OFS_SHADERS);
- AI_SWAP4(pcSurfaces->OFS_ST);
- AI_SWAP4(pcSurfaces->OFS_TRIANGLES);
- AI_SWAP4(pcSurfaces->OFS_XYZNORMAL);
-
-#endif
-
- // Validate the surface header
- ValidateSurfaceHeaderOffsets(pcSurfaces);
-
- // Navigate to the vertex list of the surface
- BE_NCONST MD3::Vertex *pcVertices = (BE_NCONST MD3::Vertex *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_XYZNORMAL);
-
- // Navigate to the triangle list of the surface
- BE_NCONST MD3::Triangle *pcTriangles = (BE_NCONST MD3::Triangle *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_TRIANGLES);
-
- // Navigate to the texture coordinate list of the surface
- BE_NCONST MD3::TexCoord *pcUVs = (BE_NCONST MD3::TexCoord *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_ST);
-
- // Navigate to the shader list of the surface
- BE_NCONST MD3::Shader *pcShaders = (BE_NCONST MD3::Shader *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_SHADERS);
-
- // If the submesh is empty ignore it
- if (0 == pcSurfaces->NUM_VERTICES || 0 == pcSurfaces->NUM_TRIANGLES) {
- pcSurfaces = (BE_NCONST MD3::Surface *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_END);
- pScene->mNumMeshes--;
- continue;
- }
-
- // Allocate output mesh
- pScene->mMeshes[iNum] = new aiMesh();
- aiMesh *pcMesh = pScene->mMeshes[iNum];
-
- std::string _texture_name;
- const char *texture_name = nullptr;
-
- // Check whether we have a texture record for this surface in the .skin file
- std::list<Q3Shader::SkinData::TextureEntry>::iterator it = std::find(
- skins.textures.begin(), skins.textures.end(), pcSurfaces->NAME);
-
- if (it != skins.textures.end()) {
- texture_name = &*(_texture_name = (*it).second).begin();
- ASSIMP_LOG_VERBOSE_DEBUG("MD3: Assigning skin texture ", (*it).second, " to surface ", pcSurfaces->NAME);
- (*it).resolved = true; // mark entry as resolved
- }
-
- // Get the first shader (= texture?) assigned to the surface
- if (!texture_name && pcSurfaces->NUM_SHADER) {
- texture_name = pcShaders->NAME;
- }
-
- std::string convertedPath;
- if (texture_name) {
- if (configLoadShaders){
- ConvertPath(texture_name, header_name, convertedPath);
- }
- else{
- convertedPath = texture_name;
- }
- }
-
- const Q3Shader::ShaderDataBlock *shader = nullptr;
-
- // Now search the current shader for a record with this name (
- // excluding texture file extension)
- if (!shaders.blocks.empty()) {
- std::string::size_type sh = convertedPath.find_last_of('.');
- if (sh == std::string::npos) {
- sh = convertedPath.length();
- }
-
- const std::string without_ext = convertedPath.substr(0, sh);
- std::list<Q3Shader::ShaderDataBlock>::const_iterator dit = std::find(shaders.blocks.begin(), shaders.blocks.end(), without_ext);
- if (dit != shaders.blocks.end()) {
- // We made it!
- shader = &*dit;
- ASSIMP_LOG_INFO("Found shader record for ", without_ext);
- } else {
- ASSIMP_LOG_WARN("Unable to find shader record for ", without_ext);
- }
- }
-
- aiMaterial *pcHelper = new aiMaterial();
-
- const int iMode = (int)aiShadingMode_Gouraud;
- pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
-
- // Add a small ambient color value - Quake 3 seems to have one
- aiColor3D clr;
- clr.b = clr.g = clr.r = 0.05f;
- pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_AMBIENT);
-
- clr.b = clr.g = clr.r = 1.0f;
- pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
- pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_SPECULAR);
-
- // use surface name + skin_name as material name
- aiString name;
- name.Set("MD3_[" + configSkinFile + "][" + pcSurfaces->NAME + "]");
- pcHelper->AddProperty(&name, AI_MATKEY_NAME);
-
- if (!shader) {
- // Setup dummy texture file name to ensure UV coordinates are kept during postprocessing
- aiString szString;
- if (convertedPath.length()) {
- szString.Set(convertedPath);
- } else {
- ASSIMP_LOG_WARN("Texture file name has zero length. Using default name");
- szString.Set("dummy_texture.bmp");
- }
- pcHelper->AddProperty(&szString, AI_MATKEY_TEXTURE_DIFFUSE(0));
-
- // prevent transparency by default
- int no_alpha = aiTextureFlags_IgnoreAlpha;
- pcHelper->AddProperty(&no_alpha, 1, AI_MATKEY_TEXFLAGS_DIFFUSE(0));
- } else {
- Q3Shader::ConvertShaderToMaterial(pcHelper, *shader);
- }
-
- pScene->mMaterials[iNumMaterials] = (aiMaterial *)pcHelper;
- pcMesh->mMaterialIndex = iNumMaterials++;
-
- // Ensure correct endianness
-#ifdef AI_BUILD_BIG_ENDIAN
-
- for (uint32_t i = 0; i < pcSurfaces->NUM_VERTICES; ++i) {
- AI_SWAP2(pcVertices[i].NORMAL);
- AI_SWAP2(pcVertices[i].X);
- AI_SWAP2(pcVertices[i].Y);
- AI_SWAP2(pcVertices[i].Z);
-
- AI_SWAP4(pcUVs[i].U);
- AI_SWAP4(pcUVs[i].V);
- }
- for (uint32_t i = 0; i < pcSurfaces->NUM_TRIANGLES; ++i) {
- AI_SWAP4(pcTriangles[i].INDEXES[0]);
- AI_SWAP4(pcTriangles[i].INDEXES[1]);
- AI_SWAP4(pcTriangles[i].INDEXES[2]);
- }
-
-#endif
-
- // Fill mesh information
- pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
-
- pcMesh->mNumVertices = pcSurfaces->NUM_TRIANGLES * 3;
- pcMesh->mNumFaces = pcSurfaces->NUM_TRIANGLES;
- pcMesh->mFaces = new aiFace[pcSurfaces->NUM_TRIANGLES];
- pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices];
- pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices];
- pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices];
- pcMesh->mNumUVComponents[0] = 2;
-
- // Fill in all triangles
- unsigned int iCurrent = 0;
- for (unsigned int i = 0; i < (unsigned int)pcSurfaces->NUM_TRIANGLES; ++i) {
- pcMesh->mFaces[i].mIndices = new unsigned int[3];
- pcMesh->mFaces[i].mNumIndices = 3;
-
- //unsigned int iTemp = iCurrent;
- for (unsigned int c = 0; c < 3; ++c, ++iCurrent) {
- pcMesh->mFaces[i].mIndices[c] = iCurrent;
-
- // Read vertices
- aiVector3D &vec = pcMesh->mVertices[iCurrent];
- uint32_t index = pcTriangles->INDEXES[c];
- if (index >= pcSurfaces->NUM_VERTICES) {
- throw DeadlyImportError("MD3: Invalid vertex index");
- }
- vec.x = pcVertices[index].X * AI_MD3_XYZ_SCALE;
- vec.y = pcVertices[index].Y * AI_MD3_XYZ_SCALE;
- vec.z = pcVertices[index].Z * AI_MD3_XYZ_SCALE;
-
- // Convert the normal vector to uncompressed float3 format
- aiVector3D &nor = pcMesh->mNormals[iCurrent];
- LatLngNormalToVec3(pcVertices[index].NORMAL, (ai_real *)&nor);
-
- // Read texture coordinates
- pcMesh->mTextureCoords[0][iCurrent].x = pcUVs[index].U;
- pcMesh->mTextureCoords[0][iCurrent].y = 1.0f - pcUVs[index].V;
- }
- // Flip face order normally, unless shader is backfacing
- if (!(shader && shader->cull == Q3Shader::CULL_CCW)) {
- std::swap(pcMesh->mFaces[i].mIndices[2], pcMesh->mFaces[i].mIndices[1]);
- }
- ++pcTriangles;
- }
-
- // Go to the next surface
- pcSurfaces = (BE_NCONST MD3::Surface *)(((unsigned char *)pcSurfaces) + pcSurfaces->OFS_END);
- }
-
- // For debugging purposes: check whether we found matches for all entries in the skins file
- if (!DefaultLogger::isNullLogger()) {
- for (std::list<Q3Shader::SkinData::TextureEntry>::const_iterator it = skins.textures.begin(); it != skins.textures.end(); ++it) {
- if (!(*it).resolved) {
- ASSIMP_LOG_ERROR("MD3: Failed to match skin ", (*it).first, " to surface ", (*it).second);
- }
- }
- }
-
- if (!pScene->mNumMeshes) {
- throw DeadlyImportError("MD3: File contains no valid mesh");
- }
- pScene->mNumMaterials = iNumMaterials;
-
- // Now we need to generate an empty node graph
- pScene->mRootNode = new aiNode("<MD3Root>");
- pScene->mRootNode->mNumMeshes = pScene->mNumMeshes;
- pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes];
-
- // Attach tiny children for all tags
- if (pcHeader->NUM_TAGS) {
- pScene->mRootNode->mNumChildren = pcHeader->NUM_TAGS;
- pScene->mRootNode->mChildren = new aiNode *[pcHeader->NUM_TAGS];
-
- for (unsigned int i = 0; i < pcHeader->NUM_TAGS; ++i, ++pcTags) {
- aiNode *nd = pScene->mRootNode->mChildren[i] = new aiNode();
- nd->mName.Set((const char *)pcTags->NAME);
- nd->mParent = pScene->mRootNode;
-
- AI_SWAP4(pcTags->origin.x);
- AI_SWAP4(pcTags->origin.y);
- AI_SWAP4(pcTags->origin.z);
-
- // Copy local origin, again flip z,y
- nd->mTransformation.a4 = pcTags->origin.x;
- nd->mTransformation.b4 = pcTags->origin.y;
- nd->mTransformation.c4 = pcTags->origin.z;
-
- // Copy rest of transformation (need to transpose to match row-order matrix)
- for (unsigned int a = 0; a < 3; ++a) {
- for (unsigned int m = 0; m < 3; ++m) {
- nd->mTransformation[m][a] = pcTags->orientation[a][m];
- AI_SWAP4(nd->mTransformation[m][a]);
- }
- }
- }
- }
-
- for (unsigned int i = 0; i < pScene->mNumMeshes; ++i)
- pScene->mRootNode->mMeshes[i] = i;
-
- // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
- pScene->mRootNode->mTransformation = aiMatrix4x4(
- 1.f, 0.f, 0.f, 0.f,
- 0.f, 0.f, 1.f, 0.f,
- 0.f, -1.f, 0.f, 0.f,
- 0.f, 0.f, 0.f, 1.f);
-}
-
-#endif // !! ASSIMP_BUILD_NO_MD3_IMPORTER
diff --git a/libs/assimp/code/AssetLib/MD3/MD3Loader.h b/libs/assimp/code/AssetLib/MD3/MD3Loader.h
deleted file mode 100644
index d911bb1..0000000
--- a/libs/assimp/code/AssetLib/MD3/MD3Loader.h
+++ /dev/null
@@ -1,314 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2022, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
- copyright notice, this list of conditions and the
- following disclaimer.
-
-* Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the
- following disclaimer in the documentation and/or other
- materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
- contributors may be used to endorse or promote products
- derived from this software without specific prior
- written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Md3Loader.h
- * @brief Declaration of the .MD3 importer class.
- */
-#ifndef AI_MD3LOADER_H_INCLUDED
-#define AI_MD3LOADER_H_INCLUDED
-
-#include "MD3FileData.h"
-#include <assimp/BaseImporter.h>
-#include <assimp/ByteSwapper.h>
-#include <assimp/StringComparison.h>
-#include <assimp/types.h>
-
-#include <list>
-
-struct aiMaterial;
-
-namespace Assimp {
-
-using namespace MD3;
-namespace Q3Shader {
-
-// ---------------------------------------------------------------------------
-/** @brief Tiny utility data structure to hold the data of a .skin file
- */
-struct SkinData {
- //! A single entry in texture list
- struct TextureEntry : public std::pair<std::string, std::string> {
- // did we resolve this texture entry?
- bool resolved;
-
- // for std::find()
- bool operator==(const std::string &f) const {
- return f == first;
- }
- };
-
- //! List of textures
- std::list<TextureEntry> textures;
-
- // rest is ignored for the moment
-};
-
-// ---------------------------------------------------------------------------
-/** @brief Specifies cull modi for Quake shader files.
- */
-enum ShaderCullMode {
- CULL_NONE,
- CULL_CW,
- CULL_CCW
-};
-
-// ---------------------------------------------------------------------------
-/** @brief Specifies alpha blend modi (src + dest) for Quake shader files
- */
-enum BlendFunc {
- BLEND_NONE,
- BLEND_GL_ONE,
- BLEND_GL_ZERO,
- BLEND_GL_DST_COLOR,
- BLEND_GL_ONE_MINUS_DST_COLOR,
- BLEND_GL_SRC_ALPHA,
- BLEND_GL_ONE_MINUS_SRC_ALPHA
-};
-
-// ---------------------------------------------------------------------------
-/** @brief Specifies alpha test modi for Quake texture maps
- */
-enum AlphaTestFunc {
- AT_NONE,
- AT_GT0,
- AT_LT128,
- AT_GE128
-};
-
-// ---------------------------------------------------------------------------
-/** @brief Tiny utility data structure to hold a .shader map data block
- */
-struct ShaderMapBlock {
- ShaderMapBlock() AI_NO_EXCEPT
- : blend_src(BLEND_NONE),
- blend_dest(BLEND_NONE),
- alpha_test(AT_NONE) {}
-
- //! Name of referenced map
- std::string name;
-
- //! Blend and alpha test settings for texture
- BlendFunc blend_src, blend_dest;
- AlphaTestFunc alpha_test;
-
- //! For std::find()
- bool operator==(const std::string &o) const {
- return !ASSIMP_stricmp(o, name);
- }
-};
-
-// ---------------------------------------------------------------------------
-/** @brief Tiny utility data structure to hold a .shader data block
- */
-struct ShaderDataBlock {
- ShaderDataBlock() AI_NO_EXCEPT
- : cull(CULL_CW) {}
-
- //! Name of referenced data element
- std::string name;
-
- //! Cull mode for the element
- ShaderCullMode cull;
-
- //! Maps defined in the shader
- std::list<ShaderMapBlock> maps;
-
- //! For std::find()
- bool operator==(const std::string &o) const {
- return !ASSIMP_stricmp(o, name);
- }
-};
-
-// ---------------------------------------------------------------------------
-/** @brief Tiny utility data structure to hold the data of a .shader file
- */
-struct ShaderData {
- //! Shader data blocks
- std::list<ShaderDataBlock> blocks;
-};
-
-// ---------------------------------------------------------------------------
-/** @brief Load a shader file
- *
- * Generally, parsing is error tolerant. There's no failure.
- * @param fill Receives output data
- * @param file File to be read.
- * @param io IOSystem to be used for reading
- * @return false if file is not accessible
- */
-bool LoadShader(ShaderData &fill, const std::string &file, IOSystem *io);
-
-// ---------------------------------------------------------------------------
-/** @brief Convert a Q3Shader to an aiMaterial
- *
- * @param[out] out Material structure to be filled.
- * @param[in] shader Input shader
- */
-void ConvertShaderToMaterial(aiMaterial *out, const ShaderDataBlock &shader);
-
-// ---------------------------------------------------------------------------
-/** @brief Load a skin file
- *
- * Generally, parsing is error tolerant. There's no failure.
- * @param fill Receives output data
- * @param file File to be read.
- * @param io IOSystem to be used for reading
- * @return false if file is not accessible
- */
-bool LoadSkin(SkinData &fill, const std::string &file, IOSystem *io);
-
-} // namespace Q3Shader
-
-// ---------------------------------------------------------------------------
-/** @brief Importer class to load MD3 files
-*/
-class MD3Importer : public BaseImporter {
-public:
- MD3Importer();
- ~MD3Importer() override;
-
- // -------------------------------------------------------------------
- /** Returns whether the class can handle the format of the given file.
- * See BaseImporter::CanRead() for details. */
- bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
- bool checkSig) const override;
-
- // -------------------------------------------------------------------
- /** Called prior to ReadFile().
- * The function is a request to the importer to update its configuration
- * basing on the Importer's configuration property list.
- */
- void SetupProperties(const Importer *pImp) override;
-
-protected:
- // -------------------------------------------------------------------
- /** Return importer meta information.
- * See #BaseImporter::GetInfo for the details
- */
- const aiImporterDesc *GetInfo() const override;
-
- // -------------------------------------------------------------------
- /** Imports the given file into the given scene structure.
- * See BaseImporter::InternReadFile() for details
- */
- void InternReadFile(const std::string &pFile, aiScene *pScene,
- IOSystem *pIOHandler) override;
-
- // -------------------------------------------------------------------
- /** Validate offsets in the header
- */
- void ValidateHeaderOffsets();
- void ValidateSurfaceHeaderOffsets(const MD3::Surface *pcSurfHeader);
-
- // -------------------------------------------------------------------
- /** Read a Q3 multipart file
- * @return true if multi part has been processed
- */
- bool ReadMultipartFile();
-
- // -------------------------------------------------------------------
- /** Try to read the skin for a MD3 file
- * @param fill Receives output information
- */
- void ReadSkin(Q3Shader::SkinData &fill) const;
-
- // -------------------------------------------------------------------
- /** Try to read the shader for a MD3 file
- * @param fill Receives output information
- */
- void ReadShader(Q3Shader::ShaderData &fill) const;
-
- // -------------------------------------------------------------------
- /** Convert a texture path in a MD3 file to a proper value
- * @param[in] texture_name Path to be converted
- * @param[in] header_path Base path specified in MD3 header
- * @param[out] out Receives the converted output string
- */
- void ConvertPath(const char *texture_name, const char *header_path,
- std::string &out) const;
-
-protected:
- /** Configuration option: frame to be loaded */
- unsigned int configFrameID;
-
- /** Configuration option: process multi-part files */
- bool configHandleMP;
-
- /** Configuration option: name of skin file to be read */
- std::string configSkinFile;
-
- /** Configuration option: whether to load shaders */
- bool configLoadShaders;
-
- /** Configuration option: name or path of shader */
- std::string configShaderFile;
-
- /** Configuration option: speed flag was set? */
- bool configSpeedFlag;
-
- /** Header of the MD3 file */
- BE_NCONST MD3::Header *pcHeader;
-
- /** File buffer */
- BE_NCONST unsigned char *mBuffer;
-
- /** Size of the file, in bytes */
- unsigned int fileSize;
-
- /** Current file name */
- std::string mFile;
-
- /** Current base directory */
- std::string path;
-
- /** Pure file we're currently reading */
- std::string filename;
-
- /** Output scene to be filled */
- aiScene *mScene;
-
- /** IO system to be used to access the data*/
- IOSystem *mIOHandler;
-};
-
-} // end of namespace Assimp
-
-#endif // AI_3DSIMPORTER_H_INC