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

#include "hsGeometry3.h"
#include "hsMatrix44.h"

// plClusterGroup
//		array of templates
//		array of materials (indexed by templates)
//		array of clusters
//		array of LOD blend 
//		array of vis sets

// plCluster
//		array of span instances that are combinable
//		LOD blend start and end index
//		vis set index
//		Combinable means:
//			same material
//			same format
//			same LOD blend
//			same vis set
//			same lights
//			same encoding?

// plSpanInstance
//		template idx
//		3x4 transform
//		encoding flags 
//			(what components does it include, delPos? color?)
//			(what's the encoding? 32bit RGBA? 16Bit/Chan? 10Bit/Chan? 8Bit/Chan?)
//			(need an encoding per channel)

// plSpanTemplate
//		numVerts
//		Format (assume pos & norm?)
//			kUVWMask
//			kColMask
//			kWeightMask
//		fPos
//		fNorm
//		fCol
//		fUVWs
//		fWeights


class plSpanEncoding
{
public:
	enum
	{
		kPosNone			= 0x0,
		kPos888				= 0x1,
		kPos161616			= 0x2,
		kPos101010			= 0x4,
		kPos008				= 0x8,
		kPosMask			= kPos888 | kPos161616 | kPos101010 | kPos008,

		kColNone			= 0x0,
		kColA8				= 0x10,
		kColI8				= 0x20,
		kColAI88			= 0x40,
		kColRGB888			= 0x80,
		kColARGB8888		= 0x100,
		kColMask			= kColNone
								| kColA8
								| kColI8
								| kColAI88
								| kColRGB888
								| kColARGB8888,
	};

	UInt32			fCode;
	hsScalar		fPosScale;

	plSpanEncoding() : fCode(kPosNone|kColNone), fPosScale(0) {}
	plSpanEncoding(UInt32 c, hsScalar s) : fCode(c), fPosScale(s) {}

	UInt32		Code() const { return fCode; }
	hsScalar	Scale() const { return fPosScale; }

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

class plSpanInstance
{
protected:
	UInt8*			fPosDelta;
	UInt8*			fCol;

	hsScalar		fL2W[3][4];

	friend class plSpanInstanceIter;
public:
	plSpanInstance();
	~plSpanInstance();

	void Read(hsStream* s, const plSpanEncoding& encoding, UInt32 numVerts);
	void Write(hsStream* s, const plSpanEncoding& encoding, UInt32 numVerts) const;

	void Encode(const plSpanEncoding& encoding, UInt32 numVerts, const hsVector3* delPos, const UInt32* color);

	void Alloc(const plSpanEncoding& encoding, UInt32 numVerts);
	void DeAlloc();

	hsMatrix44 LocalToWorld() const;
	hsMatrix44 WorldToLocal() const;

	void SetLocalToWorld(const hsMatrix44& l2w);

	hsBool HasPosDelta() const { return fPosDelta != nil; }
	hsBool HasColor() const { return fCol != nil; }

	static UInt16 PosStrideFromEncoding(const plSpanEncoding& encoding)
	{
		switch(encoding.fCode & plSpanEncoding::kPosMask)
		{
		case plSpanEncoding::kPos888:
			return 3;
		case plSpanEncoding::kPos161616:
			return 6;
		case plSpanEncoding::kPos101010:
			return 4;
		case plSpanEncoding::kPos008:
			return 1;
		}
		return 0;
	}
	static UInt16 ColStrideFromEncoding(const plSpanEncoding& encoding)
	{
		switch(encoding.fCode & plSpanEncoding::kPosMask)
		{
		case plSpanEncoding::kColNone:
			return 0;
		case plSpanEncoding::kColA8:
			return 1;
		case plSpanEncoding::kColI8:
			return 1;
		case plSpanEncoding::kColAI88:
			return 2;
		case plSpanEncoding::kColRGB888:
			return 3;
		case plSpanEncoding::kColARGB8888:
			return 4;
		}
		return 0;
	}
};

class plSpanInstanceIter
{
protected:
	plSpanInstance*		fInst;
	plSpanEncoding		fEncoding;
	UInt32				fNumVerts;
	Int32				fNumVertsLeft;
	UInt16				fPosStride;
	UInt16				fColStride;

	union {
		Int8*		fPos888;
		Int16*		fPos161616;
		UInt32*		fPos101010;
	};
	union {
		UInt8*		fA8;
		UInt8*		fI8;
		UInt16*		fAI88;
		UInt8*		fRGB888;
		UInt32*		fARGB8888;
	};

public:
	plSpanInstanceIter();
	plSpanInstanceIter(plSpanInstance* inst, const plSpanEncoding& encoding, UInt32 numVerts) { Init(inst, encoding, numVerts); }

	void Init(plSpanInstance* inst, const plSpanEncoding& encoding, UInt32 numVerts)
	{
		fInst = inst;
		fEncoding = encoding;
		fNumVerts = numVerts;
		fPosStride = inst->PosStrideFromEncoding(fEncoding);
		fColStride = inst->ColStrideFromEncoding(fEncoding);
		fNumVertsLeft = 0;
	}

	void		Begin()
	{
		fPos888 = (Int8*)fInst->fPosDelta;
		fA8 = fInst->fCol;

		fNumVertsLeft = fNumVerts;
	}
	void		Advance()
	{
		fPos888 += fPosStride;
		fA8 += fColStride;

		fNumVertsLeft--;
	}
	hsBool		More() const { return fNumVertsLeft > 0; }

	hsVector3	DelPos() const
	{
		switch(fEncoding.fCode & plSpanEncoding::kPosMask)
		{
		case plSpanEncoding::kPos888:
			return hsVector3(fPos888[0] * fEncoding.fPosScale, 
								fPos888[1] * fEncoding.fPosScale, 
								fPos888[2] * fEncoding.fPosScale);
		case plSpanEncoding::kPos161616:
			return hsVector3(fPos161616[0] * fEncoding.fPosScale, 
								fPos161616[1] * fEncoding.fPosScale, 
								fPos161616[2] * fEncoding.fPosScale);
		case plSpanEncoding::kPos101010:
			return hsVector3(int(*fPos101010 & 0x3f) * fEncoding.fPosScale,
				int((*fPos101010 >> 10) & 0x3f) * fEncoding.fPosScale,
				int((*fPos101010 >> 20) & 0x3f) * fEncoding.fPosScale);
		case plSpanEncoding::kPos008:
			return hsVector3(0,0, *fPos888 * fEncoding.fPosScale);
		}
		return hsVector3(0,0,0);
	};
	hsPoint3 Position(const hsPoint3& p) const
	{
		hsPoint3 pos(p);
		pos += DelPos();
		return pos;
	};
	UInt32		Color(UInt32 c) const 
	{ 
		switch(fEncoding.fCode & plSpanEncoding::kColMask)
		{
		case plSpanEncoding::kColA8:
			return (c & 0x00ffffff) | *fA8;
		case plSpanEncoding::kColI8:
			return (c & 0xff000000) 
				| (*fI8 << 16)
				| (*fI8 << 8)
				| (*fI8 << 0);
		case plSpanEncoding::kColAI88:
			{
				const UInt32 col = *fAI88 & 0xff;
				return ((*fAI88 & 0xff00) << 24)
					| (col << 16)
					| (col << 8)
					| (col << 0);
			}
		case plSpanEncoding::kColRGB888:
			return (c & 0xff000000)
				| (fRGB888[0] << 16)
				| (fRGB888[1] << 8)
				| (fRGB888[2] << 0);
		case plSpanEncoding::kColARGB8888:
			return *fARGB8888;
		}
		return c; 
	};
};

#endif // plSpanInstance_inc