CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plDrawable/plAccessSnapShot.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 "plAccessSnapShot.h"

#include "hsGeometry3.h"

#include <memory.h>

void plAccessSnapShot::Clear()
{
	ClearVerts();
	
	int i;
	for( i = 0; i < kNumValidChans; i++ )
		fChanSize[i] = 0;
}

void plAccessSnapShot::Destroy()
{
	Clear();

	delete [] fData;
	
	fRefCnt = 0;
}

void plAccessSnapShot::Release()
{
	hsAssert(fRefCnt, "Releasing a snapshot with no refs. Check matching TakeSnapShot/ReleaseSnapShot calls.");
	if( !--fRefCnt )
	{
		Destroy();
	}
}

UInt32 plAccessSnapShot::ICheckAlloc(const plAccessVtxSpan& src, UInt32 chanMask, UInt32 chan, UInt16 chanSize)
{
	if( ((1 << chan) & chanMask) && src.fStrides[chan] )
	{
		if( fChanSize[chan] )
		{
			// We already have this one
			chanMask &= ~(1 << chan);
		}
		else
		{
			// We'll get this one
			fChanSize[chan] = chanSize;
		}
	}
	else
	{
		// either we haven't been asked for this or src doesn't have it.
		// either way, we're never going to get it.
		chanMask &= ~(1 << chan);
	}
	return chanMask;
}

void plAccessSnapShot::IRecordSizes(UInt16 sizes[]) const
{
	int chan;
	for( chan = 0; chan < kNumValidChans; chan++ )
		sizes[chan] = fChanSize[chan];
}

UInt16 plAccessSnapShot::IComputeStride() const
{
	UInt16 stride = 0;
	int chan;
	for( chan = 0; chan < kNumValidChans; chan++ )
		stride += fChanSize[chan];

	return stride;
}

void plAccessSnapShot::ICopyOldData(UInt8* data, const UInt16* const oldSizes, UInt16 oldStride, UInt16 newStride)
{
	UInt32 oldOffset = 0;
	UInt32 newOffset = 0;
	UInt8*	srcChannels[kNumValidChans];
	UInt8*	dstChannels[kNumValidChans];
	int chan;
	for( chan = 0; chan < kNumValidChans; chan++ )
	{
		if( oldSizes[chan] )
		{
			hsAssert(fChanSize[chan], "Copying a channel we don't have");
			srcChannels[chan] = data + oldOffset;
			oldOffset += oldSizes[chan];
		}

		if( fChanSize[chan] )
		{
			dstChannels[chan] = fData + newOffset;
			newOffset += fChanSize[chan];
		}
	}
	int i;
	for( i = 0; i < fNumVerts; i++ )
	{
		for( chan = 0; chan < kNumValidChans; chan++ )
		{
			if( oldSizes[chan] )
			{
				memcpy(dstChannels[chan], srcChannels[chan], oldSizes[chan]);
				dstChannels[chan] += newStride;
				srcChannels[chan] += oldStride;
			}
		}
	}
}

void plAccessSnapShot::ISetupPointers(UInt16 newStride)
{
	fData = TRACKED_NEW UInt8[fNumVerts * newStride];

	int size = 0;
	int chan;
	for( chan = 0; chan < kNumValidChans; chan++ )
	{
		if( fChanSize[chan] )
		{
			fStrides[chan] = newStride;
			fChannels[chan] = fData + size;
			size += fChanSize[chan];
		}
	}
}

UInt32 plAccessSnapShot::CopyFrom(const plAccessVtxSpan& src, UInt32 chanMask)
{
	hsAssert(!fNumVerts || (fNumVerts == src.fNumVerts), "Copying from a different sized span");

	fNumVerts = src.fNumVerts;

	UInt16 oldSize[kNumValidChans];
	UInt8* oldData = fData;
	IRecordSizes(oldSize);

	UInt16 oldStride = IComputeStride();

	// First, allocate any storage we need. Kill any requested channels out of the
	// mask that we already have.
	chanMask = ICheckAlloc(src, chanMask, kPosition, sizeof(hsPoint3));

	chanMask = ICheckAlloc(src, chanMask, kWeight, sizeof(hsScalar) * src.fNumWeights);
	if( fChanSize[kWeight] )
		fNumWeights = src.fNumWeights;

	chanMask = ICheckAlloc(src, chanMask, kWgtIndex, sizeof(UInt32));

	chanMask = ICheckAlloc(src, chanMask, kNormal, sizeof(hsVector3));

	chanMask = ICheckAlloc(src, chanMask, kDiffuse, sizeof(UInt32));

	chanMask = ICheckAlloc(src, chanMask, kSpecular, sizeof(UInt32));

	chanMask = ICheckAlloc(src, chanMask, kUVW, sizeof(hsPoint3) * src.fNumUVWsPerVert);
	if( fChanSize[kUVW] )
		fNumUVWsPerVert = src.fNumUVWsPerVert;

	// If our chanMask has gone to zero, we've only been asked to record
	// channels we already have, so there's nothing to do.
	if( !chanMask )
		return 0;

	UInt16 newStride = IComputeStride();

	ISetupPointers(newStride);

	ICopyOldData(oldData, oldSize, oldStride, newStride);

	UInt8*	srcChannels[kNumValidChans];
	UInt8*	dstChannels[kNumValidChans];
	int chan;
	for( chan = 0; chan < kNumValidChans; chan++ )
	{
		srcChannels[chan] = src.fChannels[chan];
		dstChannels[chan] = fChannels[chan];
	}

	int i;
	for( i = 0; i < src.VertCount(); i++ )
	{
		for( chan = 0; chan < kNumValidChans; chan++ )
		{
			if( (1<< chan) & chanMask )
			{
				memcpy(dstChannels[chan], srcChannels[chan], fChanSize[chan]);
				dstChannels[chan] += fStrides[chan];
				srcChannels[chan] += src.fStrides[chan];
			}
		}
	}

	return chanMask;
}

UInt32 plAccessSnapShot::CopyTo(const plAccessVtxSpan& dst, UInt32 chanMask)
{
	hsAssert(fNumVerts == dst.fNumVerts, "Vertex count mismatch, is this our real source?");

	int chan; 
	for( chan = 0; chan < kNumValidChans; chan++ )
	{
		if( !(fChanSize[chan] && dst.fStrides[chan]) )
			chanMask &= ~(1 << chan);
	}
	// If chanMask has gone to zero, either we don't have any of the requested channels
	// recorded, or dst doesn't have them. Both being true is valid, but
	// us having a channel recorded that's not in dst is probably an error.
	if( !chanMask )
		return 0;

	int i;
	for( i = 0; i < fNumVerts; i++ )
	{
		for( chan = 0; chan < kNumValidChans; chan++ )
		{
			if( (1 << chan) & chanMask )
			{
				memcpy(
					dst.fChannels[chan] + dst.fStrides[chan] * i, 
					fChannels[chan] + fStrides[chan] * i, 
					fChanSize[chan]);
			}
		}
	}
	return chanMask;
}

void plAccessSnapShot::SetupChannels(plAccessVtxSpan& dst) const
{
	int chan;
	for( chan = 0; chan < kNumValidChans; chan++ )
	{
		if( fChanSize[chan] )
		{
			dst.fChannels[chan] = fChannels[chan];
			dst.fStrides[chan] = fStrides[chan];
			dst.fOffsets[chan] = 0;
		}
	}
}