CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plDrawable/plAccessVtxSpan.h

/*==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==*/

#ifndef plAccessVtxSpan_inc
#define plAccessVtxSpan_inc

#include "hsGeometry3.h"
#include "hsColorRGBA.h"

class hsGMaterial;
struct hsMatrix44;
class hsGDeviceRef;

// AccessSpan - a generic "vertex array". It'll at least act like one,
// whatever the underlying storage mechanism. For random access, just
// use the accessor functions. For faster sequential iteration, use
// the iterator classes defined further down. I'm leaving the actual
// data (fChannels & fStrides) public, but I'll probably regret it.
// I have to dig pretty deep to come up with a reason not to use
// either the indexed accessors or the iterator classes.
//
// You may be wondering why have separate strides for each of the data channels,
// especially since this means doing nChan pointer adds to advance rather than
// one. The answer is two part. First, the different channels may be in different
// buffers, either because we're on the export side and haven't glommed them together
// into a single stream yet, or because we finally got around to using multiple
// streams on the runtime side (say to support instancing). The point is for you
// to be able to write your code without knowing or caring. The second part is that
// those nChan adds aren't really costing you anything. Say the data is stored contiguously,
// and we keep a base pointer and an advance just adds the (single) stride to the base
// pointer. That's probably your position, and we've just saved a bunch of adds in advancing
// it. Now you want to access your normal, well, you still have to do an add on the base pointer
// to get to your normal, and another to get to your color, etc. So if you really want to 
// eliminate those extra adds, go ahead and use the iterator, just make sure you use
// the most focused iterator available. Like if you're just looking at position and
// normal, use the plAccPosNormIterator.
class plAccessVtxSpan
{
public:
	enum Channel
	{
		kPosition = 0,
		kWeight,
		kWgtIndex,
		kNormal,
		kDiffuse,
		kSpecular,
		kUVW,
		kNumValidChans,
		kInvalid = 0xffff
	};
	// Mask versions, to be or'ed together and passed in when using plAccessGeometry::SnapShotStuff.
	enum
	{
		kPositionMask	= (1 << kPosition),
		kWeightMask		= (1 << kWeight),
		kWgtIndexMask	= (1 << kWgtIndex),
		kNormalMask		= (1 << kNormal),
		kDiffuseMask	= (1 << kDiffuse),
		kSpecularMask	= (1 << kSpecular),
		kUVWMask		= (1 << kUVW)
	};

	hsGDeviceRef*	fVtxDeviceRef;

	UInt8*			fChannels[kNumValidChans];
	UInt16			fStrides[kNumValidChans];
	Int32			fOffsets[kNumValidChans];

	UInt16			fNumWeights;
	UInt16			fNumUVWsPerVert;
	UInt16			fNumVerts;

	//////////////////////////////////
	// QUERY SECTION
	// Queries on how much of what we got.
	UInt32			VertCount() const { return fNumVerts; }
	hsBool			HasChannel(Channel chan) const { return fStrides[chan] > 0; }
	hsBool				HasPositions() const { return HasChannel(kPosition); }
	hsBool				HasWeights() const { return HasChannel(kWeight); }
	int					NumWeights() const { return fNumWeights; }
	hsBool				HasWgtIndex() const { return HasChannel(kWgtIndex); }
	hsBool				HasNormals() const { return HasChannel(kNormal); }
	hsBool				HasDiffuse() const { return HasChannel(kDiffuse); }
	hsBool				HasSpecular() const { return HasChannel(kSpecular); }
	hsBool				HasUVWs() const { return HasChannel(kUVW); }
	hsBool					HasUVWs(int n) { return HasChannel(kUVW) && (n <= fNumUVWsPerVert); }
	int				NumUVWs() const { return fNumUVWsPerVert; }

	//////////////////////////////////
	// ACCESSOR SECTION
	hsPoint3&		Position(int i) const { return *(hsPoint3*)(fChannels[kPosition] + i*fStrides[kPosition]); }
	hsVector3&		Normal(int i) const { return *(hsVector3*)(fChannels[kNormal] + i*fStrides[kNormal]); }

	hsScalar&		Weight(int iVtx, int iWgt) const { return *(hsScalar*)(fChannels[kWeight] + iVtx*fStrides[kWeight] + iWgt*sizeof(hsScalar)); }
	hsScalar*		Weights(int i) const { return (hsScalar*)(fChannels[kWeight] + i*fStrides[kWeight]); }
	UInt32&			WgtIndices(int i) const { return *(UInt32*)(fChannels[kWgtIndex] + i * fStrides[kWgtIndex]); }
	UInt8&			WgtIndex(int iVtx, int iWgt) const { return *(fChannels[kWgtIndex] + iVtx*fStrides[kWgtIndex] + iWgt); }

	UInt32&			Diffuse32(int i) const { return *(UInt32*)(fChannels[kDiffuse] + i*fStrides[kDiffuse]); }
	UInt32&			Specular32(int i) const { return *(UInt32*)(fChannels[kSpecular] + i*fStrides[kSpecular]); }

	hsColorRGBA		DiffuseRGBA(int i) const { return hsColorRGBA().FromARGB32(Diffuse32(i)); }
	hsColorRGBA		SpecularRGBA(int i) const { return hsColorRGBA().FromARGB32(Specular32(i)); }

		// Two versions of UVW, first to get the iVtx'th vertex's iUVW'th uvw. 
		// Second just gets the vertex's uvw array, which is hopefully stored contiguously or we're screwed.
	hsPoint3&		UVW(int iVtx, int iUVW) const { return *(hsPoint3*)(fChannels[kUVW] + iVtx*fStrides[kUVW] + iUVW*sizeof(hsPoint3)); }
	hsPoint3*		UVWs(int i) const { return (hsPoint3*)(fChannels[kUVW] + i*fStrides[kUVW]); }

	// OFFSET VERSIONS
	// Tri and particle accessors call the offset versions because they have indices into the original
	// buffers, but our pointers are based at the beginning of our data.
	hsPoint3&		PositionOff(int i) const { return *(hsPoint3*)(fChannels[kPosition] + i*fStrides[kPosition] + fOffsets[kPosition]); }
	hsVector3&		NormalOff(int i) const { return *(hsVector3*)(fChannels[kNormal] + i*fStrides[kNormal] + fOffsets[kNormal]); }

	hsScalar&		WeightOff(int iVtx, int iWgt) const { return *(hsScalar*)(fChannels[kWeight] + iVtx*fStrides[kWeight] + fOffsets[kWeight] + iWgt*sizeof(hsScalar)); }
	hsScalar*		WeightsOff(int i) const { return (hsScalar*)(fChannels[kWeight] + i*fStrides[kWeight] + fOffsets[kWeight]); }
	UInt32&			WgtIndicesOff(int i) const { return *(UInt32*)(fChannels[kWgtIndex] + i * fStrides[kWgtIndex] + fOffsets[kWgtIndex]); }
	UInt8&			WgtIndexOff(int iVtx, int iWgt) const { return *(fChannels[kWgtIndex] + iVtx*fStrides[kWgtIndex] + fOffsets[kWgtIndex] + iWgt); }

	UInt32&			Diffuse32Off(int i) const { return *(UInt32*)(fChannels[kDiffuse] + i*fStrides[kDiffuse] + fOffsets[kDiffuse]); }
	UInt32&			Specular32Off(int i) const { return *(UInt32*)(fChannels[kSpecular] + i*fStrides[kSpecular] + fOffsets[kSpecular]); }

	hsColorRGBA		DiffuseRGBAOff(int i) const { return hsColorRGBA().FromARGB32(Diffuse32Off(i)); }
	hsColorRGBA		SpecularRGBAOff(int i) const { return hsColorRGBA().FromARGB32(Specular32Off(i)); }

		// Two versions of UVW, first to get the iVtx'th vertex's iUVW'th uvw. 
		// Second just gets the vertex's uvw array, which is hopefully stored contiguously or we're screwed.
	hsPoint3&		UVWOff(int iVtx, int iUVW) const { return *(hsPoint3*)(fChannels[kUVW] + iVtx*fStrides[kUVW] + fOffsets[kUVW] + iUVW*sizeof(hsPoint3)); }
	hsPoint3*		UVWsOff(int i) const { return (hsPoint3*)(fChannels[kUVW] + i*fStrides[kUVW] + fOffsets[kUVW]); }
	
	//////////////////////////////////
	// SETUP SECTION.
	//////////////////////////////////

	//////////////////////////////////
	// Call Clear to initialize.
	void			ClearVerts();

	// Must at least set a count and the valid channels. Note below on setting up for UVW access.
	plAccessVtxSpan&	SetVertCount(UInt16 c) { fNumVerts = c; return *this; }
	plAccessVtxSpan&	SetStream(void* p, UInt16 stride, Int32 offset, Channel chan) { fChannels[chan] = (UInt8*)p; fStrides[chan] = stride; fOffsets[chan] = offset; return *this; }

	//////////////////////////////////
	// Convenience versions. You get the idea.
	plAccessVtxSpan&	PositionStream(void* p, UInt16 stride, Int32 offset) { return SetStream(p, stride, offset, kPosition); }
	plAccessVtxSpan&	NormalStream(void* p, UInt16 stride, Int32 offset) { return SetStream(p, stride, offset, kNormal); }
	plAccessVtxSpan&	DiffuseStream(void* p, UInt16 stride, Int32 offset) { return SetStream(p, stride, offset, kDiffuse); }
	plAccessVtxSpan&	SpecularStream(void* p, UInt16 stride, Int32 offset) { return SetStream(p, stride, offset, kSpecular); }
	plAccessVtxSpan&	WeightStream(void* p, UInt16 stride, Int32 offset) { return SetStream(p, stride, offset, kWeight); }
	plAccessVtxSpan&	WgtIndexStream(void* p, UInt16 stride, Int32 offset) { return SetStream(p, stride, offset, kWgtIndex); }
	plAccessVtxSpan&	SetNumWeights(int n) { if( !(fNumWeights = n) ) SetStream(nil, 0, 0, kWeight).SetStream(nil, 0, 0, kWgtIndex); return *this; }
	// Note on UVW access setup, you don't actually "have" to set the number of uvws per vertex,
	// but one way or another you'll need to know to access the uvws. If you're going to be setting
	// up the AccessSpan and passing it off for processing, you definitely better set it. But the
	// accessor and iterators don't ever use it.
	// Note that this means the UVWStream stride is from uvw[0][0] to uvw[1][0] in bytes.
	plAccessVtxSpan&	UVWStream(void* p, UInt16 stride, Int32 offset) { return SetStream(p, stride, offset, kUVW); }
	plAccessVtxSpan&	SetNumUVWs(int n) { if( !(fNumUVWsPerVert = n) )SetStream(nil, 0, 0, kUVW); return *this; }
	//////////////////////////////////

	// Cache away any device stuff that needed to be opened (locked) to get this data, so
	// we can close (unlock) it later.
	void			SetVtxDeviceRef(hsGDeviceRef* ref) { fVtxDeviceRef = ref; }
	hsGDeviceRef*	GetVtxDeviceRef() const { return fVtxDeviceRef; }
};

inline void plAccessVtxSpan::ClearVerts()
{
	int i;
	for( i = 0; i < kNumValidChans; i++ )
	{
		fChannels[i] = nil;
		fStrides[i] = 0;
	}
	fNumVerts = 0;
	fNumUVWsPerVert = 0;
	fNumWeights = 0;
}

template <class T> class plAccIterator
{
private:
	union
	{
		T*			fValue;
		UInt8*		fValueByte;
	};
	UInt8*						fValueEnd;
	plAccessVtxSpan*			fAccess;
	plAccessVtxSpan::Channel	fChan;

	void						ISetEnd() { fValueEnd = fAccess->fChannels[fChan] + fAccess->fNumVerts * fAccess->fStrides[fChan]; }

public:
	plAccIterator(plAccessVtxSpan* acc, plAccessVtxSpan::Channel chan) { Set(acc, chan); }
	plAccIterator(const plAccIterator& accIt) { *this = accIt; }
	plAccIterator() : fValueByte(nil), fValueEnd(nil), fAccess(nil), fChan(plAccessVtxSpan::kInvalid) {}

	void Set(plAccessVtxSpan* acc, plAccessVtxSpan::Channel chan) { fAccess = acc; fChan = chan; ISetEnd(); }

	T*			Value() const { return fValue; }

	int			Count() const { return fAccess->VertCount(); }
	int			GetCount() const { return Count(); }

	void		Begin() { fValueByte = fAccess->fChannels[fChan]; }
	void		Advance() { fValueByte += fAccess->fStrides[fChan]; }
	hsBool		More() const { return fValueByte < fValueEnd; }
};

class plAccPositionIterator
{
protected:
	plAccIterator<hsPoint3>		fPosition;

public:
	plAccPositionIterator(plAccessVtxSpan* acc) 
		:	fPosition(acc, plAccessVtxSpan::kPosition) {}

	plAccPositionIterator() {}

	plAccPositionIterator& Set(plAccessVtxSpan* acc) 
	{ 
		fPosition.Set(acc, plAccessVtxSpan::kPosition); 
		return *this; 
	}

	hsPoint3*			Position() const { return fPosition.Value(); }

	void				Begin() { fPosition.Begin(); }
	void				Advance() { fPosition.Advance(); }
	hsBool				More() const { return fPosition.More(); }
};

class plAccPosNormIterator
{
protected:
	plAccIterator<hsPoint3>		fPosition;
	plAccIterator<hsVector3>	fNormal;
public:
	plAccPosNormIterator(plAccessVtxSpan* acc) 
		:	fPosition(acc, plAccessVtxSpan::kPosition), 
			fNormal(acc, plAccessVtxSpan::kNormal) {}

	plAccPosNormIterator() {}

	plAccPosNormIterator& Set(plAccessVtxSpan* acc) 
	{ 
		fPosition.Set(acc, plAccessVtxSpan::kPosition); 
		fNormal.Set(acc, plAccessVtxSpan::kNormal); 
		return *this; 
	}

	hsPoint3*			Position() const { return fPosition.Value(); }
	hsVector3*			Normal() const { return fNormal.Value(); }

	void				Begin() { fPosition.Begin(); fNormal.Begin(); }
	void				Advance() { fPosition.Advance(); fNormal.Advance(); }
	hsBool				More() const { return fPosition.More(); }
};

class plAccPosNormUVWIterator
{
protected:
	plAccIterator<hsPoint3>		fPosition;
	plAccIterator<hsVector3>	fNormal;
	plAccIterator<hsPoint3>		fUVW;
public:
	plAccPosNormUVWIterator(plAccessVtxSpan* acc) 
		:	fPosition(acc, plAccessVtxSpan::kPosition), 
			fNormal(acc, plAccessVtxSpan::kNormal), 
			fUVW(acc, plAccessVtxSpan::kUVW) {}
	plAccPosNormUVWIterator() {}

	plAccPosNormUVWIterator& Set(plAccessVtxSpan* acc) 
	{ 
		fPosition.Set(acc, plAccessVtxSpan::kPosition); 
		fNormal.Set(acc, plAccessVtxSpan::kNormal); 
		fUVW.Set(acc, plAccessVtxSpan::kUVW); 
		return *this; 
	}

	hsPoint3*			Position() const { return fPosition.Value(); }
	hsVector3*			Normal() const { return fNormal.Value(); }
	hsPoint3*			UVWs() const { return fUVW.Value(); }
	hsPoint3*			UVW(int i) const { return fUVW.Value() + i; }

	void				Begin() { fPosition.Begin(); fNormal.Begin(); fUVW.Begin(); }
	void				Advance() { fPosition.Advance(); fNormal.Advance(); fUVW.Advance(); }
	hsBool				More() const { return fPosition.More(); }
};

class plAccUVWIterator
{
	plAccIterator<hsPoint3>		fUVW;
public:
	plAccUVWIterator(plAccessVtxSpan* acc) 
		:	fUVW(acc, plAccessVtxSpan::kUVW) {}
	plAccUVWIterator() {}

	plAccUVWIterator& Set(plAccessVtxSpan* acc) 
	{ 
		fUVW.Set(acc, plAccessVtxSpan::kUVW); 
		return *this; 
	}

	hsPoint3*			UVWs() const { return fUVW.Value(); }
	hsPoint3*			UVW(int i) const { return fUVW.Value() + i; }

	void				Begin() { fUVW.Begin(); }
	void				Advance() { fUVW.Advance(); }
	hsBool				More() const { return fUVW.More(); }
};

class plAccDiffuseIterator
{
	plAccIterator<UInt32>		fDiffuse;
public:
	plAccDiffuseIterator(plAccessVtxSpan* acc) 
		:	fDiffuse(acc, plAccessVtxSpan::kDiffuse) {}
	plAccDiffuseIterator() {}

	plAccDiffuseIterator& Set(plAccessVtxSpan* acc) 
	{ 
		fDiffuse.Set(acc, plAccessVtxSpan::kDiffuse);
		return *this; 
	}

	UInt32*				Diffuse32() const { return fDiffuse.Value(); }

	hsColorRGBA			DiffuseRGBA() const { return hsColorRGBA().FromARGB32(*Diffuse32()); }

	void				Begin() { fDiffuse.Begin(); }
	void				Advance() { fDiffuse.Advance(); }
	hsBool				More() const { return fDiffuse.More(); }
};

class plAccDiffSpecIterator
{
protected:
	plAccIterator<UInt32>		fDiffuse;
	plAccIterator<UInt32>		fSpecular;
public:
	plAccDiffSpecIterator(plAccessVtxSpan* acc) 
		:	fDiffuse(acc, plAccessVtxSpan::kDiffuse),
			fSpecular(acc, plAccessVtxSpan::kSpecular) {}
	plAccDiffSpecIterator() {}

	plAccDiffSpecIterator& Set(plAccessVtxSpan* acc) 
	{ 
		fDiffuse.Set(acc, plAccessVtxSpan::kDiffuse);
		fSpecular.Set(acc, plAccessVtxSpan::kSpecular);
		return *this; 
	}

	UInt32*				Diffuse32() const { return fDiffuse.Value(); }
	UInt32*				Specular32() const { return fSpecular.Value(); }

	hsColorRGBA			DiffuseRGBA() const { return hsColorRGBA().FromARGB32(*Diffuse32()); }
	hsColorRGBA			SpecularRGBA() const { return hsColorRGBA().FromARGB32(*Specular32()); }

	void				Begin() { fDiffuse.Begin(); fSpecular.Begin(); }
	void				Advance() { fDiffuse.Advance(); fSpecular.Advance(); }
	hsBool				More() const { return fDiffuse.More(); }
};


class plAccVertexIterator
{
protected:
	plAccIterator<hsPoint3>		fPosition;
	plAccIterator<hsScalar>		fWeight;
	plAccIterator<UInt8>		fWgtIndex;
	plAccIterator<hsVector3>	fNormal;
	plAccIterator<UInt32>		fDiffuse;
	plAccIterator<UInt32>		fSpecular;
	plAccIterator<hsPoint3>		fUVW;
public:
	plAccVertexIterator(plAccessVtxSpan* acc) 
		:	fPosition(acc, plAccessVtxSpan::kPosition), 
			fWeight(acc, plAccessVtxSpan::kWeight),
			fWgtIndex(acc, plAccessVtxSpan::kWgtIndex),
			fNormal(acc, plAccessVtxSpan::kNormal), 
			fDiffuse(acc, plAccessVtxSpan::kDiffuse),
			fSpecular(acc, plAccessVtxSpan::kSpecular),
			fUVW(acc, plAccessVtxSpan::kUVW) {}
	plAccVertexIterator() {}

	plAccVertexIterator& Set(plAccessVtxSpan* acc) 
	{ 
		fPosition.Set(acc, plAccessVtxSpan::kPosition); 
		fWeight.Set(acc, plAccessVtxSpan::kWeight);
		fWgtIndex.Set(acc, plAccessVtxSpan::kWgtIndex);
		fNormal.Set(acc, plAccessVtxSpan::kNormal); 
		fDiffuse.Set(acc, plAccessVtxSpan::kDiffuse);
		fSpecular.Set(acc, plAccessVtxSpan::kSpecular);
		fUVW.Set(acc, plAccessVtxSpan::kUVW); 
		return *this; 
	}

	hsPoint3*			Position() const { return fPosition.Value(); }
	hsScalar*			Weights() const { return fWeight.Value(); }
	hsScalar*			Weight(int i) const { return fWeight.Value() + i; }
	UInt32*				WgtIndices() const { return (UInt32*)(fWgtIndex.Value()); }
	UInt8*				WgtIndex(int i) const { return fWgtIndex.Value() + i; }
	hsVector3*			Normal() const { return fNormal.Value(); }
	hsPoint3*			UVWs() const { return fUVW.Value(); }
	hsPoint3*			UVW(int i) const { return fUVW.Value() + i; }

	UInt32*				Diffuse32() const { return fDiffuse.Value(); }
	UInt32*				Specular32() const { return fSpecular.Value(); }

	hsColorRGBA			DiffuseRGBA() const { return hsColorRGBA().FromARGB32(*Diffuse32()); }
	hsColorRGBA			SpecularRGBA() const { return hsColorRGBA().FromARGB32(*Specular32()); }

	void				Begin() { fPosition.Begin(); fWeight.Begin(); fNormal.Begin(); fDiffuse.Begin(); fSpecular.Begin(); fUVW.Begin(); }
	void				Advance() { fPosition.Advance(); fWeight.Advance(); fNormal.Advance(); fDiffuse.Begin(); fSpecular.Begin(); fUVW.Advance(); }
	hsBool				More() const { return fPosition.More(); }
};


#endif // plAccessVtxSpan_inc