|
|
|
|
/*==LICENSE==*
|
|
|
|
|
|
|
|
|
|
CyanWorlds.com Engine - MMOG client, server and tools
|
|
|
|
|
Copyright (C) 2011 Cyan Worlds, Inc.
|
|
|
|
|
|
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
|
|
You can contact Cyan Worlds, Inc. by email legal@cyan.com
|
|
|
|
|
or by snail mail at:
|
|
|
|
|
Cyan Worlds, Inc.
|
|
|
|
|
14617 N Newport Hwy
|
|
|
|
|
Mead, WA 99021
|
|
|
|
|
|
|
|
|
|
*==LICENSE==*/
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
// //
|
|
|
|
|
// plGBufferGroup Class Header //
|
|
|
|
|
// Cyan, Inc. //
|
|
|
|
|
// //
|
|
|
|
|
//// Version History //////////////////////////////////////////////////////////
|
|
|
|
|
// //
|
|
|
|
|
// 2.21.2001 mcn - Created. //
|
|
|
|
|
// //
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
#ifndef _plGBufferGroup_h
|
|
|
|
|
#define _plGBufferGroup_h
|
|
|
|
|
|
|
|
|
|
#include "hsTemplates.h"
|
|
|
|
|
#include "hsGeometry3.h"
|
|
|
|
|
#include "hsColorRGBA.h"
|
|
|
|
|
|
|
|
|
|
//// plGBufferTriangle Struct Definition //////////////////////////////////////
|
|
|
|
|
//
|
|
|
|
|
// Represents a single triangle inside a plGBufferGroup, which consists of
|
|
|
|
|
// three indices (the indices of the three vertices) and a 3-D point
|
|
|
|
|
// representing the center of the triangle.
|
|
|
|
|
|
|
|
|
|
class plGBufferTriangle
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
UInt16 fIndex1, fIndex2, fIndex3, fSpanIndex;
|
|
|
|
|
hsPoint3 fCenter;
|
|
|
|
|
|
|
|
|
|
void Read( hsStream *s );
|
|
|
|
|
void Write( hsStream *s );
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
//// plGBufferCell and plGBufferColor Definitions /////////////////////////////
|
|
|
|
|
|
|
|
|
|
class plGBufferCell
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
UInt32 fVtxStart; // In bytes
|
|
|
|
|
UInt32 fColorStart; // In bytes
|
|
|
|
|
UInt32 fLength;
|
|
|
|
|
|
|
|
|
|
plGBufferCell( UInt32 vStart, UInt32 cStart, UInt32 len )
|
|
|
|
|
{
|
|
|
|
|
fVtxStart = vStart; fColorStart = cStart; fLength = len;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
plGBufferCell() {}
|
|
|
|
|
|
|
|
|
|
void Read( hsStream *s );
|
|
|
|
|
void Write( hsStream *s );
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
class plGBufferColor
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
UInt32 fDiffuse, fSpecular;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
//// plGBufferGroup Class Definition //////////////////////////////////////////
|
|
|
|
|
//
|
|
|
|
|
// Represents a list of vertex and index buffers in a nice package.
|
|
|
|
|
|
|
|
|
|
class hsStream;
|
|
|
|
|
class hsResMgr;
|
|
|
|
|
class plPipeline;
|
|
|
|
|
class hsGDeviceRef;
|
|
|
|
|
class plGeometrySpan;
|
|
|
|
|
|
|
|
|
|
class plGBufferGroup
|
|
|
|
|
{
|
|
|
|
|
protected:
|
|
|
|
|
UInt8 fFormat;
|
|
|
|
|
UInt8 fStride;
|
|
|
|
|
UInt8 fLiteStride;
|
|
|
|
|
UInt8 fNumSkinWeights;
|
|
|
|
|
UInt32 fNumVerts;
|
|
|
|
|
UInt32 fNumIndices;
|
|
|
|
|
hsBool fVertsVolatile;
|
|
|
|
|
hsBool fIdxVolatile;
|
|
|
|
|
int fLOD;
|
|
|
|
|
|
|
|
|
|
hsTArray<hsGDeviceRef *> fVertexBufferRefs;
|
|
|
|
|
hsTArray<hsGDeviceRef *> fIndexBufferRefs;
|
|
|
|
|
|
|
|
|
|
hsTArray<UInt32> fVertBuffSizes;
|
|
|
|
|
hsTArray<UInt32> fIdxBuffCounts;
|
|
|
|
|
hsTArray<UInt32> fColorBuffCounts;
|
|
|
|
|
hsTArray<UInt8 *> fVertBuffStorage;
|
|
|
|
|
hsTArray<UInt16 *> fIdxBuffStorage;
|
|
|
|
|
|
|
|
|
|
hsTArray<UInt32> fVertBuffStarts;
|
|
|
|
|
hsTArray<Int32> fVertBuffEnds;
|
|
|
|
|
hsTArray<UInt32> fIdxBuffStarts;
|
|
|
|
|
hsTArray<Int32> fIdxBuffEnds;
|
|
|
|
|
|
|
|
|
|
hsTArray<plGBufferColor *> fColorBuffStorage;
|
|
|
|
|
|
|
|
|
|
hsTArray<hsTArray<plGBufferCell> *> fCells;
|
|
|
|
|
|
|
|
|
|
virtual void ISendStorageToBuffers( plPipeline *pipe, hsBool adjustForNvidiaLighting );
|
|
|
|
|
|
|
|
|
|
UInt8 ICalcVertexSize( UInt8 &liteStride );
|
|
|
|
|
|
|
|
|
|
UInt8* IVertBuffStorage(int iBuff, int iVtx) const { return fVertBuffStorage[iBuff] + iVtx*fStride; }
|
|
|
|
|
|
|
|
|
|
UInt32 IMakeCell( UInt32 vbIndex, UInt8 flags, UInt32 vStart, UInt32 cStart, UInt32 len, UInt32 *offset );
|
|
|
|
|
void IGetStartVtxPointer( UInt32 vbIndex, UInt32 cell, UInt32 offset, UInt8 *&tempPtr, plGBufferColor *&cPtr );
|
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
|
|
|
|
|
static const UInt32 kMaxNumVertsPerBuffer;
|
|
|
|
|
static const UInt32 kMaxNumIndicesPerBuffer;
|
|
|
|
|
|
|
|
|
|
enum Formats
|
|
|
|
|
{
|
|
|
|
|
kUVCountMask = 0x0f, // Problem is, we need enough bits to store the max #, which means
|
|
|
|
|
// we really want ( max # << 1 ) - 1
|
|
|
|
|
|
|
|
|
|
kSkinNoWeights = 0x00, // 0000000
|
|
|
|
|
kSkin1Weight = 0x10, // 0010000
|
|
|
|
|
kSkin2Weights = 0x20, // 0100000
|
|
|
|
|
kSkin3Weights = 0x30, // 0110000
|
|
|
|
|
kSkinWeightMask = 0x30, // 0110000
|
|
|
|
|
|
|
|
|
|
kSkinIndices = 0x40, // 1000000
|
|
|
|
|
|
|
|
|
|
kEncoded = 0x80
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
enum
|
|
|
|
|
{
|
|
|
|
|
kReserveInterleaved = 0x01,
|
|
|
|
|
kReserveVerts = 0x02,
|
|
|
|
|
kReserveColors = 0x04,
|
|
|
|
|
kReserveSeparated = 0x08,
|
|
|
|
|
kReserveIsolate = 0x10
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
plGBufferGroup(UInt8 format, hsBool vertsVolatile, hsBool idxVolatile, int LOD = 0);
|
|
|
|
|
~plGBufferGroup();
|
|
|
|
|
|
|
|
|
|
UInt8 GetNumUVs( void ) const { return ( fFormat & kUVCountMask ); }
|
|
|
|
|
UInt8 GetNumWeights() const { return (fFormat & kSkinWeightMask) >> 4; }
|
|
|
|
|
|
|
|
|
|
static UInt8 CalcNumUVs( UInt8 format ) { return ( format & kUVCountMask ); }
|
|
|
|
|
static UInt8 UVCountToFormat( UInt8 numUVs ) { return numUVs & kUVCountMask; }
|
|
|
|
|
|
|
|
|
|
void DirtyVertexBuffer(int i);
|
|
|
|
|
void DirtyIndexBuffer(int i);
|
|
|
|
|
hsBool VertexReady(int i) const { return (i < fVertexBufferRefs.GetCount()) && fVertexBufferRefs[i]; }
|
|
|
|
|
hsBool IndexReady(int i) const { return (i < fIndexBufferRefs.GetCount()) && fIndexBufferRefs[i]; }
|
|
|
|
|
UInt8 GetVertexSize( void ) const { return fStride; }
|
|
|
|
|
UInt8 GetVertexLiteStride( void ) const { return fLiteStride; }
|
|
|
|
|
UInt8 GetVertexFormat( void ) const { return fFormat; }
|
|
|
|
|
UInt32 GetMemUsage( void ) const { return ( fNumVerts * GetVertexSize() ) + ( fNumIndices * sizeof( UInt16 ) ); }
|
|
|
|
|
UInt32 GetNumVerts( void ) const { return fNumVerts; }
|
|
|
|
|
UInt32 GetNumIndices( void ) const { return fNumIndices; }
|
|
|
|
|
UInt32 GetNumPrimaryVertsLeft( void ) const;
|
|
|
|
|
UInt32 GetNumVertsLeft( UInt32 idx ) const;
|
|
|
|
|
|
|
|
|
|
UInt32 GetVertBufferSize(UInt32 idx) const { return fVertBuffSizes[idx]; }
|
|
|
|
|
UInt32 GetVertBufferCount(UInt32 idx) const;
|
|
|
|
|
UInt32 GetIndexBufferCount(UInt32 idx) const { return fIdxBuffCounts[idx]; }
|
|
|
|
|
UInt32 GetVertStartFromCell(UInt32 idx, UInt32 cell, UInt32 offset) const;
|
|
|
|
|
|
|
|
|
|
// These should only be called by the pipeline, because only it knows when it's safe.
|
|
|
|
|
// If the data is volatile, these are no-ops
|
|
|
|
|
void PurgeVertBuffer(UInt32 idx);
|
|
|
|
|
void PurgeIndexBuffer(UInt32 idx);
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
// The following group of functions is an advanced optimization, and a pretty
|
|
|
|
|
// specialized one at that. It just limits the amount of data that will get
|
|
|
|
|
// uploaded to video. If you don't know you are limited by bandwidth to the
|
|
|
|
|
// board, or you just don't know what your are doing, don't mess with them.
|
|
|
|
|
// If you never touch them, everything will work. If you set them correcly,
|
|
|
|
|
// things may work faster. If you set them incorrectly, be sure to save
|
|
|
|
|
// all files before running.
|
|
|
|
|
// All of these are indices, not bytes. from the beginning of the buffer.
|
|
|
|
|
UInt32 GetVertBufferStart(UInt32 idx) const { return fVertBuffStarts[idx]; }
|
|
|
|
|
UInt32 GetVertBufferEnd(UInt32 idx) const { return fVertBuffEnds[idx] >= 0 ? UInt32(fVertBuffEnds[idx]) : GetVertBufferCount(idx); }
|
|
|
|
|
UInt32 GetIndexBufferStart(UInt32 idx) const { return fIdxBuffStarts[idx]; }
|
|
|
|
|
UInt32 GetIndexBufferEnd(UInt32 idx) const { return fIdxBuffEnds[idx] >= 0 ? UInt32(fIdxBuffEnds[idx]) : GetIndexBufferCount(idx); }
|
|
|
|
|
|
|
|
|
|
void SetVertBufferStart(UInt32 idx, UInt32 s) { fVertBuffStarts[idx] = s; }
|
|
|
|
|
void SetVertBufferEnd(UInt32 idx, UInt32 e) { fVertBuffEnds[idx] = e; }
|
|
|
|
|
void SetIndexBufferStart(UInt32 idx, UInt32 s) { fIdxBuffStarts[idx] = s; }
|
|
|
|
|
void SetIndexBufferEnd(UInt32 idx, UInt32 e) { fIdxBuffEnds[idx] = e; }
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
UInt32 GetNumVertexBuffers( void ) const { return fVertBuffStorage.GetCount(); }
|
|
|
|
|
UInt32 GetNumIndexBuffers( void ) const { return fIdxBuffStorage.GetCount(); }
|
|
|
|
|
|
|
|
|
|
UInt8 *GetVertBufferData( UInt32 idx ) { return fVertBuffStorage[ idx ]; }
|
|
|
|
|
UInt16 *GetIndexBufferData( UInt32 idx ) { return fIdxBuffStorage[ idx ]; }
|
|
|
|
|
plGBufferColor *GetColorBufferData( UInt32 idx ) { return fColorBuffStorage[ idx ]; }
|
|
|
|
|
|
|
|
|
|
hsGDeviceRef *GetVertexBufferRef( UInt32 i );
|
|
|
|
|
hsGDeviceRef *GetIndexBufferRef( UInt32 i );
|
|
|
|
|
|
|
|
|
|
UInt32 GetNumCells( UInt32 idx ) const { return fCells[ idx ]->GetCount(); }
|
|
|
|
|
plGBufferCell *GetCell( UInt32 idx, UInt32 cell ) { return &( (*fCells[ idx ])[ cell ] ); }
|
|
|
|
|
|
|
|
|
|
void SetVertexBufferRef( UInt32 index, hsGDeviceRef *vb );
|
|
|
|
|
void SetIndexBufferRef( UInt32 index, hsGDeviceRef *ib );
|
|
|
|
|
|
|
|
|
|
virtual void Read( hsStream* s );
|
|
|
|
|
virtual void Write( hsStream* s );
|
|
|
|
|
|
|
|
|
|
// Accessor functions
|
|
|
|
|
hsPoint3 &Position( int iBuff, UInt32 cell, int iVtx );
|
|
|
|
|
hsVector3 &Normal( int iBuff, UInt32 cell, int iVtx );
|
|
|
|
|
UInt32 &Color( int iBuff, UInt32 cell, int iVtx );
|
|
|
|
|
UInt32 &Specular( int iBuff, UInt32 cell, int iVtx );
|
|
|
|
|
hsPoint3 &UV( int iBuff, UInt32 cell, int iVtx, int channel );
|
|
|
|
|
UInt32 Format() const { return fFormat; }
|
|
|
|
|
|
|
|
|
|
// Take temp accumulators and actually build buffer data from them
|
|
|
|
|
void TidyUp( void );
|
|
|
|
|
|
|
|
|
|
// Delete the buffer data storage
|
|
|
|
|
void CleanUp( void );
|
|
|
|
|
|
|
|
|
|
// Take buffer data and convert it to device-specific buffers
|
|
|
|
|
void PrepForRendering( plPipeline *pipe, hsBool adjustForNvidiaLighting );
|
|
|
|
|
|
|
|
|
|
// Reserves space in a vertex buffer
|
|
|
|
|
hsBool ReserveVertStorage( UInt32 numVerts, UInt32 *vbIndex, UInt32 *cell, UInt32 *offset, UInt8 flags );
|
|
|
|
|
|
|
|
|
|
// Append vertex data to the first available storage buffer
|
|
|
|
|
void AppendToVertStorage( plGeometrySpan *srcSpan, UInt32 *vbIndex, UInt32 *cell, UInt32 *offset );
|
|
|
|
|
void AppendToVertAndColorStorage( plGeometrySpan *srcSpan, UInt32 *vbIndex, UInt32 *cell, UInt32 *offset );
|
|
|
|
|
void AppendToColorStorage( plGeometrySpan *srcSpan, UInt32 *vbIndex, UInt32 *cell, UInt32 *offset, UInt32 origCell );
|
|
|
|
|
|
|
|
|
|
// Reserves space in an index buffer
|
|
|
|
|
hsBool ReserveIndexStorage( UInt32 numIndices, UInt32 *ibIndex, UInt32 *ibStart, UInt16 **dataPtr = nil );
|
|
|
|
|
|
|
|
|
|
// Append index data to the first available storage buffer
|
|
|
|
|
void AppendToIndexStorage( UInt32 numIndices, UInt16 *data, UInt32 addToAll, UInt32 *ibIndex, UInt32 *ibStart );
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/// Dynamic functions (addition/deletion of raw data)
|
|
|
|
|
void DeleteVertsFromStorage( UInt32 which, UInt32 start, UInt32 length );
|
|
|
|
|
void AdjustIndicesInStorage( UInt32 which, UInt16 threshhold, Int16 delta );
|
|
|
|
|
void DeleteIndicesFromStorage( UInt32 which, UInt32 start, UInt32 length );
|
|
|
|
|
|
|
|
|
|
// Returns an array of plGBufferTriangles representing the span of indices specified
|
|
|
|
|
plGBufferTriangle *ConvertToTriList( Int16 spanIndex, UInt32 whichIdx, UInt32 whichVtx, UInt32 whichCell, UInt32 start, UInt32 numTriangles );
|
|
|
|
|
|
|
|
|
|
// Stuffs the indices from an array of plGBufferTriangles into the index storage
|
|
|
|
|
void StuffFromTriList( UInt32 which, UInt32 start, UInt32 numTriangles, UInt16 *data );
|
|
|
|
|
void StuffTri( UInt32 iBuff, UInt32 iTri, UInt16 idx0, UInt16 idx1, UInt16 idx2 );
|
|
|
|
|
|
|
|
|
|
// Stuff the data from a geometry span into vertex storage
|
|
|
|
|
void StuffToVertStorage( plGeometrySpan *srcSpan, UInt32 vbIndex, UInt32 cell, UInt32 offset, UInt8 flags );
|
|
|
|
|
|
|
|
|
|
// Are our verts volatile?
|
|
|
|
|
hsBool AreVertsVolatile() const { return fVertsVolatile; }
|
|
|
|
|
hsBool AreIdxVolatile() const { return fIdxVolatile; }
|
|
|
|
|
|
|
|
|
|
int GetLOD() const { return fLOD; }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#endif // _plGBufferGroup_h
|
|
|
|
|
|
