summaryrefslogtreecommitdiff
path: root/libs/assimp/code/AssetLib/B3D
diff options
context:
space:
mode:
Diffstat (limited to 'libs/assimp/code/AssetLib/B3D')
-rw-r--r--libs/assimp/code/AssetLib/B3D/B3DImporter.cpp744
-rw-r--r--libs/assimp/code/AssetLib/B3D/B3DImporter.h132
2 files changed, 0 insertions, 876 deletions
diff --git a/libs/assimp/code/AssetLib/B3D/B3DImporter.cpp b/libs/assimp/code/AssetLib/B3D/B3DImporter.cpp
deleted file mode 100644
index c4ef75b..0000000
--- a/libs/assimp/code/AssetLib/B3D/B3DImporter.cpp
+++ /dev/null
@@ -1,744 +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 B3DImporter.cpp
- * @brief Implementation of the b3d importer class
- */
-
-#ifndef ASSIMP_BUILD_NO_B3D_IMPORTER
-
-// internal headers
-#include "AssetLib/B3D/B3DImporter.h"
-#include "PostProcessing/ConvertToLHProcess.h"
-#include "PostProcessing/TextureTransform.h"
-
-#include <assimp/StringUtils.h>
-#include <assimp/anim.h>
-#include <assimp/importerdesc.h>
-#include <assimp/scene.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/IOSystem.hpp>
-
-#include <memory>
-
-using namespace Assimp;
-using namespace std;
-
-static const aiImporterDesc desc = {
- "BlitzBasic 3D Importer",
- "",
- "",
- "http://www.blitzbasic.com/",
- aiImporterFlags_SupportBinaryFlavour,
- 0,
- 0,
- 0,
- 0,
- "b3d"
-};
-
-#ifdef _MSC_VER
-#pragma warning(disable : 4018)
-#endif
-
-//#define DEBUG_B3D
-
-template<typename T>
-void DeleteAllBarePointers(std::vector<T> &x) {
- for (auto p : x) {
- delete p;
- }
-}
-
-B3DImporter::~B3DImporter() {
- // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-bool B3DImporter::CanRead(const std::string &pFile, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const {
- size_t pos = pFile.find_last_of('.');
- if (pos == string::npos) {
- return false;
- }
-
- string ext = pFile.substr(pos + 1);
- if (ext.size() != 3) {
- return false;
- }
-
- return (ext[0] == 'b' || ext[0] == 'B') && (ext[1] == '3') && (ext[2] == 'd' || ext[2] == 'D');
-}
-
-// ------------------------------------------------------------------------------------------------
-// Loader meta information
-const aiImporterDesc *B3DImporter::GetInfo() const {
- return &desc;
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
- 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 B3D file ", pFile, ".");
- }
-
- // check whether the .b3d file is large enough to contain
- // at least one chunk.
- size_t fileSize = file->FileSize();
- if (fileSize < 8) {
- throw DeadlyImportError("B3D File is too small.");
- }
-
- _pos = 0;
- _buf.resize(fileSize);
- file->Read(&_buf[0], 1, fileSize);
- _stack.clear();
-
- ReadBB3D(pScene);
-}
-
-// ------------------------------------------------------------------------------------------------
-AI_WONT_RETURN void B3DImporter::Oops() {
- throw DeadlyImportError("B3D Importer - INTERNAL ERROR");
-}
-
-// ------------------------------------------------------------------------------------------------
-AI_WONT_RETURN void B3DImporter::Fail(const string &str) {
-#ifdef DEBUG_B3D
- ASSIMP_LOG_ERROR("Error in B3D file data: ", str);
-#endif
- throw DeadlyImportError("B3D Importer - error in B3D file data: ", str);
-}
-
-// ------------------------------------------------------------------------------------------------
-int B3DImporter::ReadByte() {
- if (_pos > _buf.size()) {
- Fail("EOF");
- }
-
- return _buf[_pos++];
-}
-
-// ------------------------------------------------------------------------------------------------
-int B3DImporter::ReadInt() {
- if (_pos + 4 > _buf.size()) {
- Fail("EOF");
- }
-
- int n;
- memcpy(&n, &_buf[_pos], 4);
- _pos += 4;
-
- return n;
-}
-
-// ------------------------------------------------------------------------------------------------
-float B3DImporter::ReadFloat() {
- if (_pos + 4 > _buf.size()) {
- Fail("EOF");
- }
-
- float n;
- memcpy(&n, &_buf[_pos], 4);
- _pos += 4;
-
- return n;
-}
-
-// ------------------------------------------------------------------------------------------------
-aiVector2D B3DImporter::ReadVec2() {
- float x = ReadFloat();
- float y = ReadFloat();
- return aiVector2D(x, y);
-}
-
-// ------------------------------------------------------------------------------------------------
-aiVector3D B3DImporter::ReadVec3() {
- float x = ReadFloat();
- float y = ReadFloat();
- float z = ReadFloat();
- return aiVector3D(x, y, z);
-}
-
-// ------------------------------------------------------------------------------------------------
-aiQuaternion B3DImporter::ReadQuat() {
- // (aramis_acg) Fix to adapt the loader to changed quat orientation
- float w = -ReadFloat();
- float x = ReadFloat();
- float y = ReadFloat();
- float z = ReadFloat();
- return aiQuaternion(w, x, y, z);
-}
-
-// ------------------------------------------------------------------------------------------------
-string B3DImporter::ReadString() {
- if (_pos > _buf.size()) {
- Fail("EOF");
- }
- string str;
- while (_pos < _buf.size()) {
- char c = (char)ReadByte();
- if (!c) {
- return str;
- }
- str += c;
- }
- return string();
-}
-
-// ------------------------------------------------------------------------------------------------
-string B3DImporter::ReadChunk() {
- string tag;
- for (int i = 0; i < 4; ++i) {
- tag += char(ReadByte());
- }
-#ifdef DEBUG_B3D
- ASSIMP_LOG_DEBUG("ReadChunk: ", tag);
-#endif
- unsigned sz = (unsigned)ReadInt();
- _stack.push_back(_pos + sz);
- return tag;
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ExitChunk() {
- _pos = _stack.back();
- _stack.pop_back();
-}
-
-// ------------------------------------------------------------------------------------------------
-size_t B3DImporter::ChunkSize() {
- return _stack.back() - _pos;
-}
-// ------------------------------------------------------------------------------------------------
-
-template <class T>
-T *B3DImporter::to_array(const vector<T> &v) {
- if (v.empty()) {
- return 0;
- }
- T *p = new T[v.size()];
- for (size_t i = 0; i < v.size(); ++i) {
- p[i] = v[i];
- }
- return p;
-}
-
-// ------------------------------------------------------------------------------------------------
-template <class T>
-T **unique_to_array(vector<std::unique_ptr<T>> &v) {
- if (v.empty()) {
- return 0;
- }
- T **p = new T *[v.size()];
- for (size_t i = 0; i < v.size(); ++i) {
- p[i] = v[i].release();
- }
- return p;
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadTEXS() {
- while (ChunkSize()) {
- string name = ReadString();
- /*int flags=*/ReadInt();
- /*int blend=*/ReadInt();
- /*aiVector2D pos=*/ReadVec2();
- /*aiVector2D scale=*/ReadVec2();
- /*float rot=*/ReadFloat();
-
- _textures.push_back(name);
- }
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadBRUS() {
- int n_texs = ReadInt();
- if (n_texs < 0 || n_texs > 8) {
- Fail("Bad texture count");
- }
- while (ChunkSize()) {
- string name = ReadString();
- aiVector3D color = ReadVec3();
- float alpha = ReadFloat();
- float shiny = ReadFloat();
- /*int blend=**/ ReadInt();
- int fx = ReadInt();
-
- std::unique_ptr<aiMaterial> mat(new aiMaterial);
-
- // Name
- aiString ainame(name);
- mat->AddProperty(&ainame, AI_MATKEY_NAME);
-
- // Diffuse color
- mat->AddProperty(&color, 1, AI_MATKEY_COLOR_DIFFUSE);
-
- // Opacity
- mat->AddProperty(&alpha, 1, AI_MATKEY_OPACITY);
-
- // Specular color
- aiColor3D speccolor(shiny, shiny, shiny);
- mat->AddProperty(&speccolor, 1, AI_MATKEY_COLOR_SPECULAR);
-
- // Specular power
- float specpow = shiny * 128;
- mat->AddProperty(&specpow, 1, AI_MATKEY_SHININESS);
-
- // Double sided
- if (fx & 0x10) {
- int i = 1;
- mat->AddProperty(&i, 1, AI_MATKEY_TWOSIDED);
- }
-
- //Textures
- for (int i = 0; i < n_texs; ++i) {
- int texid = ReadInt();
- if (texid < -1 || (texid >= 0 && texid >= static_cast<int>(_textures.size()))) {
- Fail("Bad texture id");
- }
- if (i == 0 && texid >= 0) {
- aiString texname(_textures[texid]);
- mat->AddProperty(&texname, AI_MATKEY_TEXTURE_DIFFUSE(0));
- }
- }
- _materials.emplace_back(std::move(mat));
- }
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadVRTS() {
- _vflags = ReadInt();
- _tcsets = ReadInt();
- _tcsize = ReadInt();
- if (_tcsets < 0 || _tcsets > 4 || _tcsize < 0 || _tcsize > 4) {
- Fail("Bad texcoord data");
- }
-
- int sz = 12 + (_vflags & 1 ? 12 : 0) + (_vflags & 2 ? 16 : 0) + (_tcsets * _tcsize * 4);
- size_t n_verts = ChunkSize() / sz;
-
- int v0 = static_cast<int>(_vertices.size());
- _vertices.resize(v0 + n_verts);
-
- for (unsigned int i = 0; i < n_verts; ++i) {
- Vertex &v = _vertices[v0 + i];
-
- memset(v.bones, 0, sizeof(v.bones));
- memset(v.weights, 0, sizeof(v.weights));
-
- v.vertex = ReadVec3();
-
- if (_vflags & 1) {
- v.normal = ReadVec3();
- }
-
- if (_vflags & 2) {
- ReadQuat(); //skip v 4bytes...
- }
-
- for (int j = 0; j < _tcsets; ++j) {
- float t[4] = { 0, 0, 0, 0 };
- for (int k = 0; k < _tcsize; ++k) {
- t[k] = ReadFloat();
- }
- t[1] = 1 - t[1];
- if (!j) {
- v.texcoords = aiVector3D(t[0], t[1], t[2]);
- }
- }
- }
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadTRIS(int v0) {
- int matid = ReadInt();
- if (matid == -1) {
- matid = 0;
- } else if (matid < 0 || matid >= (int)_materials.size()) {
-#ifdef DEBUG_B3D
- ASSIMP_LOG_ERROR("material id=", matid);
-#endif
- Fail("Bad material id");
- }
-
- std::unique_ptr<aiMesh> mesh(new aiMesh);
-
- mesh->mMaterialIndex = matid;
- mesh->mNumFaces = 0;
- mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
-
- size_t n_tris = ChunkSize() / 12;
- aiFace *face = mesh->mFaces = new aiFace[n_tris];
-
- for (unsigned int i = 0; i < n_tris; ++i) {
- int i0 = ReadInt() + v0;
- int i1 = ReadInt() + v0;
- int i2 = ReadInt() + v0;
- if (i0 < 0 || i0 >= (int)_vertices.size() || i1 < 0 || i1 >= (int)_vertices.size() || i2 < 0 || i2 >= (int)_vertices.size()) {
-#ifdef DEBUG_B3D
- ASSIMP_LOG_ERROR("Bad triangle index: i0=", i0, ", i1=", i1, ", i2=", i2);
-#endif
- Fail("Bad triangle index");
- continue;
- }
- face->mNumIndices = 3;
- face->mIndices = new unsigned[3];
- face->mIndices[0] = i0;
- face->mIndices[1] = i1;
- face->mIndices[2] = i2;
- ++mesh->mNumFaces;
- ++face;
- }
-
- _meshes.emplace_back(std::move(mesh));
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadMESH() {
- /*int matid=*/ReadInt();
-
- int v0 = static_cast<int>(_vertices.size());
-
- while (ChunkSize()) {
- string t = ReadChunk();
- if (t == "VRTS") {
- ReadVRTS();
- } else if (t == "TRIS") {
- ReadTRIS(v0);
- }
- ExitChunk();
- }
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadBONE(int id) {
- while (ChunkSize()) {
- int vertex = ReadInt();
- float weight = ReadFloat();
- if (vertex < 0 || vertex >= (int)_vertices.size()) {
- Fail("Bad vertex index");
- }
-
- Vertex &v = _vertices[vertex];
- for (int i = 0; i < 4; ++i) {
- if (!v.weights[i]) {
- v.bones[i] = static_cast<unsigned char>(id);
- v.weights[i] = weight;
- break;
- }
- }
- }
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadKEYS(aiNodeAnim *nodeAnim) {
- vector<aiVectorKey> trans, scale;
- vector<aiQuatKey> rot;
- int flags = ReadInt();
- while (ChunkSize()) {
- int frame = ReadInt();
- if (flags & 1) {
- trans.push_back(aiVectorKey(frame, ReadVec3()));
- }
- if (flags & 2) {
- scale.push_back(aiVectorKey(frame, ReadVec3()));
- }
- if (flags & 4) {
- rot.push_back(aiQuatKey(frame, ReadQuat()));
- }
- }
-
- if (flags & 1) {
- nodeAnim->mNumPositionKeys = static_cast<unsigned int>(trans.size());
- nodeAnim->mPositionKeys = to_array(trans);
- }
-
- if (flags & 2) {
- nodeAnim->mNumScalingKeys = static_cast<unsigned int>(scale.size());
- nodeAnim->mScalingKeys = to_array(scale);
- }
-
- if (flags & 4) {
- nodeAnim->mNumRotationKeys = static_cast<unsigned int>(rot.size());
- nodeAnim->mRotationKeys = to_array(rot);
- }
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadANIM() {
- /*int flags=*/ReadInt();
- int frames = ReadInt();
- float fps = ReadFloat();
-
- std::unique_ptr<aiAnimation> anim(new aiAnimation);
-
- anim->mDuration = frames;
- anim->mTicksPerSecond = fps;
- _animations.emplace_back(std::move(anim));
-}
-
-// ------------------------------------------------------------------------------------------------
-aiNode *B3DImporter::ReadNODE(aiNode *parent) {
-
- string name = ReadString();
- aiVector3D t = ReadVec3();
- aiVector3D s = ReadVec3();
- aiQuaternion r = ReadQuat();
-
- aiMatrix4x4 trans, scale, rot;
-
- aiMatrix4x4::Translation(t, trans);
- aiMatrix4x4::Scaling(s, scale);
- rot = aiMatrix4x4(r.GetMatrix());
-
- aiMatrix4x4 tform = trans * rot * scale;
-
- int nodeid = static_cast<int>(_nodes.size());
-
- aiNode *node = new aiNode(name);
- _nodes.push_back(node);
-
- node->mParent = parent;
- node->mTransformation = tform;
-
- std::unique_ptr<aiNodeAnim> nodeAnim;
- vector<unsigned> meshes;
- vector<aiNode *> children;
-
- while (ChunkSize()) {
- const string chunk = ReadChunk();
- if (chunk == "MESH") {
- unsigned int n = static_cast<unsigned int>(_meshes.size());
- ReadMESH();
- for (unsigned int i = n; i < static_cast<unsigned int>(_meshes.size()); ++i) {
- meshes.push_back(i);
- }
- } else if (chunk == "BONE") {
- ReadBONE(nodeid);
- } else if (chunk == "ANIM") {
- ReadANIM();
- } else if (chunk == "KEYS") {
- if (!nodeAnim) {
- nodeAnim.reset(new aiNodeAnim);
- nodeAnim->mNodeName = node->mName;
- }
- ReadKEYS(nodeAnim.get());
- } else if (chunk == "NODE") {
- aiNode *child = ReadNODE(node);
- children.push_back(child);
- }
- ExitChunk();
- }
-
- if (nodeAnim) {
- _nodeAnims.emplace_back(std::move(nodeAnim));
- }
-
- node->mNumMeshes = static_cast<unsigned int>(meshes.size());
- node->mMeshes = to_array(meshes);
-
- node->mNumChildren = static_cast<unsigned int>(children.size());
- node->mChildren = to_array(children);
-
- return node;
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadBB3D(aiScene *scene) {
-
- _textures.clear();
-
- _materials.clear();
-
- _vertices.clear();
-
- _meshes.clear();
-
- DeleteAllBarePointers(_nodes);
- _nodes.clear();
-
- _nodeAnims.clear();
-
- _animations.clear();
-
- string t = ReadChunk();
- if (t == "BB3D") {
- int version = ReadInt();
-
- if (!DefaultLogger::isNullLogger()) {
- char dmp[128];
- ai_snprintf(dmp, 128, "B3D file format version: %i", version);
- ASSIMP_LOG_INFO(dmp);
- }
-
- while (ChunkSize()) {
- const string chunk = ReadChunk();
- if (chunk == "TEXS") {
- ReadTEXS();
- } else if (chunk == "BRUS") {
- ReadBRUS();
- } else if (chunk == "NODE") {
- ReadNODE(0);
- }
- ExitChunk();
- }
- }
- ExitChunk();
-
- if (!_nodes.size()) {
- Fail("No nodes");
- }
-
- if (!_meshes.size()) {
- Fail("No meshes");
- }
-
- // Fix nodes/meshes/bones
- for (size_t i = 0; i < _nodes.size(); ++i) {
- aiNode *node = _nodes[i];
-
- for (size_t j = 0; j < node->mNumMeshes; ++j) {
- aiMesh *mesh = _meshes[node->mMeshes[j]].get();
-
- int n_tris = mesh->mNumFaces;
- int n_verts = mesh->mNumVertices = n_tris * 3;
-
- aiVector3D *mv = mesh->mVertices = new aiVector3D[n_verts], *mn = 0, *mc = 0;
- if (_vflags & 1) {
- mn = mesh->mNormals = new aiVector3D[n_verts];
- }
- if (_tcsets) {
- mc = mesh->mTextureCoords[0] = new aiVector3D[n_verts];
- }
-
- aiFace *face = mesh->mFaces;
-
- vector<vector<aiVertexWeight>> vweights(_nodes.size());
-
- for (int vertIdx = 0; vertIdx < n_verts; vertIdx += 3) {
- for (int faceIndex = 0; faceIndex < 3; ++faceIndex) {
- Vertex &v = _vertices[face->mIndices[faceIndex]];
-
- *mv++ = v.vertex;
- if (mn) *mn++ = v.normal;
- if (mc) *mc++ = v.texcoords;
-
- face->mIndices[faceIndex] = vertIdx + faceIndex;
-
- for (int k = 0; k < 4; ++k) {
- if (!v.weights[k])
- break;
-
- int bone = v.bones[k];
- float weight = v.weights[k];
-
- vweights[bone].push_back(aiVertexWeight(vertIdx + faceIndex, weight));
- }
- }
- ++face;
- }
-
- vector<aiBone *> bones;
- for (size_t weightIndx = 0; weightIndx < vweights.size(); ++weightIndx) {
- vector<aiVertexWeight> &weights = vweights[weightIndx];
- if (!weights.size()) {
- continue;
- }
-
- aiBone *bone = new aiBone;
- bones.push_back(bone);
-
- aiNode *bnode = _nodes[weightIndx];
-
- bone->mName = bnode->mName;
- bone->mNumWeights = static_cast<unsigned int>(weights.size());
- bone->mWeights = to_array(weights);
-
- aiMatrix4x4 mat = bnode->mTransformation;
- while (bnode->mParent) {
- bnode = bnode->mParent;
- mat = bnode->mTransformation * mat;
- }
- bone->mOffsetMatrix = mat.Inverse();
- }
- mesh->mNumBones = static_cast<unsigned int>(bones.size());
- mesh->mBones = to_array(bones);
- }
- }
-
- //nodes
- scene->mRootNode = _nodes[0];
- _nodes.clear(); // node ownership now belongs to scene
-
- //material
- if (!_materials.size()) {
- _materials.emplace_back(std::unique_ptr<aiMaterial>(new aiMaterial));
- }
- scene->mNumMaterials = static_cast<unsigned int>(_materials.size());
- scene->mMaterials = unique_to_array(_materials);
-
- //meshes
- scene->mNumMeshes = static_cast<unsigned int>(_meshes.size());
- scene->mMeshes = unique_to_array(_meshes);
-
- //animations
- if (_animations.size() == 1 && _nodeAnims.size()) {
-
- aiAnimation *anim = _animations.back().get();
- anim->mNumChannels = static_cast<unsigned int>(_nodeAnims.size());
- anim->mChannels = unique_to_array(_nodeAnims);
-
- scene->mNumAnimations = static_cast<unsigned int>(_animations.size());
- scene->mAnimations = unique_to_array(_animations);
- }
-
- // convert to RH
- MakeLeftHandedProcess makeleft;
- makeleft.Execute(scene);
-
- FlipWindingOrderProcess flip;
- flip.Execute(scene);
-}
-
-#endif // !! ASSIMP_BUILD_NO_B3D_IMPORTER
diff --git a/libs/assimp/code/AssetLib/B3D/B3DImporter.h b/libs/assimp/code/AssetLib/B3D/B3DImporter.h
deleted file mode 100644
index e47d907..0000000
--- a/libs/assimp/code/AssetLib/B3D/B3DImporter.h
+++ /dev/null
@@ -1,132 +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 Definition of the .b3d importer class.
- */
-#pragma once
-#ifndef AI_B3DIMPORTER_H_INC
-#define AI_B3DIMPORTER_H_INC
-
-#include <assimp/types.h>
-#include <assimp/mesh.h>
-#include <assimp/material.h>
-#include <assimp/BaseImporter.h>
-
-#include <memory>
-#include <vector>
-
-struct aiNodeAnim;
-struct aiNode;
-struct aiAnimation;
-
-namespace Assimp{
-
-class B3DImporter : public BaseImporter{
-public:
- B3DImporter() = default;
- ~B3DImporter() override;
- bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const override;
-
-protected:
- const aiImporterDesc* GetInfo () const override;
- void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) override;
-
-private:
-
- int ReadByte();
- int ReadInt();
- float ReadFloat();
- aiVector2D ReadVec2();
- aiVector3D ReadVec3();
- aiQuaternion ReadQuat();
- std::string ReadString();
- std::string ReadChunk();
- void ExitChunk();
- size_t ChunkSize();
-
- template<class T>
- T *to_array( const std::vector<T> &v );
-
- struct Vertex{
- aiVector3D vertex;
- aiVector3D normal;
- aiVector3D texcoords;
- unsigned char bones[4];
- float weights[4];
- };
-
- AI_WONT_RETURN void Oops() AI_WONT_RETURN_SUFFIX;
- AI_WONT_RETURN void Fail(const std::string &str) AI_WONT_RETURN_SUFFIX;
-
- void ReadTEXS();
- void ReadBRUS();
-
- void ReadVRTS();
- void ReadTRIS( int v0 );
- void ReadMESH();
- void ReadBONE( int id );
- void ReadKEYS( aiNodeAnim *nodeAnim );
- void ReadANIM();
-
- aiNode *ReadNODE( aiNode *parent );
-
- void ReadBB3D( aiScene *scene );
-
- size_t _pos;
- std::vector<unsigned char> _buf;
- std::vector<size_t> _stack;
-
- std::vector<std::string> _textures;
- std::vector<std::unique_ptr<aiMaterial> > _materials;
-
- int _vflags,_tcsets,_tcsize;
- std::vector<Vertex> _vertices;
-
- std::vector<aiNode*> _nodes;
- std::vector<std::unique_ptr<aiMesh> > _meshes;
- std::vector<std::unique_ptr<aiNodeAnim> > _nodeAnims;
- std::vector<std::unique_ptr<aiAnimation> > _animations;
-};
-
-}
-
-#endif
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-24 19:11:18 +0000