Moved old implementations to src/old

4 files changed, 0 insertions, 1695 deletions

diff --git a/src/math/old/d3dmath.cpp b/src/math/old/d3dmath.cpp
deleted file mode 100644
index 2686215..0000000
--- a/src/math/old/d3dmath.cpp
+++ /dev/null
@@ -1,343 +0,0 @@
-// * This file is part of the COLOBOT source code

-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch

-// *

-// * 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/.

-

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

-// File: D3DMath.cpp

-//

-// Desc: Shortcut macros and functions for using DX objects

-//

-// Copyright (c) 1997-1999 Microsoft Corporation. All rights reserved

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

-#define D3D_OVERLOADS

-#define STRICT

-#include <math.h>

-#include <stdio.h>

-#include "d3dmath.h"

-

-

-

-

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

-// Name: D3DMath_MatrixMultiply()

-// Desc: Does the matrix operation: [Q] = [A] * [B]. Note that the order of

-//       this operation was changed from the previous version of the DXSDK.

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

-VOID D3DMath_MatrixMultiply( D3DMATRIX& q, D3DMATRIX& a, D3DMATRIX& b )

-{

-    FLOAT* pA = (FLOAT*)&a;

-    FLOAT* pB = (FLOAT*)&b;

-    FLOAT  pM[16];

-

-    ZeroMemory( pM, sizeof(D3DMATRIX) );

-

-    for( WORD i=0; i<4; i++ ) 

-        for( WORD j=0; j<4; j++ ) 

-            for( WORD k=0; k<4; k++ ) 

-                pM[4*i+j] +=  pA[4*i+k] * pB[4*k+j];

-

-    memcpy( &q, pM, sizeof(D3DMATRIX) );

-}

-

-

-

-

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

-// Name: D3DMath_MatrixInvert()

-// Desc: Does the matrix operation: [Q] = inv[A]. Note: this function only

-//       works for matrices with [0 0 0 1] for the 4th column.

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

-HRESULT D3DMath_MatrixInvert( D3DMATRIX& q, D3DMATRIX& a )

-{

-    if( fabs(a._44 - 1.0f) > .001f)

-        return E_INVALIDARG;

-    if( fabs(a._14) > .001f || fabs(a._24) > .001f || fabs(a._34) > .001f )

-        return E_INVALIDARG;

-

-    FLOAT fDetInv = 1.0f / ( a._11 * ( a._22 * a._33 - a._23 * a._32 ) -

-                             a._12 * ( a._21 * a._33 - a._23 * a._31 ) +

-                             a._13 * ( a._21 * a._32 - a._22 * a._31 ) );

-

-    q._11 =  fDetInv * ( a._22 * a._33 - a._23 * a._32 );

-    q._12 = -fDetInv * ( a._12 * a._33 - a._13 * a._32 );

-    q._13 =  fDetInv * ( a._12 * a._23 - a._13 * a._22 );

-    q._14 = 0.0f;

-

-    q._21 = -fDetInv * ( a._21 * a._33 - a._23 * a._31 );

-    q._22 =  fDetInv * ( a._11 * a._33 - a._13 * a._31 );

-    q._23 = -fDetInv * ( a._11 * a._23 - a._13 * a._21 );

-    q._24 = 0.0f;

-

-    q._31 =  fDetInv * ( a._21 * a._32 - a._22 * a._31 );

-    q._32 = -fDetInv * ( a._11 * a._32 - a._12 * a._31 );

-    q._33 =  fDetInv * ( a._11 * a._22 - a._12 * a._21 );

-    q._34 = 0.0f;

-

-    q._41 = -( a._41 * q._11 + a._42 * q._21 + a._43 * q._31 );

-    q._42 = -( a._41 * q._12 + a._42 * q._22 + a._43 * q._32 );

-    q._43 = -( a._41 * q._13 + a._42 * q._23 + a._43 * q._33 );

-    q._44 = 1.0f;

-

-    return S_OK;

-}

-

-

-

-

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

-// Name: D3DMath_VectorMatrixMultiply()

-// Desc: Multiplies a vector by a matrix

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

-HRESULT D3DMath_VectorMatrixMultiply( D3DVECTOR& vDest, D3DVECTOR& vSrc,

-                                      D3DMATRIX& mat)

-{

-    FLOAT x = vSrc.x*mat._11 + vSrc.y*mat._21 + vSrc.z* mat._31 + mat._41;

-    FLOAT y = vSrc.x*mat._12 + vSrc.y*mat._22 + vSrc.z* mat._32 + mat._42;

-    FLOAT z = vSrc.x*mat._13 + vSrc.y*mat._23 + vSrc.z* mat._33 + mat._43;

-    FLOAT w = vSrc.x*mat._14 + vSrc.y*mat._24 + vSrc.z* mat._34 + mat._44;

-    

-    if( fabs( w ) < g_EPSILON )

-        return E_INVALIDARG;

-

-    vDest.x = x/w;

-    vDest.y = y/w;

-    vDest.z = z/w;

-

-    return S_OK;

-}

-

-

-

-

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

-// Name: D3DMath_VertexMatrixMultiply()

-// Desc: Multiplies a vertex by a matrix

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

-HRESULT D3DMath_VertexMatrixMultiply( D3DVERTEX& vDest, D3DVERTEX& vSrc,

-                                      D3DMATRIX& mat )

-{

-    HRESULT    hr;

-    D3DVECTOR* pSrcVec  = (D3DVECTOR*)&vSrc.x;

-    D3DVECTOR* pDestVec = (D3DVECTOR*)&vDest.x;

-

-    if( SUCCEEDED( hr = D3DMath_VectorMatrixMultiply( *pDestVec, *pSrcVec,

-                                                      mat ) ) )

-    {

-        pSrcVec  = (D3DVECTOR*)&vSrc.nx;

-        pDestVec = (D3DVECTOR*)&vDest.nx;

-        hr = D3DMath_VectorMatrixMultiply( *pDestVec, *pSrcVec, mat );

-    }

-    return hr;

-}

-

-

-

-

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

-// Name: D3DMath_QuaternionFromRotation()

-// Desc: Converts a normalized axis and angle to a unit quaternion.

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

-VOID D3DMath_QuaternionFromRotation( FLOAT& x, FLOAT& y, FLOAT& z, FLOAT& w,

-                                     D3DVECTOR& v, FLOAT fTheta )

-{

-    x = sinf( fTheta/2.0f ) * v.x;

-    y = sinf( fTheta/2.0f ) * v.y;

-    z = sinf( fTheta/2.0f ) * v.z;

-    w = cosf( fTheta/2.0f );

-}

-

-

-

-

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

-// Name: D3DMath_RotationFromQuaternion()

-// Desc: Converts a normalized axis and angle to a unit quaternion.

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

-VOID D3DMath_RotationFromQuaternion( D3DVECTOR& v, FLOAT& fTheta,

-                                     FLOAT x, FLOAT y, FLOAT z, FLOAT w )

-                                      

-{

-    fTheta = acosf(w) * 2.0f;

-    v.x    = x / sinf( fTheta/2.0f );

-    v.y    = y / sinf( fTheta/2.0f );

-    v.z    = z / sinf( fTheta/2.0f );

-}

-

-

-

-

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

-// Name: D3DMath_QuaternionFromAngles()

-// Desc: Converts euler angles to a unit quaternion.

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

-VOID D3DMath_QuaternionFromAngles( FLOAT& x, FLOAT& y, FLOAT& z, FLOAT& w,

-                                   FLOAT fYaw, FLOAT fPitch, FLOAT fRoll )

-                                        

-{

-    FLOAT fSinYaw   = sinf( fYaw/2.0f );

-    FLOAT fSinPitch = sinf( fPitch/2.0f );

-    FLOAT fSinRoll  = sinf( fRoll/2.0f );

-    FLOAT fCosYaw   = cosf( fYaw/2.0f );

-    FLOAT fCosPitch = cosf( fPitch/2.0f );

-    FLOAT fCosRoll  = cosf( fRoll/2.0f );

-

-    x = fSinRoll * fCosPitch * fCosYaw - fCosRoll * fSinPitch * fSinYaw;

-    y = fCosRoll * fSinPitch * fCosYaw + fSinRoll * fCosPitch * fSinYaw;

-    z = fCosRoll * fCosPitch * fSinYaw - fSinRoll * fSinPitch * fCosYaw;

-    w = fCosRoll * fCosPitch * fCosYaw + fSinRoll * fSinPitch * fSinYaw;

-}

-

-

-

-

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

-// Name: D3DMath_MatrixFromQuaternion()

-// Desc: Converts a unit quaternion into a rotation matrix.

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

-VOID D3DMath_MatrixFromQuaternion( D3DMATRIX& mat, FLOAT x, FLOAT y, FLOAT z,

-                                   FLOAT w )

-{

-    FLOAT xx = x*x; FLOAT yy = y*y; FLOAT zz = z*z;

-    FLOAT xy = x*y; FLOAT xz = x*z; FLOAT yz = y*z;

-    FLOAT wx = w*x; FLOAT wy = w*y; FLOAT wz = w*z;

-    

-    mat._11 = 1 - 2 * ( yy + zz ); 

-    mat._12 =     2 * ( xy - wz );

-    mat._13 =     2 * ( xz + wy );

-

-    mat._21 =     2 * ( xy + wz );

-    mat._22 = 1 - 2 * ( xx + zz );

-    mat._23 =     2 * ( yz - wx );

-

-    mat._31 =     2 * ( xz - wy );

-    mat._32 =     2 * ( yz + wx );

-    mat._33 = 1 - 2 * ( xx + yy );

-

-    mat._14 = mat._24 = mat._34 = 0.0f;

-    mat._41 = mat._42 = mat._43 = 0.0f;

-    mat._44 = 1.0f;

-}

-

-

-

-

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

-// Name: D3DMath_QuaternionFromMatrix()

-// Desc: Converts a rotation matrix into a unit quaternion.

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

-VOID D3DMath_QuaternionFromMatrix( FLOAT& x, FLOAT& y, FLOAT& z, FLOAT& w,

-                                   D3DMATRIX& mat )

-{

-    if( mat._11 + mat._22 + mat._33 > 0.0f )

-    {

-        FLOAT s = sqrtf( mat._11 + mat._22 + mat._33 + mat._44 );

-

-        x = (mat._23-mat._32) / (2*s);

-        y = (mat._31-mat._13) / (2*s);

-        z = (mat._12-mat._21) / (2*s);

-        w = 0.5f * s;

-    }

-    else

-    {

-

-

-    }

-    FLOAT xx = x*x; FLOAT yy = y*y; FLOAT zz = z*z;

-    FLOAT xy = x*y; FLOAT xz = x*z; FLOAT yz = y*z;

-    FLOAT wx = w*x; FLOAT wy = w*y; FLOAT wz = w*z;

-    

-    mat._11 = 1 - 2 * ( yy + zz ); 

-    mat._12 =     2 * ( xy - wz );

-    mat._13 =     2 * ( xz + wy );

-

-    mat._21 =     2 * ( xy + wz );

-    mat._22 = 1 - 2 * ( xx + zz );

-    mat._23 =     2 * ( yz - wx );

-

-    mat._31 =     2 * ( xz - wy );

-    mat._32 =     2 * ( yz + wx );

-    mat._33 = 1 - 2 * ( xx + yy );

-

-    mat._14 = mat._24 = mat._34 = 0.0f;

-    mat._41 = mat._42 = mat._43 = 0.0f;

-    mat._44 = 1.0f;

-}

-

-

-

-

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

-// Name: D3DMath_QuaternionMultiply()

-// Desc: Mulitples two quaternions together as in {Q} = {A} * {B}.

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

-VOID D3DMath_QuaternionMultiply( FLOAT& Qx, FLOAT& Qy, FLOAT& Qz, FLOAT& Qw,

-                                  FLOAT Ax, FLOAT Ay, FLOAT Az, FLOAT Aw,

-                                  FLOAT Bx, FLOAT By, FLOAT Bz, FLOAT Bw )

-{

-    FLOAT Dx =  Ax*Bw + Ay*Bz - Az*By + Aw*Bx;

-    FLOAT Dy = -Ax*Bz + Ay*Bw + Az*Bx + Aw*By;

-    FLOAT Dz =  Ax*By - Ay*Bx + Az*Bw + Aw*Bz;

-    FLOAT Dw = -Ax*Bx - Ay*By - Az*Bz + Aw*Bw;

-

-    Qx = Dx; Qy = Dy; Qz = Dz; Qw = Dw;

-}

-

-

-

-

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

-// Name: D3DMath_SlerpQuaternions()

-// Desc: Compute a quaternion which is the spherical linear interpolation

-//       between two other quaternions by dvFraction.

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

-VOID D3DMath_QuaternionSlerp( FLOAT& Qx, FLOAT& Qy, FLOAT& Qz, FLOAT& Qw,

-                              FLOAT Ax, FLOAT Ay, FLOAT Az, FLOAT Aw,

-                              FLOAT Bx, FLOAT By, FLOAT Bz, FLOAT Bw,

-                              FLOAT fAlpha )

-{

-    // Compute dot product (equal to cosine of the angle between quaternions)

-    FLOAT fCosTheta = Ax*Bx + Ay*By + Az*Bz + Aw*Bw;

-

-    // Check angle to see if quaternions are in opposite hemispheres

-    if( fCosTheta < 0.0f ) 

-    {

-        // If so, flip one of the quaterions

-        fCosTheta = -fCosTheta;

-        Bx = -Bx; By = -By; Bz = -Bz; Bw = -Bw;

-    }

-

-    // Set factors to do linear interpolation, as a special case where the

-    // quaternions are close together.

-    FLOAT fBeta = 1.0f - fAlpha;

-    

-    // If the quaternions aren't close, proceed with spherical interpolation

-    if( 1.0f - fCosTheta > 0.001f ) 

-    {   

-        FLOAT fTheta = acosf( fCosTheta );

-        

-        fBeta  = sinf( fTheta*fBeta ) / sinf( fTheta);

-        fAlpha = sinf( fTheta*fAlpha ) / sinf( fTheta);

-    }

-

-    // Do the interpolation

-    Qx = fBeta*Ax + fAlpha*Bx;

-    Qy = fBeta*Ay + fAlpha*By;

-    Qz = fBeta*Az + fAlpha*Bz;

-    Qw = fBeta*Aw + fAlpha*Bw;

-}

-

-

-

-

diff --git a/src/math/old/d3dmath.h b/src/math/old/d3dmath.h
deleted file mode 100644
index 5d95290..0000000
--- a/src/math/old/d3dmath.h
+++ /dev/null
@@ -1,107 +0,0 @@
-// * This file is part of the COLOBOT source code

-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch

-// *

-// * 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/.

-

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

-// File: D3DMath.h

-//

-// Desc: Math functions and shortcuts for Direct3D programming.

-//

-// Copyright (c) 1997-1999 Microsoft Corporation. All rights reserved

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

-

-#pragma once

-

-#include <ddraw.h>

-#include <d3d.h>

-

-

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

-// Useful Math constants

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

-const FLOAT g_PI       =  3.14159265358979323846f; // Pi

-const FLOAT g_2_PI     =  6.28318530717958623200f; // 2 * Pi

-const FLOAT g_PI_DIV_2 =  1.57079632679489655800f; // Pi / 2

-const FLOAT g_PI_DIV_4 =  0.78539816339744827900f; // Pi / 4

-const FLOAT g_INV_PI   =  0.31830988618379069122f; // 1 / Pi

-const FLOAT g_DEGTORAD =  0.01745329251994329547f; // Degrees to Radians

-const FLOAT g_RADTODEG = 57.29577951308232286465f; // Radians to Degrees

-const FLOAT g_HUGE     =  1.0e+38f;                // Huge number for FLOAT

-const FLOAT g_EPSILON  =  1.0e-5f;                 // Tolerance for FLOATs

-

-

-

-

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

-// Fuzzy compares (within tolerance)

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

-//>>> func.h IsZero()

-inline bool D3DMath_IsZero( FLOAT a, FLOAT fTol = g_EPSILON )

-{ return ( a <= 0.0f ) ? ( a >= -fTol ) : ( a <= fTol ); }

-

-

-

-

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

-// Matrix functions

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

-//>>> matrix.h MultiplyMatrices()

-VOID    D3DMath_MatrixMultiply( D3DMATRIX& q, D3DMATRIX& a, D3DMATRIX& b );

-//>>> matrix.h Matrix::Invert()

-HRESULT D3DMath_MatrixInvert( D3DMATRIX& q, D3DMATRIX& a );

-

-

-

-

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

-// Vector functions

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

-

-//>>> matrix.h MatrixVectorMultiply()

-HRESULT D3DMath_VectorMatrixMultiply( D3DVECTOR& vDest, D3DVECTOR& vSrc,

-                                      D3DMATRIX& mat);

-// TODO

-HRESULT D3DMath_VertexMatrixMultiply( D3DVERTEX& vDest, D3DVERTEX& vSrc,

-                                      D3DMATRIX& mat );

-

-

-

-

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

-// Quaternion functions

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

-

-// UNUSED

-

-

-VOID D3DMath_QuaternionFromRotation( FLOAT& x, FLOAT& y, FLOAT& z, FLOAT& w,

-                                     D3DVECTOR& v, FLOAT fTheta );

-VOID D3DMath_RotationFromQuaternion( D3DVECTOR& v, FLOAT& fTheta,

-                                     FLOAT x, FLOAT y, FLOAT z, FLOAT w );

-VOID D3DMath_QuaternionFromAngles( FLOAT& x, FLOAT& y, FLOAT& z, FLOAT& w,

-                                   FLOAT fYaw, FLOAT fPitch, FLOAT fRoll );

-VOID D3DMath_MatrixFromQuaternion( D3DMATRIX& mat, FLOAT x, FLOAT y, FLOAT z,

-                                   FLOAT w );

-VOID D3DMath_QuaternionFromMatrix( FLOAT &x, FLOAT &y, FLOAT &z, FLOAT &w,

-                                   D3DMATRIX& mat );

-VOID D3DMath_QuaternionMultiply( FLOAT& Qx, FLOAT& Qy, FLOAT& Qz, FLOAT& Qw,

-                                 FLOAT Ax, FLOAT Ay, FLOAT Az, FLOAT Aw,

-                                 FLOAT Bx, FLOAT By, FLOAT Bz, FLOAT Bw );

-VOID D3DMath_QuaternionSlerp( FLOAT& Qx, FLOAT& Qy, FLOAT& Qz, FLOAT& Qw,

-                              FLOAT Ax, FLOAT Ay, FLOAT Az, FLOAT Aw,

-                              FLOAT Bx, FLOAT By, FLOAT Bz, FLOAT Bw,

-                              FLOAT fAlpha );

-

-

diff --git a/src/math/old/math3d.cpp b/src/math/old/math3d.cpp
deleted file mode 100644
index a9d67f2..0000000
--- a/src/math/old/math3d.cpp
+++ /dev/null
@@ -1,1197 +0,0 @@
-// * This file is part of the COLOBOT source code

-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch

-// *

-// * 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/.

-

-// math3d.cpp

-

-#define STRICT

-#define D3D_OVERLOADS

-

-#include <math.h>

-#include <stdio.h>

-#include <d3d.h>

-

-#include "graphics/d3d/d3dengine.h"

-#include "math/old/d3dmath.h"

-#include "graphics/d3d/d3dutil.h"

-#include "math/old/math3d.h"

-

-

-// Old defines

-#define MATH3D_PI				3.14159265358979323846f

-#define MATH3D_CHOUIA			1e-6f

-#define MATH3D_BEAUCOUP		1e6f

-

-

-// Old FPOINT struct

-struct FPOINT

-{

-	float	x;

-	float	y;

-

-	FPOINT() { }

-	FPOINT(float _x, float _y)

-	{

-		x = _x;

-		y = _y;

-	}

-};

-

-

-// === Functions already replaced by new implementation ===

-

-//>>> func.h IsEqual()

-bool		IsEqual(float a, float b);

-

-//>>> func.h Min()

-float		Min(float a, float b);

-float		Min(float a, float b, float c);

-float		Min(float a, float b, float c, float d);

-float		Min(float a, float b, float c, float d, float e);

-

-//>>> func.h Max()

-float		Max(float a, float b);

-float		Max(float a, float b, float c);

-float		Max(float a, float b, float c, float d);

-float		Max(float a, float b, float c, float d, float e);

-

-//>>> func.h Norm()

-float		Norm(float a);

-//>>> fabs()

-float		Abs(float a);

-

-//>>> func.h Swap()

-void		Swap(int &a, int &b);

-//>>> func.h Swap()

-void		Swap(float &a, float &b);

-//>>> point.h Swap()

-void		Swap(FPOINT &a, FPOINT &b);

-

-//>>> func.h Mod()

-float		Mod(float a, float m);

-//>>> func.h NormAngle()

-float		NormAngle(float angle);

-//>>> func.h TestAngle()

-bool		TestAngle(float angle, float min, float max);

-

-//>>> geometry.h RotateAngle()

-float		RotateAngle(FPOINT center, FPOINT p1, FPOINT p2);

-

-//>>> func.h Direction()

-float		Direction(float a, float g);

-

-//>>> geometry.h RotatePoint()

-FPOINT		RotatePoint(FPOINT center, float angle, FPOINT p);

-//>>> geometry.h RotatePoint()

-FPOINT		RotatePoint(float angle, FPOINT p);

-//>>> geometry.h RotatePoint()

-FPOINT		RotatePoint(float angle, float dist);

-//>>> geometry.h RotateAngle()

-float		RotateAngle(float x, float y);

-//>>> geometry.h RotatePoint()

-void		RotatePoint(float cx, float cy, float angle, float &px, float &py);

-

-//>>> geometry.h IsInsideTriangle()

-bool			IsInsideTriangle(FPOINT a, FPOINT b, FPOINT c, FPOINT p);

-

-//>>> point.h Distance()

-float		Length(FPOINT a, FPOINT b);

-

-//>>> point.h Point::Length()

-float		Length(float x, float y);

-

-//>>> func.h Rand()

-float		Rand();

-//>>> func.h Neutral()

-float		Neutral(float value, float dead);

-

-//>>> func.h PropAngle()

-float		Prop(int a, int b, float p);

-//>>> func.h Smooth()

-float		Smooth(float actual, float hope, float time);

-//>>> func.h Bounce()

-float		Bounce(float progress, float middle=0.3f, float bounce=0.4f);

-

-

-//>>> geometry.h SegmentPoint()

-D3DVECTOR	SegmentDist(const D3DVECTOR &p1, const D3DVECTOR &p2, float dist);

-

-//>>> geometry.h Intersect()

-bool			Intersect(D3DVECTOR a, D3DVECTOR b, D3DVECTOR c, D3DVECTOR d, D3DVECTOR e, D3DVECTOR &i);

-

-//>>> geometry.h IntersectY()

-bool			IntersectY(D3DVECTOR a, D3DVECTOR b, D3DVECTOR c, D3DVECTOR &p);

-

-//>>> geometry.h RotatePoint()

-void			RotatePoint(D3DVECTOR center, float angleH, float angleV, D3DVECTOR &p);

-

-//>>> geometry.h RotatePoint2()

-void			RotatePoint2(D3DVECTOR center, float angleH, float angleV, D3DVECTOR &p);

-

-//>>> geometry.h RotateView()

-D3DVECTOR	RotateView(D3DVECTOR center, float angleH, float angleV, float dist);

-

-//>>> geometry.h LookatPoint()

-D3DVECTOR	LookatPoint( D3DVECTOR eye, float angleH, float angleV, float length );

-

-//>>> vector.h Vector::Length()

-float		Length(const D3DVECTOR &u);

-

-//>>> vector.h Distance()

-float		Length(const D3DVECTOR &a, const D3DVECTOR &b);

-

-//>>> geometry.h DistanceProjected()

-float		Length2d(const D3DVECTOR &a, const D3DVECTOR &b);

-

-//>>> vector.h Angle()

-float		Angle( D3DVECTOR u, D3DVECTOR v );

-

-//>>> vector.h CrossProduct()

-D3DVECTOR	Cross( D3DVECTOR u, D3DVECTOR v );

-

-//>>> geometry.h NormalToPlane()

-D3DVECTOR	ComputeNormal( D3DVECTOR p1, D3DVECTOR p2, D3DVECTOR p3 );

-

-//>>> geometry.h Transform()

-D3DVECTOR	Transform(const D3DMATRIX &m, D3DVECTOR p);

-

-//>>> geometry.h Projection()

-D3DVECTOR	Projection(const D3DVECTOR &a, const D3DVECTOR &b, const D3DVECTOR &p);

-

-//>>> geometry.h DistanceToPlane()

-float		DistancePlanPoint(const D3DVECTOR &a, const D3DVECTOR &b, const D3DVECTOR &c, const D3DVECTOR &p);

-

-//>>> geometry.h IsSamePlane()

-bool			IsSamePlane(D3DVECTOR *plan1, D3DVECTOR *plan2);

-

-//>>> geometry.h LoadRotationXZYMatrix()

-void			MatRotateXZY(D3DMATRIX &mat, D3DVECTOR angle);

-

-//>>> geometry.h LoadRotationZXYMatrix()

-void			MatRotateZXY(D3DMATRIX &mat, D3DVECTOR angle);

-

-

-

-// UNUSED

-float		MidPoint(FPOINT a, FPOINT b, float px);

-

-// UNUSED

-bool		LineFunction(FPOINT p1, FPOINT p2, float &a, float &b);

-

-

-

-

-// Returns true if two numbers are nearly equal.

-

-bool IsEqual(float a, float b)

-{

-	return Abs(a-b) < MATH3D_CHOUIA;

-}

-

-

-// Returns the minimum value.

-

-float Min(float a, float b)

-{

-	if ( a <= b )  return a;

-	else           return b;

-}

-

-float Min(float a, float b, float c)

-{

-	return Min( Min(a,b), c );

-}

-

-float Min(float a, float b, float c, float d)

-{

-	return Min( Min(a,b), Min(c,d) );

-}

-

-float Min(float a, float b, float c, float d, float e)

-{

-	return Min( Min(a,b), Min(c,d), e );

-}

-

-

-// Returns the maximum value.

-

-float Max(float a, float b)

-{

-	if ( a >= b )  return a;

-	else           return b;

-}

-

-float Max(float a, float b, float c)

-{

-	return Max( Max(a,b), c );

-}

-

-float Max(float a, float b, float c, float d)

-{

-	return Max( Max(a,b), Max(c,d) );

-}

-

-float Max(float a, float b, float c, float d, float e)

-{

-	return Max( Max(a,b), Max(c,d), e );

-}

-

-

-// Returns the normalized value (0 .. 1).

-

-float Norm(float a)

-{

-	if ( a < 0.0f )  return 0.0f;

-	if ( a > 1.0f )  return 1.0f;

-	return a;

-}

-

-

-// Returns the absolute value of a number.

-

-float Abs(float a)

-{

-	return (float)fabs(a);

-}

-

-

-// Swaps two integers.

-

-void Swap(int &a, int &b)

-{

-	int		c;

-

-	c = a;

-	a = b;

-	b = c;

-}

-

-// Swaps two real numbers.

-

-void Swap(float &a, float &b)

-{

-	float	c;

-

-	c = a;

-	a = b;

-	b = c;

-}

-

-// Permutes two points.

-

-void Swap(FPOINT &a, FPOINT &b)

-{

-	FPOINT	c;

-

-	c = a;

-	a = b;

-	b = c;

-}

-

-// Returns the modulo of a floating point number.

-//	Mod(8.1, 4) = 0.1

-//	Mod(n, 1) = fractional part of n

-

-float Mod(float a, float m)

-{

-	return a - ((int)(a/m))*m;

-}

-

-// Returns a normalized angle, that is in other words between 0 and 2 * MATH3D_PI.

-

-float NormAngle(float angle)

-{

-	angle = Mod(angle, MATH3D_PI*2.0f);

-	if ( angle < 0.0f )

-	{

-		return MATH3D_PI*2.0f + angle;

-	}

-	else

-	{

-		return angle;

-	}

-}

-

-// Test if a angle is between two terminals.

-

-bool TestAngle(float angle, float min, float max)

-{

-	angle = NormAngle(angle);

-	min   = NormAngle(min);

-	max   = NormAngle(max);

-

-	if ( min > max )

-	{

-		return ( angle <= max || angle >= min );

-	}

-	else

-	{

-		return ( angle >= min && angle <= max );

-	}

-}

-

-

-// Calculates the angle to rotate the angle a to the angle g.

-// A positive angle is counterclockwise (CCW).

-

-float Direction(float a, float g)

-{

-	a = NormAngle(a);

-	g = NormAngle(g);

-

-	if ( a < g )

-	{

-		if ( a+MATH3D_PI*2.0f-g < g-a )  a += MATH3D_PI*2.0f;

-	}

-	else

-	{

-		if ( g+MATH3D_PI*2.0f-a < a-g )  g += MATH3D_PI*2.0f;

-	}

-	return (g-a);

-}

-

-

-// Rotates a point around a center.

-// The angle is in radians.

-// A positive angle is counterclockwise (CCW).

-

-FPOINT RotatePoint(FPOINT center, float angle, FPOINT p)

-{

-	FPOINT	a, b;

-

-	a.x = p.x-center.x;

-	a.y = p.y-center.y;

-

-	b.x = a.x*cosf(angle) - a.y*sinf(angle);

-	b.y = a.x*sinf(angle) + a.y*cosf(angle);

-

-	b.x += center.x;

-	b.y += center.y;

-	return b;

-}

-

-// Rotates a point around the origin.

-// The angle is in radians.

-// A positive angle is counterclockwise (CCW).

-

-FPOINT RotatePoint(float angle, FPOINT p)

-{

-	FPOINT	a;

-

-	a.x = p.x*cosf(angle) - p.y*sinf(angle);

-	a.y = p.x*sinf(angle) + p.y*cosf(angle);

-

-	return a;

-}

-

-// Rotates a vector (dist, 0).

-// The angle is in radians.

-// A positive angle is counterclockwise (CCW).

-

-FPOINT RotatePoint(float angle, float dist)

-{

-	FPOINT	a;

-

-	a.x = dist*cosf(angle);

-	a.y = dist*sinf(angle);

-

-	return a;

-}

-

-// Calculates the angle of a right triangle.

-// The angle is counterclockwise (CCW), between 0 and 2 * MATH3D_PI.

-// For an angle clockwise (CW), just go ahead.

-//

-//      ^

-//      |

-//    y o----o

-//      |  / |

-//      |/)a |

-//  ----o----o-->

-//      |    x 

-//      |

-

-float RotateAngle(float x, float y)

-{

-#if 1

-	if ( x == 0.0f && y == 0.0f )  return 0.0f;

-

-	if ( x >= 0.0f )

-	{

-		if ( y >= 0.0f )

-		{

-			if ( x > y )  return           atanf(y/x);

-			else          return MATH3D_PI*0.5f - atanf(x/y);

-		}

-		else

-		{

-			if ( x > -y )  return MATH3D_PI*2.0f + atanf(y/x);

-			else           return MATH3D_PI*1.5f - atanf(x/y);

-		}

-	}

-	else

-	{

-		if ( y >= 0.0f )

-		{

-			if ( -x > y )  return MATH3D_PI*1.0f + atanf(y/x);

-			else           return MATH3D_PI*0.5f - atanf(x/y);

-		}

-		else

-		{

-			if ( -x > -y )  return MATH3D_PI*1.0f + atanf(y/x);

-			else            return MATH3D_PI*1.5f - atanf(x/y);

-		}

-	}

-#else

-	float	angle;

-

-	if ( x == 0.0f )

-	{

-		if ( y > 0.0f )

-		{

-			return 90.0f*MATH3D_PI/180.0f;

-		}

-		else

-		{

-			return 270.0f*MATH3D_PI/180.0f;

-		}

-	}

-	else

-	{

-		angle = atanf(y/x);

-		if ( x < 0.0f )

-		{

-			angle += MATH3D_PI;

-		}

-		return angle;

-	}

-#endif

-}

-

-// Calculates the angle between two points and one center.

-// The angle is in radians.

-// A positive angle is counterclockwise (CCW).

-

-float RotateAngle(FPOINT center, FPOINT p1, FPOINT p2)

-{

-	float	a1, a2, a;

-

-	if ( p1.x == center.x &&

-		 p1.y == center.y )  return 0;

-

-	if ( p2.x == center.x &&

-		 p2.y == center.y )  return 0;

-

-	a1 = asinf((p1.y-center.y)/Length(p1,center));

-	a2 = asinf((p2.y-center.y)/Length(p2,center));

-

-	if ( p1.x < center.x )  a1 = MATH3D_PI-a1;

-	if ( p2.x < center.x )  a2 = MATH3D_PI-a2;

-

-	a = a2-a1;

-	if ( a < 0 )  a += MATH3D_PI*2;

-	return a;

-}

-

-// Returns py up on the line ab.

-

-float MidPoint(FPOINT a, FPOINT b, float px)

-{

-	if ( Abs(a.x-b.x) < MATH3D_CHOUIA )

-	{

-		if ( a.y < b.y )  return  MATH3D_BEAUCOUP;

-		else              return -MATH3D_BEAUCOUP;

-	}

-	return (b.y-a.y)*(px-a.x)/(b.x-a.x)+a.y;

-}

-

-// Advance "dist" along the segment p1-p2.

-

-D3DVECTOR SegmentDist(const D3DVECTOR &p1, const D3DVECTOR &p2, float dist)

-{

-	return p1+Normalize(p2-p1)*dist;

-}

-

-// Check if a point is inside a triangle.

-

-bool IsInsideTriangle(FPOINT a, FPOINT b, FPOINT c, FPOINT p)

-{

-	float	n, m;

-

-	if ( p.x < a.x && p.x < b.x && p.x < c.x )  return false;

-	if ( p.x > a.x && p.x > b.x && p.x > c.x )  return false;

-	if ( p.y < a.y && p.y < b.y && p.y < c.y )  return false;

-	if ( p.y > a.y && p.y > b.y && p.y > c.y )  return false;

-

-	if ( a.x > b.x )  Swap(a,b);

-	if ( a.x > c.x )  Swap(a,c);

-	if ( c.x < a.x )  Swap(c,a);

-	if ( c.x < b.x )  Swap(c,b);

-

-	n = MidPoint(a, b, p.x);

-	m = MidPoint(a, c, p.x);

-	if ( (n>p.y||p.y>m) && (n<p.y||p.y<m) )  return false;

-

-	n = MidPoint(c, b, p.x);

-	m = MidPoint(c, a, p.x);

-	if ( (n>p.y||p.y>m) && (n<p.y||p.y<m) )  return false;

-

-	return true;

-}

-

-// Calculates the intersection "i" right "of" the plan "abc".

-

-bool Intersect(D3DVECTOR a, D3DVECTOR b, D3DVECTOR c,

-			   D3DVECTOR d, D3DVECTOR e, D3DVECTOR &i)

-{

-	float	d1, d2;

-

-	d1 = (d.x-a.x)*((b.y-a.y)*(c.z-a.z)-(c.y-a.y)*(b.z-a.z)) -

-		 (d.y-a.y)*((b.x-a.x)*(c.z-a.z)-(c.x-a.x)*(b.z-a.z)) +

-		 (d.z-a.z)*((b.x-a.x)*(c.y-a.y)-(c.x-a.x)*(b.y-a.y));

-

-	d2 = (d.x-e.x)*((b.y-a.y)*(c.z-a.z)-(c.y-a.y)*(b.z-a.z)) -

-		 (d.y-e.y)*((b.x-a.x)*(c.z-a.z)-(c.x-a.x)*(b.z-a.z)) +

-		 (d.z-e.z)*((b.x-a.x)*(c.y-a.y)-(c.x-a.x)*(b.y-a.y));

-

-	if ( d2 == 0 )  return false;

-

-	i.x = d.x + d1/d2*(e.x-d.x);

-	i.y = d.y + d1/d2*(e.y-d.y);

-	i.z = d.z + d1/d2*(e.z-d.z);

-	return true;

-}

-

-// Calculates the intersection of the straight line passing through p (x, z)

-// parallel to the y axis, with the plane abc. Returns p.y.

-

-bool IntersectY(D3DVECTOR a, D3DVECTOR b, D3DVECTOR c, D3DVECTOR &p)

-{

-#if 0

-	D3DVECTOR	d,e,i;

-

-	d.x = p.x;

-	d.y = 0.0f;

-	d.z = p.z;

-	e.x = p.x;

-	e.y = 1.0f;

-	e.z = p.z;

-	if ( !Intersect(a,b,c,d,e,i) )  return false;

-	p.y = i.y;

-	return true;

-#else

-	float	d, d1, d2;

-

-	d  = (b.x-a.x)*(c.z-a.z) - (c.x-a.x)*(b.z-a.z);

-	d1 = (p.x-a.x)*(c.z-a.z) - (c.x-a.x)*(p.z-a.z);

-	d2 = (b.x-a.x)*(p.z-a.z) - (p.x-a.x)*(b.z-a.z);

-

-	if ( d == 0.0f )  return false;

-

-	p.y = a.y + d1/d*(b.y-a.y) + d2/d*(c.y-a.y);

-	return true;

-#endif

-}

-

-

-// Rotates a point around a center in the plan.

-// The angle is in radians.

-// A positive angle is counterclockwise (CCW).

-

-void RotatePoint(float cx, float cy, float angle, float &px, float &py)

-{

-	float	ax, ay;

-

-	px -= cx;

-	py -= cy;

-

-	ax = px*cosf(angle) - py*sinf(angle);

-	ay = px*sinf(angle) + py*cosf(angle);

-

-	px = cx+ax;

-	py = cy+ay;

-}

-

-// Rotates a point around a center in space.

-// The angle is in radians.

-// A positive angle is counterclockwise (CCW).

-

-void RotatePoint(D3DVECTOR center, float angleH, float angleV, D3DVECTOR &p)

-{

-	D3DVECTOR	a, b;

-

-	p.x -= center.x;

-	p.y -= center.y;

-	p.z -= center.z;

-

-	b.x = p.x*cosf(angleH) - p.z*sinf(angleH);

-	b.y = p.z*sinf(angleV) + p.y*cosf(angleV);

-	b.z = p.x*sinf(angleH) + p.z*cosf(angleH);

-

-	p.x = center.x+b.x;

-	p.y = center.y+b.y;

-	p.z = center.z+b.z;

-}

-

-// Rotates a point around a center in space.

-// The angle is in radians.

-// A positive angle is counterclockwise (CCW).

-

-void RotatePoint2(D3DVECTOR center, float angleH, float angleV, D3DVECTOR &p)

-{

-	D3DVECTOR	a, b;

-

-	p.x -= center.x;

-	p.y -= center.y;

-	p.z -= center.z;

-

-	a.x = p.x*cosf(angleH) - p.z*sinf(angleH);

-	a.y = p.y;

-	a.z = p.x*sinf(angleH) + p.z*cosf(angleH);

-

-	b.x = a.x;

-	b.y = a.z*sinf(angleV) + a.y*cosf(angleV);

-	b.z = a.z*cosf(angleV) - a.y*sinf(angleV);

-

-	p.x = center.x+b.x;

-	p.y = center.y+b.y;

-	p.z = center.z+b.z;

-}

-

-// Calculation point of view to look at a center

-// two angles and a distance.

-

-D3DVECTOR RotateView(D3DVECTOR center, float angleH, float angleV, float dist)

-{

-	D3DMATRIX	mat1, mat2, mat;

-	D3DVECTOR	eye;

-

-	D3DUtil_SetRotateZMatrix(mat1, -angleV);

-	D3DUtil_SetRotateYMatrix(mat2, -angleH);

-	D3DMath_MatrixMultiply(mat, mat1, mat2);

-

-	eye.x = 0.0f+dist;

-	eye.y = 0.0f;

-	eye.z = 0.0f;

-	eye = Transform(mat, eye);

-

-	return eye+center;

-}

-

-// Calculates the end point.

-

-D3DVECTOR LookatPoint( D3DVECTOR eye, float angleH, float angleV, float length )

-{

-	D3DVECTOR	lookat;

-

-	lookat = eye;

-	lookat.z += length;

-

-//?	RotatePoint(eye.x, eye.z, angleH, lookat.x, lookat.z);

-//?	RotatePoint(eye.z, eye.y, angleV, lookat.z, lookat.y);

-	RotatePoint(eye, angleH, angleV, lookat);

-

-	return lookat;

-}

-

-

-// Returns the distance between two points.

-

-float Length(FPOINT a, FPOINT b)

-{

-	return sqrtf( (a.x-b.x)*(a.x-b.x) +

-				  (a.y-b.y)*(a.y-b.y) );

-}

-

-// Returns the hypotenuse of a right triangle.

-

-float Length(float x, float y)

-{

-	return sqrtf( (x*x) + (y*y) );

-}

-

-// Returns the length of a vector.

-

-float Length(const D3DVECTOR &u)

-{

-	return sqrtf( (u.x*u.x) + (u.y*u.y) + (u.z*u.z) );

-}

-

-// Returns the distance between two points.

-

-float Length(const D3DVECTOR &a, const D3DVECTOR &b)

-{

-	return sqrtf( (a.x-b.x)*(a.x-b.x) +

-				  (a.y-b.y)*(a.y-b.y) +

-				  (a.z-b.z)*(a.z-b.z) );

-}

-

-// Returns the distance "a flat" between two points.

-

-float Length2d(const D3DVECTOR &a, const D3DVECTOR &b)

-{

-	return sqrtf( (a.x-b.x)*(a.x-b.x) +

-				  (a.z-b.z)*(a.z-b.z) );

-}

-

-

-// Returns the angle formed by two vectors.

-

-float Angle( D3DVECTOR u, D3DVECTOR v )

-{

-#if 0

-	return acosf( Abs(u.x*v.x + u.y*v.y + u.z*v.z) / (Length(u)*Length(v)) );

-#endif

-#if 0

-	float	d;

-	d = (u.y*v.z-u.z*v.y) + (u.z*v.x-u.x*v.z) + (u.x*v.y-u.y*v.x);

-	return asinf( Abs(d) / (Length(u)*Length(v)) );

-#endif

-#if 0

-	return asinf( Length(Cross(u,v)) / (Length(u)*Length(v)) );

-#endif

-#if 1

-	float	len, a, b;

-

-	len = Length(u)*Length(v);

-	a = acosf( (u.x*v.x + u.y*v.y + u.z*v.z) / len );

-	b = asinf( Length(Cross(u,v)) / len );

-	return a;

-#endif

-}

-

-// Returns the product of two vectors.

-

-D3DVECTOR Cross( D3DVECTOR u, D3DVECTOR v )

-{

-	return D3DVECTOR( u.y*v.z - u.z*v.y,

-					  u.z*v.x - u.x*v.z,

-					  u.x*v.y - u.y*v.x );

-}

-

-// Returns the normal vector of a triangular face.

-

-D3DVECTOR ComputeNormal( D3DVECTOR p1, D3DVECTOR p2, D3DVECTOR p3 )

-{

-	D3DVECTOR	u, v;

-

-	u = D3DVECTOR( p3.x-p1.x, p3.y-p1.y, p3.z-p1.z );

-	v = D3DVECTOR( p2.x-p1.x, p2.y-p1.y, p2.z-p1.z );

-

-	return Normalize(Cross(u, v));

-}

-

-

-// Transforms a point in a matrix, in exactly the same manner as Direct3D.

-

-D3DVECTOR Transform(const D3DMATRIX &m, D3DVECTOR p)

-{

-	D3DVECTOR	pp;

-

-	pp.x = p.x*m._11 + p.y*m._21 + p.z*m._31 + m._41;

-	pp.y = p.x*m._12 + p.y*m._22 + p.z*m._32 + m._42;

-	pp.z = p.x*m._13 + p.y*m._23 + p.z*m._33 + m._43;

-

-	return pp;

-}

-

-

-// Calculates the projection of a point P on a straight line AB.

-

-D3DVECTOR Projection(const D3DVECTOR &a, const D3DVECTOR &b, const D3DVECTOR &p)

-{

-	float		k;

-

-	k  = (b.x-a.x)*(p.x-a.x) + (b.y-a.y)*(p.y-a.y) + (b.z-a.z)*(p.z-a.z);

-	k /= (b.x-a.x)*(b.x-a.x) + (b.y-a.y)*(b.y-a.y) + (b.z-a.z)*(b.z-a.z);

-

-	return a + k*(b-a);

-}

-

-// The texture plate in the xz plane.

-

-void MappingObject(D3DVERTEX2* pVertices, int nb, float scale)

-{

-	int		i;

-

-	for ( i=0 ; i<nb ; i++ )

-	{

-		pVertices[i].tu = pVertices[i].x*scale;

-		pVertices[i].tv = pVertices[i].z*scale;

-	}

-}

-

-// Smooths normal.

-

-void SmoothObject(D3DVERTEX2* pVertices, int nb)

-{

-	char*		bDone;

-	int			index[100];

-	int			i, j, rank;

-	D3DVECTOR	sum;

-

-	bDone = (char*)malloc(nb*sizeof(char));

-	ZeroMemory(bDone, nb*sizeof(char));

-

-	for ( i=0 ; i<nb ; i++ )

-	{

-		bDone[i] = true;

-		rank = 0;

-		index[rank++] = i;

-

-		for ( j=0 ; j<nb ; j++ )

-		{

-			if ( bDone[j] )  continue;

-			if ( pVertices[j].x == pVertices[i].x &&

-				 pVertices[j].y == pVertices[i].y &&

-				 pVertices[j].z == pVertices[i].z )

-			{

-				bDone[j] = true;

-				index[rank++] = j;

-				if ( rank >= 100 )  break;

-			}

-		}

-

-		sum.x = 0;

-		sum.y = 0;

-		sum.z = 0;

-		for ( j=0 ; j<rank ; j++ )

-		{

-			sum.x += pVertices[index[j]].nx;

-			sum.y += pVertices[index[j]].ny;

-			sum.z += pVertices[index[j]].nz;

-		}

-		sum = Normalize(sum);

-

-		for ( j=0 ; j<rank ; j++ )

-		{

-			pVertices[index[j]].nx = sum.x;

-			pVertices[index[j]].ny = sum.y;

-			pVertices[index[j]].nz = sum.z;

-		}

-	}

-

-	free(bDone);

-}

-

-

-

-// Calculates the parameters a and b of the segment passing

-// through the points p1 and p2, knowing that:

-//		f(x) = ax+b

-// Returns false if the line is vertical.

-

-bool LineFunction(FPOINT p1, FPOINT p2, float &a, float &b)

-{

-	if ( D3DMath_IsZero(p1.x-p2.x) )

-	{

-		a = g_HUGE;  // infinite slope!

-		b = p2.x;

-		return false;

-	}

-

-	a = (p2.y-p1.y)/(p2.x-p1.x);

-	b = p2.y - p2.x*a;

-	return true;

-}

-

-

-// Calculates the distance between a plane ABC and a point P.

-

-float DistancePlanPoint(const D3DVECTOR &a, const D3DVECTOR &b,

-						const D3DVECTOR &c, const D3DVECTOR &p)

-{

-	D3DVECTOR	n;

-	float		aa,bb,cc,dd;

-

-	n = ComputeNormal(a,b,c);

-

-	aa = n.x;

-	bb = n.y;

-	cc = n.z;

-	dd = -(n.x*a.x + n.y*a.y + n.z*a.z);

-

-	return Abs(aa*p.x + bb*p.y + cc*p.z + dd);

-}

-

-// Check if two planes defined by 3 points are part of the same plan.

-

-bool IsSamePlane(D3DVECTOR *plan1, D3DVECTOR *plan2)

-{

-	D3DVECTOR	n1, n2;

-	float		dist;

-

-	n1 = ComputeNormal(plan1[0], plan1[1], plan1[2]);

-	n2 = ComputeNormal(plan2[0], plan2[1], plan2[2]);

-

-	if ( Abs(n1.x-n2.x) > 0.1f ||

-		 Abs(n1.y-n2.y) > 0.1f ||

-		 Abs(n1.z-n2.z) > 0.1f )  return false;

-

-	dist = DistancePlanPoint(plan1[0], plan1[1], plan1[2], plan2[0]);

-	if ( dist > 0.1f )  return false;

-

-	return true;

-}

-

-

-// Calculates the matrix to make three rotations in the X, Y and Z

-// >>>>>> OPTIMIZING!!!

-

-void MatRotateXZY(D3DMATRIX &mat, D3DVECTOR angle)

-{

-	D3DMATRIX	temp;

-

-	D3DUtil_SetRotateXMatrix(temp, angle.x);

-	D3DUtil_SetRotateZMatrix(mat, angle.z);

-	D3DMath_MatrixMultiply(mat, mat, temp);

-	D3DUtil_SetRotateYMatrix(temp, angle.y);

-	D3DMath_MatrixMultiply(mat, mat, temp);  // X-Z-Y

-}

-

-// Calculates the matrix to make three rotations in the order Z, X and Y.

-// >>>>>> OPTIMIZING!!!

-

-void MatRotateZXY(D3DMATRIX &mat, D3DVECTOR angle)

-{

-	D3DMATRIX	temp;

-

-	D3DUtil_SetRotateZMatrix(temp, angle.z);

-	D3DUtil_SetRotateXMatrix(mat, angle.x);

-	D3DMath_MatrixMultiply(mat, mat, temp);

-	D3DUtil_SetRotateYMatrix(temp, angle.y);

-	D3DMath_MatrixMultiply(mat, mat, temp);  // Z-X-Y

-}

-

-

-// Returns a random value between 0 and 1.

-

-float Rand()

-{

-	return (float)rand()/RAND_MAX;

-}

-

-

-// Managing the dead zone of a joystick.

-

-//  in:   -1            0            1

-//       --|-------|----o----|-------|-->

-//                      <---->

-//                       dead

-//  out:  -1       0         0       1

-

-float Neutral(float value, float dead)

-{

-	if ( Abs(value) <= dead )

-	{

-		return 0.0f;

-	}

-	else

-	{

-		if ( value > 0.0f )  return (value-dead)/(1.0f-dead);

-		else                 return (value+dead)/(1.0f-dead);

-	}

-}

-

-

-// Calculates a value (radians) proportional between a and b (degrees).

-

-float Prop(int a, int b, float p)

-{

-	float	aa, bb;

-

-	aa = (float)a*MATH3D_PI/180.0f;

-	bb = (float)b*MATH3D_PI/180.0f;

-

-	return aa+p*(bb-aa);

-}

-

-// Gently advanced a desired value from its current value.

-// Over time, the greater the progression is rapid.

-

-float Smooth(float actual, float hope, float time)

-{

-	float	futur;

-

-	futur = actual + (hope-actual)*time;

-

-	if ( hope > actual )

-	{

-		if ( futur > hope )  futur = hope;

-	}

-	if ( hope < actual )

-	{

-		if ( futur < hope )  futur = hope;

-	}

-

-	return futur;

-}

-

-

-// Bounces any movement.

-

-//	out

-//	 |

-//	1+------o-------o---

-//	 |    o | o   o |  | bounce

-//	 |   o  |   o---|---

-//	 |  o   |       |

-//	 | o    |       |

-//	-o------|-------+----> progress

-//	0|      |       1

-//	 |<---->|middle

-

-float Bounce(float progress, float middle, float bounce)

-{

-	if ( progress < middle )

-	{

-		progress = progress/middle;  // 0..1

-		return 0.5f+sinf(progress*MATH3D_PI-MATH3D_PI/2.0f)/2.0f;

-	}

-	else

-	{

-		progress = (progress-middle)/(1.0f-middle);  // 0..1

-		return (1.0f-bounce/2.0f)+sinf((0.5f+progress*2.0f)*MATH3D_PI)*(bounce/2.0f);

-	}

-}

-

-

-// Returns the color corresponding D3DCOLOR.

-

-D3DCOLOR RetColor(float intensity)

-{

-	D3DCOLOR	color;

-

-	if ( intensity <= 0.0f )  return 0x00000000;

-	if ( intensity >= 1.0f )  return 0xffffffff;

-

-	color  = (int)(intensity*255.0f)<<24;

-	color |= (int)(intensity*255.0f)<<16;

-	color |= (int)(intensity*255.0f)<<8;

-	color |= (int)(intensity*255.0f);

-

-	return color;

-}

-

-// Returns the color corresponding D3DCOLOR.

-

-D3DCOLOR RetColor(D3DCOLORVALUE intensity)

-{

-	D3DCOLOR	color;

-

-	color  = (int)(intensity.a*255.0f)<<24;

-	color |= (int)(intensity.r*255.0f)<<16;

-	color |= (int)(intensity.g*255.0f)<<8;

-	color |= (int)(intensity.b*255.0f);

-

-	return color;

-}

-

-// Returns the color corresponding D3DCOLORVALUE.

-

-D3DCOLORVALUE RetColor(D3DCOLOR intensity)

-{

-	D3DCOLORVALUE	color;

-

-	color.r = (float)((intensity>>16)&0xff)/256.0f;

-	color.g = (float)((intensity>>8 )&0xff)/256.0f;

-	color.b = (float)((intensity>>0 )&0xff)/256.0f;

-	color.a = (float)((intensity>>24)&0xff)/256.0f;

-

-	return color;

-}

-

-

-// RGB to HSV conversion.

-

-void RGB2HSV(D3DCOLORVALUE src, ColorHSV &dest)

-{

-	float	min, max, delta;

-

-	min = Min(src.r, src.g, src.b);

-	max = Max(src.r, src.g, src.b);

-

-	dest.v = max;  // intensity

-

-	if ( max == 0.0f )

-	{

-		dest.s = 0.0f;  // saturation

-		dest.h = 0.0f;  // undefined color!

-	}

-	else

-	{

-		delta = max-min;

-		dest.s = delta/max;  // saturation

-

-		if ( src.r == max )  // between yellow & magenta

-		{

-			dest.h = (src.g-src.b)/delta;

-		}

-		else if ( src.g == max )  // between cyan & yellow

-		{

-			dest.h = 2.0f+(src.b-src.r)/delta;

-		}

-		else  // between magenta & cyan

-		{

-			dest.h = 4.0f+(src.r-src.g)/delta;

-		}

-

-		dest.h *= 60.0f;  // in degrees

-		if ( dest.h < 0.0f )  dest.h += 360.0f;

-		dest.h /= 360.0f;  // 0..1

-	}

-}

-

-// HSV to RGB conversion.

-

-void HSV2RGB(ColorHSV src, D3DCOLORVALUE &dest)

-{

-	int		i;

-	float	f,v,p,q,t;

-

-	src.h = Norm(src.h)*360.0f;

-	src.s = Norm(src.s);

-	src.v = Norm(src.v);

-

-	if ( src.s == 0.0f )  // zero saturation?

-	{

-		dest.r = src.v;

-		dest.g = src.v;

-		dest.b = src.v;  // gray

-	}

-	else

-	{

-		if ( src.h == 360.0f )  src.h = 0.0f;

-		src.h /= 60.0f;

-		i = (int)src.h;  // integer part (0 .. 5)

-		f = src.h-i;     // fractional part

-

-		v = src.v;

-		p = src.v*(1.0f-src.s);

-		q = src.v*(1.0f-(src.s*f));

-		t = src.v*(1.0f-(src.s*(1.0f-f)));

-

-		switch (i)

-		{

-			case 0:  dest.r=v; dest.g=t; dest.b=p;  break;

-			case 1:  dest.r=q; dest.g=v; dest.b=p;  break;

-			case 2:  dest.r=p; dest.g=v; dest.b=t;  break;

-			case 3:  dest.r=p; dest.g=q; dest.b=v;  break;

-			case 4:  dest.r=t; dest.g=p; dest.b=v;  break;

-			case 5:  dest.r=v; dest.g=p; dest.b=q;  break;

-		}

-	}

-}

-

diff --git a/src/math/old/math3d.h b/src/math/old/math3d.h
deleted file mode 100644
index 5ef6f43..0000000
--- a/src/math/old/math3d.h
+++ /dev/null
@@ -1,48 +0,0 @@
-// * This file is part of the COLOBOT source code

-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch

-// *

-// * 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/.

-

-// math3d.h

-

-#pragma once

-

-

-#include <math.h>

-

-#include "common/struct.h"

-

-

-// TODO

-void			MappingObject( D3DVERTEX2* pVertices, int nb, float scale );

-

-// TODO

-void			SmoothObject( D3DVERTEX2* pVertices, int nb );

-

-// TODO

-D3DCOLOR		RetColor(float intensity);

-

-// TODO

-D3DCOLOR		RetColor(D3DCOLORVALUE intensity);

-

-// TODO

-D3DCOLORVALUE RetColor(D3DCOLOR intensity);

-

-// TODO

-void			RGB2HSV(D3DCOLORVALUE src, ColorHSV &dest);

-

-// TODO

-void			HSV2RGB(ColorHSV src, D3DCOLORVALUE &dest);

-

-