1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#ifndef STARK_MODEL_MODEL_H
#define STARK_MODEL_MODEL_H
#include "common/array.h"
#include "common/str.h"
#include "math/ray.h"
#include "math/vector3d.h"
namespace Stark {
namespace Gfx {
class TextureSet;
}
class ArchiveReadStream;
class VertNode {
public:
Math::Vector3d _pos1, _pos2;
Math::Vector3d _normal;
float _texS, _texT;
uint32 _bone1, _bone2;
float _boneWeight;
};
struct Face {
uint32 materialId;
Common::Array<uint32> vertexIndices;
Face() : materialId(0) {}
};
struct Material {
Common::String name;
Common::String texture;
float r, g, b;
bool doubleSided;
Material() : r(0), g(0), b(0), doubleSided(false) {};
};
class BoneNode {
public:
BoneNode() : _parent(-1), _idx(0), _u1(0) {}
~BoneNode() { }
/** Perform a collision test with the ray */
bool intersectRay(const Math::Ray &ray) const;
/** Expand a bounding box with the model space BB of this bone */
void expandModelSpaceBB(Math::AABB &aabb) const;
Common::String _name;
float _u1;
Common::Array<uint32> _children;
int _parent;
uint32 _idx;
Math::Vector3d _animPos;
Math::Quaternion _animRot;
/** Bone space bounding box */
Math::AABB _boundingBox;
};
/**
* A 3D Model
*/
class Model {
public:
Model();
~Model();
/**
* Try and initialise object from the specified stream
*/
void readFromStream(ArchiveReadStream *stream);
const Common::Array<VertNode *> &getVertices() const { return _vertices; }
const Common::Array<Face *> &getFaces() const { return _faces; }
const Common::Array<Material *> &getMaterials() const { return _materials; }
const Common::Array<BoneNode *> &getBones() const { return _bones; };
/** Perform a collision test with a ray */
bool intersectRay(const Math::Ray &ray) const;
/** Update the model bounding box with the current animation state */
void updateBoundingBox();
/** Retrieve the model space bounding box for the current animation state */
Math::AABB getBoundingBox() const;
private:
void buildBonesBoundingBoxes();
void buildBoneBoundingBox(BoneNode *bone) const;
void readBones(ArchiveReadStream *stream);
Common::String _name;
uint32 _u1;
float _u2;
Common::Array<VertNode *> _vertices;
Common::Array<Material *> _materials;
Common::Array<Face *> _faces;
Common::Array<BoneNode *> _bones;
Math::AABB _boundingBox;
};
} // End of namespace Stark
#endif // STARK_MODEL_MODEL_H
|
