Split math functions; beginning of common structures
Piotr Dziwinski
parent
449cc186d5
commit
d57258ae1c
|
|
@ -0,0 +1,150 @@
|
|||
// * This file is part of the COLOBOT source code
|
||||
// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
|
||||
// *
|
||||
// * 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/.
|
||||
|
||||
// color.cpp
|
||||
|
||||
#include "color.h"
|
||||
|
||||
// TODO
|
||||
|
||||
|
||||
// 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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
// * This file is part of the COLOBOT source code
|
||||
// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
|
||||
// *
|
||||
// * 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/.
|
||||
|
||||
// color.h
|
||||
|
||||
// TODO
|
||||
struct Color
|
||||
{
|
||||
};
|
||||
|
||||
#pragma once
|
||||
|
||||
D3DCOLOR RetColor(float intensity);
|
||||
D3DCOLOR RetColor(D3DCOLORVALUE intensity);
|
||||
D3DCOLORVALUE RetColor(D3DCOLOR intensity);
|
||||
|
||||
void RGB2HSV(D3DCOLORVALUE src, ColorHSV &dest);
|
||||
void HSV2RGB(ColorHSV src, D3DCOLORVALUE &dest);
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
// math/const.h
|
||||
|
||||
/* Math constants */
|
||||
|
||||
#pragma once
|
||||
|
||||
// Math module namespace
|
||||
namespace Math
|
||||
{
|
||||
//! Tolerance level -- minimum accepted float value
|
||||
const float TOLERANCE = 1e-6f;
|
||||
|
||||
//! PI
|
||||
const float PI = 3.14159265358979323846f;
|
||||
//! 2 * PI
|
||||
const float PI_MUL_2 = 6.28318530717958623200f;
|
||||
//! PI / 2
|
||||
const float PI_DIV_2 = 1.57079632679489655800f;
|
||||
//! PI / 4
|
||||
const float PI_DIV_4 = 0.78539816339744827900f;
|
||||
//! 1 / PI
|
||||
const float INV_PI = 0.31830988618379069122f;
|
||||
|
||||
//! Degrees to radians multiplier
|
||||
const float DEG_TO_RAD = 0.01745329251994329547f;
|
||||
//! Radians to degrees multiplier
|
||||
const FLOAT RAD_TO_DEG = 57.29577951308232286465f;
|
||||
};
|
||||
|
|
@ -0,0 +1,238 @@
|
|||
// math/func.h
|
||||
|
||||
/* Common math functions */
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "const.h"
|
||||
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
|
||||
namespace Math
|
||||
{
|
||||
|
||||
//! Compares a and b within TOLERANCE
|
||||
bool IsEqual(float a, float b)
|
||||
{
|
||||
return Abs(a - b) < TOLERANCE;
|
||||
}
|
||||
|
||||
//! Minimum
|
||||
inline float Min(float a, float b)
|
||||
{
|
||||
if ( a <= b ) return a;
|
||||
else return b;
|
||||
}
|
||||
|
||||
inline float Min(float a, float b, float c)
|
||||
{
|
||||
return Min( Min(a, b), c );
|
||||
}
|
||||
|
||||
inline float Min(float a, float b, float c, float d)
|
||||
{
|
||||
return Min( Min(a, b), Min(c, d) );
|
||||
}
|
||||
|
||||
inline float Min(float a, float b, float c, float d, float e)
|
||||
{
|
||||
return Min( Min(a, b), Min(c, d), e );
|
||||
}
|
||||
|
||||
//! Maximum
|
||||
inline float Max(float a, float b)
|
||||
{
|
||||
if ( a >= b ) return a;
|
||||
else return b;
|
||||
}
|
||||
|
||||
inline float Max(float a, float b, float c)
|
||||
{
|
||||
return Max( Max(a, b), c );
|
||||
}
|
||||
|
||||
inline float Max(float a, float b, float c, float d)
|
||||
{
|
||||
return Max( Max(a, b), Max(c, d) );
|
||||
}
|
||||
|
||||
inline 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)
|
||||
inline float Norm(float a)
|
||||
{
|
||||
if ( a < 0.0f ) return 0.0f;
|
||||
if ( a > 1.0f ) return 1.0f;
|
||||
return a;
|
||||
}
|
||||
|
||||
//! Returns the absolute value
|
||||
inline float Abs(float a)
|
||||
{
|
||||
return (float)fabs(a);
|
||||
}
|
||||
|
||||
//! Swaps two integers
|
||||
inline void Swap(int &a, int &b)
|
||||
{
|
||||
int c;
|
||||
|
||||
c = a;
|
||||
a = b;
|
||||
b = c;
|
||||
}
|
||||
|
||||
//! Swaps two real numbers
|
||||
inline void Swap(float &a, float &b)
|
||||
{
|
||||
float c;
|
||||
|
||||
c = a;
|
||||
a = b;
|
||||
b = c;
|
||||
}
|
||||
|
||||
//! Permutes two points
|
||||
inline void Swap(Point &a, Point &b)
|
||||
{
|
||||
Point 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 */
|
||||
inline 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 * PI
|
||||
inline float NormAngle(float angle)
|
||||
{
|
||||
angle = Mod(angle, PI_MUL_2);
|
||||
if ( angle < 0.0f )
|
||||
return PI_MUL_2 + angle;
|
||||
|
||||
return angle;
|
||||
}
|
||||
|
||||
//! Test if a angle is between two terminals
|
||||
inline 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 );
|
||||
|
||||
return ( angle >= min && angle <= max );
|
||||
}
|
||||
|
||||
//! Calculates the angle to rotate the angle \a a to the angle \a g
|
||||
/** A positive angle is counterclockwise (CCW). */
|
||||
inline float Direction(float a, float g)
|
||||
{
|
||||
a = NormAngle(a);
|
||||
g = NormAngle(g);
|
||||
|
||||
if ( a < g )
|
||||
{
|
||||
if ( a+PI*2.0f-g < g-a ) a += PI*2.0f;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( g+PI*2.0f-a < a-g ) g += PI*2.0f;
|
||||
}
|
||||
|
||||
return g-a;
|
||||
}
|
||||
|
||||
//! Returns a random value between 0 and 1.
|
||||
inline 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 = (float)a * DEG_TO_RAD;
|
||||
float bb = (float)b * DEG_TO_RAD;
|
||||
|
||||
return aa+p*(bb-aa);
|
||||
}
|
||||
|
||||
//! Gently advances a desired value from its current value
|
||||
/** Over time, the progression is more rapid. */
|
||||
float Smooth(float actual, float hope, float time)
|
||||
{
|
||||
float future = actual + (hope-actual)*time;
|
||||
|
||||
if ( hope > actual )
|
||||
{
|
||||
if ( future > hope ) future = hope;
|
||||
}
|
||||
if ( hope < actual )
|
||||
{
|
||||
if ( future < hope ) future = hope;
|
||||
}
|
||||
|
||||
return future;
|
||||
}
|
||||
|
||||
|
||||
//! Bounces any movement
|
||||
/** out
|
||||
|
|
||||
1+------o-------o---
|
||||
| o | o o | | bounce
|
||||
| o | o---|---
|
||||
| o | |
|
||||
| o | |
|
||||
-o------|-------+----> progress
|
||||
0| | 1
|
||||
|<---->|middle */
|
||||
inline float Bounce(float progress, float middle, float bounce)
|
||||
{
|
||||
if ( progress < middle )
|
||||
{
|
||||
progress = progress/middle; // 0..1
|
||||
return 0.5f+sinf(progress*PI-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)*PI)*(bounce/2.0f);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,178 @@
|
|||
// math/matrix.h
|
||||
|
||||
/* Matrix struct and functions */
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "const.h"
|
||||
|
||||
#include <cmath>
|
||||
|
||||
/* TODO
|
||||
|
||||
void MatRotateXZY(D3DMATRIX &mat, D3DVECTOR angle);
|
||||
void MatRotateZXY(D3DMATRIX &mat, D3DVECTOR angle);
|
||||
|
||||
*/
|
||||
|
||||
// Math module namespace
|
||||
namespace Math
|
||||
{
|
||||
|
||||
/** 4x4 matrix
|
||||
|
||||
Represents an universal 4x4 matrix that can be used in OpenGL and DirectX engines.
|
||||
Contains the required methods for operating on matrices (inverting, multiplying, etc.).
|
||||
|
||||
All methods are made inline to maximize optimization.
|
||||
|
||||
**/
|
||||
struct Matrix
|
||||
{
|
||||
//! Matrix values in row-major format
|
||||
float m[16];
|
||||
|
||||
//! Creates the indentity matrix
|
||||
inline Matrix()
|
||||
{
|
||||
LoadIdentity();
|
||||
}
|
||||
|
||||
//! Creates the matrix from given values
|
||||
/** \a m values in row-major format */
|
||||
inline Matrix(float m[16])
|
||||
{
|
||||
this->m = m;
|
||||
}
|
||||
|
||||
//! Loads the zero matrix
|
||||
inline void LoadZero()
|
||||
{
|
||||
for (int i = 0; i < 16; ++i)
|
||||
m[i] = 0.0f;
|
||||
}
|
||||
|
||||
//! Loads the identity matrix
|
||||
inline void LoadIdentity()
|
||||
{
|
||||
LoadZero();
|
||||
m[0] = m[1][1] = m[2][2] = m[3][3] = 1.0f;
|
||||
}
|
||||
|
||||
//! Calculates the determinant of the matrix
|
||||
/** \returns the determinant */
|
||||
float Det() const
|
||||
{
|
||||
float result = 0.0f;
|
||||
for (int i = 0; i < 4; ++i)
|
||||
{
|
||||
result += m[0][i] * Cofactor(0, i);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
//! Transposes the matrix
|
||||
void Transpose()
|
||||
{
|
||||
Matrix temp = *this;
|
||||
for (int r = 0; r < 4; ++r)
|
||||
{
|
||||
for (int c = 0; c < 4; ++c)
|
||||
{
|
||||
m[r][c] = temp.m[c][r];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//! Calculates the cofactor of the matrix
|
||||
/** \a r row (0 to 3)
|
||||
\a c column (0 to 3)
|
||||
\returns the cofactor or 0.0f if invalid r, c given*/
|
||||
float Cofactor(int r, int c) const
|
||||
{
|
||||
if ((r < 0) || (r > 3) || (c < 0) || (c > 3))
|
||||
return 0.0f;
|
||||
|
||||
float tab[3][3];
|
||||
int tabR = 0;
|
||||
for (int r = 0; r < 4; ++r)
|
||||
{
|
||||
if (r == i) continue;
|
||||
int tabC = 0;
|
||||
for (int c = 0; c < 4; ++c)
|
||||
{
|
||||
if (c == j) continue;
|
||||
tab[tabR][tabC] = m[r][c];
|
||||
++tabC;
|
||||
}
|
||||
++tabR;
|
||||
}
|
||||
|
||||
float result = tab[0][0] * (tab[1][1] * tab[2][2] - tab[1][2] * tab[2][1])
|
||||
- tab[0][1] * (tab[1][0] * tab[2][2] - tab[1][2] * tab[2][0])
|
||||
+ tab[0][2] * (tab[1][0] * tab[2][1] - tab[1][1] * tab[2][0]);
|
||||
|
||||
if ((i + j) % 2 == 0)
|
||||
result = -result;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
//! Inverts the matrix
|
||||
inline void Invert()
|
||||
{
|
||||
float d = Det();
|
||||
if (fabs(d) <= Math::TOLERANCE)
|
||||
return;
|
||||
|
||||
Matrix temp = *this;
|
||||
for (int r = 0; r < 4; ++r)
|
||||
{
|
||||
for (int c = 0; c < 4; ++c)
|
||||
{
|
||||
m[r][c] = (1.0f / d) * temp.Cofactor(r, c);
|
||||
}
|
||||
}
|
||||
|
||||
Tranpose();
|
||||
}
|
||||
|
||||
//! Multiplies the matrix with the given matrix
|
||||
/** \a right right-hand matrix */
|
||||
inline void Multiply(const Matrix &right)
|
||||
{
|
||||
Matrix left = *this;
|
||||
for (int r = 0; r < 4; ++r)
|
||||
{
|
||||
for (int c = 0; c < 4; ++c)
|
||||
{
|
||||
m[r][c] = 0.0;
|
||||
for (int i = 0; i < 4; ++i)
|
||||
{
|
||||
m[r][c] += left.m[r][i] * right.m[i][c];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
//! Convenience function for inverting a matrix
|
||||
/** \a m input matrix
|
||||
\a result result -- inverted matrix */
|
||||
void InvertMatrix(const Matrix &m, Matrix &result)
|
||||
{
|
||||
result = m;
|
||||
result.Invert();
|
||||
}
|
||||
|
||||
//! Convenience function for multiplying a matrix
|
||||
/** \a left left-hand matrix
|
||||
\a right right-hand matrix
|
||||
\a result result -- multiplied matrices */*
|
||||
void MultiplyMatrices(const Matrix &left, const Matrix &right, Matrix &result)
|
||||
{
|
||||
result = left;
|
||||
result.Multiply(right);
|
||||
}
|
||||
|
||||
}; // namespace Math
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
#pragma once
|
||||
|
||||
/* TODO
|
||||
FPOINT RotatePoint(FPOINT center, float angle, FPOINT p);
|
||||
FPOINT RotatePoint(float angle, FPOINT p);
|
||||
FPOINT RotatePoint(float angle, float dist);
|
||||
void RotatePoint(float cx, float cy, float angle, float &px, float &py);
|
||||
void RotatePoint(D3DVECTOR center, float angleH, float angleV, D3DVECTOR &p);
|
||||
void RotatePoint2(D3DVECTOR center, float angleH, float angleV, D3DVECTOR &p);
|
||||
float Length(FPOINT a, FPOINT b);
|
||||
|
||||
float RotateAngle(float x, float y);
|
||||
float RotateAngle(FPOINT center, FPOINT p1, FPOINT p2);
|
||||
float MidPoint(FPOINT a, FPOINT b, float px);
|
||||
BOOL IsInsideTriangle(FPOINT a, FPOINT b, FPOINT c, FPOINT p);
|
||||
|
||||
BOOL LineFunction(FPOINT p1, FPOINT p2, float &a, float &b);
|
||||
|
||||
*/
|
||||
|
|
@ -0,0 +1,119 @@
|
|||
// math/vector.h
|
||||
|
||||
/* Vector struct and functions */
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "const.h"
|
||||
|
||||
#include <cmath>
|
||||
|
||||
/*
|
||||
TODO
|
||||
|
||||
HRESULT D3DMath_VectorMatrixMultiply( D3DVECTOR& vDest, D3DVECTOR& vSrc, D3DMATRIX& mat)
|
||||
|
||||
float Length(const D3DVECTOR &a, const D3DVECTOR &b);
|
||||
float Length2d(const D3DVECTOR &a, const D3DVECTOR &b);
|
||||
float Angle( D3DVECTOR u, D3DVECTOR v );
|
||||
D3DVECTOR Cross( D3DVECTOR u, D3DVECTOR v );
|
||||
D3DVECTOR ComputeNormal( D3DVECTOR p1, D3DVECTOR p2, D3DVECTOR p3 );
|
||||
D3DVECTOR Transform(const D3DMATRIX &m, D3DVECTOR p);
|
||||
D3DVECTOR Projection(const D3DVECTOR &a, const D3DVECTOR &b, const D3DVECTOR &p);
|
||||
|
||||
D3DVECTOR SegmentDist(const D3DVECTOR &p1, const D3DVECTOR &p2, float dist);
|
||||
|
||||
BOOL Intersect(D3DVECTOR a, D3DVECTOR b, D3DVECTOR c, D3DVECTOR d, D3DVECTOR e, D3DVECTOR &i);
|
||||
BOOL IntersectY(D3DVECTOR a, D3DVECTOR b, D3DVECTOR c, D3DVECTOR &p);
|
||||
|
||||
|
||||
D3DVECTOR RotateView(D3DVECTOR center, float angleH, float angleV, float dist);
|
||||
D3DVECTOR LookatPoint( D3DVECTOR eye, float angleH, float angleV, float length );
|
||||
|
||||
void MappingObject( D3DVERTEX2* pVertices, int nb, float scale );
|
||||
void SmoothObject( D3DVERTEX2* pVertices, int nb );
|
||||
|
||||
float DistancePlanPoint(const D3DVECTOR &a, const D3DVECTOR &b, const D3DVECTOR &c, const D3DVECTOR &p);
|
||||
BOOL IsSamePlane(D3DVECTOR *plan1, D3DVECTOR *plan2);
|
||||
*/
|
||||
|
||||
// Math module namespace
|
||||
namespace Math
|
||||
{
|
||||
|
||||
/** 4x1 Vector
|
||||
|
||||
Represents an universal 4x1 vector that can be used in OpenGL and DirectX engines.
|
||||
Contains the required methods for operating on vectors.
|
||||
|
||||
All methods are made inline to maximize optimization.
|
||||
|
||||
*/
|
||||
struct Vector
|
||||
{
|
||||
//! X - 1st coord
|
||||
float x;
|
||||
//! Y - 2nd coord
|
||||
float y;
|
||||
//! Z - 3rd coord
|
||||
float z;
|
||||
//! W - 4th coord
|
||||
float w;
|
||||
|
||||
//! Creates an identity vector (0, 0, 0, 1)
|
||||
Vector()
|
||||
{
|
||||
LoadIdentity();
|
||||
}
|
||||
|
||||
//! Creates a vector from given values
|
||||
Vector(float x, float y, float z, float w = 1.0f)
|
||||
{
|
||||
this->x = x;
|
||||
this->y = y;
|
||||
this->z = z;
|
||||
this->w = w;
|
||||
}
|
||||
|
||||
//! Loads the identity vector (0, 0, 0, 1)
|
||||
void LoadIdentity()
|
||||
{
|
||||
x = y = z = 0.0f;
|
||||
w = 1.0f;
|
||||
}
|
||||
|
||||
//! Loads the zero vector (0, 0, 0, 0)
|
||||
void LoadZero()
|
||||
{
|
||||
x = y = z = w = 0.0f;
|
||||
}
|
||||
|
||||
//! Returns the vector length
|
||||
float Length() const
|
||||
{
|
||||
return sqrt(x*x + y*y + z*z + w*w);
|
||||
}
|
||||
|
||||
//! Normalizes the vector
|
||||
void Normalize()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
const Vector3D& operator-();
|
||||
const Vector3D& operator+=(const Vector3D &vector);
|
||||
const Vector3D& operator-=(const Vector3D &vector);
|
||||
const Vector3D& operator*=(double value);
|
||||
const Vector3D& operator/=(double value);
|
||||
|
||||
friend Vector3D operator+(const Vector3D &left, const Vector3D &right);
|
||||
friend Vector3D operator-(const Vector3D &left, const Vector3D &right);
|
||||
friend Vector3D operator*(double left, const Vector3D &right);
|
||||
friend Vector3D operator*(const Vector3D &left, double right);
|
||||
friend Vector3D operator/(const Vector3D &left, double right);
|
||||
|
||||
friend Vector3D crossProduct(const Vector3D &left, const Vector3D &right);
|
||||
friend double dotProduct(const Vector3D &left, const Vector3D &right);
|
||||
friend double cosAngle(const Vector3D &vector1, const Vector3D &vector2);
|
||||
friend double angle(const Vector3D &vector1, const Vector3D &vector2);
|
||||
};
|
||||
Loading…
Reference in New Issue