658 lines
18 KiB
C++
658 lines
18 KiB
C++
// QuakeModel.cpp
|
|
|
|
#include "stdafx.h"
|
|
#include "resource.h"
|
|
#include "DDUtil.h"
|
|
#include "Matrix.h"
|
|
#include "Model.h"
|
|
#include "FrameManager2.h"
|
|
#include "QuakeModel.h"
|
|
|
|
//
|
|
// CQuakeModel
|
|
//
|
|
|
|
CQuakeModel::CQuakeModel()
|
|
{
|
|
}
|
|
|
|
CQuakeModel::~CQuakeModel()
|
|
{
|
|
}
|
|
|
|
void CQuakeModel::Init()
|
|
{
|
|
m_mesh = NULL;
|
|
m_scale.x = 0;
|
|
m_scale.y = 0;
|
|
m_scale.z = 0;
|
|
m_origin.x = 0;
|
|
m_origin.y = 0;
|
|
m_origin.z = 0;
|
|
m_radius = 0;
|
|
m_eye.x = 0;
|
|
m_eye.y = 0;
|
|
m_eye.z = 0;
|
|
m_sync = 0;
|
|
m_flags = 0;
|
|
m_size = 0;
|
|
CModel::Init();
|
|
}
|
|
|
|
void CQuakeModel::DeleteMeshs(LPDIRECT3DRMFRAME frame)
|
|
{
|
|
if (m_mesh != NULL)
|
|
{
|
|
frame->DeleteVisual(m_mesh);
|
|
m_mesh->Release();
|
|
m_mesh = NULL;
|
|
}
|
|
}
|
|
|
|
void CQuakeModel::Delete()
|
|
{
|
|
if (m_frames!=NULL)
|
|
{
|
|
for (int i=0;i<m_num_frames;i++)
|
|
{
|
|
if (((frame_t*)m_frames)[i].data!=NULL)
|
|
{
|
|
for (int j=0;j<((frame_t*)m_frames)[i].numgroupframes;j++)
|
|
{
|
|
if (((frame_t*)m_frames)[i].data[j]!=NULL) free(((frame_t*)m_frames)[i].data[j]);
|
|
}
|
|
free(((frame_t*)m_frames)[i].data);
|
|
}
|
|
if (((frame_t*)m_frames)[i].info!=NULL) free(((frame_t*)m_frames)[i].info);
|
|
if (((frame_t*)m_frames)[i].interval!=NULL) free(((frame_t*)m_frames)[i].interval);
|
|
}
|
|
free(m_frames);
|
|
}
|
|
CModel::Delete();
|
|
}
|
|
|
|
void CQuakeModel::SetBackOrientation(LPDIRECT3DRMFRAME frame, LPDIRECT3DRMFRAME scene)
|
|
{
|
|
frame->SetOrientation( scene,
|
|
D3DVALUE(0), D3DVALUE(0), D3DVALUE(1),
|
|
D3DVALUE(0), D3DVALUE(-1), D3DVALUE(0) );
|
|
}
|
|
|
|
void CQuakeModel::SetFrontOrientation(LPDIRECT3DRMFRAME frame, LPDIRECT3DRMFRAME scene)
|
|
{
|
|
frame->SetOrientation( scene,
|
|
D3DVALUE(0), D3DVALUE(-1), D3DVALUE(0),
|
|
D3DVALUE(-1), D3DVALUE(0), D3DVALUE(0) );
|
|
}
|
|
|
|
void CQuakeModel::SetLeftOrientation(LPDIRECT3DRMFRAME frame, LPDIRECT3DRMFRAME scene)
|
|
{
|
|
frame->SetOrientation( scene,
|
|
D3DVALUE(0), D3DVALUE(-1), D3DVALUE(0),
|
|
D3DVALUE(0), D3DVALUE(0), D3DVALUE(1) );
|
|
}
|
|
|
|
void CQuakeModel::SetRightOrientation(LPDIRECT3DRMFRAME frame, LPDIRECT3DRMFRAME scene)
|
|
{
|
|
frame->SetOrientation( scene,
|
|
D3DVALUE(0), D3DVALUE(-1), D3DVALUE(0),
|
|
D3DVALUE(0), D3DVALUE(0), D3DVALUE(-1) );
|
|
}
|
|
|
|
void CQuakeModel::SetTopOrientation(LPDIRECT3DRMFRAME frame, LPDIRECT3DRMFRAME scene)
|
|
{
|
|
frame->SetOrientation( scene,
|
|
D3DVALUE(0), D3DVALUE(0), D3DVALUE(1),
|
|
D3DVALUE(0), D3DVALUE(1), D3DVALUE(0) );
|
|
}
|
|
|
|
void CQuakeModel::SetBottomOrientation(LPDIRECT3DRMFRAME frame, LPDIRECT3DRMFRAME scene)
|
|
{
|
|
frame->SetOrientation( scene,
|
|
D3DVALUE(0), D3DVALUE(0), D3DVALUE(-1),
|
|
D3DVALUE(0), D3DVALUE(1), D3DVALUE(0) );
|
|
}
|
|
|
|
void CQuakeModel::SetInitialOrientation(LPDIRECT3DRMFRAME frame, LPDIRECT3DRMFRAME scene)
|
|
{
|
|
frame->SetOrientation( scene,
|
|
D3DVALUE(0), D3DVALUE(-1), D3DVALUE(0),
|
|
D3DVALUE(-1), D3DVALUE(0), D3DVALUE(0) );
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
long onseam;
|
|
long s;
|
|
long t;
|
|
} stvert_t;
|
|
|
|
void CQuakeModel::Serialize(CArchive& ar)
|
|
{
|
|
m_curFrame = 0;
|
|
m_curscale = -150;
|
|
m_playing = false;
|
|
|
|
ar >> m_ident >> m_version;
|
|
ar.Read(&m_scale, sizeof(m_scale));
|
|
ar.Read(&m_origin, sizeof(m_origin));
|
|
ar.Read(&m_radius, sizeof(m_radius));
|
|
ar.Read(&m_eye, sizeof(m_eye));
|
|
ar >> m_num_skins >> m_skinwidth >>
|
|
m_skinheight >> m_num_xyz >> m_num_tris >> m_num_frames >>
|
|
m_sync >> m_flags >> m_size;
|
|
m_num_st = m_num_xyz;
|
|
if (m_ident != 0x4F504449)
|
|
{
|
|
AfxMessageBox("Invalid File");
|
|
return;
|
|
}
|
|
|
|
if (m_version != 6)
|
|
{
|
|
AfxMessageBox("Invalid MDL Version");
|
|
return;
|
|
}
|
|
|
|
CFile* file = ar.GetFile();
|
|
AfxMessageBox("not currently reading quake models properly");
|
|
if (true)
|
|
{
|
|
return;
|
|
}
|
|
/* file->Seek(0x54, CFile::begin);
|
|
|
|
m_skins = (skin_t *)malloc(m_num_skins*sizeof(skin_t));
|
|
if (m_skins==NULL)
|
|
{
|
|
AfxMessageBox("Could not allocate skin page");
|
|
return;
|
|
}
|
|
memset(m_skins,0,m_num_skins*sizeof(skin_t));
|
|
for (int i=0;i<m_num_skins;i++)
|
|
{
|
|
file->Read(&(m_skins[i].type),sizeof(long));
|
|
|
|
if (m_skins[i].type==0)
|
|
{
|
|
m_skins[i].numgroupskins = 1;
|
|
|
|
m_skins[i].skin = (u_char **)malloc(sizeof(unsigned char *));
|
|
if (m_skins[i].skin==NULL)
|
|
{
|
|
AfxMessageBox("Could not allocate skin page buffer");
|
|
return;
|
|
}
|
|
m_skins[i].skin[0] = (u_char *)malloc(m_skinwidth*m_skinheight);
|
|
if (m_skins[i].skin[0]==NULL)
|
|
{
|
|
AfxMessageBox("Could not do something");
|
|
return;
|
|
}
|
|
memset(m_skins[i].skin[0],0,m_skinwidth*m_skinheight);
|
|
|
|
file->Read(m_skins[i].skin[0],m_skinwidth*m_skinheight);
|
|
|
|
m_skins[i].interval = (float *)malloc(sizeof(float));
|
|
if (m_skins[i].interval==NULL)
|
|
{
|
|
AfxMessageBox("Could not allocate intervals");
|
|
return;
|
|
}
|
|
*(m_skins[i].interval) = (float)0;
|
|
|
|
}
|
|
else
|
|
{
|
|
file->Read(&(m_skins[i].numgroupskins),sizeof(long));
|
|
|
|
m_skins[i].interval = (float *)malloc(sizeof(float)*(m_skins[i].numgroupskins));
|
|
if (m_skins[i].interval==NULL) AfxMessageBox("Could not load");
|
|
memset(m_skins[i].interval,0,sizeof(float)*m_skins[i].numgroupskins);
|
|
for (int j=0;j<m_skins[i].numgroupskins;j++)
|
|
{
|
|
file->Read(&(m_skins[i].interval[j]),sizeof(float));
|
|
}
|
|
|
|
m_skins[i].skin = (u_char **)malloc(sizeof(unsigned char *)*(m_skins[i].numgroupskins));
|
|
if (m_skins[i].skin==NULL) AfxMessageBox("Could not load");
|
|
memset(m_skins[i].skin,0,sizeof(unsigned char *)*(m_skins[i].numgroupskins));
|
|
for (j=0;j<m_skins[i].numgroupskins;j++)
|
|
{
|
|
m_skins[i].skin[j] = (unsigned char *)malloc(m_skinwidth*m_skinheight);
|
|
if (m_skins[i].skin[j]==NULL) AfxMessageBox("Could not load");
|
|
memset(m_skins[i].skin[j],0,m_skinwidth*m_skinheight);
|
|
file->Read(m_skins[i].skin[j],m_skinwidth*m_skinheight);
|
|
}
|
|
}
|
|
}
|
|
|
|
*/ if (m_stverts != NULL)
|
|
{
|
|
free(m_stverts);
|
|
}
|
|
m_stverts = (void*)malloc(m_num_st*sizeof(stvert_t));
|
|
if (m_stverts==NULL) AfxMessageBox("1");
|
|
memset(m_stverts,0,m_num_st*sizeof(stvert_t));
|
|
file->Read(m_stverts,m_num_st*sizeof(stvert_t));
|
|
m_tris = (void*)malloc(m_num_tris*sizeof(itriangle_t));
|
|
if (m_tris==NULL) AfxMessageBox("2");
|
|
memset(m_tris,0,m_num_tris*sizeof(itriangle_t));
|
|
file->Read(m_tris,m_num_tris*sizeof(itriangle_t));
|
|
|
|
m_frames = (void*)malloc(m_num_frames*sizeof(frame_t));
|
|
if (m_frames==NULL) AfxMessageBox("3");
|
|
memset(m_frames,0,m_num_frames*sizeof(frame_t));
|
|
|
|
for (int i=0;i<m_num_frames;i++)
|
|
{
|
|
file->Read(&(((frame_t*)m_frames)[i].type),sizeof(long));
|
|
if (((frame_t*)m_frames)[i].type==0)
|
|
{
|
|
((frame_t*)m_frames)[i].numgroupframes = 1;
|
|
|
|
((frame_t*)m_frames)[i].info = (frameinfo_t *)malloc(sizeof(frameinfo_t));
|
|
if (((frame_t*)m_frames)[i].info==NULL) AfxMessageBox("4");
|
|
|
|
file->Read(((frame_t*)m_frames)[i].info,sizeof(frameinfo_t));
|
|
((frame_t*)m_frames)[i].data = (trivertx_t **)malloc(sizeof(u_char *));
|
|
if (((frame_t*)m_frames)[i].data==NULL) AfxMessageBox("5");
|
|
|
|
((frame_t*)m_frames)[i].data[0] = (trivertx_t *)malloc(m_num_xyz*sizeof(trivertx_t));
|
|
if (((frame_t*)m_frames)[i].data[0]==NULL) AfxMessageBox("6");
|
|
memset(((frame_t*)m_frames)[i].data[0],0,m_num_xyz*sizeof(trivertx_t));
|
|
file->Read(((frame_t*)m_frames)[i].data[0],m_num_xyz*sizeof(trivertx_t));
|
|
|
|
((frame_t*)m_frames)[i].interval = (float *)malloc(sizeof(float));
|
|
if (((frame_t*)m_frames)[i].interval==NULL) AfxMessageBox("7");
|
|
*(((frame_t*)m_frames)[i].interval) = (float)0;
|
|
}
|
|
else
|
|
{
|
|
file->Read(&(((frame_t*)m_frames)[i].numgroupframes),sizeof(long));
|
|
file->Read(&(((frame_t*)m_frames)[i].groupmin),sizeof(trivertx_t));
|
|
file->Read(&(((frame_t*)m_frames)[i].groupmax),sizeof(trivertx_t));
|
|
|
|
((frame_t*)m_frames)[i].data = (trivertx_t **)malloc(sizeof(u_char *)*(((frame_t*)m_frames)[i].numgroupframes));
|
|
if (((frame_t*)m_frames)[i].data==NULL) AfxMessageBox("8");
|
|
memset(((frame_t*)m_frames)[i].data,0,sizeof(u_char *)*(((frame_t*)m_frames)[i].numgroupframes));
|
|
|
|
((frame_t*)m_frames)[i].info = (frameinfo_t *)malloc(sizeof(frameinfo_t)*(((frame_t*)m_frames)[i].numgroupframes));
|
|
if (((frame_t*)m_frames)[i].info==NULL) AfxMessageBox("9");
|
|
memset(((frame_t*)m_frames)[i].info,0,sizeof(frameinfo_t)*(((frame_t*)m_frames)[i].numgroupframes));
|
|
|
|
((frame_t*)m_frames)[i].interval = (float *)malloc(sizeof(float)*(((frame_t*)m_frames)[i].numgroupframes));
|
|
if (((frame_t*)m_frames)[i].interval==NULL) AfxMessageBox("10");
|
|
memset(((frame_t*)m_frames)[i].interval,0,sizeof(float)*((frame_t*)m_frames)[i].numgroupframes);
|
|
for (int j=0;j<((frame_t*)m_frames)[i].numgroupframes;j++)
|
|
{
|
|
file->Read(&(((frame_t*)m_frames)[i].interval[j]),sizeof(float));
|
|
}
|
|
|
|
for (j=0;j<((frame_t*)m_frames)[i].numgroupframes;j++)
|
|
{
|
|
file->Read(&(((frame_t*)m_frames)[i].info[j]),sizeof(frameinfo_t));
|
|
|
|
((frame_t*)m_frames)[i].data[j] = (trivertx_t *)malloc(m_num_xyz*sizeof(trivertx_t));
|
|
if (((frame_t*)m_frames)[i].data[j]==NULL) AfxMessageBox("11");
|
|
memset(((frame_t*)m_frames)[i].data[j],0,m_num_xyz*sizeof(trivertx_t));
|
|
file->Read(((frame_t*)m_frames)[i].data[j],m_num_xyz*sizeof(trivertx_t));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CQuakeModel::BuildMesh(LPDIRECT3DRM2 d3drm, LPDIRECT3DRMFRAME frame, LPDIRECT3DRMFRAME scene, CDC* pDC)
|
|
{
|
|
D3DVECTOR p[3], n1, n2, n3;
|
|
int i,j;
|
|
trivertx_t *triverts;
|
|
int v1, curvert;
|
|
vec3_t pt1;
|
|
long s, t;
|
|
D3DRMVERTEX *vertexlist;
|
|
unsigned *vertorder;
|
|
unsigned numread = 0;
|
|
|
|
vertexlist = new D3DRMVERTEX[m_num_tris*3+1];
|
|
if (vertexlist == NULL)
|
|
{
|
|
AfxMessageBox("Cannot make vertexlist");
|
|
return;
|
|
}
|
|
|
|
curvert = m_num_tris * 3;
|
|
|
|
vertorder = new unsigned[m_num_tris*3+1];
|
|
if (vertorder == NULL)
|
|
{
|
|
AfxMessageBox("Cannot make vertorder");
|
|
return;
|
|
}
|
|
|
|
curvert = m_num_tris * 3;
|
|
|
|
for (i = 0; i < (m_num_tris * 3); i++)
|
|
{
|
|
curvert--;
|
|
vertorder[i] = curvert;
|
|
}
|
|
|
|
curvert=0;
|
|
|
|
d3drm->CreateMesh(&m_mesh);
|
|
|
|
triverts = ((frame_t*)m_frames)[0].data[0];
|
|
|
|
for (i = 0; i < m_num_tris; i++)
|
|
{
|
|
for (j = 2; j >= 0; j--)
|
|
{
|
|
v1 = ((itriangle_t*)m_tris)[i].vertices[j];
|
|
|
|
pt1.x = triverts[v1].x;
|
|
pt1.y = triverts[v1].y;
|
|
pt1.z = triverts[v1].z;
|
|
|
|
s = ((stvert_t*)m_stverts)[v1].s;
|
|
t = ((stvert_t*)m_stverts)[v1].t;
|
|
|
|
if (s > m_skinwidth)
|
|
AfxMessageBox("Invalid skin vertex (S)");
|
|
|
|
if (t > m_skinheight)
|
|
AfxMessageBox("Invalid skin vertex (T)");
|
|
|
|
if( (((stvert_t*)m_stverts)[v1].onseam) && (!((itriangle_t*)m_tris)[i].facesfront))
|
|
s += m_skinwidth / 2;
|
|
|
|
p[j].x = ( m_scale.x * pt1.x ) + m_origin.x;
|
|
p[j].y = ( m_scale.y * pt1.y ) + m_origin.y;
|
|
p[j].z = ( m_scale.z * pt1.z ) + m_origin.z;
|
|
|
|
vertexlist[curvert].position.x = -p[j].x;
|
|
vertexlist[curvert].position.y = -p[j].y;
|
|
vertexlist[curvert].position.z = -p[j].z;
|
|
|
|
vertexlist[curvert].tu = D3DVALUE(s) / m_skinwidth;
|
|
vertexlist[curvert].tv = D3DVALUE(t) / m_skinheight;
|
|
vertexlist[curvert].color = D3DCOLOR(0);
|
|
|
|
if (curvert+1 < m_num_tris*3) curvert++;
|
|
}
|
|
|
|
D3DRMVectorSubtract(&n2, &p[2], &p[1]);
|
|
D3DRMVectorSubtract(&n1, &p[1], &p[0]);
|
|
|
|
D3DRMVectorCrossProduct(&n3, &n1, &n2);
|
|
D3DRMVectorNormalize(&n3);
|
|
|
|
for (j = 0; j < 3; j++)
|
|
{
|
|
vertexlist[curvert-j+1].normal.x = -n3.x;
|
|
vertexlist[curvert-j+1].normal.y = -n3.y;
|
|
vertexlist[curvert-j+1].normal.z = -n3.z;
|
|
}
|
|
|
|
numread++;
|
|
//statusDlg->m_nProgressBar3.SetPos(numread);
|
|
}
|
|
|
|
m_mesh->AddGroup( m_num_tris * 3, m_num_tris, 3, vertorder, &m_group );
|
|
m_mesh->SetVertices(m_group, 0, m_num_tris * 3, vertexlist );
|
|
|
|
// m_mesh->SetGroupTexture(m_group, m_texture);
|
|
// m_mesh->SetGroupMapping(m_group, D3DRMMAP_PERSPCORRECT);
|
|
// m_mesh->SetGroupQuality(m_group, D3DRMRENDER_FLAT);
|
|
|
|
// ddrval = frame->AddVisual(m_mesh);
|
|
// if (ddrval != D3DRM_OK)
|
|
// AfxMessageBox(CDDHelper::TraceError(ddrval));
|
|
|
|
if (vertexlist) delete vertexlist;
|
|
if (vertorder) delete vertorder;
|
|
|
|
}
|
|
|
|
BOOL CQuakeModel::ShowFrame(LPDIRECT3DRM2 d3drm, CDC* pDC)
|
|
{
|
|
long s,t;
|
|
D3DVECTOR p[3], v;
|
|
int curvert = 0;
|
|
trivertx_t *triverts;
|
|
int v1;
|
|
D3DRMVERTEX *vertexlist;
|
|
int i,j;
|
|
|
|
vertexlist = new D3DRMVERTEX[m_num_tris*3+1];
|
|
if (vertexlist == NULL)
|
|
return AfxMessageBox("Cannot make vertexlist");
|
|
|
|
m_mesh->GetVertices(m_group, 0, m_num_tris*3, vertexlist);
|
|
triverts = ((frame_t*)m_frames)[m_curFrame].data[0];
|
|
|
|
for (i = 0; i < m_num_tris; i++)
|
|
{
|
|
for (j = 2; j >= 0; j--)
|
|
{
|
|
v1 = ((itriangle_t*)m_tris)[i].vertices[j];
|
|
|
|
v.x = triverts[v1].x;
|
|
v.y = triverts[v1].y;
|
|
v.z = triverts[v1].z;
|
|
|
|
s = ((stvert_t*)m_stverts)[v1].s;
|
|
t = ((stvert_t*)m_stverts)[v1].t;
|
|
|
|
if (s > m_skinwidth)
|
|
s = m_skinwidth;;
|
|
|
|
if (t > m_skinheight)
|
|
t = m_skinheight;
|
|
|
|
if( (((stvert_t*)m_stverts)[v1].onseam) && (!((itriangle_t*)m_tris)[i].facesfront))
|
|
s += m_skinwidth / 2;
|
|
|
|
p[j].x = ( m_scale.x * v.x ) + m_origin.x;
|
|
p[j].y = ( m_scale.y * v.y ) + m_origin.y;
|
|
p[j].z = ( m_scale.z * v.z ) + m_origin.z;
|
|
|
|
vertexlist[curvert].position.x = -p[j].x;
|
|
vertexlist[curvert].position.y = -p[j].y;
|
|
vertexlist[curvert].position.z = -p[j].z;
|
|
|
|
vertexlist[curvert].tu = D3DVALUE(s) / m_skinwidth;
|
|
vertexlist[curvert].tv = D3DVALUE(t) / m_skinheight;
|
|
|
|
curvert++;
|
|
}
|
|
}
|
|
m_mesh->SetVertices(m_group, 0, m_num_tris*3, vertexlist );
|
|
|
|
delete (vertexlist);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CQuakeModel::CalcInterpolate(LPDIRECT3DRM2 d3drm, CDC* pDC, int step, int numsteps, int intertype, int direction)
|
|
{
|
|
D3DVECTOR delta;
|
|
D3DVECTOR d1,d2;
|
|
D3DVECTOR p[3];
|
|
int curvert = 0;
|
|
trivertx_t *triverts, *triverts2;
|
|
int v1;
|
|
D3DRMVERTEX *vertexlist;
|
|
int lastframe, i, j;
|
|
|
|
long s, t;
|
|
|
|
vertexlist = new D3DRMVERTEX[m_num_tris*3+1];
|
|
if (vertexlist == NULL)
|
|
return AfxMessageBox("Cannot make vertexlist");
|
|
if (direction == ANIM_FORWARD)
|
|
{
|
|
if (m_curGroup == -1)
|
|
{
|
|
if (m_curFrame + 1 > m_num_frames-1)
|
|
lastframe = 0;
|
|
else
|
|
lastframe = m_curFrame + 1;
|
|
}
|
|
else
|
|
{
|
|
if (m_curFrame + 1 > m_treeInfo[m_curGroup].eFrame)
|
|
lastframe = m_treeInfo[m_curGroup].bFrame;
|
|
else
|
|
lastframe = m_curFrame + 1;
|
|
}
|
|
}
|
|
//mesh->GetVertices( group, 0, mainModel.header->numtris*3, vertexlist);
|
|
|
|
triverts = ((frame_t*)m_frames)[m_curFrame].data[0];
|
|
triverts2 = ((frame_t*)m_frames)[lastframe].data[0];
|
|
|
|
for (i = 0; i < m_num_tris; i++)
|
|
{
|
|
for (j = 2; j >= 0; j--)
|
|
{
|
|
|
|
v1 = ((itriangle_t*)m_tris)[i].vertices[j];
|
|
|
|
s = ((stvert_t*)m_stverts)[v1].s;
|
|
t = ((stvert_t*)m_stverts)[v1].t;
|
|
|
|
if (s > m_skinwidth)
|
|
AfxMessageBox("Invalid skin vertex (S)");
|
|
|
|
if (t > m_skinheight)
|
|
AfxMessageBox("Invalid skin vertex (T)");
|
|
|
|
if( (((stvert_t*)m_stverts)[v1].onseam) && (!((itriangle_t*)m_tris)[i].facesfront))
|
|
s += m_skinwidth / 2;
|
|
|
|
d1.x = triverts[v1].x;
|
|
d1.y = triverts[v1].y;
|
|
d1.z = triverts[v1].z;
|
|
|
|
d2.x = triverts2[v1].x;
|
|
d2.y = triverts2[v1].y;
|
|
d2.z = triverts2[v1].z;
|
|
|
|
delta.x = (d1.x - d2.x) / numsteps;
|
|
delta.y = (d1.y - d2.y) / numsteps;
|
|
delta.z = (d1.z - d2.z) / numsteps;
|
|
|
|
d1.x -= delta.x * step;
|
|
d1.y -= delta.y * step;
|
|
d1.z -= delta.z * step;
|
|
|
|
p[j].x = ( m_scale.x * d1.x ) + m_origin.x;
|
|
p[j].y = ( m_scale.y * d1.y ) + m_origin.y;
|
|
p[j].z = ( m_scale.z * d1.z ) + m_origin.z;
|
|
|
|
vertexlist[curvert].position.x = -p[j].x;
|
|
vertexlist[curvert].position.y = -p[j].y;
|
|
vertexlist[curvert].position.z = -p[j].z;
|
|
|
|
vertexlist[curvert].tu = D3DVALUE(s) / m_skinwidth;
|
|
vertexlist[curvert].tv = D3DVALUE(t) / m_skinheight;
|
|
|
|
curvert++;
|
|
}
|
|
}
|
|
|
|
m_mesh->SetVertices(m_group, 0, m_num_tris*3, vertexlist );
|
|
|
|
delete (vertexlist);
|
|
|
|
if (step + 1 > numsteps) m_curstep = 0;
|
|
else m_curstep++;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CQuakeModel::FillMenuWithSkins(CMenu* menu)
|
|
{
|
|
}
|
|
|
|
void CQuakeModel::AddSkin(LPCTSTR skinname)
|
|
{
|
|
}
|
|
|
|
void CQuakeModel::ReplaceSkin(int i, LPCTSTR skinname)
|
|
{
|
|
}
|
|
|
|
CSkin* CQuakeModel::GetSkin(int i)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
LPDIRECT3DRMMESH CQuakeModel::GetMesh(int i)
|
|
{
|
|
return m_mesh;
|
|
}
|
|
|
|
// info window support
|
|
|
|
void CQuakeModel::LoadFrameInfo(CTreeCtrl* treeDlg, HTREEITEM rootFrame)
|
|
{
|
|
int thisgroup = 0;
|
|
char name[16], *newname;
|
|
HTREEITEM point;
|
|
int groupcount = 0;
|
|
|
|
if (m_num_frames < 1) return;
|
|
|
|
m_numGroups = 0;
|
|
|
|
m_treeInfo = new CTreeHead[m_num_frames];
|
|
if (m_treeInfo == NULL) AfxMessageBox("Null tree");
|
|
|
|
CTreeGroup* groupList = new CTreeGroup[m_num_frames];
|
|
if (groupList == NULL) AfxMessageBox("Null groupList");
|
|
|
|
for (int i = 0; i < m_num_frames; i++)
|
|
{
|
|
if (((frame_t*)m_frames)[i].type == 1)
|
|
{
|
|
AfxMessageBox("Tricky Frames not supported!\n");
|
|
}
|
|
else
|
|
{
|
|
strcpy(name , ((frame_t*)m_frames)[i].info->name);
|
|
newname = (char *)&name;
|
|
StripGroupName(newname);
|
|
|
|
if ((thisgroup = InGroupList(newname, groupList, m_numGroups)) == -1)
|
|
{
|
|
point = treeDlg->InsertItem(newname, rootFrame, TVI_LAST);
|
|
groupList[thisgroup].head = point;
|
|
treeDlg->SetItemData(point, m_numGroups);
|
|
m_treeInfo[m_numGroups].bFrame = i;
|
|
m_treeInfo[m_numGroups].eFrame = i;
|
|
point = treeDlg->InsertItem(((frame_t*)m_frames)[i].info->name, point, TVI_LAST);
|
|
treeDlg->SetItemData(point, i);
|
|
m_numGroups++;
|
|
}
|
|
else
|
|
{
|
|
if (i > m_treeInfo[thisgroup].eFrame)
|
|
m_treeInfo[thisgroup].eFrame = i;
|
|
|
|
point = treeDlg->InsertItem(((frame_t*)m_frames)[i].info->name, groupList[thisgroup].head, TVI_LAST);
|
|
treeDlg->SetItemData(point, i);
|
|
}
|
|
treeDlg->SetItemImage(point, 1, 1);
|
|
}
|
|
}
|
|
if (groupList)
|
|
{
|
|
delete groupList;
|
|
groupList = NULL;
|
|
}
|
|
|
|
treeDlg->Expand(rootFrame, TVE_EXPAND);
|
|
}
|
|
|