📄 as_object.cpp
字号:
CurrentFrame.fMax[Z]);
glVertex3f(CurrentFrame.fMax[X],
CurrentFrame.fMax[Y],
CurrentFrame.fMin[Z]);
glEnd();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_CULL_FACE);
} // end AS_OBJECT::DrawBounding()
void AS_OBJECT::Destroy(void)
{ // begin AS_OBJECT::Destroy()
int i, i2;
AS_OBJECT_FRAME *pFrameT;
AS_OBJECT_ANIMATION_STEP *pStepT;
if(pbyFilename)
delete pbyFilename;
if(pChild)
{
for(i = 0; i < Header.iChildren; i++)
{
if(!pChild[i])
continue;
pChild[i]->Destroy();
free(pChild[i]);
}
free(pChild);
}
if(pAnimation)
{
for(i = 0; i < Header.iAnimations; i++)
{
pAnimationT = &pAnimation[i];
for(i2 = 0; i2 < pAnimationT->iSteps; i2++)
{
pStepT = &pAnimationT->pStep[i2];
if(pStepT->fDiffuseColorIncreasePos)
free(pStepT->fDiffuseColorIncreasePos);
if(pStepT->fVertexIncreasePos)
free(pStepT->fVertexIncreasePos);
if(pStepT->fNormalIncreasePos)
free(pStepT->fNormalIncreasePos);
if(pStepT->fTextureCoordIncreasePos)
free(pStepT->fTextureCoordIncreasePos);
}
if(pAnimationT->pStep)
free(pAnimationT->pStep);
}
free(pAnimation);
}
if(pFrame)
{
for(i = 0; i < Header.iFrames; i++)
{
pFrameT = &pFrame[i];
if(pFrameT->fDiffuseColor)
free(pFrameT->fDiffuseColor);
if(pFrameT->fVertex)
free(pFrameT->fVertex);
if(pFrameT->fNormal)
free(pFrameT->fNormal);
if(pFrameT->fTextureCoord)
free(pFrameT->fTextureCoord);
if(pFrameT->iFace)
free(pFrameT->iFace);
}
free(pFrame);
}
} // end AS_OBJECT::Destroy()
HRESULT AS_OBJECT::Load(char *pbyFilenameT)
{ // begin AS_OBJECT::Load()
FILE *fp;
int iObjectsT;
if(!pbyFilenameT)
return 1;
fp = fopen(pbyFilenameT, "rb");
if(!fp)
return 1;
pbyFilename = new char[strlen(pbyFilenameT)+1];
strcpy(pbyFilename, pbyFilenameT);
iObjectsT = LoadPart(fp); // Load now the object
fclose(fp);
SetupAnimationData(TRUE);
SetFrameT(0);
SetAnimationT(0);
SetAnimationStepT(0);
return iObjectsT;
} // end AS_OBJECT::Load()
HRESULT AS_OBJECT::LoadPart(FILE *fp)
{ // begin AS_OBJECT::LoadPart()
static iObjectsT = 0;
int i, i2, i3;
// Read the header:
fread(&Header, sizeof(AS_OBJECT_HEADER), 1, fp);
iID = iObjectsT;
// Read the main matrix:
fread(&Matrix, sizeof(MATRIX), 1, fp);
// Read the object:
if(Header.iFrames)
{
// Read the frames:
pFrame = new AS_OBJECT_FRAME[Header.iFrames];
memset(pFrame, 0, sizeof(AS_OBJECT_FRAME)*Header.iFrames);
for(i = 0; i < Header.iFrames; i++)
{
pFrameT = &pFrame[i];
// Name:
fread(&pFrameT->byName, sizeof(char)*256, 1, fp);
// ID:
pFrameT->iID = i;
// Transformation matrix:
fread(&pFrameT->Matrix, sizeof(MATRIX), 1, fp);
// Diffuse colors:
if(Header.bUseVertexColorData)
{
fread(&pFrameT->iDiffuseColors, sizeof(short), 1, fp);
pFrameT->fDiffuseColor = new FLOAT3[pFrameT->iDiffuseColors];
for(i2 = 0; i2 < pFrameT->iDiffuseColors; i2++)
fread(&pFrameT->fDiffuseColor[i2], sizeof(FLOAT3), 1, fp);
}
// Vertices:
fread(&pFrameT->iVertices, sizeof(short), 1, fp);
pFrameT->fVertex = new FLOAT3[pFrameT->iVertices];
for(i2 = 0; i2 < pFrameT->iVertices; i2++)
{
fread(&pFrameT->fVertex[i2], sizeof(FLOAT3), 1, fp);
for(i3 = 0; i3 < 3; i3++)
{
// Max:
if(pFrameT->fVertex[i2][i3] > pFrameT->fMax[i3])
pFrameT->fMax[i3] = pFrameT->fVertex[i2][i3];
// Min:
if(pFrameT->fVertex[i2][i3] < pFrameT->fMin[i3])
pFrameT->fMin[i3] = pFrameT->fVertex[i2][i3];
}
}
// Middle bounding size:
for(i3 = 0; i3 < 3; i3++)
if(pFrameT->fMin[i3] > 0.0f)
{
if(pFrameT->fMax[i3] > 0.0f)
pFrameT->fMiddle[i3] = (pFrameT->fMin[i3]+pFrameT->fMax[i3])/2;
else
pFrameT->fMiddle[i3] = (pFrameT->fMin[i3]-pFrameT->fMax[i3])/2;
}
else
{
if(pFrameT->fMax[i3] > 0.0f)
pFrameT->fMiddle[i3] = (-pFrameT->fMin[i3]+pFrameT->fMax[i3])/2;
else
pFrameT->fMiddle[i3] = (-pFrameT->fMin[i3]-pFrameT->fMax[i3])/2;
}
// Texture coords:
if(Header.bUseVertexTexturePosData)
{
fread(&pFrameT->iTextureCoords, sizeof(short), 1, fp);
pFrameT->fTextureCoord = new FLOAT2[pFrameT->iTextureCoords];
for(i2 = 0; i2 < pFrameT->iTextureCoords; i2++)
fread(&pFrameT->fTextureCoord[i2], sizeof(FLOAT2), 1, fp);
}
// Faces:
fread(&pFrameT->iFaces, sizeof(short), 1, fp);
pFrameT->iFace = new SHORT3[pFrameT->iFaces];
for(i2 = 0; i2 < pFrameT->iFaces; i2++)
fread(&pFrameT->iFace[i2], sizeof(SHORT3), 1, fp);
// Calculate normals:
pFrameT->iNormals = pFrameT->iFaces;
pFrameT->fNormal = new FLOAT3[pFrameT->iNormals];
for(i2 = 0; i2 < pFrameT->iFaces; i2++)
NormalizeFace(&pFrameT->fNormal[i2], pFrameT->fVertex[pFrameT->iFace[i2][0]],
pFrameT->fVertex[pFrameT->iFace[i2][1]],
pFrameT->fVertex[pFrameT->iFace[i2][2]]);
}
// Read the animations:
if(Header.iAnimations)
{
pAnimation = new AS_OBJECT_ANIMATION[Header.iAnimations];
memset(pAnimation, 0, sizeof(AS_OBJECT_ANIMATION)*Header.iAnimations);
for(i = 0; i < Header.iAnimations; i++)
{
pAnimationT = &pAnimation[i];
// Name:
fread(&pAnimationT->byName, sizeof(char)*256, 1, fp);
// ID:
pAnimationT->iID = i;
// Animation steps:
fread(&pAnimationT->iSteps, sizeof(short), 1, fp);
// Read the animation steps:
pAnimationT->pStep = new AS_OBJECT_ANIMATION_STEP[pAnimationT->iSteps];
memset(pAnimationT->pStep, 0, sizeof(AS_OBJECT_ANIMATION_STEP)*pAnimationT->iSteps);
for(i2 = 0; i2 < pAnimationT->iSteps; i2++)
{
// Interpolation time:
fread(&pAnimationT->pStep[i2].dwInterpolateTime, sizeof(DWORD), 1, fp);
// Step ID;
pAnimationT->pStep[i2].iID = i2;
// Frame ID:
fread(&pAnimationT->pStep[i2].iFrameID, sizeof(short), 1, fp);
pAnimationT->pStep[i2].pFrame = &pFrame[pAnimationT->pStep[i2].iFrameID];
pAnimationT->pStep[i2].pFrame->iUsed++;
// Precalculated data:
pAnimationT->pStep[i2].fDiffuseColorIncreasePos = new FLOAT3[pFrameT->iDiffuseColors];
pAnimationT->pStep[i2].fVertexIncreasePos = new FLOAT3[pFrameT->iVertices];
pAnimationT->pStep[i2].fNormalIncreasePos = new FLOAT3[pFrameT->iNormals];
pAnimationT->pStep[i2].fTextureCoordIncreasePos = new FLOAT2[pFrameT->iTextureCoords];
}
}
}
}
// Read now all the children whith their children:
if(!Header.iChildren)
return 0;
pChild = (AS_OBJECT **) malloc(sizeof(AS_OBJECT)*Header.iChildren);
for(i = 0; i < Header.iChildren; i++)
{
pChild[i] = new AS_OBJECT;
memset(pChild[i], 0, sizeof(AS_OBJECT));
iObjectsT++;
pChild[i]->LoadPart(fp);
}
return iObjectsT;
} // end AS_OBJECT::LoadPart()
void AS_OBJECT::SetupAnimationData(BOOL bChildrenToo)
{ // begin AS_OBJECT::SetupAnimationData()
AS_OBJECT_ANIMATION *pTempAnimation;
AS_OBJECT_ANIMATION_STEP *pTempObjAnimationStep;
int i, i2;
if(bChildrenToo)
for(i = 0; i < Header.iChildren; i++)
pChild[i]->SetupAnimationData(bChildrenToo);
// Setup precalculated data:
for(i2 = 0; i2 < Header.iAnimations; i2++)
{
pTempAnimation = &pAnimation[i2];
for(i = 0; i < pTempAnimation->iSteps; i++)
{
pTempObjAnimationStep = &pTempAnimation->pStep[i];
if(!pTempObjAnimationStep->pFrame)
continue;
if(!pTempObjAnimationStep->fDiffuseColorIncreasePos)
pTempObjAnimationStep->fDiffuseColorIncreasePos = new FLOAT3[pTempObjAnimationStep->pFrame->iDiffuseColors];
if(!pTempObjAnimationStep->fVertexIncreasePos)
pTempObjAnimationStep->fVertexIncreasePos = new FLOAT3[pTempObjAnimationStep->pFrame->iVertices];
if(!pTempObjAnimationStep->fNormalIncreasePos)
pTempObjAnimationStep->fNormalIncreasePos = new FLOAT3[pTempObjAnimationStep->pFrame->iNormals];
if(!pTempObjAnimationStep->fTextureCoordIncreasePos)
pTempObjAnimationStep->fTextureCoordIncreasePos = new FLOAT2[pTempObjAnimationStep->pFrame->iTextureCoords];
}
}
// Setup current frame info:
if(!Header.iFrames)
return;
// Each frame has the same number of elements...
CurrentFrame.iDiffuseColors = pFrame[0].iDiffuseColors;
CurrentFrame.iVertices = pFrame[0].iVertices;
CurrentFrame.iTextureCoords = pFrame[0].iTextureCoords;
CurrentFrame.iNormals = pFrame[0].iNormals;
CurrentFrame.iFaces = pFrame[0].iFaces;
if(!CurrentFrame.fDiffuseColor)
CurrentFrame.fDiffuseColor = new FLOAT3[CurrentFrame.iDiffuseColors];
if(!CurrentFrame.fVertex)
CurrentFrame.fVertex = new FLOAT3[CurrentFrame.iVertices];
if(!CurrentFrame.fTextureCoord)
CurrentFrame.fTextureCoord = new FLOAT2[CurrentFrame.iTextureCoords];
if(!CurrentFrame.fNormal)
CurrentFrame.fNormal = new FLOAT3[CurrentFrame.iNormals];
CalculateInterpolations();
} // end AS_OBJECT::SetupAnimationData()⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -