mirrors/thug
1
Fork 0
mirror of https://github.com/thug1src/thug.git synced 2025-01-22 05:43:47 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
d8eb714766
thug/Code/Gfx/NGPS/NX/mesh.cpp

1220 lines
30 KiB
C++
Raw Normal View History

thug1src
2016-02-13 21:39:12 +00:00
#include <core/defines.h>
#include <core/math.h>
#include <stdio.h>
#include <stdlib.h>
#include "group.h"
#include "scene.h"
#include "dma.h"
#include "vif.h"
#include "vu1.h"
#include "gif.h"
#include "gs.h"
#include "texture.h"
#include "material.h"
#include "mesh.h"
#include "vu1code.h"
#include "dmacalls.h"
#include "render.h"
#include <sys/file/filesys.h>
#include <sys/file/memfile.h>
#include <sys/mem/memman.h>
#include <gfx/nx.h>
namespace NxPs2
{
#ifdef __NOPT_ASSERT__
extern uint32 gPassMask1; // 1<<6 | 1<<7 (0x40, 0x80)
extern uint32 gPassMask0; // 1<<6 | 1<<7 (0x40, 0x80)
#endif
#if 0
//----------------------------------------------------------------------------------------
// Mesh Group Functions
//----------------------------------------------------------------------------------------
sMesh *sGroup::GetMeshArray()
{
return &(Meshes[FirstMeshIndex]);
}
sGroup* NewMeshGroup(uint32 group_ID, uint32 num_meshes)
{
uint32 i;
int Group = -1;
// resolve ID
for (i=0; i<NumTextureGroups; i++)
{
if (Groups[i].ID == group_ID)
{
Group = i;
break;
}
}
Dbg_MsgAssert(Groups[i].ID==group_ID, ("Couldn't find group ID #%d\n", group_ID));
// get number of meshes
// set group info
Groups[Group].NumMeshes = num_meshes;
Groups[Group].FirstMeshIndex = NumMeshes;
NumMeshes += num_meshes;
return &(Groups[Group]);
}
#endif
//----------------------------------------------------------------------------------------
// Mesh scaling parameters
// GJ: Used for vertex scaling at load-time (needed for cutscene head scaling)
// I decided to make global functions to set these from the cutscene code,
// so that I wouldn't have to pass extra parameters through the various loading
// functions
//----------------------------------------------------------------------------------------
bool s_meshScalingEnabled = false;
char* s_pWeightIndices = NULL;
float* s_pWeights = NULL;
Mth::Vector* s_pBonePositions = NULL;
Mth::Vector* s_pBoneScales = NULL;
int s_currentVertIndex = 0;
void SetMeshScalingParameters( Nx::SMeshScalingParameters* pParams )
{
Dbg_Assert( pParams );
s_meshScalingEnabled = true;
s_pWeights = pParams->pWeights;
s_pWeightIndices = pParams->pWeightIndices;
s_pBoneScales = pParams->pBoneScales;
s_pBonePositions = pParams->pBonePositions;
s_currentVertIndex = 0;
}
void DisableMeshScaling()
{
s_meshScalingEnabled = false;
s_pWeights = NULL;
s_pWeightIndices = NULL;
s_pBoneScales = NULL;
s_pBonePositions = NULL;
s_currentVertIndex = 0;
}
//----------------------------------------------------------------------------------------
// L O A D M E S H E S
//----------------------------------------------------------------------------------------
void * LoadMeshes(void *pFile, sScene *pScene, bool IsSkin, bool IsInstanceable, uint32 texDictOffset)
{
int i;
// initialise sScene bounding sphere to avoid rewriting it multiple times
pScene->Sphere[3] = -1.0f;
int skinnedVertexCount=0;
// iterate over mesh groups
for (i=0; i<pScene->NumGroups; i++)
{
pFile = LoadMeshGroup(pFile, pScene, IsSkin, IsInstanceable, texDictOffset, skinnedVertexCount);
}
// Check hierarchy data
int num_hier = -1;
MEM_Read(&num_hier, sizeof(int), 1, pFile);
Dbg_MsgAssert(num_hier == 0, ("num_hier = %d", num_hier));
// clear it out for future use
DisableMeshScaling();
return pFile;
}
void *LoadMeshGroup(void *pFile, sScene *pScene, bool IsSkin, bool IsInstanceable, uint32 texDictOffset, int& skinnedVertexCount)
{
sMesh *pMesh;
sMaterial *pMat;
sGroup *pGroup;
uint32 MaterialChecksum, GroupChecksum;
int NumMeshesThisGroup,i,j;
Mth::Vector sphere;
// get group checksum and number of meshes
MEM_Read(&GroupChecksum, sizeof(uint32), 1, pFile);
MEM_Read(&NumMeshesThisGroup, sizeof(uint32), 1, pFile);
GroupChecksum += texDictOffset;
// resolve checksum
for (pGroup=sGroup::pHead; pGroup; pGroup=pGroup->pNext)
if (pGroup->Checksum == GroupChecksum)
break;
Dbg_MsgAssert(pGroup, ("Couldn't find group checksum #%0X\n", GroupChecksum));
// set mesh info in the group
pGroup->pMeshes = pScene->pMeshes+pScene->NumMeshes;
pGroup->NumMeshes = NumMeshesThisGroup;
// loop over meshes
for (i=0,pMesh=pGroup->pMeshes; i<NumMeshesThisGroup; i++,pMesh++)
{
// start a subroutine for this mesh
dma::BeginSub3D();
// start a ret tag
dma::BeginTag(dma::ret, 0);
// get object checksum
MEM_Read(&pMesh->Checksum, sizeof(uint32), 1, pFile);
// get object sphere for mesh version 2 onwards
if (sMesh::Version >= 2)
{
unsigned int lod_stuff_not_used_here;
MEM_Read(&lod_stuff_not_used_here, sizeof(unsigned int), 1, pFile);
MEM_Read(&lod_stuff_not_used_here, sizeof(unsigned int), 1, pFile);
// Just process parent/child stuff
int num_child, hier_data;
MEM_Read(&hier_data, sizeof(unsigned int), 1, pFile);
MEM_Read(&num_child, sizeof(unsigned int), 1, pFile);
for (int j = 0; j < num_child; j++)
{
MEM_Read(&hier_data, sizeof(unsigned int), 1, pFile);
}
MEM_Read(&sphere, sizeof(Mth::Vector), 1, pFile);
// write sphere into sScene
if (pScene->Sphere[3] < 0.0f)
pScene->Sphere = sphere;
#if 0
// GJ: the following assertion is no longer valid...
// there are occasionally multiple NxObjects inside a
// single MDL file, and each mesh will have a different
// bounding sphere depending on which NxObject is belongs
// to... Mike agreed to rewrite the bounding sphere
// calculation code so that all meshes will have a
// new bounding sphere that encompasses all the individual
// meshes' bounding spheres...
// check object spheres from different meshes match ok
Dbg_MsgAssert((pScene->Sphere[0]==sphere[0] && pScene->Sphere[1]==sphere[1] &&
pScene->Sphere[2]==sphere[2] && pScene->Sphere[3]==sphere[3]),
("object bounding sphere differs between meshes"));
#else
// ...so, if the object spheres differ, just combine them...
if (pScene->Sphere[0]!=sphere[0] || pScene->Sphere[1]!=sphere[1] ||
pScene->Sphere[2]!=sphere[2] || pScene->Sphere[3]!=sphere[3])
{
//printf("\n\n");
//printf("**********************************************\n");
//printf("* *\n");
//printf("* Tell Mike if you see this line printing! *\n");
//printf("* *\n");
//printf("**********************************************\n");
//printf("\n\n");
//printf("combining spheres (%g,%g,%g,%g) and (%g,%g,%g,%g)\n",
// pScene->Sphere[0], pScene->Sphere[1], pScene->Sphere[2], pScene->Sphere[3],
// sphere[0], sphere[1], sphere[2], sphere[3]);
Mth::Vector x0, x1, d;
if (pScene->Sphere[3] > sphere[3])
{
x0 = pScene->Sphere;
x1 = sphere;
}
else
{
x0 = sphere;
x1 = pScene->Sphere;
}
float r0=x0[3], r1=x1[3];
// (x0,r0) is the larger sphere, (x1,r1) the smaller
// d is the vector between centres
d = x1 - x0;
// square of distance between centres
float D2 = DotProduct(d,d);
// (r0-r1)^2
float R2 = (r0-r1)*(r0-r1);
// m = max { (r1-r0+|d|)/2, 0 }
float m = 0.0f;
if (R2-D2 < 0)
{
m = (r1-r0 + sqrtf(D2)) * 0.5f;
}
pScene->Sphere = x0 + m * d;
pScene->Sphere[3] = r0 + m;
//printf("result is (%g,%g,%g,%g)\n",
// pScene->Sphere[0], pScene->Sphere[1], pScene->Sphere[2], pScene->Sphere[3]);
//Dbg_MsgAssert( 0, ( "Please tell Mike if you see this assert firing off!" ) );
}
#endif
}
// get material checksum and look it up
MEM_Read(&MaterialChecksum, sizeof(uint32), 1, pFile);
for (j=0,pMat=pScene->pMaterials; j<pScene->NumMaterials; j++,pMat++)
if (pMat->Checksum == MaterialChecksum)
break;
Dbg_MsgAssert(pMat->Checksum==MaterialChecksum, ("couldn't find material with checksum %08X\n", MaterialChecksum));
pMesh->pMaterial = pMat;
// get mesh flags
MEM_Read(&pMesh->Flags, sizeof(uint32), 1, pFile);
// make it active
pMesh->SetActive(true);
// get bounding volume data
MEM_Read(&pMesh->ObjBox, sizeof(float) * 3, 1, pFile);
MEM_Read(&pMesh->Box, sizeof(float) * 3, 1, pFile);
MEM_Read(&pMesh->Sphere, sizeof(float) * 4, 1, pFile);
// pass number
if (sMesh::Version >= 5)
{
MEM_Read(&pMesh->Pass, sizeof(int), 1, pFile);
}
// material name
if (sMesh::Version >= 6)
{
MEM_Read(&pMesh->MaterialName, sizeof(int), 1, pFile);
}
// import vertices of this mesh
pFile = LoadVertices(pFile, pMesh, pMat, pGroup, skinnedVertexCount);
// end the dma tag
dma::EndTag();
// end the model subroutine
pMesh->pSubroutine = dma::EndSub3D();
}
// add to total number for scene
pScene->NumMeshes += NumMeshesThisGroup;
return pFile;
}
//----------------------------------------------------------------------------------------
// L O A D V E R T I C E S
//----------------------------------------------------------------------------------------
int UnpackOffset;
void * LoadVertices(void *pFile, sMesh *pMesh, sMaterial *pMat, sGroup *pGroup, int& skinnedIndexCount)
{
uint32 NumVertices;
uint REGS, NREG, PRIM, ADDR;
sTexture *pTex;
uint32 i;
uint8 VertexData[64];
int STOffset, ColourOffset, NormalOffset, SkinOffset, XYZOffset, VertexSize;
int texture_width=0, texture_height=0;
// get number of vertices for this mesh
MEM_Read(&NumVertices, sizeof(uint32), 1, pFile);
// skip mesh if it has no vertices
if (NumVertices==0)
return pFile;
// work out giftag fields
REGS = gs::XYZF2;
NREG = 1;
PRIM = TRISTRIP|ABE|FGE;
ADDR = VU1_ADDR(Proj);
if (pMesh->Flags & MESHFLAG_COLOURS)
{
REGS = REGS<<4 | gs::RGBAQ;
NREG++;
}
if (pMesh->Flags & MESHFLAG_NORMALS)
{
if (pMat->Flags & MATFLAG_ENVIRONMENT)
{
ADDR = VU1_ADDR(Refl);
REGS = REGS<<4 | gs::ST;
PRIM |= TME;
}
else
{
REGS = REGS<<4 | gs::NOP;
}
NREG++;
}
if ((pMesh->Flags & MESHFLAG_TEXTURE) && !(pMat->Flags & MATFLAG_ENVIRONMENT))
{
REGS = REGS<<4 | gs::ST;
NREG++;
PRIM |= TME;
ADDR = VU1_ADDR(PTex);
}
if (pMat->Flags & MATFLAG_SMOOTH)
PRIM |= IIP;
// override everything for skinned models!
if (pMesh->Flags & MESHFLAG_SKINNED)
{
if (pMat->RegCLAMP & PackCLAMP(3,3,0,0,0,0))
{
// clamped case, send texture coords as 32 bits floating point STs
REGS = gs::XYZ2<<16 | gs::RGBAQ<<12 | gs::NOP<<8 | gs::NOP<<4 | gs::ST;
NREG = 5;
PRIM |= TME;
ADDR = VU1_ADDR(Skin);
}
else
{
// standard case, non-clamped, compress texture coords to 16 bit fixed point UVs
REGS = gs::XYZ2<<16 | gs::RGBAQ<<12 | gs::NOP<<8 | gs::NOP<<4 | gs::UV;
NREG = 5;
PRIM |= TME|FST;
ADDR = VU1_ADDR(Skin);
}
}
// output GS context for material
gs::BeginPrim(REL,0,0);
gs::Reg1(gs::ALPHA_1, pMat->RegALPHA);
gs::Reg1(gs::TEST_1, PackTEST(1,AGEQUAL,pMat->Aref,KEEP,0,0,1,ZGEQUAL));
// texture registers if necessary
if (pMat->Flags & MATFLAG_TEXTURED)
{
pTex = pMat->pTex;
gs::Reg1(gs::TEX0_1, pTex->RegTEX0);
gs::Reg1(gs::TEX1_1, pMat->RegTEX1);
gs::Reg1(gs::CLAMP_1, pMat->RegCLAMP);
if (pTex->MXL > 0)
{
gs::Reg1(gs::MIPTBP1_1,pTex->RegMIPTBP1);
if (pTex->MXL > 3)
{
gs::Reg1(gs::MIPTBP2_1,pTex->RegMIPTBP2);
}
}
// extract texture dimensions
texture_width = 1 << ((pTex->RegTEX0 >> 26) & 0xF);
texture_height = 1 << ((pTex->RegTEX0 >> 30) & 0xF);
}
gs::EndPrim(0);
// set maximum vu buffer size
vu1::MaxBuffer = pMesh->Flags&MESHFLAG_SKINNED ? 240 : 240;
// begin a batch of vertices
BeginModelMultiPrim(REGS, NREG, PRIM, NumVertices, ADDR);
// work out vertex size and data offsets
VertexSize = (pMesh->Flags & MESHFLAG_SKINNED) ? 8 : 16;
XYZOffset = SkinOffset = NormalOffset = ColourOffset = STOffset = 0;
if (pMesh->Flags & MESHFLAG_SKINNED)
{
VertexSize += 8;
XYZOffset += 8;
}
if (pMesh->Flags & MESHFLAG_NORMALS)
{
VertexSize += 4;
XYZOffset += 4;
SkinOffset += 4;
}
if (pMesh->Flags & MESHFLAG_COLOURS)
{
VertexSize += 4;
XYZOffset += 4;
SkinOffset += 4;
NormalOffset += 4;
}
if (pMesh->Flags & MESHFLAG_TEXTURE)
{
int size = (pMesh->Flags & MESHFLAG_SKINNED) ? 4 : 8;
VertexSize += size;
XYZOffset += size;
SkinOffset += size;
NormalOffset += size;
ColourOffset += size;
}
// loop over vertices
for (i=0; i<NumVertices; i++)
{
UnpackOffset=1;
MEM_Read(VertexData, 1, VertexSize, pFile);
BeginVertex(pMesh, pMat);
// special case for skinned models
if (pMesh->Flags & MESHFLAG_SKINNED)
{
// texture coords
UnpackOffset = 1;
if ((pMesh->Flags & MESHFLAG_TEXTURE) && !(pMat->Flags & MATFLAG_ENVIRONMENT))
{
if (pMat->RegCLAMP & PackCLAMP(3,3,0,0,0,0))
{
VertexSTFloat(VertexData+STOffset);
}
else
{
VertexUV(VertexData+STOffset, texture_width<<4, texture_height<<4);
}
}
// weights
UnpackOffset = 2;
VertexWeights(VertexData+SkinOffset);
// normal and transform offsets
UnpackOffset = 3;
VertexSkinNormal(VertexData+NormalOffset, VertexData+SkinOffset+4);
// colour
UnpackOffset = 4;
if (pMesh->Flags & MESHFLAG_COLOURS)
{
VertexRGBA(VertexData+ColourOffset);
}
// position
UnpackOffset = 5;
VertexXYZ(VertexData+XYZOffset, true, skinnedIndexCount);
}
else
{
// texture coords
if ((pMesh->Flags & MESHFLAG_TEXTURE) && !(pMat->Flags & MATFLAG_ENVIRONMENT))
{
VertexST16(VertexData+STOffset);
}
// normal normals
if (pMesh->Flags & MESHFLAG_NORMALS)
{
VertexNormal(VertexData+NormalOffset);
}
// colour
if (pMesh->Flags & MESHFLAG_COLOURS)
{
VertexRGBA(VertexData+ColourOffset);
}
// position
VertexXYZ(VertexData+XYZOffset, false, skinnedIndexCount);
}
EndVertex();
// current vert being processed
s_currentVertIndex++;
}
// accumulate number of vertices
sMesh::TotalNumVertices += NumVertices;
// finish batch of vertices
EndModelMultiPrim();
return pFile;
}
//---------------------------------------------------------
// M O D E L P R I M C O N S T R U C T I O N
//---------------------------------------------------------
uint MeshRegs, MeshNReg, MeshPrim, MeshNLoop, MeshAddr;
uint NumVerticesThisBuffer, NumOutputVertices;
uint32 *pColour;
sint32 *pST32;
sint16 *pST16, *pVertex, *pNormal, *pSkinData;
uint8 *pWeights;
uint16 *pUV;
// begin model prim (i.e. begin a vertex packet)
void BeginModelPrim(uint32 Regs, uint NReg, uint Prim, uint Pre, uint Addr)
{
vif::STCYCL(1,NReg);
vif::UNPACK(0,V4_32,1,REL,UNSIGNED,0);
gif::BeginTag1(Regs, NReg, PACKED, Prim, Pre, Addr);
}
// end model prim (i.e. end a vertex packet)
void EndModelPrim(uint Eop)
{
gif::EndTag1(Eop);
}
// begin model prim (i.e. begin a vertex packet)
void BeginModelPrimImmediate(uint32 Regs, uint NReg, uint Prim, uint Pre, uint Addr)
{
vif::STCYCL(1,NReg);
vif::UNPACK(0,V4_32,1,ABS,UNSIGNED,0);
gif::BeginTag1(Regs, NReg, PACKED, Prim, Pre, Addr);
}
// end model prim (i.e. end a vertex packet)
void EndModelPrimImmediate(uint Eop)
{
gif::EndTag1(Eop);
}
// begin a model prim which may span multiple VU1 buffers
void BeginModelMultiPrim(uint32 Regs, uint NReg, uint Prim, uint NLoop, uint Addr)
{
// record tag info
MeshRegs = Regs;
MeshNReg = NReg;
MeshPrim = Prim;
MeshNLoop = NLoop;
MeshAddr = Addr;
// work out number of vertices to unpack first
// (and go ahead with it for now, even if there's only room for 1 vertex)
NumVerticesThisBuffer = (vu1::MaxBuffer - ((vu1::Loc-vu1::Buffer)&0x3FF) - 1) / NReg;
if (NumVerticesThisBuffer > MeshNLoop)
NumVerticesThisBuffer = MeshNLoop;
BeginModelPrim(Regs, NReg, Prim, 1, Addr);
NumOutputVertices = 0;
}
void EndModelMultiPrim(void)
{
EndModelPrim(1);
vif::MSCAL(VU1_ADDR(Parser));
vif::FLUSH();
}
int RestartTristrip=0;
void BeginVertex(sMesh *pMesh, sMaterial *pMat)
{
if (NumOutputVertices == NumVerticesThisBuffer)
{
// end the model prim
if ((pMesh->Flags & MESHFLAG_SKINNED) && (768-((vu1::Buffer+vif::UnpackSize*vif::CycleLength+1)&1023) < vu1::MaxBuffer))
{
EndModelPrim(0);
vif::UNPACK(0, V4_32, 1, REL, UNSIGNED, 0);
gif::Tag1(0, 0, PACKED, 0, 0, 1, 0, VU1_ADDR(Jump)); // reset address to 0
vu1::Loc = 0;
// start VU1 execution
vif::MSCAL(VU1_ADDR(Parser));
vif::FLUSH();
}
else
{
EndModelPrim(1);
// start VU1 execution
vif::MSCAL(VU1_ADDR(Parser));
vif::FLUSH();
}
// reduce number still to go
MeshNLoop -= NumOutputVertices;
// work out number of vertices to unpack next
NumVerticesThisBuffer = vu1::MaxBuffer / MeshNReg;
if (NumVerticesThisBuffer > MeshNLoop)
NumVerticesThisBuffer = MeshNLoop;
// start a new buffalo'd
// add a dummy gs context
gs::BeginPrim(REL,0,0);
gs::Reg1(gs::A_D_NOP,0);
gs::EndPrim(0);
BeginModelPrim(MeshRegs, MeshNReg, MeshPrim, 1, MeshAddr);
NumOutputVertices = 0;
// signal tristrip restart
RestartTristrip=1;
}
}
void VertexST16(uint8 *pData)
{
static sint16 s0,t0,s1,t1;
if (NumOutputVertices==0)
{
vif::BeginUNPACK(0, V2_16, REL, SIGNED, UnpackOffset);
pST16 = (sint16 *)dma::pLoc;
if (RestartTristrip)
{
*pST16++ = s0;
*pST16++ = t0;
*pST16++ = s1;
*pST16++ = t1;
}
dma::pLoc = (uint8 *)pST16 + NumVerticesThisBuffer * 4;
vif::EndUNPACK();
}
*pST16++ = (sint16) (int) (((float *)pData)[0] * 4096.0f);
*pST16++ = (sint16) (int) (((float *)pData)[1] * 4096.0f);
s0=s1, s1=pST16[-2];
t0=t1, t1=pST16[-1];
UnpackOffset++;
}
void VertexSTFloat(uint8 *pData)
{
static sint32 s0,t0,s1,t1;
if (NumOutputVertices==0)
{
vif::STMASK(0xE0);
vif::BeginUNPACK(1, V2_32, REL, SIGNED, UnpackOffset);
pST32 = (sint32 *)dma::pLoc;
if (RestartTristrip)
{
*pST32++ = s0;
*pST32++ = t0;
*pST32++ = s1;
*pST32++ = t1;
}
dma::pLoc = (uint8 *)pST32 + NumVerticesThisBuffer * 8;
vif::EndUNPACK();
}
*(float *)pST32++ = (float)((sint16 *)pData)[0] * 0.000244140625f;
*(float *)pST32++ = (float)((sint16 *)pData)[1] * 0.000244140625f;
s0=s1, s1=pST32[-2];
t0=t1, t1=pST32[-1];
UnpackOffset++;
}
void VertexUV(uint8 *pData, int textureWidth16, int textureHeight16)
{
static uint16 u0,v0,u1,v1;
if (NumOutputVertices==0)
{
vif::BeginUNPACK(0, V2_16, REL, UNSIGNED, UnpackOffset);
pUV = (uint16 *)dma::pLoc;
if (RestartTristrip)
{
*pUV++ = u0;
*pUV++ = v0;
*pUV++ = u1;
*pUV++ = v1;
}
dma::pLoc = (uint8 *)pUV + NumVerticesThisBuffer * 4;
vif::EndUNPACK();
}
*pUV++ = (uint16)((int)((float)((sint16 *)pData)[0] * (float)textureWidth16 * 0.000244140625f) + 0x00002000);
*pUV++ = (uint16)((int)((float)((sint16 *)pData)[1] * (float)textureHeight16 * 0.000244140625f) + 0x00002000);
u0=u1, u1=pUV[-2];
v0=v1, v1=pUV[-1];
UnpackOffset++;
}
void VertexNormal(uint8 *pData)
{
static sint16 nx0,ny0,nz0,nx1,ny1,nz1;
if (NumOutputVertices==0)
{
vif::BeginUNPACK(0, V3_16, REL, SIGNED, UnpackOffset);
pNormal = (sint16 *)dma::pLoc;
if (RestartTristrip)
{
*pNormal++ = nx0;
*pNormal++ = ny0;
*pNormal++ = nz0;
*pNormal++ = nx1;
*pNormal++ = ny1;
*pNormal++ = nz1;
}
dma::pLoc = (uint8 *)pNormal + NumVerticesThisBuffer * 6;
vif::EndUNPACK();
}
*pNormal++ = ((sint16 *)pData)[0];
*pNormal++ = ((sint16 *)pData)[1];
//*pNormal++ = ((sint16 *)pData)[2];
sint16 coord = (sint16)sqrtf(32767.0f*32767.0f - (float)((sint16 *)pData)[0] * (float)((sint16 *)pData)[0]
- (float)((sint16 *)pData)[1] * (float)((sint16 *)pData)[1]);
if (((sint16 *)pData)[0] & 0x0001)
{
coord = -coord;
}
*pNormal++ = coord;
nx0=nx1, nx1=pNormal[-3];
ny0=ny1, ny1=pNormal[-2];
nz0=nz1, nz1=pNormal[-1];
UnpackOffset++;
}
#if 0
void VertexWeights(uint8 *pData)
{
static sint16 wa0,wb0,wc0,wa1,wb1,wc1;
if (NumOutputVertices==0)
{
vif::BeginUNPACK(0, V3_16, REL, SIGNED, UnpackOffset);
pWeights = (sint16 *)dma::pLoc;
if (RestartTristrip)
{
*pWeights++ = wa0;
*pWeights++ = wb0;
*pWeights++ = wc0;
*pWeights++ = wa1;
*pWeights++ = wb1;
*pWeights++ = wc1;
}
dma::pLoc = (uint8 *)pWeights + NumVerticesThisBuffer * 6;
vif::EndUNPACK();
}
*pWeights++ = ((sint16 *)pData)[0];
*pWeights++ = ((sint16 *)pData)[1];
*pWeights++ = 0x7FFF - pWeights[-1] - pWeights[-2];
wa0=wa1, wa1=pWeights[-3];
wb0=wb1, wb1=pWeights[-2];
wc0=wc1, wc1=pWeights[-1];
UnpackOffset++;
}
#else
void VertexWeights(uint8 *pData)
{
static uint8 wa0,wb0,wc0,wa1,wb1,wc1;
if (NumOutputVertices==0)
{
vif::BeginUNPACK(0, V3_8, REL, UNSIGNED, UnpackOffset);
pWeights = dma::pLoc;
if (RestartTristrip)
{
*pWeights++ = wa0;
*pWeights++ = wb0;
*pWeights++ = wc0;
*pWeights++ = wa1;
*pWeights++ = wb1;
*pWeights++ = wc1;
}
dma::pLoc = pWeights + NumVerticesThisBuffer * 3;
vif::EndUNPACK();
}
wa0=wa1;
wb0=wb1;
wc0=wc1;
wa1 = (uint8)(sint8)(((float)((sint16 *)pData)[0] + 0.5f) * 0.007818608f);
wb1 = (uint8)(sint8)(((float)((sint16 *)pData)[1] + 0.5f) * 0.007818608f);
if (wb1==0)
{
wa1=255, wb1=1;
}
wc1 = 256 - wa1 - wb1;
*pWeights++ = wa1;
*pWeights++ = wb1;
*pWeights++ = wc1;
UnpackOffset++;
}
#endif
void VertexSkinNormal(uint8 *pNormData, uint8 *pTOData)
{
static sint16 nx0,ny0,nz0,nx1,ny1,nz1;
if (NumOutputVertices==0)
{
vif::BeginUNPACK(0, V3_16, REL, SIGNED, UnpackOffset);
pSkinData = (sint16 *)dma::pLoc;
if (RestartTristrip)
{
*pSkinData++ = nx0;
*pSkinData++ = ny0;
*pSkinData++ = nz0;
*pSkinData++ = nx1;
*pSkinData++ = ny1;
*pSkinData++ = nz1;
}
dma::pLoc = (uint8 *)pSkinData + NumVerticesThisBuffer * 6;
vif::EndUNPACK();
}
*pSkinData++ = (sint16) (((sint32) ((sint16 *)pNormData)[0]) & 0xFFFFFC00 | (((uint32)((uint8 *)pTOData)[0]) << 2));
*pSkinData++ = (sint16) (((sint32) ((sint16 *)pNormData)[1]) & 0xFFFFFC00 | (((uint32)((uint8 *)pTOData)[1]) << 2));
//*pSkinData++ = (sint16) (((sint32) ((sint16 *)pNormData)[2]) & 0xFFFFFC00 | (((uint32)((uint8 *)pTOData)[2]) << 2));
sint16 coord = (sint16)sqrtf(32767.0f*32767.0f - (float)((sint16 *)pNormData)[0] * (float)((sint16 *)pNormData)[0]
- (float)((sint16 *)pNormData)[1] * (float)((sint16 *)pNormData)[1]);
if (((sint16 *)pNormData)[0] & 0x0001)
{
coord = -coord;
}
*pSkinData++ = (sint16) ((sint32)coord & 0xFFFFFC00) | (((uint8 *)pTOData)[2] << 2);
nx0=nx1, nx1=pSkinData[-3];
ny0=ny1, ny1=pSkinData[-2];
nz0=nz1, nz1=pSkinData[-1];
UnpackOffset++;
}
void VertexRGBA(uint8 *pData)
{
static uint32 rgba0,rgba1;
if (NumOutputVertices==0)
{
vif::BeginUNPACK(0, V4_8, REL, UNSIGNED, UnpackOffset);
pColour = (uint32 *)dma::pLoc;
if (RestartTristrip)
{
*pColour++ = rgba0;
*pColour++ = rgba1;
}
dma::pLoc = (uint8 *)pColour + NumVerticesThisBuffer * 4;
vif::EndUNPACK();
}
*pColour++ = ((uint32 *)pData)[0];
rgba0=rgba1, rgba1=pColour[-1];
UnpackOffset++;
}
Mth::Vector get_bone_scale( int bone_index )
{
Mth::Vector returnVec( 1.0f, 1.0f, 1.0f, 1.0f );
if ( bone_index >= 29 && bone_index <= 33 )
{
// this only works with the thps5 skeleton, whose
// head bones are between 29 and 33...
// (eventually, we can remove the subtract 29
// once the exporter is massaging the data correctly)
returnVec = s_pBoneScales[ bone_index - 29 ];
// Y & Z are reversed... odd!
Mth::Vector tempVec = returnVec;
returnVec[Y] = tempVec[Z];
returnVec[Z] = tempVec[Y];
}
else if ( bone_index == -1 )
{
// implies that it's not weighted to a bone
return returnVec;
}
else
{
// implies that it's weighted to the wrong bone
return returnVec;
}
return returnVec;
}
Mth::Vector get_bone_pos( int bone_index )
{
Mth::Vector returnVec( 0.0f, 0.0f, 0.0f, 1.0f );
if ( bone_index >= 29 && bone_index <= 33 )
{
// this only works with the thps5 skeleton, whose
// head bones are between 29 and 33...
// (eventually, we can remove the subtract 29
// once the exporter is massaging the data correctly)
returnVec = s_pBonePositions[ bone_index - 29 ];
}
else if ( bone_index == -1 )
{
// implies that it's not weighted to a bone
return returnVec;
}
else
{
// implies that it's weighted to the wrong bone
return returnVec;
}
// need to get into fixed point
returnVec.Scale( 16.0f );
returnVec[W] = 1.0f;
return returnVec;
}
void VertexXYZ(uint8 *pData, bool IsSkin, int& skinnedVertexCount)
{
static sint64 x0,y0,z0,x1,y1,z1,x2,y2,z2;
sint64 det0,det1,det2;
if (NumOutputVertices==0)
{
vif::STMOD(1);
vif::BeginUNPACK(0, V4_16, REL, SIGNED, UnpackOffset);
pVertex = (sint16 *)dma::pLoc;
if (RestartTristrip)
{
*pVertex++ = x1;
*pVertex++ = y1;
*pVertex++ = z1;
*pVertex++ = 0x8000;
*pVertex++ = x2;
*pVertex++ = y2;
*pVertex++ = z2;
*pVertex++ = 0x8000;
}
dma::pLoc = (uint8 *)pVertex + NumVerticesThisBuffer * 8;
vif::EndUNPACK();
vif::STMOD(0);
}
if (IsSkin)
{
if ( s_meshScalingEnabled )
{
float x = (float)((sint16 *)pData)[0];
float y = (float)((sint16 *)pData)[1];
float z = (float)((sint16 *)pData)[2];
Mth::Vector origPos( x, y, z, 1.0f );
Mth::Vector bonePos0 = get_bone_pos( s_pWeightIndices[s_currentVertIndex * 3] );
Mth::Vector bonePos1 = get_bone_pos( s_pWeightIndices[s_currentVertIndex * 3 + 1] );
Mth::Vector bonePos2 = get_bone_pos( s_pWeightIndices[s_currentVertIndex * 3 + 2] );
// need to scale each vert relative to its parent bone
Mth::Vector localPos0 = origPos - bonePos0;
Mth::Vector localPos1 = origPos - bonePos1;
Mth::Vector localPos2 = origPos - bonePos2;
localPos0.Scale( get_bone_scale( s_pWeightIndices[s_currentVertIndex * 3] ) );
localPos1.Scale( get_bone_scale( s_pWeightIndices[s_currentVertIndex * 3 + 1] ) );
localPos2.Scale( get_bone_scale( s_pWeightIndices[s_currentVertIndex * 3 + 2] ) );
localPos0 += bonePos0;
localPos1 += bonePos1;
localPos2 += bonePos2;
Mth::Vector scaledPos = ( localPos0 * s_pWeights[s_currentVertIndex * 3] )
+ ( localPos1 * s_pWeights[s_currentVertIndex * 3 + 1] )
+ ( localPos2 * s_pWeights[s_currentVertIndex * 3 + 2] );
x = scaledPos[X];
y = scaledPos[Y];
z = scaledPos[Z];
*pVertex++ = (sint16)x;
*pVertex++ = (sint16)y;
*pVertex++ = (sint16)z;
}
else
{
*pVertex++ = (((sint16 *)pData)[0] * 1);
*pVertex++ = (((sint16 *)pData)[1] * 1);
*pVertex++ = (((sint16 *)pData)[2] * 1);
}
}
else
{
*pVertex++ = (sint16) (((float *)pData)[0] * SUB_INCH_PRECISION);
*pVertex++ = (sint16) (((float *)pData)[1] * SUB_INCH_PRECISION);
*pVertex++ = (sint16) (((float *)pData)[2] * SUB_INCH_PRECISION);
}
if (IsSkin)
{
// GJ: if it's a skinned model, then check to see
// if the skinnedVertexCount matches one of the ones
// that requires a pointer to the ADC bit
AddCASFlag( skinnedVertexCount, (uint16*)pVertex );
}
skinnedVertexCount++;
if (IsSkin)
{
*pVertex++ = ((uint16 *)pData)[3] ? 0x8000 : 0x0000;
}
else
{
*pVertex++ = ((uint32 *)pData)[3] ? 0x8000 : 0x0000;
}
// advance vertex queue and cull triangle if zero area
x0=x1, y0=y1, z0=z1;
x1=x2, y1=y2, z1=z2;
x2=pVertex[-4], y2=pVertex[-3], z2=pVertex[-2];
det0 = y1*z2+y2*z0+y0*z1-y2*z1-y0*z2-y1*z0;
det1 = z1*x2+z2*x0+z0*x1-z2*x1-z0*x2-z1*x0;
det2 = x1*y2+x2*y0+x0*y1-x2*y1-x0*y2-x1*y0;
if (det0*det0 + det1*det1 + det2*det2 == 0)
pVertex[-1] = 0x8000;
UnpackOffset++;
}
void EndVertex(void)
{
if (NumOutputVertices==0 && RestartTristrip)
{
RestartTristrip = 0;
}
NumOutputVertices++;
}
void sMesh::SetActive(bool active)
{
if (active)
{
Flags |= MESHFLAG_ACTIVE;
}
else
{
Flags &= ~MESHFLAG_ACTIVE;
}
}
// Note, Meshflags and passmasks are off by 2 bits
//#define MESHFLAG_PASS_BIT_0 (1<<8)
//#define MESHFLAG_PASS_BIT_1 (1<<9)
//uint32 gPassMask1 = 0; // 1<<6 | 1<<7 (0x40, 0x80)
//uint32 gPassMask0 = 0; // 1<<6 | 1<<7 (0x40, 0x80)
bool sMesh::IsActive()
{
#ifdef __NOPT_ASSERT__
// Mick: debug check for global pass on/off
// Note, shifting flags by 2, so mesh flags match geomnode flags
// Eventually, meshes will be replaced by leaf nodes in CGeomNode tree
// if (((Flags>>2) & gPassMask1) != gPassMask0)
// {
// return false;
// }
#endif
return (Flags&MESHFLAG_ACTIVE) ? true : false;
}
const int MAX_CAS_DATA_LOOKUP = 10000;
// array of pointers to sCASData*
sCASData** sCASDataLookupTable = NULL;
void CreateCASDataLookupTable()
{
Mem::Manager::sHandle().PushContext(Mem::Manager::sHandle().TopDownHeap());
Dbg_MsgAssert( sCASDataLookupTable == NULL, ( "CAS data lookup table already exists" ) );
sCASDataLookupTable = (sCASData**)Mem::Malloc( MAX_CAS_DATA_LOOKUP * sizeof(sCASData*) );
for ( int i = 0; i < MAX_CAS_DATA_LOOKUP; i++ )
{
sCASDataLookupTable[i] = NULL;
}
Mem::Manager::sHandle().PopContext();
}
void DestroyCASDataLookupTable()
{
if ( sCASDataLookupTable )
{
Mem::Free( sCASDataLookupTable );
sCASDataLookupTable = NULL;
}
}
void SetCASDataLookupData( int index, sCASData* pData )
{
Dbg_MsgAssert( sCASDataLookupTable != NULL, ( "CAS data lookup table doesn't exist" ) );
Dbg_MsgAssert( index >= 0 && index < MAX_CAS_DATA_LOOKUP, ( "Out of range lookup index %d (must be between 0 and %d)", index, MAX_CAS_DATA_LOOKUP ) );
Dbg_MsgAssert( sCASDataLookupTable[index] == NULL, ( "Lookup index %d already used", index, MAX_CAS_DATA_LOOKUP ) );
sCASDataLookupTable[index] = pData;
}
void AddCASFlag( int skinnedVertexIndex, uint16* pADCBit )
{
if ( !sCASDataLookupTable )
{
return;
}
Dbg_MsgAssert( skinnedVertexIndex >= 0 && skinnedVertexIndex < MAX_CAS_DATA_LOOKUP, ( "Out of range lookup index %d (must be between 0 and %d", skinnedVertexIndex, MAX_CAS_DATA_LOOKUP ) );
if ( sCASDataLookupTable[skinnedVertexIndex] != NULL )
{
sCASDataLookupTable[skinnedVertexIndex]->pADCBit = pADCBit;
}
}
int sMesh::TotalNumVertices;
uint32 sMesh::Version;
} // namespace NxPs2
Reference in New Issue Copy Permalink