CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plDrawable/plSpanTemplate.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 plSpanTemplate_inc
#define plSpanTemplate_inc

#include "hsGeometry3.h"
#include "hsBounds.h"
#include "hsColorRGBA.h"
#include "plRenderLevel.h"

class hsStream;

class INode;
class hsGMaterial;

class plSpanTemplate
{
public:
	// 99% of the time, the defaults are fine. Just tell me
	// how many UVWs, and whether you've got color.
	static UInt16 MakeFormat(hsBool hasColor, int numUVWs,
							hsBool hasWgtIdx = false,
							int numWgts = 0,
							hsBool hasNorm = true,
							hsBool hasPos = true,
							hsBool hasColor2 = true)
	{
		return (hasPos ? kPosMask : 0)
			| (hasNorm ? kNormMask : 0)
			| (hasColor ? kColorMask : 0)
			| (hasWgtIdx ? kWgtIdxMask : 0)
			| ((numUVWs << 4) & kUVWMask)
			| ((numWgts << 8) & kWeightMask)
			| (hasColor2 ? kColor2Mask : 0); // Till we can get this out of here.
	};
	enum
	{
		kPosMask		= 0x1,

		kNormMask		= 0x2,

		kColorMask		= 0x4,

		kWgtIdxMask		= 0x8,

		kUVWMask		= 0xf0,

		kWeightMask		= 0x300,

		kColor2Mask		= 0x400
	};
	enum Channel
	{
		kPosition,
		kWeight,
		kWgtIdx,
		kNormal,
		kColor,
		kColor2,
		kUVW
	};
protected:

	UInt16	fNumVerts;
	UInt16	fFormat;
	UInt8	fStride;
	UInt16	fNumTris;

	// Data stored interleaved. Any channels may be omitted, but
	// existing channels are in exactly the following order:
	//	Position
	//	Weights
	//	Indices
	//	Normal
	//	Color
	//	Color2
	//	UVWs
	UInt8*			fData;

	UInt16*			fIndices;

	friend class plClusterUtil;
public:
	plSpanTemplate();
	virtual ~plSpanTemplate() { DeAlloc(); }

	const UInt8*	VertData() const { return fData; }

	const UInt16*	IndexData() const { return fIndices; }

	UInt32	NumVerts() const { return fNumVerts; }
	UInt32	Stride() const { return UInt32(fStride); }
	UInt32	CalcStride();
	UInt32	VertSize() const { return NumVerts() * Stride(); }

	UInt32	NumTris() const { return fNumTris; }
	UInt32	NumIndices() const { return NumTris() * 3; }
	UInt32	IndexSize() const { return NumIndices() * sizeof(UInt16); }
	
	UInt8	PositionOffset() const { return UInt8(0); }
	UInt8	WgtIdxOffset() const { return UInt8(PositionOffset() + NumPos() * sizeof(hsPoint3)); }
	UInt8	WeightOffset() const { return UInt8(WgtIdxOffset() + NumWgtIdx() * sizeof(UInt32)); }
	UInt8	NormalOffset() const { return UInt8(WeightOffset() + NumWeights() * sizeof(hsScalar)); }
	UInt8	ColorOffset() const { return UInt8(NormalOffset() + NumNorm() * sizeof(hsVector3)); }
	UInt8	Color2Offset() const { return UInt8(ColorOffset() + NumColor() * sizeof(UInt32)); }
	UInt8	UVWOffset() const { return UInt8(Color2Offset() + NumColor2() * sizeof(UInt32)); }

	UInt32	NumUVWs() const { return (fFormat & kUVWMask) >> 4; }
	UInt32	NumWeights() const { return (fFormat & kWeightMask) >> 8; }

	UInt32	NumPos() const { return (fFormat & kPosMask) >> 0; }
	UInt32	NumNorm() const { return (fFormat & kNormMask) >> 1; }
	UInt32	NumColor() const { return (fFormat & kColorMask) >> 2; }
	UInt32	NumColor2() const { return (fFormat & kColor2Mask) >> 10; }
	UInt32	NumWgtIdx() const { return (fFormat & kWgtIdxMask) >> 3; }

	hsPoint3*			Position(int i) const { return (hsPoint3*)GetData(kPosition, i); }
	hsVector3*			Normal(int i) const { return (hsVector3*)GetData(kNormal, i); }
	UInt32*				Color(int i) const { return (UInt32*)GetData(kColor, i); }
	UInt32*				Color2(int i) const { return (UInt32*)GetData(kColor2, i); }
	UInt32*				WgtIdx(int i) const { return (UInt32*)GetData(kWgtIdx, i); }
	hsPoint3*			UVWs(int iv, int iuv) const { return (hsPoint3*)GetData(kUVW, iv, iuv); }
	hsScalar*			Weight(int iv, int iw) const { return (hsScalar*)GetData(kWeight, iv, iw); }

	UInt8*				GetData(Channel chan, int i, int j=0) const
	{
		ValidateInput(chan, i, j);
		UInt8* base = fData + i * fStride;
		switch(chan)
		{
		case kPosition:
			return base;
		case kWeight:
			return base 
				+ NumPos() * sizeof(hsPoint3)
				+ j * sizeof(hsScalar);
		case kWgtIdx:
			return base 
				+ NumPos() * sizeof(hsPoint3)
				+ NumWeights() * sizeof(hsScalar);
		case kNormal:
			return base 
				+ NumPos() * sizeof(hsPoint3)
				+ NumWeights() * sizeof(hsScalar)
				+ NumWgtIdx() * sizeof(UInt32);
		case kColor:
			return base 
				+ NumPos() * sizeof(hsPoint3)
				+ NumWeights() * sizeof(hsScalar)
				+ NumWgtIdx() * sizeof(UInt32)
				+ NumNorm() * sizeof(hsVector3);
		case kColor2:
			return base 
				+ NumPos() * sizeof(hsPoint3)
				+ NumWeights() * sizeof(hsScalar)
				+ NumWgtIdx() * sizeof(UInt32)
				+ NumNorm() * sizeof(hsVector3)
				+ NumColor() * sizeof(UInt32);
		case kUVW:
			return base 
				+ NumPos() * sizeof(hsPoint3)
				+ NumWeights() * sizeof(hsScalar)
				+ NumWgtIdx() * sizeof(UInt32)
				+ NumNorm() * sizeof(hsVector3)
				+ NumColor() * sizeof(UInt32)
				+ NumColor2() * sizeof(UInt32)
				+ j * sizeof(hsPoint3);
		}
		hsAssert(false, "Unrecognized vertex channel");
		return nil;
	}

	hsBool ValidateInput(Channel chan, int i, int j) const
	{
		switch(chan)
		{
		case kPosition:
			hsAssert(NumPos(), "Invalid data request");
			return NumPos() > 0;
		case kWeight:
			hsAssert(NumWeights(), "Invalid data request");
			return NumWeights() > 0;
		case kWgtIdx:
			hsAssert(NumWgtIdx() > j, "Invalid data request");
			return NumWgtIdx() > j;
		case kNormal:
			hsAssert(NumNorm(), "Invalid data request");
			return NumNorm() > 0;
		case kColor:
			hsAssert(NumColor(), "Invalid data request");
			return NumColor() > 0;
		case kColor2:
			hsAssert(NumColor2(), "Invalid data request");
			return NumColor2() > 0;
		case kUVW:
			hsAssert(NumUVWs() > j, "Invalid data request");
			return NumUVWs() > j;
		}
		hsAssert(false, "Unrecognized vertex channel");
		return false;
	}
	
	void Alloc(UInt16 format, UInt32 numVerts, UInt32 numTris);
	void DeAlloc();

	void Read(hsStream* s);
	void Write(hsStream* s) const;
};

// An export only version
class plSpanTemplateB : public plSpanTemplate
{
	INode*			fSrc;
	hsBounds3Ext	fLocalBounds;

	hsColorRGBA*	fMultColors;
	hsColorRGBA*	fAddColors;

public:
	plSpanTemplateB(INode* src) : plSpanTemplate(), fSrc(src), fMaterial(nil) {}
	virtual ~plSpanTemplateB() { DeAllocColors(); }

	void ComputeBounds();

	const hsBounds3Ext& GetLocalBounds() const { return fLocalBounds; }

	INode*			GetSrcNode() const { return fSrc; }

	hsGMaterial*	fMaterial;

	plRenderLevel	fRenderLevel;

	hsColorRGBA*	MultColor(int i) const { return &fMultColors[i]; }
	hsColorRGBA*	AddColor(int i) const { return &fAddColors[i]; }

	void AllocColors();
	void DeAllocColors();
};

#endif // plSpanTemplate_inc