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

#include "hsStream.h"
#include "hsMemory.h"

#include "plAccessGeometry.h"
#include "plAccessSpan.h"
#include "plAccessVtxSpan.h"
#include "plGeometrySpan.h"

#include "plTweak.h"

static const hsScalar kMinWeight = 1.e-2f;

plMorphSpan::plMorphSpan()
:	fUVWs(nil),
	fNumUVWChans(0)
{
}

plMorphSpan::~plMorphSpan()
{
	delete [] fUVWs;
}

plMorphDelta::plMorphDelta()
:	fWeight(0)
{
}

plMorphDelta::~plMorphDelta()
{
}

plMorphDelta::plMorphDelta(const plMorphDelta& src)
{
	*this = src;
}

plMorphDelta& plMorphDelta::operator=(const plMorphDelta& src)
{
	SetNumSpans(src.GetNumSpans());
	int i;
	for( i = 0; i < fSpans.GetCount(); i++ )
	{
		SetDeltas(i, src.fSpans[i].fDeltas, src.fSpans[i].fNumUVWChans, src.fSpans[i].fUVWs);
	}
	return *this;
}

void plMorphDelta::Apply(hsTArray<plAccessSpan>& dst, hsScalar weight /* = -1.f */) const
{
	if( weight == -1.f)
		weight = fWeight; // None passed in, use our stored value

	if( weight <= kMinWeight )
		return;

	// Easy
	// For each span
	int iSpan;
	for( iSpan = 0; iSpan < fSpans.GetCount(); iSpan++ )
	{
		plAccessVtxSpan& vtxDst = dst[iSpan].AccessVtx();

		plMorphSpan& span = fSpans[iSpan];

		// For each vertDelta
		const hsPoint3* uvwDel = span.fUVWs;
		int iDelta;
		for( iDelta = 0; iDelta < span.fDeltas.GetCount(); iDelta++ )
		{
			const plVertDelta& delta = span.fDeltas[iDelta];
			// Add delPos * wgt to position
			// Add delNorm * wgt to normal
			vtxDst.Position(delta.fIdx) += delta.fPos * weight;
			vtxDst.Normal(delta.fIdx) += delta.fNorm * weight;

			// Leave skin weights and indices alone?

			// Skip color for now, since diffuse and specular are
			// ignored on the avatar?
			// // Add delDiff * wgt to diffuse
			// // Add delSpec * wgt to specular

			// For each UVW
			hsPoint3* uvws = vtxDst.UVWs(delta.fIdx);
			int iUVW;
			for( iUVW = 0; iUVW < span.fNumUVWChans; iUVW++ )
			{
				// Add delUVW * wgt to uvw
				*uvws += *uvwDel * weight;
				uvws++;
				uvwDel++;
			}
		}
	}
}

// MorphDelta - ComputeDeltas
void plMorphDelta::ComputeDeltas(const hsTArray<plAccessSpan>& base, const hsTArray<plAccessSpan>& moved)
{
	SetNumSpans(base.GetCount());

	// For each span
	{
		// for( i = 0; i < numVerts; i++ )
		{
			// NOTE: we want to discard zero deltas, but a
			// delta in any channel forces us to save the whole thing.
			// But we don't want to compare to zero (because we'll end
			// up with a lot of near zero deltas), but the epsilon we
			// compare to needs to be different for comparing something
			// like a normal delta and a position delta.
			//
			// For position, normal, color and all uvws
			// Calc del and delLenSq
			// If any delLenSq big enough, set nonZero to true
			// If nonZero
			{
				// Append to deltas (i, del's)
			}
		}
	}
}

// MorphDelta - ComputeDeltas
void plMorphDelta::ComputeDeltas(const hsTArray<plGeometrySpan*>& base, const hsTArray<plGeometrySpan*>& moved, const hsMatrix44& d2b, const hsMatrix44& d2bTInv)
{
	SetNumSpans(base.GetCount());

	hsPoint3 delUVWs[8];

	// For each span
	int iSpan;
	for( iSpan = 0; iSpan < base.GetCount(); iSpan++ )
	{
		plAccessSpan baseAcc;
		plAccessGeometry::Instance()->AccessSpanFromGeometrySpan(baseAcc, base[iSpan]);
		plAccessSpan movedAcc;
		plAccessGeometry::Instance()->AccessSpanFromGeometrySpan(movedAcc, moved[iSpan]);

		plAccPosNormUVWIterator baseIter(&baseAcc.AccessVtx());
		plAccPosNormUVWIterator movedIter(&movedAcc.AccessVtx());


		plMorphSpan& dst = fSpans[iSpan];

		const UInt16 numUVWs = baseAcc.AccessVtx().NumUVWs();

		hsTArray<plVertDelta> deltas;
		hsTArray<hsPoint3> uvws;
		deltas.SetCount(0);
		uvws.SetCount(0);


		int iVert = 0;;
		for( baseIter.Begin(), movedIter.Begin(); baseIter.More(); baseIter.Advance(), movedIter.Advance() )
		{
			// NOTE: we want to discard zero deltas, but a
			// delta in any channel forces us to save the whole thing.
			// But we don't want to compare to zero (because we'll end
			// up with a lot of near zero deltas), but the epsilon we
			// compare to needs to be different for comparing something
			// like a normal delta and a position delta.
			//
			// For position, normal, color and all uvws
			// Calc del and delLenSq
			// If any delLenSq big enough, set nonZero to true
			hsBool nonZero = false;

			// These are actually min del SQUARED.
			plConst(hsScalar) kMinDelPos(1.e-4f); // From Budtpueller's Handbook of Constants
			plConst(hsScalar) kMinDelNorm(3.e-2f); // About 10 degrees
			plConst(hsScalar) kMinDelUVW(1.e-4f); // From BHC
			hsPoint3 mPos = d2b * *movedIter.Position();
			hsVector3 delPos( &mPos, baseIter.Position());
			hsScalar delPosSq = delPos.MagnitudeSquared();
			if( delPosSq > kMinDelPos )
				nonZero = true;
			else
				delPos.Set(0,0,0);


			hsVector3 delNorm = (d2bTInv * *movedIter.Normal()) - *baseIter.Normal();
			hsScalar delNormSq = delNorm.MagnitudeSquared();
			if( delNormSq > kMinDelNorm )
				nonZero = true;
			else
				delNorm.Set(0,0,0);

			int i;
			for( i = 0; i < numUVWs; i++ )
			{
				delUVWs[i] = *movedIter.UVW(i) - *baseIter.UVW(i);
				hsScalar delUVWSq = delUVWs[i].MagnitudeSquared();
				if( delUVWSq > kMinDelUVW )
					nonZero = true;
				else
					delUVWs[i].Set(0,0,0);
			}

			if( nonZero )
			{
				// Append to deltas (i, del's)
				plVertDelta del;
				del.fIdx = iVert;
				del.fPos = delPos;
				del.fNorm = delNorm;
				deltas.Append(del);

				for( i = 0; i < numUVWs; i++ )
					uvws.Append(delUVWs[i]);
			}
			else
			{
				nonZero = false; // Breakpoint.
			}

			iVert++;
		}
		SetDeltas(iSpan, deltas, numUVWs, uvws.AcquireArray());
	}
}

void plMorphDelta::SetNumSpans(int n)
{
	fSpans.Reset();
	fSpans.SetCount(n);
}


void plMorphDelta::AllocDeltas(int iSpan, int nDel, int nUVW)
{
	fSpans[iSpan].fDeltas.SetCount(nDel);
	fSpans[iSpan].fNumUVWChans = nUVW;

	delete [] fSpans[iSpan].fUVWs;

	int uvwCnt = nDel * nUVW;
	if( uvwCnt )
		fSpans[iSpan].fUVWs = TRACKED_NEW hsPoint3[uvwCnt];
	else
		fSpans[iSpan].fUVWs = nil;
}

void plMorphDelta::SetDeltas(int iSpan, const hsTArray<plVertDelta>& deltas, int numUVWChans, const hsPoint3* uvws)
{
	AllocDeltas(iSpan, deltas.GetCount(), numUVWChans);
	if( deltas.GetCount() )
	{
		HSMemory::BlockMove(&deltas[0], fSpans[iSpan].fDeltas.AcquireArray(), deltas.GetCount() * sizeof(plVertDelta));

		if( numUVWChans )
			HSMemory::BlockMove(uvws, fSpans[iSpan].fUVWs, deltas.GetCount() * numUVWChans * sizeof(*uvws));
	}
}

void plMorphDelta::Read(hsStream* s, hsResMgr* mgr)
{
	fWeight = s->ReadSwapScalar();

	int n = s->ReadSwap32();
	SetNumSpans(n);
	int iSpan;
	for( iSpan = 0; iSpan < n; iSpan++ )
	{
		int nDel = s->ReadSwap32();
		int nUVW = s->ReadSwap32();
		AllocDeltas(iSpan, nDel, nUVW);
		if( nDel )
		{
			s->Read(nDel * sizeof(plVertDelta), fSpans[iSpan].fDeltas.AcquireArray());
			if( nUVW )
				s->Read(nDel * nUVW * sizeof(hsPoint3), fSpans[iSpan].fUVWs);
		}
	}

}

void plMorphDelta::Write(hsStream* s, hsResMgr* mgr)
{
	s->WriteSwapScalar(fWeight);

	s->WriteSwap32(fSpans.GetCount());

	int iSpan;
	for( iSpan = 0; iSpan < fSpans.GetCount(); iSpan++ )
	{
		int nDel = fSpans[iSpan].fDeltas.GetCount();
		int nUVW = fSpans[iSpan].fNumUVWChans;
		s->WriteSwap32(nDel);
		s->WriteSwap32(nUVW);

		if( nDel )
		{
			// Initialize our padding here, so we don't write random data
			for (int i = 0; i < nDel; i++)
			{
				plVertDelta& delta = fSpans[iSpan].fDeltas[i];
				delta.fPadding = 0;
			}

			s->Write(nDel * sizeof(plVertDelta), fSpans[iSpan].fDeltas.AcquireArray());

			if( nUVW )
				s->Write(nDel * nUVW * sizeof(hsPoint3), fSpans[iSpan].fUVWs);
		}
	}
}