OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
Browse Source

Merge pull request #491 from Hoikas/stlize 

GBufferGroup hsTArray -> std::vector
Michael Hansen 10 years ago
parent
5b9f915e8e f48a80ab60
commit
b9b02d757c
2 changed files with 186 additions and 202 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 342
      Sources/Plasma/PubUtilLib/plPipeline/plGBufferGroup.cpp
  2. 44
      Sources/Plasma/PubUtilLib/plPipeline/plGBufferGroup.h

342
Sources/Plasma/PubUtilLib/plPipeline/plGBufferGroup.cpp
Unescape View File

@ -110,50 +110,36 @@ void plGBufferCell::Write( hsStream *s )
//// Constructor ////////////////////////////////////////////////////////////// //// Constructor //////////////////////////////////////////////////////////////
plGBufferGroup::plGBufferGroup( uint8_t format, bool vertsVolatile, bool idxVolatile, int LOD ) plGBufferGroup::plGBufferGroup(uint8_t format, bool vertsVolatile, bool idxVolatile, int LOD)
: fNumVerts(0), fNumIndices(0), fFormat(format), fVertsVolatile(vertsVolatile),
fIdxVolatile(idxVolatile), fLOD(LOD)
{ {
fVertBuffStorage.Reset(); fStride = ICalcVertexSize(fLiteStride);
fIdxBuffStorage.Reset();
fColorBuffStorage.Reset();
fVertexBufferRefs.Reset();
fIndexBufferRefs.Reset();
fCells.Reset();
fNumVerts = fNumIndices = 0;
fFormat = format;
fStride = ICalcVertexSize( fLiteStride );
fVertsVolatile = vertsVolatile;
fIdxVolatile = idxVolatile;
fLOD = LOD;
} }
//// Destructor /////////////////////////////////////////////////////////////// //// Destructor ///////////////////////////////////////////////////////////////
plGBufferGroup::~plGBufferGroup() plGBufferGroup::~plGBufferGroup()
{ {
uint32_t i;
CleanUp(); CleanUp();
for( i = 0; i < fVertexBufferRefs.GetCount(); i++ ) for (auto i : fVertexBufferRefs) {
hsRefCnt_SafeUnRef( fVertexBufferRefs[ i ] ); hsRefCnt_SafeUnRef(i);
}
for( i = 0; i < fIndexBufferRefs.GetCount(); i++ ) for (auto i : fIndexBufferRefs) {
hsRefCnt_SafeUnRef( fIndexBufferRefs[ i ] ); hsRefCnt_SafeUnRef(i);
}
fVertexBufferRefs.Reset();
fIndexBufferRefs.Reset();
} }
void plGBufferGroup::DirtyVertexBuffer(int i) void plGBufferGroup::DirtyVertexBuffer(size_t i)
{ {
if( (i < fVertexBufferRefs.GetCount()) && fVertexBufferRefs[i] ) if( (i < fVertexBufferRefs.size()) && fVertexBufferRefs[i] )
fVertexBufferRefs[i]->SetDirty(true); fVertexBufferRefs[i]->SetDirty(true);
} }
void plGBufferGroup::DirtyIndexBuffer(int i) void plGBufferGroup::DirtyIndexBuffer(size_t i)
{ {
if( (i < fIndexBufferRefs.GetCount()) && fIndexBufferRefs[i] ) if( (i < fIndexBufferRefs.size()) && fIndexBufferRefs[i] )
fIndexBufferRefs[i]->SetDirty(true); fIndexBufferRefs[i]->SetDirty(true);
} }
@ -202,52 +188,46 @@ void plGBufferGroup::PurgeIndexBuffer(uint32_t idx)
void plGBufferGroup::CleanUp( void ) void plGBufferGroup::CleanUp( void )
{ {
int i;
// Clean up the storage // Clean up the storage
for( i = 0; i < fVertBuffStorage.GetCount(); i++ ) for (size_t i = 0; i < fVertBuffSizes.size(); ++i)
{ {
plProfile_DelMem(MemBufGrpVertex, fVertBuffSizes[i]); plProfile_DelMem(MemBufGrpVertex, fVertBuffSizes[i]);
delete [] fVertBuffStorage[ i ]; delete [] fVertBuffStorage[ i ];
} }
for( i = 0; i < fIdxBuffStorage.GetCount(); i++ ) for (size_t i = 0; i < fIdxBuffStorage.size(); i++)
{ {
plProfile_DelMem(MemBufGrpIndex, fIdxBuffCounts[i] * sizeof(uint16_t)); plProfile_DelMem(MemBufGrpIndex, fIdxBuffCounts[i] * sizeof(uint16_t));
delete [] fIdxBuffStorage[ i ]; delete [] fIdxBuffStorage[ i ];
} }
for( i = 0; i < fColorBuffStorage.GetCount(); i++ ) for (size_t i = 0; i < fColorBuffStorage.size(); ++i)
{ {
plProfile_DelMem(MemBufGrpVertex, fColorBuffCounts[i] * sizeof(plGBufferColor)); plProfile_DelMem(MemBufGrpVertex, fColorBuffCounts[i] * sizeof(plGBufferColor));
delete [] fColorBuffStorage[ i ]; delete [] fColorBuffStorage[ i ];
} }
for( i = 0; i < fCells.GetCount(); i++ ) fVertBuffStorage.clear();
delete fCells[ i ]; fVertBuffSizes.clear();
fVertBuffStarts.clear();
fVertBuffStorage.Reset(); fVertBuffEnds.clear();
fVertBuffSizes.Reset(); fIdxBuffStorage.clear();
fVertBuffStarts.Reset(); fIdxBuffCounts.clear();
fVertBuffEnds.Reset(); fIdxBuffStarts.clear();
fIdxBuffStorage.Reset(); fIdxBuffEnds.clear();
fIdxBuffCounts.Reset(); fColorBuffStorage.clear();
fIdxBuffStarts.Reset(); fColorBuffCounts.clear();
fIdxBuffEnds.Reset();
fColorBuffStorage.Reset(); fCells.clear();
fColorBuffCounts.Reset();
fCells.Reset();
} }
//// SetVertexBufferRef /////////////////////////////////////////////////////// //// SetVertexBufferRef ///////////////////////////////////////////////////////
void plGBufferGroup::SetVertexBufferRef( uint32_t index, hsGDeviceRef *vb ) void plGBufferGroup::SetVertexBufferRef( uint32_t index, hsGDeviceRef *vb )
{ {
hsAssert( index < fVertexBufferRefs.GetCount() + 1, "Vertex buffers must be assigned linearly!" ); hsAssert( index < fVertexBufferRefs.size() + 1, "Vertex buffers must be assigned linearly!" );
if( (int)index > (int)fVertexBufferRefs.GetCount() - 1 ) if (index > fVertexBufferRefs.size() - 1)
{ {
fVertexBufferRefs.Append( vb ); fVertexBufferRefs.push_back( vb );
hsRefCnt_SafeRef( vb ); hsRefCnt_SafeRef( vb );
} }
else else
@ -261,11 +241,11 @@ void plGBufferGroup::SetVertexBufferRef( uint32_t index, hsGDeviceRef *vb )
void plGBufferGroup::SetIndexBufferRef( uint32_t index, hsGDeviceRef *ib ) void plGBufferGroup::SetIndexBufferRef( uint32_t index, hsGDeviceRef *ib )
{ {
hsAssert( index < fIndexBufferRefs.GetCount() + 1, "Index buffers must be assigned linearly!" ); hsAssert( index < fIndexBufferRefs.size() + 1, "Index buffers must be assigned linearly!" );
if( (int)index > (int)fIndexBufferRefs.GetCount() - 1 ) if(index > fIndexBufferRefs.size() - 1)
{ {
fIndexBufferRefs.Append( ib ); fIndexBufferRefs.push_back( ib );
hsRefCnt_SafeRef( ib ); hsRefCnt_SafeRef( ib );
} }
else else
@ -288,16 +268,16 @@ void plGBufferGroup::PrepForRendering( plPipeline *pipe, bool adjustForNvidia
hsGDeviceRef* plGBufferGroup::GetVertexBufferRef(uint32_t i) hsGDeviceRef* plGBufferGroup::GetVertexBufferRef(uint32_t i)
{ {
if( i >= fVertexBufferRefs.GetCount() ) if( i >= fVertexBufferRefs.size() )
fVertexBufferRefs.ExpandAndZero(i+1); fVertexBufferRefs.resize(i+1);
return fVertexBufferRefs[i]; return fVertexBufferRefs[i];
} }
hsGDeviceRef* plGBufferGroup::GetIndexBufferRef(uint32_t i) hsGDeviceRef* plGBufferGroup::GetIndexBufferRef(uint32_t i)
{ {
if( i >= fIndexBufferRefs.GetCount() ) if( i >= fIndexBufferRefs.size() )
fIndexBufferRefs.ExpandAndZero(i+1); fIndexBufferRefs.resize(i+1);
return fIndexBufferRefs[i]; return fIndexBufferRefs[i];
} }
@ -309,19 +289,14 @@ void plGBufferGroup::ISendStorageToBuffers( plPipeline *pipe, bool adjustForN
plProfile_BeginTiming(DrawRefillVertex); plProfile_BeginTiming(DrawRefillVertex);
/// Creating or refreshing? /// Creating or refreshing?
int i; for (size_t i = 0; i < fVertBuffStorage.size(); i++)
for( i = 0; i < fVertBuffStorage.GetCount(); i++ )
{
pipe->CheckVertexBufferRef(this, i); pipe->CheckVertexBufferRef(this, i);
}
plProfile_EndTiming(DrawRefillVertex); plProfile_EndTiming(DrawRefillVertex);
plProfile_BeginTiming(DrawRefillIndex); plProfile_BeginTiming(DrawRefillIndex);
for( i = 0; i < fIdxBuffStorage.GetCount(); i++ ) for (size_t i = 0; i < fIdxBuffStorage.size(); i++)
{
pipe->CheckIndexBufferRef(this, i); pipe->CheckIndexBufferRef(this, i);
}
plProfile_EndTiming(DrawRefillIndex); plProfile_EndTiming(DrawRefillIndex);
} }
@ -371,19 +346,26 @@ void plGBufferGroup::Read( hsStream *s )
totalDynSize = s->ReadLE32(); totalDynSize = s->ReadLE32();
fStride = ICalcVertexSize( fLiteStride ); fStride = ICalcVertexSize( fLiteStride );
fVertBuffSizes.Reset(); fVertBuffSizes.clear();
fVertBuffStarts.Reset(); fVertBuffStarts.clear();
fVertBuffEnds.Reset(); fVertBuffEnds.clear();
fColorBuffCounts.Reset(); fColorBuffCounts.clear();
fIdxBuffCounts.Reset(); fIdxBuffCounts.clear();
fIdxBuffStarts.Reset(); fIdxBuffStarts.clear();
fIdxBuffEnds.Reset(); fIdxBuffEnds.clear();
fVertBuffStorage.Reset(); fVertBuffStorage.clear();
fIdxBuffStorage.Reset(); fIdxBuffStorage.clear();
plVertCoder coder; plVertCoder coder;
/// Create buffers and read in as we go /// Create buffers and read in as we go
count = s->ReadLE32(); count = s->ReadLE32();
fVertBuffSizes.reserve(count);
fVertBuffStarts.reserve(count);
fVertBuffEnds.reserve(count);
fVertBuffStorage.reserve(count);
fColorBuffCounts.reserve(count);
fColorBuffStorage.reserve(count);
for( i = 0; i < count; i++ ) for( i = 0; i < count; i++ )
{ {
if( fFormat & kEncoded ) if( fFormat & kEncoded )
@ -391,36 +373,36 @@ void plGBufferGroup::Read( hsStream *s )
const uint16_t numVerts = s->ReadLE16(); const uint16_t numVerts = s->ReadLE16();
const uint32_t size = numVerts * fStride; const uint32_t size = numVerts * fStride;
fVertBuffSizes.Append(size); fVertBuffSizes.push_back(size);
fVertBuffStarts.Append(0); fVertBuffStarts.push_back(0);
fVertBuffEnds.Append(-1); fVertBuffEnds.push_back(-1);
vData = new uint8_t[size]; vData = new uint8_t[size];
fVertBuffStorage.Append( vData ); fVertBuffStorage.push_back( vData );
plProfile_NewMem(MemBufGrpVertex, temp); plProfile_NewMem(MemBufGrpVertex, temp);
coder.Read(s, vData, fFormat, fStride, numVerts); coder.Read(s, vData, fFormat, fStride, numVerts);
fColorBuffCounts.Append(0); fColorBuffCounts.push_back(0);
fColorBuffStorage.Append(nil); fColorBuffStorage.push_back(nullptr);
} }
else else
{ {
temp = s->ReadLE32(); temp = s->ReadLE32();
fVertBuffSizes.Append( temp ); fVertBuffSizes.push_back( temp );
fVertBuffStarts.Append(0); fVertBuffStarts.push_back(0);
fVertBuffEnds.Append(-1); fVertBuffEnds.push_back(-1);
vData = new uint8_t[ temp ]; vData = new uint8_t[ temp ];
hsAssert( vData != nil, "Not enough memory to read in vertices" ); hsAssert(vData, "Not enough memory to read in vertices");
s->Read( temp, (void *)vData ); s->Read( temp, (void *)vData );
fVertBuffStorage.Append( vData ); fVertBuffStorage.push_back( vData );
plProfile_NewMem(MemBufGrpVertex, temp); plProfile_NewMem(MemBufGrpVertex, temp);
temp = s->ReadLE32(); temp = s->ReadLE32();
fColorBuffCounts.Append( temp ); fColorBuffCounts.push_back( temp );
if( temp > 0 ) if( temp > 0 )
{ {
@ -431,35 +413,39 @@ void plGBufferGroup::Read( hsStream *s )
else else
cData = nil; cData = nil;
fColorBuffStorage.Append( cData ); fColorBuffStorage.push_back( cData );
} }
} }
count = s->ReadLE32(); count = s->ReadLE32();
fIdxBuffCounts.reserve(count);
fIdxBuffStarts.reserve(count);
fIdxBuffEnds.reserve(count);
fIdxBuffStorage.reserve(count);
for( i = 0; i < count; i++ ) for( i = 0; i < count; i++ )
{ {
temp = s->ReadLE32(); temp = s->ReadLE32();
fIdxBuffCounts.Append( temp ); fIdxBuffCounts.push_back(temp);
fIdxBuffStarts.Append(0); fIdxBuffStarts.push_back(0);
fIdxBuffEnds.Append(-1); fIdxBuffEnds.push_back(-1);
iData = new uint16_t[ temp ]; iData = new uint16_t[ temp ];
hsAssert( iData != nil, "Not enough memory to read in indices" ); hsAssert( iData != nil, "Not enough memory to read in indices" );
s->ReadLE16( temp, (uint16_t *)iData ); s->ReadLE16( temp, (uint16_t *)iData );
fIdxBuffStorage.Append( iData ); fIdxBuffStorage.push_back( iData );
plProfile_NewMem(MemBufGrpIndex, temp * sizeof(uint16_t)); plProfile_NewMem(MemBufGrpIndex, temp * sizeof(uint16_t));
} }
/// Read in cell arrays, one per vBuffer /// Read in cell arrays, one per vBuffer
for( i = 0; i < fVertBuffStorage.GetCount(); i++ ) fCells.resize(fVertBuffStorage.size());
for( i = 0; i < fVertBuffStorage.size(); i++ )
{ {
temp = s->ReadLE32(); temp = s->ReadLE32();
fCells.Append( new hsTArray<plGBufferCell> ); fCells[ i ].resize( temp );
fCells[ i ]->SetCount( temp );
for( j = 0; j < temp; j++ ) for( j = 0; j < temp; j++ )
(*fCells[ i ])[ j ].Read( s ); fCells[ i ][ j ].Read( s );
} }
} }
@ -482,10 +468,10 @@ void plGBufferGroup::Write( hsStream *s )
/// Calc total dynamic data size, for fun /// Calc total dynamic data size, for fun
totalDynSize = 0; totalDynSize = 0;
for( i = 0; i < fVertBuffSizes.GetCount(); i++ ) for (auto it : fVertBuffSizes)
totalDynSize += fVertBuffSizes[ i ]; totalDynSize += it;
for( i = 0; i < fIdxBuffCounts.GetCount(); i++ ) for (auto it : fIdxBuffCounts)
totalDynSize += sizeof( uint16_t ) * fIdxBuffCounts[ i ]; totalDynSize += sizeof( uint16_t ) * it;
s->WriteLE( fFormat ); s->WriteLE( fFormat );
s->WriteLE32( totalDynSize ); s->WriteLE32( totalDynSize );
@ -493,12 +479,12 @@ void plGBufferGroup::Write( hsStream *s )
plVertCoder coder; plVertCoder coder;
/// Write out dyanmic data /// Write out dyanmic data
s->WriteLE32( (uint32_t)fVertBuffStorage.GetCount() ); s->WriteLE32( (uint32_t)fVertBuffStorage.size() );
for( i = 0; i < fVertBuffStorage.GetCount(); i++ ) for (i = 0; i < fVertBuffStorage.size(); ++i)
{ {
#ifdef MF_VERTCODE_ENABLED #ifdef MF_VERTCODE_ENABLED
hsAssert(fCells[i]->GetCount() == 1, "Data must be interleaved for compression"); hsAssert(fCells[i].size() == 1, "Data must be interleaved for compression");
uint32_t numVerts = fVertBuffSizes[i] / fStride; uint32_t numVerts = fVertBuffSizes[i] / fStride;
s->WriteLE16((uint16_t)numVerts); s->WriteLE16((uint16_t)numVerts);
coder.Write(s, fVertBuffStorage[i], fFormat, fStride, (uint16_t)numVerts); coder.Write(s, fVertBuffStorage[i], fFormat, fStride, (uint16_t)numVerts);
@ -528,19 +514,19 @@ void plGBufferGroup::Write( hsStream *s )
#endif // MF_VERTCODE_ENABLED #endif // MF_VERTCODE_ENABLED
} }
s->WriteLE32( (uint32_t)fIdxBuffCounts.GetCount() ); s->WriteLE32( (uint32_t)fIdxBuffCounts.size() );
for( i = 0; i < fIdxBuffStorage.GetCount(); i++ ) for( i = 0; i < fIdxBuffStorage.size(); i++ )
{ {
s->WriteLE32( fIdxBuffCounts[ i ] ); s->WriteLE32( fIdxBuffCounts[ i ] );
s->WriteLE16( fIdxBuffCounts[ i ], fIdxBuffStorage[ i ] ); s->WriteLE16( fIdxBuffCounts[ i ], fIdxBuffStorage[ i ] );
} }
/// Write out cell arrays /// Write out cell arrays
for( i = 0; i < fVertBuffStorage.GetCount(); i++ ) for (i = 0; i < fVertBuffStorage.size(); i++)
{ {
s->WriteLE32( fCells[ i ]->GetCount() ); s->WriteLE32( fCells[ i ].size() );
for( j = 0; j < fCells[ i ]->GetCount(); j++ ) for( j = 0; j < fCells[ i ].size(); j++ )
(*fCells[ i ])[ j ].Write( s ); fCells[ i ][ j ].Write( s );
} }
#ifdef VERT_LOG #ifdef VERT_LOG
@ -567,10 +553,10 @@ void plGBufferGroup::DeleteVertsFromStorage( uint32_t which, uint32_t start,
uint32_t amount; uint32_t amount;
hsAssert( fCells[ which ]->GetCount() == 1, "Cannot delete verts on a mixed buffer group" ); hsAssert( fCells[ which ].size() == 1, "Cannot delete verts on a mixed buffer group" );
// Adjust cell 0 // Adjust cell 0
(*fCells[ which ])[ 0 ].fLength -= length; fCells[ which ][ 0 ].fLength -= length;
start *= fStride; start *= fStride;
length *= fStride; length *= fStride;
@ -588,10 +574,10 @@ void plGBufferGroup::DeleteVertsFromStorage( uint32_t which, uint32_t start,
fVertBuffSizes[ which ] -= length; fVertBuffSizes[ which ] -= length;
plProfile_DelMem(MemBufGrpVertex, length); plProfile_DelMem(MemBufGrpVertex, length);
if( fVertexBufferRefs.GetCount() > which && fVertexBufferRefs[ which ] != nil ) if (fVertexBufferRefs.size() > which && fVertexBufferRefs[which])
{ {
hsRefCnt_SafeUnRef(fVertexBufferRefs[which]); hsRefCnt_SafeUnRef(fVertexBufferRefs[which]);
fVertexBufferRefs[which] = nil; fVertexBufferRefs[which] = nullptr;
} }
} }
@ -611,8 +597,8 @@ void plGBufferGroup::AdjustIndicesInStorage( uint32_t which, uint16_t threshh
fIdxBuffStorage[ which ][ i ] += delta; fIdxBuffStorage[ which ][ i ] += delta;
} }
if( fIndexBufferRefs.GetCount() > which && fIndexBufferRefs[ which ] != nil ) if (fIndexBufferRefs.size() > which && fIndexBufferRefs[which])
fIndexBufferRefs[ which ]->SetDirty( true ); fIndexBufferRefs[which]->SetDirty( true );
} }
@ -641,10 +627,10 @@ void plGBufferGroup::DeleteIndicesFromStorage( uint32_t which, uint32_t start
fIdxBuffCounts[ which ] -= length; fIdxBuffCounts[ which ] -= length;
plProfile_DelMem(MemBufGrpIndex, length * sizeof(uint16_t)); plProfile_DelMem(MemBufGrpIndex, length * sizeof(uint16_t));
if( fIndexBufferRefs.GetCount() > which && fIndexBufferRefs[ which ] != nil ) if (fIndexBufferRefs.size() > which && fIndexBufferRefs[which])
{ {
hsRefCnt_SafeUnRef(fIndexBufferRefs[which]); hsRefCnt_SafeUnRef(fIndexBufferRefs[which]);
fIndexBufferRefs[which] = nil; fIndexBufferRefs[which] = nullptr;
} }
} }
@ -662,14 +648,12 @@ uint32_t plGBufferGroup::GetNumPrimaryVertsLeft( void ) const
uint32_t plGBufferGroup::GetNumVertsLeft( uint32_t idx ) const uint32_t plGBufferGroup::GetNumVertsLeft( uint32_t idx ) const
{ {
if( idx >= fCells.GetCount() ) if( idx >= fCells.size() )
return kMaxNumVertsPerBuffer; return kMaxNumVertsPerBuffer;
uint32_t i, total = kMaxNumVertsPerBuffer; uint32_t total = kMaxNumVertsPerBuffer;
for( const auto& i : fCells[ idx ] )
total -= i.fLength;
for( i = 0; i < fCells[ idx ]->GetCount(); i++ )
total -= (*fCells[ idx ])[ i ].fLength;
return total; return total;
} }
@ -679,7 +663,7 @@ uint32_t plGBufferGroup::GetNumVertsLeft( uint32_t idx ) const
uint32_t plGBufferGroup::IMakeCell( uint32_t vbIndex, uint8_t flags, uint32_t vStart, uint32_t cStart, uint32_t len, uint32_t *offset ) uint32_t plGBufferGroup::IMakeCell( uint32_t vbIndex, uint8_t flags, uint32_t vStart, uint32_t cStart, uint32_t len, uint32_t *offset )
{ {
hsTArray<plGBufferCell> *cells = fCells[ vbIndex ]; std::vector<plGBufferCell>& cells = fCells[ vbIndex ];
if( !(flags & kReserveInterleaved) ) if( !(flags & kReserveInterleaved) )
@ -690,27 +674,27 @@ uint32_t plGBufferGroup::IMakeCell( uint32_t vbIndex, uint8_t flags, uint32_t v
/// we never merge any separated cells /// we never merge any separated cells
if( flags & kReserveSeparated ) if( flags & kReserveSeparated )
cells->Append( plGBufferCell( vStart, cStart, len ) ); cells.emplace_back(vStart, cStart, len);
else else
cells->Append( plGBufferCell( (uint32_t)-1, cStart, len ) ); cells.emplace_back((uint32_t)-1, cStart, len);
*offset = 0; *offset = 0;
} }
else else
{ {
/// Merge if the last cell was an interleaved cell /// Merge if the last cell was an interleaved cell
if( cells->GetCount() > 0 && (*cells)[ cells->GetCount() - 1 ].fColorStart == (uint32_t)-1 ) if( !cells.empty() && cells.back().fColorStart == (uint32_t)-1 )
{ {
*offset = (*cells)[ cells->GetCount() - 1 ].fLength; *offset = cells.back().fLength;
(*cells)[ cells->GetCount() - 1 ].fLength += len; cells.back().fLength += len;
} }
else else
{ {
cells->Append( plGBufferCell( vStart, (uint32_t)-1, len ) ); cells.emplace_back(vStart, (uint32_t)-1, len);
*offset = 0; *offset = 0;
} }
} }
return cells->GetCount() - 1; return cells.size() - 1;
} }
//// ReserveVertStorage /////////////////////////////////////////////////////// //// ReserveVertStorage ///////////////////////////////////////////////////////
@ -735,7 +719,7 @@ bool plGBufferGroup::ReserveVertStorage( uint32_t numVerts, uint32_t *vbIndex
/// Find a spot /// Find a spot
if( !(flags & kReserveIsolate) ) if( !(flags & kReserveIsolate) )
{ {
for( i = 0; i < fVertBuffStorage.GetCount(); i++ ) for( i = 0; i < fVertBuffStorage.size(); i++ )
{ {
if( GetNumVertsLeft( i ) >= numVerts ) if( GetNumVertsLeft( i ) >= numVerts )
break; break;
@ -743,22 +727,22 @@ bool plGBufferGroup::ReserveVertStorage( uint32_t numVerts, uint32_t *vbIndex
} }
else else
{ {
i = fVertBuffStorage.GetCount(); i = fVertBuffStorage.size();
} }
if( i == fVertBuffStorage.GetCount() ) if( i == fVertBuffStorage.size() )
{ {
if( (flags & kReserveInterleaved) || (flags & kReserveSeparated) ) if( (flags & kReserveInterleaved) || (flags & kReserveSeparated) )
{ {
fVertBuffStorage.Append( nil ); fVertBuffStorage.push_back(nullptr);
fVertBuffSizes.Append( 0 ); fVertBuffSizes.push_back(0);
} }
fVertBuffStarts.Append(0); fVertBuffStarts.push_back(0);
fVertBuffEnds.Append(-1); fVertBuffEnds.push_back(-1);
fColorBuffStorage.Append( nil ); fColorBuffStorage.push_back(nullptr);
fColorBuffCounts.Append( 0 ); fColorBuffCounts.push_back(0);
fCells.Append( new hsTArray<plGBufferCell> ); fCells.emplace_back();
} }
*vbIndex = i; *vbIndex = i;
@ -797,25 +781,25 @@ bool plGBufferGroup::ReserveVertStorage( uint32_t numVerts, uint32_t *vbIndex
} }
/// Switch over /// Switch over
if( storagePtr != nil ) if (storagePtr)
{ {
if( fVertBuffStorage[ i ] != nil ) if( fVertBuffStorage[ i ] != nil )
delete [] fVertBuffStorage[ i ]; delete [] fVertBuffStorage[ i ];
fVertBuffStorage[ i ] = storagePtr; fVertBuffStorage[ i ] = storagePtr;
} }
if( cStoragePtr != nil ) if (cStoragePtr)
{ {
if( fColorBuffStorage[ i ] != nil ) if (fColorBuffStorage[ i ])
delete [] fColorBuffStorage[ i ]; delete [] fColorBuffStorage[ i ];
fColorBuffStorage[ i ] = cStoragePtr; fColorBuffStorage[ i ] = cStoragePtr;
fColorBuffCounts[ i ] += numVerts; fColorBuffCounts[ i ] += numVerts;
plProfile_NewMem(MemBufGrpVertex, numVerts * sizeof(plGBufferColor)); plProfile_NewMem(MemBufGrpVertex, numVerts * sizeof(plGBufferColor));
} }
if( fVertexBufferRefs.GetCount() > i && fVertexBufferRefs[ i ] != nil ) if (fVertexBufferRefs.size() > i && fVertexBufferRefs[i])
{ {
hsRefCnt_SafeUnRef(fVertexBufferRefs[i]); hsRefCnt_SafeUnRef(fVertexBufferRefs[i]);
fVertexBufferRefs[i] = nil; fVertexBufferRefs[i] = nullptr;
} }
/// Append a cell entry /// Append a cell entry
@ -864,7 +848,7 @@ void plGBufferGroup::AppendToColorStorage( plGeometrySpan *srcSpan, uint32_t
if( !ReserveVertStorage( srcSpan->fNumVerts, vbIndex, cell, offset, kReserveColors ) ) if( !ReserveVertStorage( srcSpan->fNumVerts, vbIndex, cell, offset, kReserveColors ) )
return; return;
(*fCells[ *vbIndex ])[ *cell ].fVtxStart = (*fCells[ *vbIndex ])[ origCell ].fVtxStart; fCells[ *vbIndex ][ *cell ].fVtxStart = fCells[ *vbIndex ][ origCell ].fVtxStart;
StuffToVertStorage( srcSpan, *vbIndex, *cell, *offset, kReserveColors ); StuffToVertStorage( srcSpan, *vbIndex, *cell, *offset, kReserveColors );
} }
@ -874,18 +858,18 @@ void plGBufferGroup::AppendToColorStorage( plGeometrySpan *srcSpan, uint32_t
void plGBufferGroup::IGetStartVtxPointer( uint32_t vbIndex, uint32_t cell, uint32_t offset, uint8_t *&tempPtr, plGBufferColor *&cPtr ) void plGBufferGroup::IGetStartVtxPointer( uint32_t vbIndex, uint32_t cell, uint32_t offset, uint8_t *&tempPtr, plGBufferColor *&cPtr )
{ {
hsAssert( vbIndex < fVertBuffStorage.GetCount(), "Invalid vbIndex in StuffToVertStorage()" ); hsAssert( vbIndex < fVertBuffStorage.size(), "Invalid vbIndex in StuffToVertStorage()" );
hsAssert( cell < fCells[ vbIndex ]->GetCount(), "Invalid cell in StuffToVertStorage()" ); hsAssert( cell < fCells[ vbIndex ].size(), "Invalid cell in StuffToVertStorage()" );
tempPtr = fVertBuffStorage[ vbIndex ]; tempPtr = fVertBuffStorage[ vbIndex ];
cPtr = fColorBuffStorage[ vbIndex ]; cPtr = fColorBuffStorage[ vbIndex ];
tempPtr += (*fCells[ vbIndex ])[ cell ].fVtxStart; tempPtr += fCells[ vbIndex ][ cell ].fVtxStart;
cPtr += (*fCells[ vbIndex ])[ cell ].fColorStart; cPtr += fCells[ vbIndex ][ cell ].fColorStart;
if( offset > 0 ) if( offset > 0 )
{ {
tempPtr += offset * ( ( (*fCells[ vbIndex ])[ cell ].fColorStart == (uint32_t)-1 ) ? fStride : fLiteStride ); tempPtr += offset * ( ( fCells[ vbIndex ][ cell ].fColorStart == (uint32_t)-1 ) ? fStride : fLiteStride );
cPtr += offset; cPtr += offset;
} }
} }
@ -894,7 +878,7 @@ void plGBufferGroup::IGetStartVtxPointer( uint32_t vbIndex, uint32_t cell, ui
uint32_t plGBufferGroup::GetVertBufferCount( uint32_t idx ) const uint32_t plGBufferGroup::GetVertBufferCount( uint32_t idx ) const
{ {
return GetVertStartFromCell( idx, fCells[ idx ]->GetCount(), 0 ); return GetVertStartFromCell( idx, fCells[ idx ].size(), 0 );
} }
//// GetVertStartFromCell ///////////////////////////////////////////////////// //// GetVertStartFromCell /////////////////////////////////////////////////////
@ -904,12 +888,12 @@ uint32_t plGBufferGroup::GetVertStartFromCell( uint32_t vbIndex, uint32_t cell,
uint32_t i, numVerts; uint32_t i, numVerts;
hsAssert( vbIndex < fVertBuffStorage.GetCount(), "Invalid vbIndex in StuffToVertStorage()" ); hsAssert( vbIndex < fVertBuffStorage.size(), "Invalid vbIndex in StuffToVertStorage()" );
hsAssert( cell <= fCells[ vbIndex ]->GetCount(), "Invalid cell in StuffToVertStorage()" ); hsAssert( cell <= fCells[ vbIndex ].size(), "Invalid cell in StuffToVertStorage()" );
numVerts = 0; numVerts = 0;
for( i = 0; i < cell; i++ ) for( i = 0; i < cell; i++ )
numVerts += (*fCells[ vbIndex ])[ i ].fLength; numVerts += fCells[ vbIndex ][ i ].fLength;
numVerts += offset; numVerts += offset;
@ -928,11 +912,11 @@ void plGBufferGroup::StuffToVertStorage( plGeometrySpan *srcSpan, uint32_t vb
plGBufferCell *cellPtr; plGBufferCell *cellPtr;
hsAssert( vbIndex < fVertBuffStorage.GetCount(), "Invalid vbIndex in StuffToVertStorage()" ); hsAssert( vbIndex < fVertBuffStorage.size(), "Invalid vbIndex in StuffToVertStorage()" );
hsAssert( cell < fCells[ vbIndex ]->GetCount(), "Invalid cell in StuffToVertStorage()" ); hsAssert( cell < fCells[ vbIndex ].size(), "Invalid cell in StuffToVertStorage()" );
IGetStartVtxPointer( vbIndex, cell, offset, tempPtr, cPtr ); IGetStartVtxPointer( vbIndex, cell, offset, tempPtr, cPtr );
cellPtr = &(*fCells[ vbIndex ])[ cell ]; cellPtr = &fCells[ vbIndex ][ cell ];
stride = ( cellPtr->fColorStart != (uint32_t)-1 ) ? fLiteStride : fStride; stride = ( cellPtr->fColorStart != (uint32_t)-1 ) ? fLiteStride : fStride;
numVerts = srcSpan->fNumVerts; numVerts = srcSpan->fNumVerts;
@ -1025,7 +1009,7 @@ void plGBufferGroup::StuffToVertStorage( plGeometrySpan *srcSpan, uint32_t vb
cPtr++; cPtr++;
} }
if( ( vbIndex < fVertexBufferRefs.GetCount() ) && fVertexBufferRefs[ vbIndex ] ) if( ( vbIndex < fVertexBufferRefs.size() ) && fVertexBufferRefs[ vbIndex ] )
fVertexBufferRefs[ vbIndex ]->SetDirty( true ); fVertexBufferRefs[ vbIndex ]->SetDirty( true );
} }
@ -1046,19 +1030,19 @@ bool plGBufferGroup::ReserveIndexStorage( uint32_t numIndices, uint32_t *ibIn
} }
/// Find a spot /// Find a spot
for( i = 0; i < fIdxBuffStorage.GetCount(); i++ ) for( i = 0; i < fIdxBuffStorage.size(); i++ )
{ {
if( fIdxBuffCounts[ i ] + numIndices < kMaxNumIndicesPerBuffer ) if( fIdxBuffCounts[ i ] + numIndices < kMaxNumIndicesPerBuffer )
break; break;
} }
if( i == fIdxBuffStorage.GetCount() ) if( i == fIdxBuffStorage.size() )
{ {
fIdxBuffStorage.Append( nil ); fIdxBuffStorage.push_back(nullptr);
fIdxBuffCounts.Append( 0 ); fIdxBuffCounts.push_back(0);
fIdxBuffStarts.Append(0); fIdxBuffStarts.push_back(0);
fIdxBuffEnds.Append(-1); fIdxBuffEnds.push_back(-1);
} }
*ibIndex = i; *ibIndex = i;
@ -1081,10 +1065,10 @@ bool plGBufferGroup::ReserveIndexStorage( uint32_t numIndices, uint32_t *ibIn
plProfile_NewMem(MemBufGrpIndex, numIndices * sizeof(uint16_t)); plProfile_NewMem(MemBufGrpIndex, numIndices * sizeof(uint16_t));
/// All done! /// All done!
if( fIndexBufferRefs.GetCount() > i && fIndexBufferRefs[ i ] != nil ) if ( fIndexBufferRefs.size() > i && fIndexBufferRefs[i])
{ {
hsRefCnt_SafeUnRef(fIndexBufferRefs[i]); hsRefCnt_SafeUnRef(fIndexBufferRefs[i]);
fIndexBufferRefs[i] = nil; fIndexBufferRefs[i] = nullptr;
} }
return true; return true;
@ -1127,11 +1111,11 @@ plGBufferTriangle *plGBufferGroup::ConvertToTriList( int16_t spanIndex, uint32
/// Sanity checks /// Sanity checks
hsAssert( whichIdx < fIdxBuffStorage.GetCount(), "Invalid index buffer ID to ConvertToTriList()" ); hsAssert( whichIdx < fIdxBuffStorage.size(), "Invalid index buffer ID to ConvertToTriList()" );
hsAssert( whichVtx < fVertBuffStorage.GetCount(), "Invalid vertex buffer ID to ConvertToTriList()" ); hsAssert( whichVtx < fVertBuffStorage.size(), "Invalid vertex buffer ID to ConvertToTriList()" );
hsAssert( start < fIdxBuffCounts[ whichIdx ], "Invalid start index to ConvertToTriList()" ); hsAssert( start < fIdxBuffCounts[ whichIdx ], "Invalid start index to ConvertToTriList()" );
hsAssert( start + numTriangles * 3 <= fIdxBuffCounts[ whichIdx ], "Invalid count to ConvertToTriList()" ); hsAssert( start + numTriangles * 3 <= fIdxBuffCounts[ whichIdx ], "Invalid count to ConvertToTriList()" );
hsAssert( whichCell < fCells[ whichVtx ]->GetCount(), "Invalid cell to ConvertToTriList()" ); hsAssert( whichCell < fCells[ whichVtx ].size(), "Invalid cell to ConvertToTriList()" );
/// Create the array and fill it /// Create the array and fill it
array = new plGBufferTriangle[ numTriangles ]; array = new plGBufferTriangle[ numTriangles ];
@ -1140,7 +1124,7 @@ plGBufferTriangle *plGBufferGroup::ConvertToTriList( int16_t spanIndex, uint32
storagePtr = fIdxBuffStorage[ whichIdx ]; storagePtr = fIdxBuffStorage[ whichIdx ];
IGetStartVtxPointer( whichVtx, whichCell, 0, vertStgPtr, wastePtr ); IGetStartVtxPointer( whichVtx, whichCell, 0, vertStgPtr, wastePtr );
offsetBy = GetVertStartFromCell( whichVtx, whichCell, 0 ); offsetBy = GetVertStartFromCell( whichVtx, whichCell, 0 );
stride = ( (*fCells[ whichVtx ])[ whichCell ].fColorStart == (uint32_t)-1 ) ? fStride : fLiteStride; stride = ( fCells[ whichVtx ][ whichCell ].fColorStart == (uint32_t)-1 ) ? fStride : fLiteStride;
for( i = 0, j = 0; i < numTriangles; i++, j += 3 ) for( i = 0, j = 0; i < numTriangles; i++, j += 3 )
{ {
@ -1189,7 +1173,7 @@ void plGBufferGroup::StuffFromTriList( uint32_t which, uint32_t start, uint32
/// Sanity checks /// Sanity checks
hsAssert( which < fIdxBuffStorage.GetCount(), "Invalid index buffer ID to StuffFromTriList()" ); hsAssert( which < fIdxBuffStorage.size(), "Invalid index buffer ID to StuffFromTriList()" );
hsAssert( start < fIdxBuffCounts[ which ], "Invalid start index to StuffFromTriList()" ); hsAssert( start < fIdxBuffCounts[ which ], "Invalid start index to StuffFromTriList()" );
hsAssert( start + numTriangles * 3 <= fIdxBuffCounts[ which ], "Invalid count to StuffFromTriList()" ); hsAssert( start + numTriangles * 3 <= fIdxBuffCounts[ which ], "Invalid count to StuffFromTriList()" );
@ -1210,8 +1194,8 @@ void plGBufferGroup::StuffFromTriList( uint32_t which, uint32_t start, uint32
#endif // MF_SPEED_THIS_UP #endif // MF_SPEED_THIS_UP
/// All done! Just make sure we refresh before we render... /// All done! Just make sure we refresh before we render...
if( fIndexBufferRefs.GetCount() > which && fIndexBufferRefs[ which ] != nil ) if (fIndexBufferRefs.size() > which && fIndexBufferRefs[which])
fIndexBufferRefs[ which ]->SetDirty( true ); fIndexBufferRefs[which]->SetDirty(true);
} }
@ -1220,7 +1204,7 @@ void plGBufferGroup::StuffFromTriList( uint32_t which, uint32_t start, uint32
void plGBufferGroup::StuffTri( uint32_t iBuff, uint32_t iTri, uint16_t idx0, uint16_t idx1, uint16_t idx2 ) void plGBufferGroup::StuffTri( uint32_t iBuff, uint32_t iTri, uint16_t idx0, uint16_t idx1, uint16_t idx2 )
{ {
/// Sanity checks /// Sanity checks
hsAssert( iBuff < fIdxBuffStorage.GetCount(), "Invalid index buffer ID to StuffFromTriList()" ); hsAssert( iBuff < fIdxBuffStorage.size(), "Invalid index buffer ID to StuffFromTriList()" );
hsAssert( iTri < fIdxBuffCounts[ iBuff ], "Invalid start index to StuffFromTriList()" ); hsAssert( iTri < fIdxBuffCounts[ iBuff ], "Invalid start index to StuffFromTriList()" );
fIdxBuffStorage[ iBuff ][ iTri + 0 ] = idx0; fIdxBuffStorage[ iBuff ][ iTri + 0 ] = idx0;
@ -1258,7 +1242,7 @@ uint32_t &plGBufferGroup::Color( int iBuff, uint32_t cell, int iVtx )
IGetStartVtxPointer( iBuff, cell, iVtx, vertStgPtr, cPtr ); IGetStartVtxPointer( iBuff, cell, iVtx, vertStgPtr, cPtr );
if( (*fCells[ iBuff ])[ cell ].fColorStart != (uint32_t)-1 ) if( fCells[ iBuff ][ cell ].fColorStart != (uint32_t)-1 )
return *(uint32_t *)( &cPtr->fDiffuse ); return *(uint32_t *)( &cPtr->fDiffuse );
else else
return *(uint32_t *)( vertStgPtr + 2 * sizeof( hsPoint3 ) ); return *(uint32_t *)( vertStgPtr + 2 * sizeof( hsPoint3 ) );
@ -1271,7 +1255,7 @@ uint32_t &plGBufferGroup::Specular( int iBuff, uint32_t cell, int iVtx )
IGetStartVtxPointer( iBuff, cell, iVtx, vertStgPtr, cPtr ); IGetStartVtxPointer( iBuff, cell, iVtx, vertStgPtr, cPtr );
if( (*fCells[ iBuff ])[ cell ].fColorStart != (uint32_t)-1 ) if( fCells[ iBuff ][ cell ].fColorStart != (uint32_t)-1 )
return *(uint32_t *)( &cPtr->fSpecular ); return *(uint32_t *)( &cPtr->fSpecular );
else else
return *(uint32_t *)( vertStgPtr + 2 * sizeof( hsPoint3 ) ); return *(uint32_t *)( vertStgPtr + 2 * sizeof( hsPoint3 ) );
@ -1286,7 +1270,7 @@ hsPoint3 &plGBufferGroup::UV( int iBuff, uint32_t cell, int iVtx, int channel
vertStgPtr += 2 * sizeof( hsPoint3 ) + channel * sizeof( hsPoint3 ); vertStgPtr += 2 * sizeof( hsPoint3 ) + channel * sizeof( hsPoint3 );
if( (*fCells[ iBuff ])[ cell ].fColorStart != (uint32_t)-1 ) if( fCells[ iBuff ][ cell ].fColorStart != (uint32_t)-1 )
return *(hsPoint3 *)( vertStgPtr ); return *(hsPoint3 *)( vertStgPtr );
else else
return *(hsPoint3 *)( vertStgPtr + 2 * sizeof( uint32_t ) ); return *(hsPoint3 *)( vertStgPtr + 2 * sizeof( uint32_t ) );

44
Sources/Plasma/PubUtilLib/plPipeline/plGBufferGroup.h
Unescape View File

@ -122,23 +122,23 @@ class plGBufferGroup
bool fIdxVolatile; bool fIdxVolatile;
int fLOD; int fLOD;
hsTArray<hsGDeviceRef *> fVertexBufferRefs; std::vector<hsGDeviceRef*> fVertexBufferRefs;
hsTArray<hsGDeviceRef *> fIndexBufferRefs; std::vector<hsGDeviceRef*> fIndexBufferRefs;
hsTArray<uint32_t> fVertBuffSizes; std::vector<uint32_t> fVertBuffSizes;
hsTArray<uint32_t> fIdxBuffCounts; std::vector<uint32_t> fIdxBuffCounts;
hsTArray<uint32_t> fColorBuffCounts; std::vector<uint32_t> fColorBuffCounts;
hsTArray<uint8_t *> fVertBuffStorage; std::vector<uint8_t *> fVertBuffStorage;
hsTArray<uint16_t *> fIdxBuffStorage; std::vector<uint16_t*> fIdxBuffStorage;
hsTArray<uint32_t> fVertBuffStarts; std::vector<uint32_t> fVertBuffStarts;
hsTArray<int32_t> fVertBuffEnds; std::vector<int32_t> fVertBuffEnds;
hsTArray<uint32_t> fIdxBuffStarts; std::vector<uint32_t> fIdxBuffStarts;
hsTArray<int32_t> fIdxBuffEnds; std::vector<int32_t> fIdxBuffEnds;
hsTArray<plGBufferColor *> fColorBuffStorage; std::vector<plGBufferColor*> fColorBuffStorage;
hsTArray<hsTArray<plGBufferCell> *> fCells; std::vector<std::vector<plGBufferCell>> fCells;
virtual void ISendStorageToBuffers( plPipeline *pipe, bool adjustForNvidiaLighting ); virtual void ISendStorageToBuffers( plPipeline *pipe, bool adjustForNvidiaLighting );
@ -188,10 +188,10 @@ class plGBufferGroup
static uint8_t CalcNumUVs( uint8_t format ) { return ( format & kUVCountMask ); } static uint8_t CalcNumUVs( uint8_t format ) { return ( format & kUVCountMask ); }
static uint8_t UVCountToFormat( uint8_t numUVs ) { return numUVs & kUVCountMask; } static uint8_t UVCountToFormat( uint8_t numUVs ) { return numUVs & kUVCountMask; }
void DirtyVertexBuffer(int i); void DirtyVertexBuffer(size_t i);
void DirtyIndexBuffer(int i); void DirtyIndexBuffer(size_t i);
bool VertexReady(int i) const { return (i < fVertexBufferRefs.GetCount()) && fVertexBufferRefs[i]; } bool VertexReady(size_t i) const { return (i < fVertexBufferRefs.size()) && fVertexBufferRefs[i]; }
bool IndexReady(int i) const { return (i < fIndexBufferRefs.GetCount()) && fIndexBufferRefs[i]; } bool IndexReady(size_t i) const { return (i < fIndexBufferRefs.size()) && fIndexBufferRefs[i]; }
uint8_t GetVertexSize( void ) const { return fStride; } uint8_t GetVertexSize( void ) const { return fStride; }
uint8_t GetVertexLiteStride( void ) const { return fLiteStride; } uint8_t GetVertexLiteStride( void ) const { return fLiteStride; }
uint8_t GetVertexFormat( void ) const { return fFormat; } uint8_t GetVertexFormat( void ) const { return fFormat; }
@ -231,18 +231,18 @@ class plGBufferGroup
void SetIndexBufferEnd(uint32_t idx, uint32_t e) { fIdxBuffEnds[idx] = e; } void SetIndexBufferEnd(uint32_t idx, uint32_t e) { fIdxBuffEnds[idx] = e; }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
uint32_t GetNumVertexBuffers( void ) const { return fVertBuffStorage.GetCount(); } uint32_t GetNumVertexBuffers( void ) const { return fVertBuffStorage.size(); }
uint32_t GetNumIndexBuffers( void ) const { return fIdxBuffStorage.GetCount(); } uint32_t GetNumIndexBuffers( void ) const { return fIdxBuffStorage.size(); }
uint8_t *GetVertBufferData( uint32_t idx ) { return fVertBuffStorage[ idx ]; } uint8_t *GetVertBufferData( uint32_t idx ) { return fVertBuffStorage[ idx ]; }
uint16_t *GetIndexBufferData( uint32_t idx ) { return fIdxBuffStorage[ idx ]; } uint16_t *GetIndexBufferData( uint32_t idx ) { return fIdxBuffStorage[ idx ]; }
plGBufferColor *GetColorBufferData( uint32_t idx ) { return fColorBuffStorage[ idx ]; } plGBufferColor *GetColorBufferData( size_t idx ) { return fColorBuffStorage[ idx ]; }
hsGDeviceRef *GetVertexBufferRef( uint32_t i ); hsGDeviceRef *GetVertexBufferRef( uint32_t i );
hsGDeviceRef *GetIndexBufferRef( uint32_t i ); hsGDeviceRef *GetIndexBufferRef( uint32_t i );
uint32_t GetNumCells( uint32_t idx ) const { return fCells[ idx ]->GetCount(); } size_t GetNumCells( size_t idx ) const { return fCells[ idx ].size(); }
plGBufferCell *GetCell( uint32_t idx, uint32_t cell ) { return &( (*fCells[ idx ])[ cell ] ); } plGBufferCell *GetCell( size_t idx, size_t cell ) { return &(fCells[ idx ][ cell ]); }
void SetVertexBufferRef( uint32_t index, hsGDeviceRef *vb ); void SetVertexBufferRef( uint32_t index, hsGDeviceRef *vb );
void SetIndexBufferRef( uint32_t index, hsGDeviceRef *ib ); void SetIndexBufferRef( uint32_t index, hsGDeviceRef *ib );

Write Preview
Loading…
Cancel
Save