CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plDrawable/plSpanInstance.cpp

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

#include "hsTypes.h"
#include "plSpanInstance.h"

#include "hsGeometry3.h"
#include "hsStream.h"

void plSpanEncoding::Read(hsStream* s)
{
	fCode = s->ReadByte();
	fPosScale = s->ReadSwapScalar();
}

void plSpanEncoding::Write(hsStream* s) const
{
	s->WriteByte((UInt8)fCode);
	s->WriteSwapScalar(fPosScale);
}


plSpanInstance::plSpanInstance()
:	fPosDelta(nil),
	fCol(nil)
{
	fL2W[0][1] = fL2W[0][2] = 0.f;
	fL2W[1][0] = fL2W[1][2] = 0.f;
	fL2W[2][0] = fL2W[2][1] = 0.f;
	fL2W[0][0] = fL2W[1][1] = fL2W[2][2] = 1.f;
}

plSpanInstance::~plSpanInstance()
{
	DeAlloc();
}

void plSpanInstance::DeAlloc()
{
	delete [] fPosDelta;
	fPosDelta = nil;
	delete [] fCol;
	fCol = nil;
}

void plSpanInstance::Alloc(const plSpanEncoding& encoding, UInt32 numVerts)
{
	DeAlloc();
	UInt32 posStride = PosStrideFromEncoding(encoding);
	if( posStride )
		fPosDelta = TRACKED_NEW UInt8[numVerts * posStride];

	UInt32 colStride = ColStrideFromEncoding(encoding);
	if( colStride )
		fCol = TRACKED_NEW UInt8[numVerts * colStride];
}

void plSpanInstance::Read(hsStream* stream, const plSpanEncoding& encoding, UInt32 numVerts)
{
	Alloc(encoding, numVerts);

	stream->Read(12 * sizeof(hsScalar), fL2W[0]);
	if( fPosDelta )
	{
		stream->Read(numVerts * PosStrideFromEncoding(encoding), fPosDelta);
	}

	if( fCol )
	{
		stream->Read(numVerts * ColStrideFromEncoding(encoding), fCol);
	}
}

void plSpanInstance::Write(hsStream* stream, const plSpanEncoding& encoding, UInt32 numVerts) const
{
	stream->Write(12 * sizeof(hsScalar), fL2W[0]);
	if( fPosDelta )
	{
		stream->Write(numVerts * PosStrideFromEncoding(encoding), fPosDelta);
	}
	if( fCol )
	{
		stream->Write(numVerts * ColStrideFromEncoding(encoding), fCol);
	}
}

hsMatrix44 plSpanInstance::LocalToWorld() const
{
	hsMatrix44 retVal;
	retVal.NotIdentity();
	int i;
	for( i = 0; i < 3; i++ )
	{
		int j;
		for( j = 0; j < 4; j++ )
		{
			retVal.fMap[i][j] = fL2W[i][j];
		}
	}
	retVal.fMap[3][0] =
		retVal.fMap[3][1] =
		retVal.fMap[3][2] = 0.f;
	retVal.fMap[3][3] = 1.f;

	return retVal;
}

hsMatrix44 plSpanInstance::WorldToLocal() const
{
	hsMatrix44 l2w = LocalToWorld();
	hsMatrix44 w2l;
	l2w.GetInverse(&w2l);
	return w2l;
}

void plSpanInstance::SetLocalToWorld(const hsMatrix44& l2w)
{
	int i;
	for( i = 0; i < 3; i++ )
	{
		int j;
		for( j = 0; j < 4; j++ )
		{
			fL2W[i][j] = l2w.fMap[i][j];
		}
	}
}

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

	hsAssert(!(encoding.fCode & plSpanEncoding::kPosMask) == !delPos, "Position encoding mismatch");
	hsAssert(!(encoding.fCode & plSpanEncoding::kColMask) == !color, "Color encoding mismatch");

	// Check that there's anything to encode.
	if( !(fPosDelta || fCol) )
		return;

	Int8* pos888 = (Int8*)fPosDelta;
	Int16* pos161616 = (Int16*)fPosDelta;
	UInt32* pos101010 = (UInt32*)fPosDelta;

	UInt8* col8 = (UInt8*)fCol;
	UInt16* col16 = (UInt16*)fCol;
	UInt32*	col32 = (UInt32*)fCol;
	int i;
	for( i = 0; i < numVerts; i++ )
	{
		switch(encoding.fCode & plSpanEncoding::kPosMask)
		{
		case plSpanEncoding::kPos888:
			pos888[0] = Int8(delPos->fX / encoding.fPosScale);
			pos888[1] = Int8(delPos->fY / encoding.fPosScale);
			pos888[2] = Int8(delPos->fZ / encoding.fPosScale);
			pos888 += 3;
			delPos++;
			break;
		case plSpanEncoding::kPos161616:
			pos161616[0] = Int16(delPos->fX / encoding.fPosScale);
			pos161616[1] = Int16(delPos->fY / encoding.fPosScale);
			pos161616[2] = Int16(delPos->fZ / encoding.fPosScale);
			pos161616 += 3;
			delPos++;
			break;
		case plSpanEncoding::kPos101010:
			*pos101010 =
				((UInt32(delPos->fX / encoding.fPosScale) & 0x3f) << 0)
				| ((UInt32(delPos->fY / encoding.fPosScale) & 0x3f) << 10)
				| ((UInt32(delPos->fZ / encoding.fPosScale) & 0x3f) << 20);
			pos101010++;
			delPos++;
			break;
		case plSpanEncoding::kPos008:
			*pos888 = Int8(delPos->fZ / encoding.fPosScale);
			pos888++;
			delPos++;
			break;
		case plSpanEncoding::kPosNone:
		default:
			break;
		}
		switch(encoding.fCode & plSpanEncoding::kColMask)
		{
		case plSpanEncoding::kColA8:
			*col8 = (UInt8)((*color) >> 24);
			col8++;
			color++;
			break;
		case plSpanEncoding::kColI8:
			*col8 = (UInt8)((*color) & 0xff);
			col8++;
			color++;
			break;
		case plSpanEncoding::kColAI88:
			*col16 = (UInt16)(((*color) >> 16) & 0xffff);
			col16++;
			color++;
			break;
		case plSpanEncoding::kColRGB888:
			*col8++ = (UInt8)((*color >> 16) & 0xff);
			*col8++ = (UInt8)((*color >> 8) & 0xff);
			*col8++ = (UInt8)((*color >> 0) & 0xff);
			color++;
			break;
		case plSpanEncoding::kColARGB8888:
			*col32++ = *color;
			color++;
			break;
		case plSpanEncoding::kColNone:
		default:
			break;
		}
	}
}