/*
BobToolz plugin for GtkRadiant
Copyright (C) 2001 Gordon Biggans

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library 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
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

// DPlane.cpp: implementation of the DPlane class.
//
//////////////////////////////////////////////////////////////////////

#include "DPlane.h"

#include <list>

#include "DPoint.h"
#include "DWinding.h"

#include "str.h"
#include "misc.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

DPlane::DPlane(const vec3_t va, const vec3_t vb, const vec3_t vc, const _QERFaceData* texData)
{
	MakeNormal( va, vb, vc, normal );
	if(VectorNormalize(normal, normal) == 0)	// normalizes and returns length
		globalErrorStream() << "DPlane::DPlane: Bad Normal.\n";

	_d = (normal[0]*va[0]) + (normal[1]*va[1]) + (normal[2]*va[2]);

	VectorCopy(va, points[0]);
	VectorCopy(vb, points[1]);
	VectorCopy(vc, points[2]);

	m_bChkOk = true;

	if(texData)
		memcpy(&texInfo, texData, sizeof(_QERFaceData));
	else
		FillDefaultTexture(&texInfo, points[0], points[1], points[2], "textures/common/caulk");
}

DPlane::~DPlane()
{

}

//////////////////////////////////////////////////////////////////////
// Implementation
//////////////////////////////////////////////////////////////////////

vec_t DPlane::DistanceToPoint(vec3_t pnt)
{
	vec3_t tmp;
	VectorSubtract(pnt, points[0], tmp);
	return DotProduct(tmp, normal);
}

bool DPlane::PlaneIntersection(DPlane *pl1, DPlane *pl2, vec3_t out)
{
	float a1, a2, a3;
	float b1, b2, b3;
	float c1, c2, c3;
	
	a1 = normal[0];			a2 = normal[1];			a3 = normal[2];
	b1 = pl1->normal[0];	b2 = pl1->normal[1];	b3 = pl1->normal[2];
	c1 = pl2->normal[0];	c2 = pl2->normal[1];	c3 = pl2->normal[2];

	float d = Determinant3x3(a1, a2, a3, b1, b2, b3, c1, c2, c3);

	if(d == 0)
		return false;
	
	float v1 = _d;
	float v2 = pl1->_d;
	float v3 = pl2->_d;

	float d1 = Determinant3x3(v1, a2, a3, v2, b2, b3, v3, c2, c3);
	float d2 = Determinant3x3(a1, v1, a3, b1, v2, b3, c1, v3, c3);
	float d3 = Determinant3x3(a1, a2, v1, b1, b2, v2, c1, c2, v3);

	out[0] = d1/d;	
	out[1] = d2/d;	
	out[2] = d3/d;	

	return true;
}

bool DPlane::IsRedundant(std::list<DPoint*>& pointList)
{
	int cnt = 0;

	//std::list<DPoint *>::const_iterator point=pointList.begin();
	for(std::list<DPoint *>::const_iterator point=pointList.begin(); point!=pointList.end(); point++)
	{
		 if(fabs(DistanceToPoint((*point)->_pnt)) < MAX_ROUND_ERROR)
			 cnt++;

		 if(cnt == 3)
			 return false;
	}
	return true;
}

bool DPlane::operator == (DPlane& other)
{
	vec3_t chk;
	VectorSubtract(other.normal, normal, chk);
	if(fabs(VectorLength(chk)) > MAX_ROUND_ERROR)
		return false;

	if(fabs(other._d - _d) > MAX_ROUND_ERROR)
		return false;

	return true;
}

bool DPlane::operator != (DPlane& other)
{
	vec3_t chk;
	VectorAdd(other.normal, normal, chk);
	if(fabs(VectorLength(chk)) > MAX_ROUND_ERROR)
		return false;

	return true;
}

DWinding* DPlane::BaseWindingForPlane()
{
	int		i, x;
	vec_t	max, v;
	vec3_t	org, vright, vup;
	
// find the major axis

	max = -131072;
	x = -1;
	for (i=0 ; i<3; i++)
	{
		v = (float)fabs(normal[i]);
		if (v > max)
		{
			x = i;
			max = v;
		}
	}
	if (x==-1)
		globalOutputStream() << "BaseWindingForPlane: no axis found";
		
	VectorCopy (vec3_origin, vup);	
	switch (x)
	{
	case 0:
	case 1:
		vup[2] = 1;
		break;		
	case 2:
		vup[0] = 1;
		break;		
	}

	v = DotProduct (vup, normal);
	VectorMA (vup, -v, normal, vup);
	VectorNormalize (vup, vup);
		
	VectorScale (normal, _d, org);
	
	CrossProduct (vup, normal, vright);
	
	VectorScale (vup, 131072, vup);
	VectorScale (vright, 131072, vright);

// project a really big	axis aligned box onto the plane
	DWinding* w = new DWinding;
	w->AllocWinding(4);
	
	VectorSubtract (org, vright, w->p[0]);
	VectorAdd (w->p[0], vup, w->p[0]);
	
	VectorAdd (org, vright, w->p[1]);
	VectorAdd (w->p[1], vup, w->p[1]);
	
	VectorAdd (org, vright, w->p[2]);
	VectorSubtract (w->p[2], vup, w->p[2]);
	
	VectorSubtract (org, vright, w->p[3]);
	VectorSubtract (w->p[3], vup, w->p[3]);
		
	return w;	
}

void DPlane::Rebuild()
{
	vec3_t v1, v2;
	VectorSubtract(points[0], points[1], v1);
	VectorSubtract(points[2], points[1], v2);
	CrossProduct(v1, v2, normal);

	if(VectorNormalize(normal, normal) == 0)	// normalizes and returns length
		globalErrorStream() << "DPlane::Rebuild: Bad Normal.\n";

	_d = (normal[0]*points[0][0]) + (normal[1]*points[0][1]) + (normal[2]*points[0][2]);

	VectorCopy(points[0], texInfo.m_p0);
	VectorCopy(points[1], texInfo.m_p1);
	VectorCopy(points[2], texInfo.m_p2);
}

bool DPlane::AddToBrush(scene::Node& brush)
{
  bool changed = false;
  if(!(m_bChkOk || !strcmp(m_shader.c_str(), "textures/common/caulk")))
  {
	  m_shader = "textures/common/caulk";
    changed = true;
  }

  _QERFaceData faceData;
  faceData.m_p0 = vector3_from_array(points[0]);
  faceData.m_p1 = vector3_from_array(points[1]);
  faceData.m_p2 = vector3_from_array(points[2]);
  faceData.m_texdef = texInfo.m_texdef;
  faceData.m_shader = m_shader.c_str();
  GlobalBrushCreator().Brush_addFace(brush, faceData);

	return changed;
}

void DPlane::ScaleTexture()
{ }

DPlane::DPlane(const vec3_t va, const vec3_t vb, const vec3_t vc, const char* textureName, bool bDetail)
{
	vec3_t v1, v2;
	VectorSubtract(va, vb, v1);
	VectorSubtract(vc, vb, v2);
	CrossProduct(v1, v2, normal);

	if(VectorNormalize(normal, normal) == 0)	// normalizes and returns length
		globalErrorStream() << "DPlane::DPlane: Bad Normal.\n";

	_d = (normal[0]*va[0]) + (normal[1]*va[1]) + (normal[2]*va[2]);

	VectorCopy(va, points[0]);
	VectorCopy(vb, points[1]);
	VectorCopy(vc, points[2]);

	m_bChkOk = true;

	FillDefaultTexture(&texInfo, points[0], points[1], points[2], textureName);
	if(bDetail)
		texInfo.contents |= FACE_DETAIL;
}