void XfmReset(struct Transform *transform)
{
MatIdentity(transform->matrix);
MatIdentity(transform->inverse);
transform->transform_order = ORDER_SRT;
transform->rotate_order = ORDER_XYZ;
VEC3_SET(transform->translate, 0, 0, 0);
VEC3_SET(transform->rotate, 0, 0, 0);
VEC3_SET(transform->scale, 1, 1, 1);
}
static void make_transform_matrix(
int transform_order, int rotate_order,
double tx, double ty, double tz,
double rx, double ry, double rz,
double sx, double sy, double sz,
double *transform)
{
int i;
double T[16], R[16], S[16], RX[16], RY[16], RZ[16];
double *queue[3];
MatTranslate(T, tx, ty, tz);
MatRotateX(RX, rx);
MatRotateY(RY, ry);
MatRotateZ(RZ, rz);
MatScale(S, sx, sy, sz);
switch (rotate_order) {
case ORDER_XYZ: VEC3_SET(queue, RX, RY, RZ); break;
case ORDER_XZY: VEC3_SET(queue, RX, RZ, RY); break;
case ORDER_YXZ: VEC3_SET(queue, RY, RX, RZ); break;
case ORDER_YZX: VEC3_SET(queue, RY, RZ, RX); break;
case ORDER_ZXY: VEC3_SET(queue, RZ, RX, RY); break;
case ORDER_ZYX: VEC3_SET(queue, RZ, RY, RX); break;
default:
assert(!"invalid rotate order");
break;
}
MatIdentity(R);
for (i = 0; i < 3; i++)
MatMultiply(R, queue[i], R);
switch (transform_order) {
case ORDER_SRT: VEC3_SET(queue, S, R, T); break;
case ORDER_STR: VEC3_SET(queue, S, T, R); break;
case ORDER_RST: VEC3_SET(queue, R, S, T); break;
case ORDER_RTS: VEC3_SET(queue, R, T, S); break;
case ORDER_TRS: VEC3_SET(queue, T, R, S); break;
case ORDER_TSR: VEC3_SET(queue, T, S, R); break;
default:
assert(!"invalid transform order order");
break;
}
MatIdentity(transform);
for (i = 0; i < 3; i++)
MatMultiply(transform, queue[i], transform);
}
shared_ptr<IActor> BLOCO_API PhysicObjectParams::VCreate( BaseGameLogic *logic )
{
m_Mat = MatIdentity();
shared_ptr<IActor> pModelObjectParams(DEBUG_CLIENTBLOCK BaseActor( m_Mat, AT_Model, shared_ptr<PhysicObjectParams>(DEBUG_CLIENTBLOCK PhysicObjectParams(*this))));
logic->VAddActor(pModelObjectParams, this);
return pModelObjectParams;
}
CameraObjectParams::CameraObjectParams( int actorID )
{
m_Id = actorID;
m_Type=AT_Camera;
m_Col= Vec(0.5f,0.5f,0.5f,0.5f);
m_Mat= MatIdentity();
m_Size=sizeof(CameraObjectParams);
strcpy( m_sName, "" );
m_IsModified = false;
}
BLOCO_API PhysicObjectParams::PhysicObjectParams( int actorID )
{
m_Mat = MatIdentity();
m_Id = actorID;
m_Type=AT_Model;
m_Col= Vec(0.5f,0.5f,0.5f,0.5f);
m_Size=sizeof(ModelObjectParams);
strcpy( m_sName, "" );
m_IsModified = false;
m_bHasScript = false;
}
VoxelObjectParams::VoxelObjectParams()
{
m_Mat = MatIdentity();
m_Type = AT_Voxel;
m_Col= Vec(0.5f,0.5f,0.5f,0.5f);
strcpy( m_sScriptFilename, "" );
m_Size=sizeof(VoxelObjectParams);
m_IsModified = false;
m_AABB = Vec(10.0f,10.0f,10.0f);
m_bPhysicActor = true;
strcpy( m_sName, "" );
}
CameraObjectParams::CameraObjectParams()
{
m_Type=AT_Camera;
m_Col= Vec(0.5f,0.5f,0.5f,0.5f);
m_Mat= MatIdentity();
m_Size=sizeof(CameraObjectParams);
strcpy( m_sScriptFilename, "" );
strcpy( m_sName, "" );
m_IsModified = false;
m_bHasScript = false;
}
BLOCO_API ModelObjectParams::ModelObjectParams( const char* modelFilename, const char* fxFilename, const char* fxTechinqueName )
{
m_Mat = MatIdentity();
m_Type=AT_Model;
m_Col= Vec(0.5f,0.5f,0.5f,0.5f);
strcpy(m_ModellFilename, modelFilename);
strcpy( m_FXFileName, fxFilename );
strcpy( m_FXTechniqueName, fxTechinqueName );
m_Size=sizeof(ModelObjectParams);
m_IsModified = false;
m_bPhysicActor = true;
strcpy( m_sName, GetTitle(m_ModellFilename).c_str() );
}
BoneObjectParams::BoneObjectParams( string name, string parentName, Mat global, Mat bindPose )
{
m_Mat = MatIdentity();
m_Type=AT_Model;
m_Col= Vec(0.5f,0.5f,0.5f,0.5f);
m_Size=sizeof(BoneObjectParams);
m_IsModified = false;
m_AABB = Vec(10.0f,10.0f,10.0f);
strcpy( m_sScriptFilename, "" );
strcpy( m_sName, "" );
m_bPhysicActor = true;
m_bHasScript = false;
}
BLOCO_API ActorParams::ActorParams()
{
m_Mat = MatIdentity();
m_Pos=Vec(0,0,0);
m_Type=AT_Unknown;
m_Col = Col(1.0f,1.0f,1.0f,1.0f);
strcpy( m_OnCreateLuaFunctionName, "" );
strcpy( m_sScriptFilename, "" );
strcpy( m_sName, "" );
strcpy( m_OnDestroyLuaFunctionName, "" );
m_Size=sizeof(ActorParams);
m_IsModified= false;
m_bPhysicActor = true;
m_bHasScript = false;
}
BLOCO_API ModelObjectParams::ModelObjectParams()
{
m_Mat = MatIdentity();
m_Type=AT_Model;
m_Col= Vec(0.5f,0.5f,0.5f,0.5f);
strcpy( m_ModellFilename, "-" );
strcpy( m_FXFileName, "-" );
strcpy( m_FXTechniqueName, "-" );
strcpy( m_sScriptFilename, "" );
m_Size=sizeof(ModelObjectParams);
m_IsModified = false;
m_AABB = Vec(10.0f,10.0f,10.0f);
m_bPhysicActor = true;
strcpy( m_sName, "" );
}
VoxelObjectParams::VoxelObjectParams( int width, int height, int depth, int ChunkSize ) :
m_width(width),
m_height(height),
m_depth(depth),
m_ChunkSize(ChunkSize)
{
m_Mat = MatIdentity();
m_Type=AT_Voxel;
m_Col= Vec(0.5f,0.5f,0.5f,0.5f);
strcpy( m_sScriptFilename, "" );
m_Size=sizeof(VoxelObjectParams);
m_IsModified = false;
m_bPhysicActor = true;
strcpy( m_sName, "" );
}
BLOCO_API ModelChildObjectParams::ModelChildObjectParams( int actorID )
{
m_Mat = MatIdentity();
m_Id = actorID;
m_Type=AT_ModelChild_Mesh;
m_Col= Vec(0.5f,0.5f,0.5f,0.5f);
strcpy( m_ModellFilename, "" );
strcpy( m_FXFileName, "" );
strcpy( m_FXTechniqueName, "" );
m_AABB = Vec(10.0f,10.0f,10.0f);
m_Size=sizeof(ModelChildObjectParams);
m_IsModified = false;
m_bDynamic = true;
m_bHasScript = false;
}
bool CameraObjectParams::VInit( LuaObject srcData, TErrorMessageList & errorMessages )
{
if ( false == ActorParams::VInit( srcData, errorMessages ) )
{
return false;
}
m_Type = AT_Camera;
m_Mat = MatIdentity();
LuaObject matObj = srcData[ "Mat" ];
if ( matObj.IsTable() )
{
const int tableCount = matObj.GetTableCount();
if ( 16 != tableCount )
{
const std::string err( "Incorrect number of parameters in the 'Mat' member." );
errorMessages.push_back( err );
return false;
}
else
{
char name[4] = "_00";
for( int i = 1; i <= 4; ++i )
{
name[1] = '0' + i;
for( int j = 1; j <= 4; ++j )
{
name[2] = '0' + j;
LuaObject entry = matObj[ name ];
if( entry.IsNumber() )
{
m_Mat.GetStorage().m[i - 1][j - 1] = entry.GetFloat();
}
}
}
}
}
return true;
}
bool BLOCO_API ModelObjectParams::VInit( LuaObject srcData, TErrorMessageList & errorMessages )
{
if ( false == ActorParams::VInit( srcData, errorMessages ) )
{
return false;
}
m_Type = AT_Model;
m_bDynamic = true;
m_Mat = MatIdentity();
//Positon
LuaObject positionObj = srcData[ "Position" ];
if ( positionObj.IsTable() )
{
float x = positionObj[ "x" ].GetFloat();
float y = positionObj[ "y" ].GetFloat();
float z = positionObj[ "z" ].GetFloat();
m_Mat = MatTranslation( x, y, z );
}
LuaObject matObj = srcData[ "Mat" ];
if ( matObj.IsTable() )
{
const int tableCount = matObj.GetTableCount();
if ( 16 != tableCount )
{
const std::string err( "Incorrect number of parameters in the 'Mat' member." );
errorMessages.push_back( err );
return false;
}
else
{
char name[4] = "_00";
for( int i = 1; i <= 4; ++i )
{
name[1] = '0' + i;
for( int j = 1; j <= 4; ++j )
{
name[2] = '0' + j;
LuaObject entry = matObj[ name ];
if( entry.IsNumber() )
{
m_Mat.GetStorage().m[i - 1][j - 1] = entry.GetFloat();
}
}
}
}
}
LuaObject XFileObj = srcData[ "ModelFile" ];
if ( XFileObj.IsString() )
{
//Check if it is a Path
bool bPath = false;
const char * filename = XFileObj.GetString();
strcpy( m_ModellFilename, MODEL_PATH(filename) );
m_bHasScript = true;
string tmp = m_ModellFilename;
tmp.erase(tmp.end()-3,tmp.end());
tmp += "lua";
strcpy( m_sScriptFilename, tmp.c_str() );
}
//Physic
LuaObject PhysicObj = srcData[ "Physic" ];
if ( PhysicObj.IsString() )
{
string strPhysic = PhysicObj.GetString();
if ( strPhysic == "static")
m_bDynamic = false;
else if( strPhysic == "dynamic")
m_bDynamic = true;
else if( strPhysic == "none")
m_bPhysicActor = false;
}
LuaObject FXFileObj = srcData[ "FXFile" ];
if ( FXFileObj.IsString() )
{
const char * pFXFile = FXFileObj.GetString();
strcpy( m_FXFileName, pFXFile );
}
LuaObject FXTechniqueObj = srcData[ "FXTechnique" ];
if ( FXTechniqueObj.IsString() )
{
const char * pFXTechnique = FXTechniqueObj.GetString();
strcpy( m_FXTechniqueName, pFXTechnique );
}
return true;
}
bool VoxelObjectParams::VInit( LuaObject srcData, TErrorMessageList & errorMessages )
{
if ( false == ActorParams::VInit( srcData, errorMessages ) )
{
return false;
}
m_Type = AT_Model;
m_bDynamic = true;
m_Mat = MatIdentity();
//Positon
LuaObject positionObj = srcData[ "Position" ];
if ( positionObj.IsTable() )
{
float x = positionObj[ "x" ].GetFloat();
float y = positionObj[ "y" ].GetFloat();
float z = positionObj[ "z" ].GetFloat();
m_Mat = MatTranslation( x, y, z );
}
LuaObject matObj = srcData[ "Mat" ];
if ( matObj.IsTable() )
{
const int tableCount = matObj.GetTableCount();
if ( 16 != tableCount )
{
const std::string err( "Incorrect number of parameters in the 'Mat' member." );
errorMessages.push_back( err );
return false;
}
else
{
char name[4] = "_00";
for( int i = 1; i <= 4; ++i )
{
name[1] = '0' + i;
for( int j = 1; j <= 4; ++j )
{
name[2] = '0' + j;
LuaObject entry = matObj[ name ];
if( entry.IsNumber() )
{
m_Mat.GetStorage().m[i - 1][j - 1] = entry.GetFloat();
}
}
}
}
}
//Physic
LuaObject PhysicObj = srcData[ "Physic" ];
if ( PhysicObj.IsString() )
{
string strPhysic = PhysicObj.GetString();
if ( strPhysic == "static")
m_bDynamic = false;
else
m_bDynamic = true;
}
//Voxel
LuaObject widthObj = srcData[ "width" ];
if ( widthObj.IsInteger() )
{
m_width = widthObj.GetInteger();
}
LuaObject heightObj = srcData[ "height" ];
if ( heightObj.IsInteger() )
{
m_height = heightObj.GetInteger();
}
LuaObject depthObj = srcData[ "depth" ];
if ( depthObj.IsInteger() )
{
m_depth = depthObj.GetInteger();
}
LuaObject chunkSizeObj = srcData[ "chunkSize" ];
if ( chunkSizeObj.IsInteger() )
{
m_ChunkSize = chunkSizeObj.GetInteger();
}
return true;
}
void OGL_ModelData::Load()
{
// Already loaded?
if (ModelPresent()) {
return;
}
// Load the model
Model.Clear();
if (ModelFile == FileSpecifier()) {
return;
}
if (!ModelFile.Exists()) {
return;
}
bool Success = false;
char *Type = &ModelType[0];
if (StringsEqual(Type,"wave",4)) {
// Alias|Wavefront
Success = LoadModel_Wavefront(ModelFile, Model);
}
else if (StringsEqual(Type,"3ds",3)) {
// 3D Studio Max
Success = LoadModel_Studio(ModelFile, Model);
}
else if (StringsEqual(Type,"dim3",4)) {
// Brian Barnes's "Dim3" model format (first pass: model geometry)
Success = LoadModel_Dim3(ModelFile, Model, LoadModelDim3_First);
// Second and third passes: frames and sequences
try
{
if (ModelFile1 == FileSpecifier()) {
throw 0;
}
if (!ModelFile1.Exists()) {
throw 0;
}
if (!LoadModel_Dim3(ModelFile1, Model, LoadModelDim3_Rest)) {
throw 0;
}
}
catch(...)
{}
//
try
{
if (ModelFile2 == FileSpecifier()) {
throw 0;
}
if (!ModelFile2.Exists()) {
throw 0;
}
if (!LoadModel_Dim3(ModelFile2, Model, LoadModelDim3_Rest)) {
throw 0;
}
}
catch(...)
{}
}
#if HAVE_QUESA
else if (StringsEqual(Type,
"qd3d") ||
StringsEqual(Type,"3dmf") || StringsEqual(Type,"quesa")) {
// QuickDraw 3D / Quesa
Success = LoadModel_QD3D(ModelFile, Model);
}
#endif
if (!Success) {
Model.Clear();
return;
}
// Calculate transformation matrix
GLfloat Angle, Cosine, Sine;
GLfloat RotMatrix[3][3], NewRotMatrix[3][3], IndivRotMatrix[3][3];
MatIdentity(RotMatrix);
MatIdentity(IndivRotMatrix);
Angle = (float)Degree2Radian*XRot;
Cosine = (float)cos(Angle);
Sine = (float)sin(Angle);
IndivRotMatrix[1][1] = Cosine;
IndivRotMatrix[1][2] = -Sine;
IndivRotMatrix[2][1] = Sine;
IndivRotMatrix[2][2] = Cosine;
MatMult(IndivRotMatrix,RotMatrix,NewRotMatrix);
MatCopy(NewRotMatrix,RotMatrix);
MatIdentity(IndivRotMatrix);
Angle = (float)Degree2Radian*YRot;
Cosine = (float)cos(Angle);
Sine = (float)sin(Angle);
IndivRotMatrix[2][2] = Cosine;
IndivRotMatrix[2][0] = -Sine;
IndivRotMatrix[0][2] = Sine;
IndivRotMatrix[0][0] = Cosine;
MatMult(IndivRotMatrix,RotMatrix,NewRotMatrix);
MatCopy(NewRotMatrix,RotMatrix);
MatIdentity(IndivRotMatrix);
Angle = (float)Degree2Radian*ZRot;
Cosine = (float)cos(Angle);
Sine = (float)sin(Angle);
IndivRotMatrix[0][0] = Cosine;
IndivRotMatrix[0][1] = -Sine;
IndivRotMatrix[1][0] = Sine;
IndivRotMatrix[1][1] = Cosine;
MatMult(IndivRotMatrix,RotMatrix,NewRotMatrix);
MatCopy(NewRotMatrix,RotMatrix);
MatScalMult(NewRotMatrix,Scale); // For the position vertices
if (Scale < 0) {
MatScalMult(RotMatrix,-1); // For the normals
}
// Is model animated or static?
// Test by trying to find neutral positions (useful for working with the normals later on)
if (Model.FindPositions_Neutral(false)) {
// Copy over the vector and normal transformation matrices:
for (int k=0; k<3; k++)
for (int l=0; l<3; l++)
{
Model.TransformPos.M[k][l] = NewRotMatrix[k][l];
Model.TransformNorm.M[k][l] = RotMatrix[k][l];
}
Model.TransformPos.M[0][3] = XShift;
Model.TransformPos.M[1][3] = YShift;
Model.TransformPos.M[2][3] = ZShift;
// Find the transformed bounding box:
bool RestOfCorners = false;
GLfloat NewBoundingBox[2][3];
// The indices i1, i2, and i3 are for selecting which of the box's two principal corners
// to get coordinates from
for (int i1=0; i1<2; i1++)
{
GLfloat X = Model.BoundingBox[i1][0];
for (int i2=0; i2<2; i2++)
{
GLfloat Y = Model.BoundingBox[i2][0];
for (int i3=0; i3<2; i3++)
{
GLfloat Z = Model.BoundingBox[i3][0];
GLfloat Corner[3];
for (int ic=0; ic<3; ic++)
{
GLfloat *Row = Model.TransformPos.M[ic];
Corner[ic] = Row[0]*X + Row[1]*Y + Row[2]*Z + Row[3];
}
if (RestOfCorners) {
// Find minimum and maximum for each coordinate
for (int ic=0; ic<3; ic++)
{
NewBoundingBox[0][ic] = min(NewBoundingBox[0][ic],Corner[ic]);
NewBoundingBox[1][ic] = max(NewBoundingBox[1][ic],Corner[ic]);
}
}
else
{
// Simply copy it in:
for (int ic=0; ic<3; ic++)
NewBoundingBox[0][ic] = NewBoundingBox[1][ic] = Corner[ic];
RestOfCorners = true;
}
}
}
}
for (int ic=0; ic<2; ic++)
objlist_copy(Model.BoundingBox[ic],NewBoundingBox[ic],3);
}
else
{
// Static model
size_t NumVerts = Model.Positions.size()/3;
for (size_t k=0; k<NumVerts; k++)
{
GLfloat *Pos = Model.PosBase() + 3*k;
GLfloat NewPos[3];
MatVecMult(NewRotMatrix,Pos,NewPos); // Has the scaling
Pos[0] = NewPos[0] + XShift;
Pos[1] = NewPos[1] + YShift;
Pos[2] = NewPos[2] + ZShift;
}
size_t NumNorms = Model.Normals.size()/3;
for (size_t k=0; k<NumNorms; k++)
{
GLfloat *Norms = Model.NormBase() + 3*k;
GLfloat NewNorms[3];
MatVecMult(RotMatrix,Norms,NewNorms); // Not scaled
objlist_copy(Norms,NewNorms,3);
}
// So as to be consistent with the new points
Model.FindBoundingBox();
}
Model.AdjustNormals(NormalType,NormalSplit);
Model.CalculateTangents();
// Don't forget the skins
OGL_SkinManager::Load();
}
