inline LL triarea(plane::iterator x){
		LL res=0;
		if (x!=t.begin()) res+=traparea(pre(x),x);
		if (next(x)!=t.end()) res+=traparea(x,next(x));
		if (x!=t.begin() && next(x)!=t.end()) res+=traparea(next(x),pre(x));
		return res;
	}

Camera Camera::reflected(const plane& pl) const
{
    Camera result(*this);

    vec3 s = normalize(reflect(side(), pl.normal()));
    vec3 u = normalize(reflect(up(), pl.normal()));
    vec3 d = normalize(reflect(direction(), pl.normal()));
    vec3 p = pl.reflect(position());

    mat4 mv = _modelViewMatrix;
    mv[0][0] = s.x;
    mv[0][1] = u.x;
    mv[0][2] = d.x;
    mv[1][0] = s.y;
    mv[1][1] = u.y;
    mv[1][2] = d.y;
    mv[2][0] = s.z;
    mv[2][1] = u.z;
    mv[2][2] = d.z;
    mv[3] = vec4(-mv.rotationMultiply(p), mv[3][3]);

    result.unlockUpVector();
    result.setModelViewMatrix(mv);

    return result;
}

	inline int contain(int x,int y){
		plane :: iterator S=t.begin() , T=pre(t.end()) ;
		if (x<S->first || x>T->first) return 0;
		if (x==S->first) return y<=S->second;
		if (x==T->first) return y<=T->second;
		plane::iterator it=t.lower_bound(x) , p=pre(it);
		int x1=p->first , y1=p->second , x2=it->first , y2=it->second;
		return (LL)(y-y1)*(x2-x1) <= (LL)(y2-y1)*(x-x1);
	}

//Intersecao entre dois planos
pair<pt3, pt3> plane_intersect(plane u, plane v){
    pt3 p1 = u.n * u.d();
    pt3 uv = cross(u.n, v.n);
    pt3 uvu = cross(uv, u.n);
    
    if (!cmp(dot(v.n, uvu))) return mp(pt3(inf, inf), pt3(inf, inf)); //planos paralelos
    pt3 p2 = p1 - uvu * (dot(v.n, p1) - v.d()) / dot(v.n, uvu);
    return mp(p2, p2 + uv);
}

bool et::intersect::rayPlane(const ray3d& r, const plane& p, vec3* intersection_pt)
{
	float d = dot(r.direction, p.normal());
	if (d < 0.0f)
	{
		if (intersection_pt)
			*intersection_pt = r.origin + r.direction * dot(p.normal(), p.planePoint() - r.origin) / d;
		return true;
	}
	return false;
}

void setByplane(plane plane) {
	glLoadIdentity();
	plane->updateV();plane->doth2();
	float td=plane->thetha*toDg,ad=plane->alpha*toDg;
	glRotatef(-90,1,0,0);
	glRotatef(-plane->tht*toDg, 0.0f, 1.0f, 0.0f);
	glRotatef(-td,1,0,0);
	glRotatef(-ad, 0.0f, 1.0f, 0.0f);
	glTranslatef(-plane->cx,-plane->cy,-plane->cz); 

}

bool isZero(plane x, plane y) {
    if (!(x.vect(y) == 0 && x.scalar(y) < 0)) return false;
    point yy;
    if (y.a == 0) {
        yy.x = 0.0;
        yy.y = -y.c / (double)y.b;
    } else {
        yy.x = -y.c / (double)y.a;
        yy.y = 0.0;
    }
    return (x.a * yy.x + x.b * yy.y + x.c) <= 0;
}

plane convolve_vert( const plane &p, const std::vector<float> &k )
{
	if ( k.size() == 3 )
	{
		if ( base::equal( k[0], k[2] ) )
			return plane( "p.sep_conv3_mirror_v", p.dims(), p, k[0], k[1] );

		return plane( "p.sep_conv3_v", p.dims(), p, k[0], k[1], k[2] );
	}

	precondition( k.size() % 2 != 0, "non-odd-sized kernel {0}", k.size() );
	return plane( "p.sep_conv_v", p.dims(), p, k );
}

int cross(const line &l, const plane &pl,
          point &res) {
  ld d = sp(pl.n, l.v);
  if (sgn(d) == 0) {
    return (pl.side(l.p) == 0) ? 2 : 0;
  }
  ld t = (-sp(pl.n, l.p) - pl.d) / d;
  res = l.p + l.v * t;
  #ifdef DEBUG
  assert(pl.side(res) == 0);
  #endif
  return 1;
}

void timer(int v){
	//update planes position
	planeView.update();

	//set roll angles accoring to rate set by button press
	rollAngle = rollRate;
	pitchAngle = pitchRate;

	//compute roll and pitch
	planeView.Roll(rollAngle);
	planeView.Pitch(pitchAngle);

	glutPostRedisplay(); // trigger display function by sending redraw into message queue
	glutTimerFunc(1000 / nFPS, timer, v);
}

//--------------------------------------------------------------------------------------
// Release D3D11 resources created in OnD3D11CreateDevice 
//--------------------------------------------------------------------------------------
void CALLBACK OnD3D11DestroyDevice( void* pUserContext )
{
    g_DialogResourceManager.OnD3D11DestroyDevice();
    g_D3DSettingsDlg.OnD3D11DestroyDevice();
    //CDXUTDirectionWidget::StaticOnD3D11DestroyDevice();
    DXUTGetGlobalResourceCache().OnDestroyDevice();
	test.destroy();
	tessplane.destroy();
	lightsphere.destroy();
	tesscube.destroy();
	fuse.destroy();
	deboard.destroy();
	board1.destroy();
	geo_alien.destroy();
	FirePart.destroy();
    SAFE_DELETE( g_pTxtHelper );
	SAFE_RELEASE(g_DepthState);
    //g_Mesh11.Destroy();
    //            
    //SAFE_RELEASE( g_pVertexLayout11 );
    //SAFE_RELEASE( g_pVertexBuffer );
    //SAFE_RELEASE( g_pIndexBuffer );
    //SAFE_RELEASE( g_pVertexShader );
    //SAFE_RELEASE( g_pPixelShader );
    //SAFE_RELEASE( g_pSamLinear );

 /*   SAFE_RELEASE( g_pcbVSPerObject );
    SAFE_RELEASE( g_pcbPSPerObject );
    SAFE_RELEASE( g_pcbPSPerFrame );*/
}

    bool triangle<T,color_type>::intersects(const plane<T,color_type>& p) const
    {
        T unused;
        const point3<T>& pp = plane<T,color_type>::get_origin();
        point3<T> pu = plane<T,color_type>::get_origin() + plane<T,color_type>::get_u_vector();
        point3<T> pv = plane<T,color_type>::get_origin() + plane<T,color_type>::get_v_vector();

        if (p.quick_intersection( unit_line3<T>(pp, pu), 0, unused ) ||
            p.quick_intersection( unit_line3<T>(pp, pv), 0, unused ) ||
            p.quick_intersection( unit_line3<T>(pu, pv), 0, unused ))
        {
            return true;
        }

        return false;
    }

int apeq(const plane &pl1, const plane &pl2, vfloat prec)
{
  pvecerror("int apeq(const plane &pl1, const plane &pl2, vfloat prec)");
  if( check_par( pl1.dir, pl2.dir, prec) == 0 ) return 0;
  if( apeq( pl1.piv , pl2.piv, prec) == 1) return 1;
  if( pl1.check_point_in(pl2.piv, prec) == 1 ) return 1;
  else return 0;
}

int operator==(const plane &pl1, const plane &pl2)
{
  pvecerror("int operator==(const plane &pl1, const plane &pl2)");

  if( !(pl1.dir == pl2.dir || pl1.dir == -pl2.dir) ) return 0;
  if( pl1.piv == pl2.piv ) return 1;
  if( pl1.check_point_in(pl2.piv,0) == 1 ) return 1;
  else return 0;
}

plane::plane(const plane& _plane)
	: object(_plane)
	, l1(_plane.L1())
	, l2(_plane.L2())
	, xw(_plane.XW())
	, uw(_plane.UW())
	, u1(_plane.U1())
	, u2(_plane.U2())
	, pa(_plane.PA())
	, pb(_plane.PB())
{
	
}

bool isPP(plane x, plane y) {
//	cout << x.a << " " << x.b << " " << x.c << " " << y.a <<" "<< y.b <<" " << y.c << endl;
    if (x.vect(y) != 0) return false;
    point yy;
    if (y.a == 0) {
        yy.x = 0.0;
        yy.y = -y.c / (double)y.b;
    } else {
        yy.x = -y.c / (double)y.a;
        yy.y = 0.0;
    }
    return (x.a * yy.x + x.b * yy.y + x.c) > 0;
}

// Cutting point of three planes
Foam::point Foam::plane::planePlaneIntersect
(
    const plane& plane2,
    const plane& plane3
) const
{
    List<scalarList> pcs(3);
    pcs[0]= planeCoeffs();
    pcs[1]= plane2.planeCoeffs();
    pcs[2]= plane3.planeCoeffs();

    tensor a
    (
        pcs[0][0],pcs[0][1],pcs[0][2],
        pcs[1][0],pcs[1][1],pcs[1][2],
        pcs[2][0],pcs[2][1],pcs[2][2]
    );

    vector b(pcs[0][3],pcs[1][3],pcs[2][3]);

    return (inv(a) & (-b));
}

void
plane::
xformOrtho4 ( const plane& planeIn, const matrix4& mat )
{
	vec3 ptOn ( vec3::NoInit );
	planeIn.closestPtIn ( ptOn, 0.0, 0.0, 0.0 );
	
	normal.xformVec4 ( planeIn.normal, mat );
	normal.normalize ();
	ptOn.xformPt4 ( ptOn, mat );
	
	// just like in setNormPt, but without redundant set of normal
	// setNormPt ( normal, ptOn )
	offset = normal.dot ( ptOn );
}

	void insert(int x,int y){
		if (t.find(x)!=t.end()){
			if (y<=t[x]) return;
			area-=triarea(t.lower_bound(x));
			t.erase(x);
		}
		plane::iterator it=t.insert(make_pair(x,y)).first;
		if (check(it)){
			t.erase(it);
			return;
		}
		area+=triarea(it);
		while (check(pre(it))){
			area-=triarea(pre(it));
			t.erase(pre(it));
		}
		while (check(next(it))){
			area-=triarea(next(it));
			t.erase(next(it));
		}
	}

void render()
{
	fr.SetCameraPos(Camera.getPos());
	glm::mat4 view = Camera.getView();
	glm::mat4 projection = Camera.getProjection();
    glClearColor( 0.f, 0.f, 0.0f, 0.f );
	glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

	fr.render(view, projection);
	
    glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	pr.render(view,projection);
	pr2.render(view,projection);
	pr3.render(view,projection);
	glDisable(GL_BLEND);

	GBuffer::BindForWriting();
	glDepthMask(GL_TRUE);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LESS);

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glClearColor( 0.f, 0.f, 0.0f, 0.f );

	

    Plane.render(view,projection);
    
	glDisable(GL_DEPTH_TEST);

	GBuffer::DefaultBuffer();

	return;
}