293 lines
9.7 KiB
C++
293 lines
9.7 KiB
C++
/*
|
|
Open Asset Import Library (assimp)
|
|
----------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2024, 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 IRRLoader.h
|
|
* @brief Declaration of the .irrMesh (Irrlight Engine Mesh Format)
|
|
* importer class.
|
|
*/
|
|
#ifndef AI_IRRLOADER_H_INCLUDED
|
|
#define AI_IRRLOADER_H_INCLUDED
|
|
|
|
#include "AssetLib/Irr/IRRShared.h"
|
|
#include "Common/Importer.h"
|
|
|
|
#include <assimp/SceneCombiner.h>
|
|
#include <assimp/StringUtils.h>
|
|
#include <assimp/anim.h>
|
|
|
|
namespace Assimp {
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** Irr importer class.
|
|
*
|
|
* Irr is the native scene file format of the Irrlight engine and its editor
|
|
* irrEdit. As IrrEdit itself is capable of importing quite many file formats,
|
|
* it might be a good file format for data exchange.
|
|
*/
|
|
class IRRImporter : public BaseImporter, public IrrlichtBase {
|
|
public:
|
|
IRRImporter();
|
|
~IRRImporter() 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;
|
|
|
|
protected:
|
|
const aiImporterDesc *GetInfo() const override;
|
|
void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
|
|
void SetupProperties(const Importer *pImp) override;
|
|
|
|
private:
|
|
/** Data structure for a scene-graph node animator
|
|
*/
|
|
struct Animator {
|
|
// Type of the animator
|
|
enum AT {
|
|
UNKNOWN = 0x0,
|
|
ROTATION = 0x1,
|
|
FLY_CIRCLE = 0x2,
|
|
FLY_STRAIGHT = 0x3,
|
|
FOLLOW_SPLINE = 0x4,
|
|
OTHER = 0x5
|
|
|
|
} type;
|
|
|
|
explicit Animator(AT t = UNKNOWN) :
|
|
type(t), speed(ai_real(0.001)), direction(ai_real(0.0), ai_real(1.0), ai_real(0.0)), circleRadius(ai_real(1.0)), tightness(ai_real(0.5)), loop(true), timeForWay(100) {
|
|
}
|
|
|
|
// common parameters
|
|
ai_real speed;
|
|
aiVector3D direction;
|
|
|
|
// FLY_CIRCLE
|
|
aiVector3D circleCenter;
|
|
ai_real circleRadius;
|
|
|
|
// FOLLOW_SPLINE
|
|
ai_real tightness;
|
|
std::vector<aiVectorKey> splineKeys;
|
|
|
|
// ROTATION (angles given in direction)
|
|
|
|
// FLY STRAIGHT
|
|
// circleCenter = start, direction = end
|
|
bool loop;
|
|
int timeForWay;
|
|
};
|
|
|
|
/** Data structure for a scene-graph node in an IRR file
|
|
*/
|
|
struct Node {
|
|
// Type of the node
|
|
enum ET {
|
|
LIGHT,
|
|
CUBE,
|
|
MESH,
|
|
SKYBOX,
|
|
DUMMY,
|
|
CAMERA,
|
|
TERRAIN,
|
|
SPHERE,
|
|
ANIMMESH
|
|
} type;
|
|
|
|
explicit Node(ET t) :
|
|
type(t), scaling(1.0, 1.0, 1.0) // assume uniform scaling by default
|
|
,
|
|
parent(),
|
|
framesPerSecond(0.0),
|
|
id(),
|
|
sphereRadius(1.0),
|
|
spherePolyCountX(100),
|
|
spherePolyCountY(100) {
|
|
|
|
// Generate a default name for the node
|
|
char buffer[128];
|
|
static int cnt;
|
|
ai_snprintf(buffer, 128, "IrrNode_%i", cnt++);
|
|
name = std::string(buffer);
|
|
|
|
// reserve space for up to 5 materials
|
|
materials.reserve(5);
|
|
|
|
// reserve space for up to 5 children
|
|
children.reserve(5);
|
|
}
|
|
|
|
// Transformation of the node
|
|
aiVector3D position, rotation, scaling;
|
|
|
|
// Name of the node
|
|
std::string name;
|
|
|
|
// List of all child nodes
|
|
std::vector<Node *> children;
|
|
|
|
// Parent node
|
|
Node *parent;
|
|
|
|
// Animated meshes: frames per second
|
|
// 0.f if not specified
|
|
ai_real framesPerSecond;
|
|
|
|
// Meshes: path to the mesh to be loaded
|
|
std::string meshPath;
|
|
unsigned int id;
|
|
|
|
// Meshes: List of materials to be assigned
|
|
// along with their corresponding material flags
|
|
std::vector<std::pair<aiMaterial *, unsigned int>> materials;
|
|
|
|
// Spheres: radius of the sphere to be generates
|
|
ai_real sphereRadius;
|
|
|
|
// Spheres: Number of polygons in the x,y direction
|
|
unsigned int spherePolyCountX, spherePolyCountY;
|
|
|
|
// List of all animators assigned to the node
|
|
std::list<Animator> animators;
|
|
};
|
|
|
|
/** Data structure for a vertex in an IRR skybox
|
|
*/
|
|
struct SkyboxVertex {
|
|
SkyboxVertex() = default;
|
|
|
|
//! Construction from single vertex components
|
|
SkyboxVertex(ai_real px, ai_real py, ai_real pz,
|
|
ai_real nx, ai_real ny, ai_real nz,
|
|
ai_real uvx, ai_real uvy)
|
|
|
|
:
|
|
position(px, py, pz), normal(nx, ny, nz), uv(uvx, uvy, 0.0) {}
|
|
|
|
aiVector3D position, normal, uv;
|
|
};
|
|
|
|
// -------------------------------------------------------------------
|
|
// Parse <node> tag from XML file and extract child node
|
|
// @param node XML node
|
|
// @param guessedMeshesContained number of extra guessed meshes
|
|
IRRImporter::Node *ParseNode(pugi::xml_node &node, BatchLoader& batch);
|
|
|
|
// -------------------------------------------------------------------
|
|
// Parse <attributes> tags within <node> tags and apply to scene node
|
|
// @param attributeNode XML child node
|
|
// @param nd Attributed scene node
|
|
void ParseNodeAttributes(pugi::xml_node &attributeNode, IRRImporter::Node *nd, BatchLoader& batch);
|
|
|
|
// -------------------------------------------------------------------
|
|
// Parse an <animator> node and attach an animator to a node
|
|
// @param animatorNode XML animator node
|
|
// @param nd Animated scene node
|
|
void ParseAnimators(pugi::xml_node &animatorNode, IRRImporter::Node *nd);
|
|
|
|
// -------------------------------------------------------------------
|
|
/// Fill the scene-graph recursively
|
|
void GenerateGraph(Node *root, aiNode *rootOut, aiScene *scene,
|
|
BatchLoader &batch,
|
|
std::vector<aiMesh *> &meshes,
|
|
std::vector<aiNodeAnim *> &anims,
|
|
std::vector<AttachmentInfo> &attach,
|
|
std::vector<aiMaterial *> &materials,
|
|
unsigned int &defaultMatIdx);
|
|
|
|
// -------------------------------------------------------------------
|
|
/// Generate a mesh that consists of just a single quad
|
|
aiMesh *BuildSingleQuadMesh(const SkyboxVertex &v1,
|
|
const SkyboxVertex &v2,
|
|
const SkyboxVertex &v3,
|
|
const SkyboxVertex &v4);
|
|
|
|
// -------------------------------------------------------------------
|
|
/// Build a sky-box
|
|
///
|
|
/// @param meshes Receives 6 output meshes
|
|
/// @param materials The last 6 materials are assigned to the newly
|
|
/// created meshes. The names of the materials are adjusted.
|
|
void BuildSkybox(std::vector<aiMesh *> &meshes,
|
|
std::vector<aiMaterial *> materials);
|
|
|
|
// -------------------------------------------------------------------
|
|
/** Copy a material for a mesh to the output material list
|
|
*
|
|
* @param materials Receives an output material
|
|
* @param inmaterials List of input materials
|
|
* @param defMatIdx Default material index - UINT_MAX if not present
|
|
* @param mesh Mesh to work on
|
|
*/
|
|
void CopyMaterial(std::vector<aiMaterial *> &materials,
|
|
std::vector<std::pair<aiMaterial *, unsigned int>> &inmaterials,
|
|
unsigned int &defMatIdx,
|
|
aiMesh *mesh);
|
|
|
|
// -------------------------------------------------------------------
|
|
/** Compute animations for a specific node
|
|
*
|
|
* @param root Node to be processed
|
|
* @param anims The list of output animations
|
|
*/
|
|
void ComputeAnimations(Node *root, aiNode *real,
|
|
std::vector<aiNodeAnim *> &anims);
|
|
|
|
private:
|
|
/// Configuration option: desired output FPS
|
|
double fps;
|
|
|
|
/// Configuration option: speed flag was set?
|
|
bool configSpeedFlag;
|
|
|
|
std::vector<aiCamera*> cameras;
|
|
std::vector<aiLight*> lights;
|
|
unsigned int guessedMeshCnt;
|
|
unsigned int guessedMatCnt;
|
|
unsigned int guessedAnimCnt;
|
|
};
|
|
|
|
} // end of namespace Assimp
|
|
|
|
#endif // AI_IRRIMPORTER_H_INC
|