Mirrors/SBSPSS
1
0
Fork 0
Code Releases Activity
8788076d39
SBSPSS/Utils/Libs/GinLib/gintex.h

781 lines
22 KiB
C
Raw Normal View History

2000-12-02 19:55:49 +01:00
/********************/
/*** Daves GinTex ***/
/********************/
#pragma warning( disable : 4786 )
#ifndef __GINTEX_H__
#define __GINTEX_H__
#include <vector>
#include "ginio.h"
#include "maths.h"
#include "IniClass.h"
/*****************************************************************************/
int IsStrSame(char *Str0,char *Str1,int Len=-1);
/*****************************************************************************/
/*** Version Chunk ***********************************************************/
/*****************************************************************************/
class CVers : public GinChunk
{
public:
virtual char const * GetName(void) const {return("VERS");}
int GetVersion(void) {return(Version);}
protected:
virtual GinChunk * MakeNew(void) {return(new CVers);}
virtual void Load(Gifstream & In)
{
Version=In.Get32();
}
int Version;
};
/*****************************************************************************/
/*** Material Chunk **********************************************************/
/*****************************************************************************/
struct Material
{
int TexId;
int Flags;
};
class CMat4 : public GinChunk
{
public:
virtual char const * GetName(void) const {return("MAT4");}
std::vector<Material> const & GetMaterials(void) const {return(Mats);}
int GetTexId(int v);
protected:
virtual GinChunk * MakeNew(void) {return(new CMat4);}
virtual void Load(Gifstream & In);
std::vector<Material> Mats;
};
/*****************************************************************************/
/*** Mesh Chunk **************************************************************/
/*****************************************************************************/
struct MeshChunk
{
int MatId;
int NumFace;
int MeshNum;
int Attrib;
int Normals;
int Vcol;
int Tex;
};
class CMesh : public GinChunk
{
public:
virtual char const * GetName(void) const {return("MESH");}
std::vector<MeshChunk> const & GetChunk(void) const {return(Chunk);}
int getObj( void ) const {return Obj;}
protected:
int Obj;
std::vector<MeshChunk> Chunk;
virtual GinChunk * MakeNew(void) {return(new CMesh);}
virtual void Load(Gifstream & In);
};
/*****************************************************************************/
/*** Model Chunk *************************************************************/
/*****************************************************************************/
struct Mod4Chunk
{
long nCurObj;
char Name[32];
float Radius;
float CentreX,CentreY,CentreZ;
float ApX,ApY,ApZ;
};
class CMod4: public GinChunk
{
public:
virtual char const * GetName(void) const {return("MOD4");}
std::vector<Mod4Chunk> const & GetChunk(void) const {return(Chunk);}
char * GetModelName() {return(Chunk[0].Name);}
protected:
std::vector<Mod4Chunk> Chunk;
virtual GinChunk * MakeNew(void) {return(new CMod4);}
virtual void Load(Gifstream & In);
};
/*****************************************************************************/
/*** Texture Name Chunk ******************************************************/
/*****************************************************************************/
class CTexName : public GinChunk
{
public:
virtual char const * GetName(void) const {return("TEX4");}
std::vector<GString> const & GetTexNames(void) const {return(Names);}
virtual GinChunk * MakeNew(void) {return(new CTexName);}
virtual void Load(Gifstream & In);
protected:
std::vector<GString> Names;
};
/*****************************************************************************/
/*** Vtx Chunk ***************************************************************/
/*****************************************************************************/
/*struct vec
{
float x,y,z;
vec() {x = y = z = 0.f;}
vec(float _x, float _y, float _z) {x = _x; y = _y;z = _z;}
};
*/
class CPts4: public GinChunk
{
virtual char const * GetName(void) const {return("PTS4");}
virtual GinChunk * MakeNew(void) {return(new CPts4);}
virtual void Load(Gifstream & In)
{
ModNum = In.Get32();
int nv = In.Get32();
Pnts.resize(nv);
for (int i = 0; i< nv ;i++)
{
float x,y,z;
In.read((char*)&x, 4);
In.read((char*)&y, 4);
In.read((char*)&z, 4);
Pnts[i] = TVECTOR(x,y,z);
}
}
public:
std::vector<TVECTOR> const & GetPts(void) const {return(Pnts);}
int GetModNum(void) const {return ModNum;}
protected:
int ModNum;
std::vector<TVECTOR> Pnts;
};
/*****************************************************************************/
/*** Poly Chunk **************************************************************/
/*****************************************************************************/
struct sGinTri
{
int p[3];
int vis[3];
BOOL operator==(sGinTri const &v1)
{
for (int i=0; i<3;i++)
{
if (p[i]!=v1.p[i]) return(FALSE);
if (vis[i]!=v1.vis[i]) return(FALSE);
}
return (TRUE);
}
};
class CPoly: public GinChunk
{
virtual char const * GetName(void) const {return("POLY");}
virtual GinChunk * MakeNew(void) {return(new CPoly);}
virtual void Load(Gifstream & In)
{
ModNum = In.Get16();
MeshNum = In.Get16();
int nf = In.Get32();
Tris.resize(nf);
for(int i=0; i<nf; i++)
{
for (int j=0; j<3; j++) Tris[i].p[j] = In.Get32();
for (int h=0; h<3; h++) Tris[i].vis[h] = In.Get32();
}
}
public:
std::vector<sGinTri> const & GetTris(void) const {return(Tris);}
int GetModNum(void) const {return ModNum;}
int GetMeshNum(void) const {return MeshNum;}
protected:
int ModNum,MeshNum;
std::vector<sGinTri> Tris;
};
/*****************************************************************************/
/*** Vtx Color Chunk *********************************************************/
/*****************************************************************************/
struct sRGB
{
float r,g,b;
};
struct sVColTri
{
sRGB p[3];
};
class CVcol: public GinChunk
{
virtual char const * GetName(void) const {return("VCOL");}
virtual GinChunk * MakeNew(void) {return(new CVcol);}
virtual void Load(Gifstream & In)
{
ModNum = In.Get32();
MeshNum = In.Get32();
int nf = In.Get32();
Tris.resize(nf);
for(int i=0; i<nf; i++)
{
for (int j=0; j<3; j++)
{
float r,g,b;
In.read((char*)&r, 4);
In.read((char*)&g, 4);
In.read((char*)&b, 4);
Tris[i].p[j].r = r;
Tris[i].p[j].g = g;
Tris[i].p[j].b = b;
}
}
}
public:
std::vector<sVColTri> const & GetVcolTris(void) const {return(Tris);}
int GetModNum(void) const {return ModNum;}
int GetMeshNum(void) const {return MeshNum;}
protected:
int ModNum,MeshNum;
std::vector<sVColTri> Tris;
};
/*****************************************************************************/
/*** Texture UV's Chunk ******************************************************/
/*****************************************************************************/
struct sUV
{
float u,v;
BOOL operator==(sUV const &v1)
{
return(u==v1.u && v==v1.v);
}
};
struct sUVTri
{
sUV p[3];
BOOL operator==(sUVTri const &v1)
{
for (int i=0; i<3;i++)
{
if (!(p[i]==v1.p[i])) return(FALSE);
}
return (TRUE);
}
};
class CUVtri: public GinChunk
{
virtual char const * GetName(void) const {return("MAP4");}
virtual GinChunk * MakeNew(void) {return(new CUVtri);}
virtual void Load(Gifstream & In)
{
ModNum = In.Get16();
MeshNum = In.Get16();
int nf = In.Get32();
Tris.resize(nf);
for(int i=0; i<nf; i++)
{
for (int j=0; j<3; j++)
{
float u,v;
In.read((char*)&u, 4);
In.read((char*)&v, 4);
Tris[i].p[j].u = u;
Tris[i].p[j].v = v;
}
}
}
public:
std::vector<sUVTri> const & GetUVTris(void) const {return(Tris);}
int GetModNum(void) const {return ModNum;}
int GetMeshNum(void) const {return MeshNum;}
protected:
int ModNum,MeshNum;
std::vector<sUVTri> Tris;
};
/*****************************************************************************/
/*** Scene Tree Chunk ********************************************************/
/*****************************************************************************/
struct sGinWeight
{
long VertNo;
float Weight;
float X,Y,Z;
};
struct sGinAnim
{
int Frame;
float XPos,YPos,ZPos;
float XAng,YAng,ZAng,WAng;
float kX,kY,kZ;
float uX,uY,uZ,uW;
};
class CNode
{
public:
int IsNodePrefix(char *InName) // Checks prefix
{
return(IsStrSame(InName,Name,strlen(InName)));
}
int IsNodeName(char *InName) // Checks full name
{
return(IsStrSame(InName,Name));
}
void AddChild(std::vector<CNode> &Tree,CNode &Node,int Parent)
{
Node.ChildList.clear();
int TreeSize=Tree.size();
Node.ParentIdx=Parent;
Node.Idx=TreeSize;
Node.Active=true;
if (Parent!=-1) Tree[Parent].ChildList.push_back(Node.Idx);
if (!(Parent==-1 && Node.Idx)) Tree.push_back(Node);
}
void AddPruneChild(std::vector<CNode> &SceneTree,std::vector<int> &PruneTree,int Parent)
{
PruneIdx=PruneTree.size();
PruneTree.push_back(Idx);
if (Parent!=-1)
{
PruneParentIdx=SceneTree[Parent].PruneIdx;
SceneTree[Parent].PruneChildList.push_back(Idx);
}
else
{
PruneParentIdx=-1;
}
}
TVECTOR GetWorldPos(TVECTOR &Pos);// {return(WorldMtx*Pos);}
TVECTOR GetWorldPos(float X,float Y,float Z) {return(GetWorldPos(TVECTOR (X,Y,Z)));}
TVECTOR GetWorldPos() {return(GetWorldPos(TVECTOR (XPos,YPos,ZPos)));}
TQUAT GetWorldAng(TQUAT &Q);// {return(WorldMtx*Pos);}
TQUAT GetWorldAng(float X,float Y,float Z,float W) {return(GetWorldAng(TQUAT (X,Y,Z,W)));}
TQUAT GetWorldAng() {return(GetWorldAng(TQUAT (XAng,YAng,ZAng,WAng)));}
int GetChildCount() {return(ChildList.size());}
int GetPruneChildCount() {return(PruneChildList.size());}
std::vector<TVECTOR> const &GetPts() const {return(Pts);}
std::vector<TVECTOR> const &GetRelPts() const {return(RelPts);}
std::vector<sGinTri> const &GetTris() const {return(Tris);}
std::vector<sVColTri> const &GetVColTris() const {return(VColTris);}
std::vector<sUVTri> const &GetUVTris() const {return(UVTris);}
std::vector<int> const &GetTriMaterial() const {return(TriMaterial);}
std::vector<sGinAnim> const &GetAnim() const {return(Anim);}
std::vector<sGinAnim> const &GetKeyAnim() const {return(KeyAnim);}
std::vector<sGinAnim> const &GetShrunkAnim() const {return(ShrunkAnim);}
std::vector<sGinAnim> const &GetShrunkKeyAnim() const {return(ShrunkKeyAnim);}
char *GetName() {return(Name);}
int Idx,ParentIdx;
int PruneIdx,PruneParentIdx;
char Name[32];
float XPos,YPos,ZPos;
float XAng,YAng,ZAng,WAng;
float Xapk,Yapk,Zapk;
float Xapu,Yapu,Zapu,Wapu;
int Active;
TMATRIX Mtx,WorldMtx;
CIni UserProp;
std::vector<int> ChildList;
std::vector<int> PruneChildList;
std::vector<sGinWeight> Weights;
std::vector<TVECTOR> Pts;
std::vector<TVECTOR> RelPts;
std::vector<sGinTri> Tris;
std::vector<sVColTri> VColTris;
std::vector<sUVTri> UVTris;
std::vector<int> TriMaterial;
std::vector<sGinAnim> Anim;
std::vector<sGinAnim> KeyAnim;
// Shrunk Anim stuff
int StartFrame,EndFrame;
std::vector<sGinAnim> ShrunkAnim;
std::vector<sGinAnim> ShrunkKeyAnim;
long Flags,Pad;
int TriggerCount,TriggerIdx;
int TriBase;
};
class CGinTree: public GinChunk
{
virtual char const * GetName(void) const {return("TREE");}
virtual GinChunk * MakeNew(void) {return(new CGinTree);}
virtual void Load(Gifstream & In);
void LoadTree(Gifstream & In,int Parent);
public:
std::vector<CNode> const & GetTree(void) const{return(SceneTree);}
protected:
std::vector<CNode> SceneTree;
};
/*****************************************************************************/
/*** Skin Chunk **************************************************************/
/*****************************************************************************/
class CSkinTree: public GinChunk
{
virtual char const * GetName(void) const {return("BONE");}
virtual GinChunk * MakeNew(void) {return(new CSkinTree);}
virtual void Load(Gifstream & In);
void LoadTree(Gifstream & In,int Parent);
public:
std::vector<CNode> const & GetTree(void) const{return(SkinTree);}
protected:
std::vector<CNode> SkinTree;
};
/*****************************************************************************/
/*** Tree Anim Chunk *********************************************************/
/*****************************************************************************/
class CAnimTree: public GinChunk
{
virtual char const * GetName(void) const {return("ANIM");}
virtual GinChunk * MakeNew(void) {return(new CAnimTree);}
virtual void Load(Gifstream & In);
void LoadTree(Gifstream & In,int Parent,int FrameCount);
public:
std::vector<CNode> const & GetTree(void) const{return(AnimTree);}
// int GetFrameCount() {return(FrameCount);}
protected:
// int FrameCount;
std::vector<CNode> AnimTree;
};
/*****************************************************************************/
/*** Tree Key Anim Chunk *****************************************************/
/*****************************************************************************/
class CKeyAnimTree: public GinChunk
{
virtual char const * GetName(void) const {return("KEY4");}
virtual GinChunk * MakeNew(void) {return(new CKeyAnimTree);}
virtual void Load(Gifstream & In);
void LoadTree(Gifstream & In,int Parent);
public:
std::vector<CNode> const & GetTree(void) const{return(AnimTree);}
protected:
std::vector<CNode> AnimTree;
};
/*****************************************************************************/
/*** User Prop Chunk *********************************************************/
/*****************************************************************************/
class CUserProp: public GinChunk
{
virtual char const * GetName(void) const {return("PROP");}
virtual GinChunk * MakeNew(void) {return(new CUserProp);}
virtual void Load(Gifstream & In)
{
ModNum = In.Get32()-1;
int Size = In.Get32();
Prop.resize(Size+1);
for(int i=0; i<Size; i++)
{
In.read((char*)&Prop[i],1);
}
Prop[Size]=0;
}
public:
std::vector<char> const & GetUserProp() const {return(Prop);}
int GetModNum(void) const {return ModNum;}
protected:
int ModNum;
std::vector<char> Prop;
};
/*****************************************************************************/
/*** Camera Chunk ************************************************************/
/*****************************************************************************/
struct sCam
{
std::vector<TVECTOR> CamPos;
std::vector<TVECTOR> Target;
} ;
class CCamera: public GinChunk
{
virtual char const * GetName(void) const {return("CAM4");}
virtual GinChunk * MakeNew(void) {return(new CCamera);}
virtual void Load(Gifstream & In)
{
int Frame,FrameCount = In.Get32();
ThisCam.CamPos.resize(FrameCount);
ThisCam.Target.resize(FrameCount);
for (Frame = 0; Frame< FrameCount;Frame++)
{
float x,y,z;
In.read((char*)&x, 4);
In.read((char*)&y, 4);
In.read((char*)&z, 4);
ThisCam.CamPos[Frame] = TVECTOR(x,y,z);
}
for (Frame = 0; Frame< FrameCount;Frame++)
{
float x,y,z;
In.read((char*)&x, 4);
In.read((char*)&y, 4);
In.read((char*)&z, 4);
ThisCam.Target[Frame]= TVECTOR(x,y,z);
}
}
public:
sCam const & GetCam(void) const {return(ThisCam);}
protected:
sCam ThisCam;
};
/*****************************************************************************/
/*** Gin Loader **************************************************************/
/*****************************************************************************/
class Gin4File : public GObject
{
public:
Gin4File(void)
{
MyFile.AddHandler(new CTexName);
MyFile.AddHandler(new CVers);
MyFile.AddHandler(new CMesh);
MyFile.AddHandler(new CMod4);
MyFile.AddHandler(new CMat4);
MyFile.AddHandler(new CPts4);
MyFile.AddHandler(new CPoly);
MyFile.AddHandler(new CVcol);
MyFile.AddHandler(new CUVtri);
MyFile.AddHandler(new CGinTree);
MyFile.AddHandler(new CAnimTree);
MyFile.AddHandler(new CKeyAnimTree);
MyFile.AddHandler(new CSkinTree);
MyFile.AddHandler(new CUserProp);
MyFile.AddHandler(new CCamera);
}
void Load(char const * Name);
std::vector<GinChunk const *> GetVersionChunk() {return(VersionChunk);}
std::vector<GinChunk const *> GetTexNamesChunk() {return(TexNamesChunk);}
std::vector<GinChunk const *> GetMatChunk() {return(MatChunk);}
std::vector<GinChunk const *> GetMod4Chunk() {return(Mod4Chunk);}
std::vector<GinChunk const *> GetMshChunk() {return(MshChunk);}
std::vector<GinChunk const *> GetPointsChunk() {return(PointsChunk);}
std::vector<GinChunk const *> GetTrisChunk() {return(TrisChunk);}
std::vector<GinChunk const *> GetVColTrisChunk() {return(VColTrisChunk);}
std::vector<GinChunk const *> GetUVtrisChunk() {return(UVtrisChunk);}
std::vector<GinChunk const *> GetSceneTreeChunk() {return(SceneTreeChunk);}
std::vector<GinChunk const *> GetAnimTreeChunk() {return(AnimTreeChunk);}
std::vector<GinChunk const *> GetKeyAnimTreeChunk(){return(KeyAnimTreeChunk);}
std::vector<GinChunk const *> GetSkinTreeChunk() {return(SkinTreeChunk);}
std::vector<GinChunk const *> GetUserPropChunk() {return(UserPropChunk);}
std::vector<GinChunk const *> GetCameraChunk() {return(CameraChunk);}
char * GetModelName(int ModelNum)
{
CMod4 *Mod=(CMod4*)Mod4Chunk[ModelNum];
return(Mod->GetModelName());
};
protected:
GinFile MyFile;
std::vector<GinChunk const *> VersionChunk;
std::vector<GinChunk const *> TexNamesChunk;
std::vector<GinChunk const *> MatChunk;
std::vector<GinChunk const *> Mod4Chunk;
std::vector<GinChunk const *> MshChunk;
std::vector<GinChunk const *> PointsChunk;
std::vector<GinChunk const *> TrisChunk;
std::vector<GinChunk const *> VColTrisChunk;
std::vector<GinChunk const *> UVtrisChunk;
std::vector<GinChunk const *> SceneTreeChunk;
std::vector<GinChunk const *> AnimTreeChunk;
std::vector<GinChunk const *> KeyAnimTreeChunk;
std::vector<GinChunk const *> SkinTreeChunk;
std::vector<GinChunk const *> UserPropChunk;
std::vector<GinChunk const *> CameraChunk;
};
/*****************************************************************************/
/*** Scene Storage ***********************************************************/
/*****************************************************************************/
class CScene
{
public:
void LoadWithTextures(char const * Name);
void Load(char const * Name);
//------------------
//--- Tree Stuff ---
//------------------
CNode &GetNode(int Idx) {return(SceneTree[Idx]);}
CNode *GetNodePtr(int Idx) {return(&GetNode(Idx));}
CNode *GetNodePtr(char *Name,int Start=0)
{
int TreeSize=GetSceneTreeSize();
for (int N=Start; N<TreeSize; N++) if (GetNode(N).IsNodeName(Name)) return(GetNodePtr(N));
return(0);
}
CNode *GetNodePtrPrefix(char *Name,int Start=0)
{
int TreeSize=GetSceneTreeSize();
for (int N=Start; N<TreeSize; N++) if (GetNode(N).IsNodePrefix(Name)) return(GetNodePtr(N));
return(0);
}
int GetSceneNodeCount() {return(SceneTree.size());}
int GetSceneTreeSize() {return(SceneTree.size());}
int GetPruneTreeSize() {return(PruneTree.size());}
CNode &GetSceneNode(int Idx) {return(GetNode(Idx));}
CNode &GetPruneNode(int Idx) {return(GetNode(PruneTree[Idx]));}
void PrintSceneTree(int Idx=0)
{
// printf("SceneTree - %i Nodes\n\n",SceneTree.size());
PrintTreeSpace=0;
PrintTreeNode(Idx,0);
}
void PrintPruneTree(int Idx=0)
{
// printf("PruneTree - %i Nodes\n\n",PruneTree.size());
PrintTreeSpace=0;
PrintTreeNode(Idx,1);
}
void PrintTreeNode(int Idx,const int);
void BuildPruneTree(int Idx, int ParentIdx);
bool SetPruneNodes(int Idx);
void ResetSceneTree() {SceneTree.clear();}
void ResetPruneTree()
{
int TreeSize=SceneTree.size();
for (int n=0;n<TreeSize;n++) SceneTree[n].PruneChildList.clear();
}
int CountAllChildren(int Idx) {return(_CountAllChildren(Idx)+1);}
//-----------------
//-----------------
//-----------------
std::vector<GString> const & GetTexNames(void) const {return(AllTexNames);}
std::vector<GString> const & GetTexList(void) const {return(TextureList);}
std::vector<Material> const & GetMaterials(void) const {return(AllMaterials);}
std::vector<int> const & GetUsedMaterialIdx(void) const {return(UsedMaterials);}
std::vector<sCam> const & GetCamera(void) const {return(Camera);}
void GetNonSharedTextures(std::vector<GString> const & SharedTextures,std::vector<GString> & Dest);
protected:
int loadPoints(int CurMod, std::vector<GinChunk const *> &Points,CNode *ThisNode);
int loadTris(int CurMod, int CurMesh, std::vector<GinChunk const *> &Tris,CNode *ThisNode);
int loadUV(int CurMod, int CurMesh, std::vector<GinChunk const *> &UVTris,CNode *ThisNode);
int loadVCol(int CurMod, int CurMesh, std::vector<GinChunk const *> &VColTris,CNode *ThisNode);
int addMaterialIdx( int idx );
int _CountAllChildren(int Idx)
{
CNode &ThisNode=GetNode(Idx);
int NodeCount=0;
int ChildCount= ThisNode.GetPruneChildCount();
for (int Loop=0;Loop<ChildCount;Loop++) NodeCount+=_CountAllChildren(ThisNode.PruneChildList[Loop]);
return(NodeCount+ChildCount);
}
GString FileName;
std::vector<GString> AllTexNames;
std::vector<GString> TextureList;
std::vector<Material> AllMaterials;
std::vector<int> UsedMaterials;
std::vector<CNode> SceneTree;
std::vector<int> PruneTree;
std::vector<sCam> Camera;
int CurTree;
int PrintTreeSpace;
};
/*****************************************************************************/
TMATRIX GetWorldMatrix(std::vector<CNode> const &Tree,int Idx);
TVECTOR GetWorldPos(std::vector<CNode> const &Tree,int Idx);
TVECTOR GetWorldPos(TMATRIX &WorldMtx,TVECTOR &ThisPos);
#endif
Copy Permalink