H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-22 14:16:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
1ccbe2bbb6
source-engine/vphysics/ledgewriter.cpp

518 lines
19 KiB
C++
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: low-level code to write IVP_Compact_Ledge/IVP_Compact_Triangle.
// also includes code to pack/unpack outer hull ledges to 8-bit rep
//
//=============================================================================
#include "cbase.h"
#include "convert.h"
#include <ivp_surface_manager.hxx>
#include <ivp_surman_polygon.hxx>
#include <ivp_template_surbuild.hxx>
#include <ivp_compact_surface.hxx>
#include <ivp_compact_ledge.hxx>
#include "utlbuffer.h"
#include "ledgewriter.h"
// gets the max vertex index referenced by a compact ledge
static int MaxLedgeVertIndex( const IVP_Compact_Ledge *pLedge )
{
int maxIndex = -1;
for ( int i = 0; i < pLedge->get_n_triangles(); i++ )
{
const IVP_Compact_Triangle *pTri = pLedge->get_first_triangle() + i;
for ( int j = 0; j < 3; j++ )
{
int ivpIndex = pTri->get_edge(j)->get_start_point_index();
maxIndex = max(maxIndex, ivpIndex);
}
}
return maxIndex;
}
struct vertmap_t
{
CUtlVector<int> map;
int minRef;
int maxRef;
};
// searches pVerts for each vert used by pLedge and builds a one way map from ledge indices to pVerts indices
// NOTE: pVerts is in HL coords, pLedge is in IVP coords
static void BuildVertMap( vertmap_t &out, const Vector *pVerts, int vertexCount, const IVP_Compact_Ledge *pLedge )
{
out.map.EnsureCount(MaxLedgeVertIndex(pLedge)+1);
for ( int i = 0; i < out.map.Count(); i++ )
{
out.map[i] = -1;
}
out.minRef = vertexCount;
out.maxRef = 0;
const IVP_Compact_Poly_Point *pVertList = pLedge->get_point_array();
for ( int i = 0; i < pLedge->get_n_triangles(); i++ )
{
// iterate each triangle, for each referenced vert that hasn't yet been mapped, search for the nearest match
const IVP_Compact_Triangle *pTri = pLedge->get_first_triangle() + i;
for ( int j = 0; j < 3; j++ )
{
int ivpIndex = pTri->get_edge(j)->get_start_point_index();
if ( out.map[ivpIndex] < 0 )
{
int index = -1;
Vector tmp;
ConvertPositionToHL( &pVertList[ivpIndex], tmp);
float minDist = 1e16;
for ( int k = 0; k < vertexCount; k++ )
{
float dist = (tmp-pVerts[k]).Length();
if ( dist < minDist )
{
index = k;
minDist = dist;
}
}
Assert(minDist<0.1f);
out.map[ivpIndex] = index;
out.minRef = min(out.minRef, index);
out.maxRef = max(out.maxRef, index);
}
}
}
}
// Each IVP_Compact_Triangle and IVP_Compact_Edge occupies an index
// 0,1,2,3 is tri, edge, edge, edge (tris and edges are both 16 bytes)
// So you can just add the index to get_first_triangle to get a pointer
inline int EdgeIndex( const IVP_Compact_Ledge *pLedge, const IVP_Compact_Edge *pEdge )
{
return pEdge - (const IVP_Compact_Edge *)pLedge->get_first_triangle();
}
// Builds a packedhull_t from a IVP_Compact_Ledge. Assumes that the utlbuffer points at the memory following pHull (pHull is the header, utlbuffer is the body)
void PackLedgeIntoBuffer( packedhull_t *pHull, CUtlBuffer &buf, const IVP_Compact_Ledge *pLedge, const virtualmeshlist_t &list )
{
if ( !pLedge )
return;
// The lists store the ivp index of each element to be written out
// The maps store the output packed index for each ivp index
CUtlVector<int> triangleList, triangleMap;
CUtlVector<int> edgeList, edgeMap;
vertmap_t vertMap;
BuildVertMap( vertMap, list.pVerts, list.vertexCount, pLedge );
pHull->baseVert = vertMap.minRef;
// clear the maps
triangleMap.EnsureCount(pLedge->get_n_triangles());
for ( int i = 0; i < triangleMap.Count(); i++ )
{
triangleMap[i] = -1;
}
edgeMap.EnsureCount(pLedge->get_n_triangles()*4); // each triangle also occupies an edge index
for ( int i = 0; i < edgeMap.Count(); i++ )
{
edgeMap[i] = -1;
}
// we're going to reorder the triangles and edges so that the ones marked virtual
// appear first in the list. This way we only need a virtual count, not a per-item
// flag.
// also, the edges are stored relative to the first triangle that references them
// so an edge from 0->1 means that the first triangle that references the edge is 0->1 and the
// second triangle is 1->0. This way we store half the edges and the winged edge pointers are implicit
// sort triangles in two passes
for ( int i = 0; i < pLedge->get_n_triangles(); i++ )
{
const IVP_Compact_Triangle *pTri = pLedge->get_first_triangle() + i;
if ( pTri->get_is_virtual() )
{
triangleMap[i] = triangleList.AddToTail(i);
}
}
pHull->vtriCount = triangleList.Count();
for ( int i = 0; i < pLedge->get_n_triangles(); i++ )
{
const IVP_Compact_Triangle *pTri = pLedge->get_first_triangle() + i;
if ( !pTri->get_is_virtual() )
{
triangleMap[i] = triangleList.AddToTail(i);
}
}
// sort edges in two passes
for ( int i = 0; i < pLedge->get_n_triangles(); i++ )
{
const IVP_Compact_Triangle *pTri = pLedge->get_first_triangle() + triangleList[i];
for ( int j = 0; j < 3; j++ )
{
const IVP_Compact_Edge *pEdge = pTri->get_edge(j);
if ( pEdge->get_is_virtual() && edgeMap[EdgeIndex(pLedge, pEdge->get_opposite())] < 0 )
{
edgeMap[EdgeIndex(pLedge, pEdge)] = edgeList.AddToTail(EdgeIndex(pLedge, pEdge));
}
}
}
pHull->vedgeCount = edgeList.Count();
for ( int i = 0; i < pLedge->get_n_triangles(); i++ )
{
const IVP_Compact_Triangle *pTri = pLedge->get_first_triangle() + triangleList[i];
for ( int j = 0; j < 3; j++ )
{
const IVP_Compact_Edge *pEdge = pTri->get_edge(j);
int index = EdgeIndex(pLedge, pEdge);
int oppositeIndex = EdgeIndex(pLedge, pEdge->get_opposite());
if ( !pEdge->get_is_virtual() && edgeMap[oppositeIndex] < 0 )
{
edgeMap[index] = edgeList.AddToTail(index);
}
if ( edgeMap[index] < 0 )
{
Assert(edgeMap[oppositeIndex] >= 0);
edgeMap[index] = edgeMap[oppositeIndex];
}
}
}
Assert( edgeList.Count() == pHull->edgeCount );
// now write the packed triangles
for ( int i = 0; i < pHull->triangleCount; i++ )
{
packedtriangle_t tri;
const IVP_Compact_Triangle *pTri = pLedge->get_first_triangle() + triangleList[i];
const IVP_Compact_Edge *pEdge;
pEdge = pTri->get_edge(0);
tri.opposite = triangleMap[pTri->get_pierce_index()];
Assert(tri.opposite<pHull->triangleCount);
tri.e0 = edgeMap[EdgeIndex(pLedge, pEdge)];
pEdge = pTri->get_edge(1);
tri.e1 = edgeMap[EdgeIndex(pLedge, pEdge)];
pEdge = pTri->get_edge(2);
tri.e2 = edgeMap[EdgeIndex(pLedge, pEdge)];
Assert(tri.e0<pHull->edgeCount);
Assert(tri.e1<pHull->edgeCount);
Assert(tri.e2<pHull->edgeCount);
buf.Put(&tri, sizeof(tri));
}
// now write the packed edges
for ( int i = 0; i < pHull->edgeCount; i++ )
{
packededge_t edge;
const IVP_Compact_Edge *pEdge = (const IVP_Compact_Edge *)pLedge->get_first_triangle() + edgeList[i];
Assert((edgeList[i]&3) != 0); // must not be a triangle
int v0 = vertMap.map[pEdge->get_start_point_index()] - pHull->baseVert;
int v1 = vertMap.map[pEdge->get_next()->get_start_point_index()] - pHull->baseVert;
Assert(v0>=0 && v0<256);
Assert(v1>=0 && v1<256);
edge.v0 = v0;
edge.v1 = v1;
buf.Put(&edge, sizeof(edge));
}
}
// decompress packed hull into a compact ledge
void CVPhysicsVirtualMeshWriter::UnpackCompactLedgeFromHull( IVP_Compact_Ledge *pLedge, int materialIndex, const IVP_Compact_Poly_Point *pPointList, const virtualmeshhull_t *pHullHeader, int hullIndex, bool isVirtualLedge )
{
const packedhull_t *pHull = pHullHeader->GetPackedHull(hullIndex);
const packedtriangle_t *pPackedTris = pHullHeader->GetPackedTriangles(hullIndex);
// write the ledge
pLedge->set_offset_ledge_points( (int)((char *)pPointList - (char *)pLedge) ); // byte offset from 'this' to (ledge) point array
pLedge->set_is_compact( IVP_TRUE );
pLedge->set_size(sizeof(IVP_Compact_Ledge) + sizeof(IVP_Compact_Triangle)*pHull->triangleCount); // <0 indicates a non compact compact ledge
pLedge->n_triangles = pHull->triangleCount;
pLedge->has_chilren_flag = isVirtualLedge ? IVP_TRUE : IVP_FALSE;
// Make the offset -pLedge so the result is a NULL ledgetree node - we haven't needed to create one of these as of yet
//pLedge->ledgetree_node_offset = -((int)pLedge);
// keep track of which triangle edge referenced this edge (so the next one can swap the order and point to the first one)
int forwardEdgeIndex[255];
for ( int i = 0; i < pHull->edgeCount; i++ )
{
forwardEdgeIndex[i] = -1;
}
packededge_t *pPackedEdges = (packededge_t *)(pPackedTris + pHull->triangleCount);
IVP_Compact_Triangle *pOut = pLedge->get_first_triangle();
// now write the compact triangles and their edges
int baseVert = pHull->baseVert;
for ( int i = 0; i < pHull->triangleCount; i++ )
{
pOut[i].set_tri_index(i);
pOut[i].set_material_index(materialIndex);
pOut[i].set_is_virtual( i < pHull->vtriCount ? IVP_TRUE : IVP_FALSE );
pOut[i].set_pierce_index(pPackedTris[i].opposite);
Assert(pPackedTris[i].opposite<pHull->triangleCount);
int edges[3] = {pPackedTris[i].e0, pPackedTris[i].e1, pPackedTris[i].e2};
for ( int j = 0; j < 3; j++ )
{
Assert(edges[j]<pHull->edgeCount);
if ( forwardEdgeIndex[edges[j]] < 0 )
{
// this is the first triangle to use this edge, so it's forward (and the other triangle sharing (opposite edge pointer) is unknown)
int startVert = pPackedEdges[edges[j]].v0 + baseVert;
pOut[i].c_three_edges[j].set_start_point_index(startVert);
pOut[i].c_three_edges[j].set_is_virtual( edges[j] < pHull->vedgeCount ? IVP_TRUE : IVP_FALSE );
forwardEdgeIndex[edges[j]] = EdgeIndex(pLedge, &pOut[i].c_three_edges[j]);
}
else
{
// this is the second triangle to use this edge, so it's reversed (and the other triangle sharing is in the forward edge table)
int oppositeIndex = forwardEdgeIndex[edges[j]];
int startVert = pPackedEdges[edges[j]].v1 + baseVert;
pOut[i].c_three_edges[j].set_start_point_index(startVert);
pOut[i].c_three_edges[j].set_is_virtual( edges[j] < pHull->vedgeCount ? IVP_TRUE : IVP_FALSE );
// now build the links between the triangles sharing this edge
int thisEdgeIndex = EdgeIndex( pLedge, &pOut[i].c_three_edges[j] );
pOut[i].c_three_edges[j].set_opposite_index( oppositeIndex - thisEdgeIndex );
pOut[i].c_three_edges[j].get_opposite()->set_opposite_index( thisEdgeIndex - oppositeIndex );
}
}
}
}
// low-level code to initialize a 2-sided triangle
static void InitTriangle( IVP_Compact_Triangle *pTri, int index, int materialIndex, int v0, int v1, int v2, int opp0, int opp1, int opp2 )
{
pTri->set_tri_index(index);
pTri->set_material_index(materialIndex);
pTri->c_three_edges[0].set_start_point_index(v0);
pTri->c_three_edges[1].set_start_point_index(v1);
pTri->c_three_edges[2].set_start_point_index(v2);
pTri->c_three_edges[0].set_opposite_index(opp0);
pTri->c_three_edges[1].set_opposite_index(opp1);
pTri->c_three_edges[2].set_opposite_index(opp2);
}
void CVPhysicsVirtualMeshWriter::InitTwoSidedTriangleLege( triangleledge_t *pOut, const IVP_Compact_Poly_Point *pPoints, int v0, int v1, int v2, int materialIndex )
{
IVP_Compact_Ledge *pLedge = &pOut->ledge;
pLedge->set_offset_ledge_points( (int)((char *)pPoints - (char *)pLedge) ); // byte offset from 'this' to (ledge) point array
pLedge->set_is_compact( IVP_TRUE );
pLedge->set_size(sizeof(triangleledge_t)); // <0 indicates a non compact compact ledge
pLedge->n_triangles = 2;
pLedge->has_chilren_flag = IVP_FALSE;
// triangles
InitTriangle( &pOut->faces[0], 0, materialIndex, v0, v1, v2, 6, 4, 2 );
InitTriangle( &pOut->faces[1], 1, materialIndex, v0, v2, v1, -2, -4, -6);
pOut->faces[0].set_pierce_index(1);
pOut->faces[1].set_pierce_index(0);
}
bool CVPhysicsVirtualMeshWriter::LedgeCanBePacked(const IVP_Compact_Ledge *pLedge, const virtualmeshlist_t &list)
{
int edgeCount = pLedge->get_n_triangles() * 3;
if ( edgeCount > 512 )
return false;
vertmap_t vertMap;
BuildVertMap( vertMap, list.pVerts, list.vertexCount, pLedge );
if ( (vertMap.maxRef - vertMap.minRef) > 255 )
return false;
return true;
}
// this builds a packed hull array from a compact ledge array (needs the virtualmeshlist for reference)
virtualmeshhull_t *CVPhysicsVirtualMeshWriter::CreatePackedHullFromLedges( const virtualmeshlist_t &list, const IVP_Compact_Ledge **pLedges, int ledgeCount )
{
int triCount = 0;
int edgeCount = 0;
for ( int i = 0; i < ledgeCount; i++ )
{
triCount += pLedges[i]->get_n_triangles();
edgeCount += (pLedges[i]->get_n_triangles() * 3)/2;
Assert(LedgeCanBePacked(pLedges[i], list));
}
unsigned int totalSize = sizeof(packedtriangle_t)*triCount + sizeof(packededge_t)*edgeCount + sizeof(packedhull_t)*ledgeCount + sizeof(virtualmeshhull_t);
byte *pBuf = new byte[totalSize];
CUtlBuffer buf;
buf.SetExternalBuffer( pBuf, totalSize, 0, 0 );
if ( 1 )
{
virtualmeshhull_t tmp;
Q_memset( &tmp, 0, sizeof(tmp) );
tmp.hullCount = ledgeCount;
buf.Put(&tmp, sizeof(tmp));
}
// write the headers
Assert(ledgeCount < 16);
packedhull_t *pHulls[16];
for ( int i = 0; i < ledgeCount; i++ )
{
pHulls[i] = (packedhull_t *)buf.PeekPut();
packedhull_t hull;
hull.triangleCount = pLedges[i]->get_n_triangles();
hull.edgeCount = (hull.triangleCount * 3) / 2;
buf.Put(&hull, sizeof(hull));
}
// write the data itself
for ( int i = 0; i < ledgeCount; i++ )
{
PackLedgeIntoBuffer( pHulls[i], buf, pLedges[i], list );
}
return (virtualmeshhull_t *)pBuf;
}
// frees the memory associated with this packed hull
void CVPhysicsVirtualMeshWriter::DestroyPackedHull( virtualmeshhull_t *pHull )
{
byte *pData = (byte *)pHull;
delete[] pData;
}
unsigned int CVPhysicsVirtualMeshWriter::UnpackLedgeListFromHull( byte *pOut, virtualmeshhull_t *pHull, IVP_Compact_Poly_Point *pPoints )
{
unsigned int memOffset = 0;
for ( int i = 0; i < pHull->hullCount; i++ )
{
IVP_Compact_Ledge *pHullLedge = (IVP_Compact_Ledge *)(pOut + memOffset);
CVPhysicsVirtualMeshWriter::UnpackCompactLedgeFromHull( pHullLedge, 0, pPoints, pHull, i, true );
memOffset += pHullLedge->get_size();
}
return memOffset;
}
/*
#define DUMP_FILES 1
static bool DumpListToGLView( const char *pFilename, const virtualmeshlist_t &list )
{
#if DUMP_FILES
FILE *fp = fopen( pFilename, "a+" );
for ( int i = 0; i < list.triangleCount; i++ )
{
fprintf( fp, "3\n" );
fprintf( fp, "%6.3f %6.3f %6.3f 1 0 0\n", list.pVerts[list.indices[i*3+0]].x, list.pVerts[list.indices[i*3+0]].y, list.pVerts[list.indices[i*3+0]].z );
fprintf( fp, "%6.3f %6.3f %6.3f 0 1 0\n", list.pVerts[list.indices[i*3+1]].x, list.pVerts[list.indices[i*3+1]].y, list.pVerts[list.indices[i*3+1]].z );
fprintf( fp, "%6.3f %6.3f %6.3f 0 0 1\n", list.pVerts[list.indices[i*3+2]].x, list.pVerts[list.indices[i*3+2]].y, list.pVerts[list.indices[i*3+2]].z );
}
fclose(fp);
#endif
return true;
}
static bool DumpLedgeToGLView( const char *pFilename, const IVP_Compact_Ledge *pLedge, float r=1.0f, float g=1.0f, float b=1.0f, float offset=0.0f )
{
#if DUMP_FILES
FILE *fp = fopen( pFilename, "a+" );
int ivpIndex;
Vector tmp[3];
const IVP_Compact_Poly_Point *pPoints = pLedge->get_point_array();
for ( int i = 0; i < pLedge->get_n_triangles(); i++ )
{
// iterate each triangle, for each referenced vert that hasn't yet been mapped, search for the nearest match
const IVP_Compact_Triangle *pTri = pLedge->get_first_triangle() + i;
ivpIndex = pTri->get_edge(2)->get_start_point_index();
ConvertPositionToHL( &pPoints[ivpIndex], tmp[0] );
ivpIndex = pTri->get_edge(1)->get_start_point_index();
ConvertPositionToHL( &pPoints[ivpIndex], tmp[1] );
ivpIndex = pTri->get_edge(0)->get_start_point_index();
ConvertPositionToHL( &pPoints[ivpIndex], tmp[2] );
tmp[0].x += offset;
tmp[1].x += offset;
tmp[2].x += offset;
fprintf( fp, "2\n" );
fprintf( fp, "%6.3f %6.3f %6.3f %.1f %.1f %.1f\n", tmp[0].x, tmp[0].y, tmp[0].z, r, g, b );
fprintf( fp, "%6.3f %6.3f %6.3f %.1f %.1f %.1f\n", tmp[1].x, tmp[1].y, tmp[1].z, r, g, b );
fprintf( fp, "2\n" );
fprintf( fp, "%6.3f %6.3f %6.3f %.1f %.1f %.1f\n", tmp[1].x, tmp[1].y, tmp[1].z, r, g, b );
fprintf( fp, "%6.3f %6.3f %6.3f %.1f %.1f %.1f\n", tmp[2].x, tmp[2].y, tmp[2].z, r, g, b );
fprintf( fp, "2\n" );
fprintf( fp, "%6.3f %6.3f %6.3f %.1f %.1f %.1f\n", tmp[2].x, tmp[2].y, tmp[2].z, r, g, b );
fprintf( fp, "%6.3f %6.3f %6.3f %.1f %.1f %.1f\n", tmp[0].x, tmp[0].y, tmp[0].z, r, g, b );
}
fclose( fp );
#endif
return true;
}
static int ComputeSize( virtualmeshhull_t *pHeader )
{
packedhull_t *pHull = (packedhull_t *)(pHeader+1);
unsigned int size = pHeader->hullCount * sizeof(IVP_Compact_Ledge);
for ( int i = 0; i < pHeader->hullCount; i++ )
{
size += sizeof(IVP_Compact_Triangle) * pHull[i].triangleCount;
}
return size;
}
bool CVPhysicsVirtualMeshWriter::CheckHulls( virtualmeshhull_t *pHull0, virtualmeshhull_t *pHull1, const virtualmeshlist_t &list )
{
for ( int i = 0; i < pHull0->hullCount; i++ )
{
const packedhull_t *pP0 = pHull0->GetPackedHull(i);
const packedhull_t *pP1 = pHull1->GetPackedHull(i);
Assert(pP0->triangleCount == pP1->triangleCount);
Assert(pP0->vtriCount == pP1->vtriCount);
Assert(pP0->edgeCount == pP1->edgeCount);
Assert(pP0->vedgeCount == pP1->vedgeCount);
Assert(pP0->baseVert == pP1->baseVert);
const packedtriangle_t *pTri0 = pHull0->GetPackedTriangles( i );
const packedtriangle_t *pTri1 = pHull1->GetPackedTriangles( i );
for ( int j = 0; j < pP0->triangleCount; j++ )
{
Assert(pTri0[j].e0 == pTri1[j].e0);
Assert(pTri0[j].e1 == pTri1[j].e1);
Assert(pTri0[j].e2 == pTri1[j].e2);
Assert(pTri0[j].opposite == pTri1[j].opposite);
}
}
{
int size0 = ComputeSize(pHull0);
int pointSize0 = sizeof(IVP_Compact_Poly_Point) * list.vertexCount;
byte *pMem0 = (byte *)ivp_malloc_aligned( size0+pointSize0, 16 );
IVP_Compact_Poly_Point *pPoints = (IVP_Compact_Poly_Point *)pMem0;
IVP_Compact_Ledge *pLedge0 = (IVP_Compact_Ledge *)(pPoints + list.vertexCount);
for ( int i = 0; i < list.vertexCount; i++ )
{
ConvertPositionToIVP( list.pVerts[i], pPoints[i] );
}
UnpackLedgeListFromHull( (byte *)pLedge0, pHull0, pPoints );
for ( int i = 0; i < pHull0->hullCount; i++ )
{
if ( i == i ) DumpLedgeToGLView( "c:\\jay.txt", pLedge0, 1, 0, 0, 0 );
pLedge0 = (IVP_Compact_Ledge *)( ((byte *)pLedge0 ) + pLedge0->get_size() );
}
ivp_free_aligned(pMem0);
}
{
int size1 = ComputeSize(pHull1);
int pointSize1 = sizeof(IVP_Compact_Poly_Point) * list.vertexCount;
byte *pMem1 = (byte *)ivp_malloc_aligned( size1+pointSize1, 16 );
IVP_Compact_Poly_Point *pPoints = (IVP_Compact_Poly_Point *)pMem1;
IVP_Compact_Ledge *pLedge1 = (IVP_Compact_Ledge *)(pPoints + list.vertexCount);
for ( int i = 0; i < list.vertexCount; i++ )
{
ConvertPositionToIVP( list.pVerts[i], pPoints[i] );
}
UnpackLedgeListFromHull( (byte *)pLedge1, pHull1, pPoints );
for ( int i = 0; i < pHull1->hullCount; i++ )
{
if ( i == i ) DumpLedgeToGLView( "c:\\jay.txt", pLedge1, 0, 1, 0, 1024 );
pLedge1 = (IVP_Compact_Ledge *)( ((byte *)pLedge1 ) + pLedge1->get_size() );
}
ivp_free_aligned(pMem1);
}
return true;
}
*/
Reference in New Issue View Git Blame Copy Permalink