khanat-opennel-code/code/nel/tools/pacs/build_rbank/surface_splitter.cpp

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#include "surface_splitter.h"

using namespace std;
using namespace NLMISC;
using namespace NLPACS;

// -----------------------
//

// Constructor
CSurfaceSplitter::CSurfaceSplitter()
{
}


//
void	CSurfaceSplitter::build(CLocalRetriever &lr)
{
	nlinfo("--- Build SurfaceSplitter...");
	nlinfo("------------------------------------------");
	uint	i;

	initEdgeGrid();

	_NumChains = 0;
	_NumSurfaces = 0;
	_NumTips = 0;

	for (i=0; i<lr.getChains().size(); ++i)
		buildChain(lr, i);

	for (i=0; i<lr.getSurfaces().size(); ++i)
		buildSurface(lr, i);

	nlinfo("converted %d chains & %d surfaces", lr.getChains().size(), lr.getSurfaces().size());
	_NumSurfaces = (uint)lr.getSurfaces().size();
	_NumChains = (uint)lr.getChains().size();

	//splitChains();

	dump();

	nlinfo("------------------------------------------");
}

//
void	CSurfaceSplitter::buildChain(CLocalRetriever &lr, uint chain)
{
	const NLPACS::CChain	&pacsChain = lr.getChain(chain);

	CSurfaceId				left = pacsChain.getLeft() >= 0 ? CSurfaceId(0, (uint16)pacsChain.getLeft()) : CSurfaceId();
	CSurfaceId				right = pacsChain.getRight() >= 0 ? CSurfaceId(0, (uint16)pacsChain.getRight()) : CSurfaceId();
	vector<CVector2s64>		vertices;

	uint	i;
	// walk through all subchains
	for (i=0; i<pacsChain.getSubChains().size(); ++i)
	{
		uint	ochain = pacsChain.getSubChain(i);
		const NLPACS::COrderedChain	&pacsOChain = lr.getOrderedChain(ochain);

		sint	j;
		// walk through subchain, forward or backward
		if (pacsOChain.isForward())
		{
			for (j=0; j<(sint)pacsOChain.getVertices().size()-1; ++j)
				vertices.push_back(CVector2s64(pacsOChain[j]));
		}
		else
		{
			for (j=(sint)pacsOChain.getVertices().size()-1; j>0; --j)
				vertices.push_back(CVector2s64(pacsOChain[j]));
		}

		// add final chain point
		if (i == pacsChain.getSubChains().size()-1)
			vertices.push_back(CVector2s64(pacsOChain[j]));
	}

	addChain(left,right, vertices);
}

//
void	CSurfaceSplitter::buildSurface(CLocalRetriever &lr, uint surface)
{
	const NLPACS::CRetrievableSurface	&pacsSurface = lr.getSurface(surface);
	CSurface							newSurface;

	newSurface.Id = CSurfaceId(0, surface);

	uint	i;
	// walk through all loops
	for (i=0; i<pacsSurface.getLoops().size(); ++i)
	{
		const NLPACS::CRetrievableSurface::TLoop	&pacsLoop = pacsSurface.getLoop(i);
		newSurface.Loops.push_back(CSurfaceSplitter::CLoop());
		newSurface.Loops.back().Surface = newSurface.Id;

		uint	j;
		// walk through loop
		for (j=0; j<pacsLoop.size(); ++j)
		{
			uint	chainIndex = pacsLoop[j];
			uint	chain = pacsSurface.getChain(chainIndex).Chain;

			newSurface.Loops.back().Chains.push_back(CChainId(chain));
		}
	}

	_Surfaces.insert(make_pair(newSurface.Id, newSurface));
}



//
void	CSurfaceSplitter::initEdgeGrid()
{
	_Edges.create(256, 2.0f);
}


//
void	CSurfaceSplitter::splitChains()
{
	nlinfo("Split chains...");

	uint	numInters = 0;
	uint	i;

	for (i=0; i<_NumChains; ++i)
	{
		TChainMap::iterator	it = _Chains.find(CChainId(i));
		if (it != _Chains.end())
			splitChain(it, numInters);
	}

	nlinfo("%d intersections found", numInters);
}

//
void	CSurfaceSplitter::splitChain(TChainMap::iterator it, uint &numInters)
{
	CChain	&chain = (*it).second;

	if (chain.DontSplit)
		return;

	uint	edge;
	// for each edge of the chain, test for other edges collision
	for (edge=0; edge<chain.Vertices.size()-1; ++edge)
	{
		CVector	p0 = chain.Vertices[edge].asVector();
		CVector	p1 = chain.Vertices[edge+1].asVector();
		CVector	pmin, pmax;
		pmin.minof(p0, p1);
		pmax.maxof(p0, p1);

		_Edges.select(pmin, pmax);

		CFixed64	closerDist(10.0);
		bool		collisionFound = false;
		CEdgeId		collidingEdge;
		CVector2s64	collision;

		TEdgeGrid::CIterator	it;
		for (it=_Edges.begin(); it!=_Edges.end(); ++it)
		{
			CEdgeId		iedge = *it;

			//
			if (chain.Id == iedge.Chain && (edge == iedge.Edge || edge+1 == iedge.Edge || edge-1 == iedge.Edge))
				continue;

			CChain		*ichain = getChain(iedge.Chain);

			if (ichain == NULL)
			{
				nlwarning("Couldn't find referenced chain %d", iedge.Chain.Id);
				continue;
			}

			if (ichain->DontSplit)
				continue;

			CVector2s64	inters;
			CFixed64	ndist;

			if (intersect(chain.Vertices[edge], chain.Vertices[edge+1], ichain->Vertices[iedge.Edge], ichain->Vertices[iedge.Edge+1], inters, ndist))
			{
				if (inters != chain.Vertices[edge+1] || edge != chain.Vertices.size()-2)
				{
					++numInters;
					nlinfo("Intersection: %d:%d[%.3f,%.3f-%.3f,%.3f]-%d:%d[%.3f,%.3f-%.3f,%.3f] : [%.3f,%.3f]", chain.Id.Id, edge, p0.x, p0.y, p1.x, p1.y, iedge.Chain.Id, iedge.Edge, ichain->Vertices[iedge.Edge].asVector().x, ichain->Vertices[iedge.Edge].asVector().y, ichain->Vertices[iedge.Edge+1].asVector().x, ichain->Vertices[iedge.Edge+1].asVector().y, inters.asVector().x, inters.asVector().y);

					if (closerDist > ndist)
					{
						collisionFound = true;
						collidingEdge = iedge;
						collision = inters;
					}
				}
				else
				{
					nlinfo("Intersection: %d:%d[%.3f,%.3f-%.3f,%.3f]-%d:%d[%.3f,%.3f-%.3f,%.3f] : [%.3f,%.3f] -- SKIPPED", chain.Id.Id, edge, p0.x, p0.y, p1.x, p1.y, iedge.Chain.Id, iedge.Edge, ichain->Vertices[iedge.Edge].asVector().x, ichain->Vertices[iedge.Edge].asVector().y, ichain->Vertices[iedge.Edge+1].asVector().x, ichain->Vertices[iedge.Edge+1].asVector().y, inters.asVector().x, inters.asVector().y);
				}
			}
		}

		// split chain
		if (collisionFound)
		{
			if (chain.Id == collidingEdge.Chain)
			{
				// self colliding chain

				// check order
				//nlassert(edge >= 0); // always true for unsigned
				nlassert(edge < collidingEdge.Edge);
				nlassert(collidingEdge.Edge < chain.Vertices.size()-1);

				// must split the chain in 3 parts
				uint				e;
				vector<CVector2s64>	begin;
				vector<CVector2s64>	middle;
				vector<CVector2s64>	end;
				vector<CChainId>	v;
				CChainId			beginId;
				CChainId			middleId;
				CChainId			endId;

				for (e=0; e<=edge; ++e)
					begin.push_back(chain.Vertices[e]);

				begin.push_back(collision);

				if (collision != chain.Vertices[e])
					middle.push_back(collision);

				for (; e<=collidingEdge.Edge; ++e)
					middle.push_back(chain.Vertices[e]);

				middle.push_back(collision);

				if (collision != chain.Vertices[e])
					end.push_back(collision);

				for (; e<chain.Vertices.size(); ++e)
					end.push_back(chain.Vertices[e]);

				beginId = addChain(chain.Left, chain.Right, begin, true);
				middleId = addChain(chain.Left, chain.Right, middle);
				endId = addChain(chain.Left, chain.Right, end);

				v.push_back(beginId);
				v.push_back(middleId);
				v.push_back(endId);

				replaceChain(chain.Id, v);
			}
			else
			{
				//nlassert(edge >= 0); // always true for unsigned
				nlassert(edge < chain.Vertices.size()-1);

				// split the chain
				uint				e;
				vector<CVector2s64>	begin;
				vector<CVector2s64>	end;
				vector<CChainId>	v;
				CChainId			beginId;
				CChainId			endId;

				// split the first chain
				for (e=0; e<=edge; ++e)
					begin.push_back(chain.Vertices[e]);

				begin.push_back(collision);

				if (collision != chain.Vertices[e])
					end.push_back(collision);

				for (; e<chain.Vertices.size(); ++e)
					end.push_back(chain.Vertices[e]);

				beginId = addChain(chain.Left, chain.Right, begin, true);
				endId = addChain(chain.Left, chain.Right, end);

				v.push_back(beginId);
				v.push_back(endId);

				replaceChain(chain.Id, v);

				// reset for second chain
				begin.clear();
				end.clear();
				v.clear();

				// split the second chain
				CChain	*collide = getChain(collidingEdge.Chain);

				for (e=0; e<=collidingEdge.Edge; ++e)
					begin.push_back(collide->Vertices[e]);

				begin.push_back(collision);

				if (collision != collide->Vertices[e])
					end.push_back(collision);

				for (; e<collide->Vertices.size(); ++e)
					end.push_back(collide->Vertices[e]);

				beginId = addChain(collide->Left, collide->Right, begin);
				endId = addChain(collide->Left, collide->Right, end);

				v.push_back(beginId);
				v.push_back(endId);

				replaceChain(collide->Id, v);
			}

			return;
		}
	}
}

//
bool	CSurfaceSplitter::intersect(const CVector2s64 &v0, const CVector2s64 &v1,
									const CVector2s64 &c0, const CVector2s64 &c1,
									CVector2s64 &intersect,
									CFixed64 &ndist)
{
	if (v0 == c0 || v0 == c1)
		return false;

	if (v1 == c0 || v1 == c1)
	{
		intersect = v1;
		ndist = CFixed64(1.0);
		return true;
	}

	CVector2s64		nnc(c0.y-c1.y, c1.x-c0.x),
					nnv(v0.y-v1.y, v1.x-v0.x);

	CFixed64		dv = (v1-v0)*nnc;

	// vectors are colinears ?
	if ((sint64)dv == 0)
		return false;

	CFixed64		nv = (c0-v0)*nnc;

	if ((sint64)dv < 0)
		dv=-dv, nv=-nv;
	// intersection outside main edge ? (or at first point ?)
	if ((sint64)nv<=0 || nv>dv)
		return false;

	CFixed64		dc = (c1-c0)*(c1-c0);
	// second edge null ?
	if ((sint64)dc == 0)
		return false;

	CFixed64		lv = nv/dv;

	if ((sint64)lv == 0)
		return false;

	CFixed64		nc = (v0-c0 + (v1-v0)*lv)*(c1-c0);
	// intersection outside colliding edge ?
	if ((sint64)nc<0 || nc>dc)
		return false;

	// treat each singular case
	if (nv == dv)
		intersect = v1;
	else if ((sint64)nc == 0)
		intersect = c0;
	else if (nc == dc)
		intersect = c1;
	else
		// compute intersecting point
		intersect = v0 + (v1-v0)*lv;

	ndist = lv;

	return true;
}



//
CSurfaceSplitter::CChainId	CSurfaceSplitter::addChain(const CSurfaceId &left, const CSurfaceId &right, const vector<CVector2s64> &points, bool dontSplit)
{
	pair<TChainMap::iterator, bool>	res = _Chains.insert(make_pair(CChainId(_NumChains++), CChain()));

	CChain	&chain = (*(res.first)).second;

	chain.Id = (*(res.first)).first;
	chain.Left = left;
	chain.Right = right;

	uint	i;
	for (i=0; i<points.size()-1; ++i)
	{
		if (points[i] == points[i+1])
		{
			nlwarning("--- !! points are together !! ---");
			nlstop;
		}
	}

	chain.Vertices = points;
	chain.DontSplit = dontSplit;

	uint	edge;
	for (edge=0; edge<chain.Vertices.size()-1; ++edge)
	{
		CVector	p0 = chain.Vertices[edge].asVector();
		CVector	p1 = chain.Vertices[edge+1].asVector();

		p0.z = -100.0f;
		p1.z = +100.0f;

		CVector	pmin, pmax;
		pmin.minof(p0, p1);
		pmax.maxof(p0, p1);

		chain.Iterators.push_back(_Edges.insert(pmin, pmax, CEdgeId(chain.Id, edge)));
	}

	return chain.Id;
}

//
void	CSurfaceSplitter::removeChain(CChainId chainId)
{
	// get chain it
	TChainMap::iterator	it = _Chains.find(chainId);

	if (it == _Chains.end())
		return;

	CChain	&chain = (*it).second;

	CSurface	*surf;
	
	if ((surf = getSurface(chain.Left)))
		surf->removeChain(chainId);

	if ((surf = getSurface(chain.Right)))
		surf->removeChain(chainId);
}

//
void	CSurfaceSplitter::replaceChain(CChainId chainId, const vector<CChainId> &chains)
{
	// get chain it
	TChainMap::iterator	it = _Chains.find(chainId);

	if ((it == _Chains.end()))
		return;

	CChain	&chain = (*it).second;

	CSurface	*surf;

	nlinfo("-- Replace --");
	dumpChain(chainId);
	nlinfo("-- By --");
	uint	c;
	for (c=0; c<chains.size(); ++c)
		dumpChain(chains[c]);
	nlinfo("-- End Replace --");
	
	if ((surf = getSurface(chain.Left)))
	{
		uint	loop;
		for (loop=0; loop<surf->Loops.size(); ++loop)
		{
			CLoop	&ploop = surf->Loops[loop];
			vector<CChainId>::iterator	it;
			for (it=ploop.Chains.begin(); it!=ploop.Chains.end(); ++it)
			{
				if (*it == chainId)
				{
					it = ploop.Chains.erase(it);
					sint	i;
					for (i=(sint)chains.size()-1; i>=0; --i)
					{
						it = ploop.Chains.insert(it, chains[i]);
					}
				}
			}
		}
	}

	if ((surf = getSurface(chain.Right)))
	{
		uint	loop;
		for (loop=0; loop<surf->Loops.size(); ++loop)
		{
			CLoop	&ploop = surf->Loops[loop];
			vector<CChainId>::iterator	it;
			for (it=ploop.Chains.begin(); it!=ploop.Chains.end(); ++it)
			{
				if (*it == chainId)
				{
					it = ploop.Chains.erase(it);
					uint	i;
					for (i=0; i<chains.size(); ++i)
					{
						it = ploop.Chains.insert(it, chains[i]);
					}
				}
			}
		}
	}

	uint	i;
	for (i=0; i<chain.Iterators.size(); ++i)
		_Edges.erase(chain.Iterators[i]);

	_Chains.erase(it);
}