mirror of
https://github.com/glest/glest-source.git
synced 2025-09-28 16:39:01 +02:00
321 lines
7.4 KiB
C++
321 lines
7.4 KiB
C++
// ==============================================================
|
|
// This file is part of Glest Shared Library (www.glest.org)
|
|
//
|
|
// Copyright (C) 2001-2008 Martiño Figueroa
|
|
//
|
|
// You can redistribute this code and/or modify it under
|
|
// the terms of the GNU General Public License as published
|
|
// by the Free Software Foundation; either version 2 of the
|
|
// License, or (at your option) any later version
|
|
// ==============================================================
|
|
|
|
#ifndef _SHARED_GRAPHICS_MATHUTIL_H_
|
|
#define _SHARED_GRAPHICS_MATHUTIL_H_
|
|
|
|
#include "math_wrapper.h"
|
|
#include "vec.h"
|
|
#include "data_types.h"
|
|
#include "leak_dumper.h"
|
|
|
|
using namespace std;
|
|
using namespace Shared::Platform;
|
|
|
|
namespace Shared {
|
|
namespace Graphics {
|
|
|
|
const float pi = 3.1415926f;
|
|
const float sqrt2 = 1.41421356f;
|
|
const float zero = 1e-6f;
|
|
const float infinity = 1e6f;
|
|
|
|
// =====================================================
|
|
// class Rect
|
|
// =====================================================
|
|
|
|
// 0 +-+
|
|
// | |
|
|
// +-+ 1
|
|
|
|
template<typename T>
|
|
class Rect2 {
|
|
public:
|
|
Vec2<T> p[2];
|
|
public:
|
|
Rect2() {
|
|
};
|
|
|
|
Rect2(const Vec2<T> &p0, const Vec2<T> &p1) {
|
|
this->p[0] = p0;
|
|
this->p[1] = p1;
|
|
}
|
|
|
|
Rect2(T p0x, T p0y, T p1x, T p1y) {
|
|
p[0].x = p0x;
|
|
p[0].y = p0y;
|
|
p[1].x = p1x;
|
|
p[1].y = p1y;
|
|
}
|
|
|
|
Rect2<T> operator*(T scalar) {
|
|
return Rect2<T>(
|
|
p[0] * scalar,
|
|
p[1] * scalar);
|
|
}
|
|
|
|
Rect2<T> operator/(T scalar) {
|
|
return Rect2<T>(
|
|
p[0] / scalar,
|
|
p[1] / scalar);
|
|
}
|
|
|
|
bool isInside(const Vec2<T> &p) const {
|
|
return
|
|
p.x >= this->p[0].x &&
|
|
p.y >= this->p[0].y &&
|
|
p.x < this->p[1].x &&
|
|
p.y < this->p[1].y;
|
|
}
|
|
|
|
void clamp(T minX, T minY, T maxX, T maxY) {
|
|
for (int i = 0; i < 2; ++i) {
|
|
if (p[i].x < minX) {
|
|
p[i].x = minX;
|
|
}
|
|
if (p[i].y < minY) {
|
|
p[i].y = minY;
|
|
}
|
|
if (p[i].x > maxX) {
|
|
p[i].x = maxX;
|
|
}
|
|
if (p[i].y > maxY) {
|
|
p[i].y = maxY;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string getString() const {
|
|
std::ostringstream streamOut;
|
|
streamOut << "#1: " << this->p[0].getString();
|
|
streamOut << "#2: " << this->p[1].getString();
|
|
std::string result = streamOut.str();
|
|
streamOut.str(std::string());
|
|
return result;
|
|
}
|
|
|
|
};
|
|
|
|
typedef Rect2<int> Rect2i;
|
|
typedef Rect2<char> Rect2c;
|
|
typedef Rect2<float> Rect2f;
|
|
typedef Rect2<double> Rect2d;
|
|
|
|
// =====================================================
|
|
// class Quad
|
|
// =====================================================
|
|
|
|
// 0 +-+ 2
|
|
// | |
|
|
// 1 +-+ 3
|
|
|
|
template<typename T>
|
|
class Quad2 {
|
|
public:
|
|
Vec2<T> p[4];
|
|
public:
|
|
Quad2() {
|
|
};
|
|
|
|
Quad2(const Vec2<T> &p0, const Vec2<T> &p1, const Vec2<T> &p2, const Vec2<T> &p3) {
|
|
this->p[0] = p0;
|
|
this->p[1] = p1;
|
|
this->p[2] = p2;
|
|
this->p[3] = p3;
|
|
}
|
|
|
|
explicit Quad2(const Rect2<T> &rect) {
|
|
this->p[0] = rect.p[0];
|
|
this->p[1] = Vec2<T>(rect.p[0].x, rect.p[1].y);
|
|
this->p[2] = rect.p[1];
|
|
this->p[3] = Vec2<T>(rect.p[1].x, rect.p[0].y);
|
|
}
|
|
|
|
Quad2<T> operator*(T scalar) {
|
|
return Quad2<T>(
|
|
p[0] * scalar,
|
|
p[1] * scalar,
|
|
p[2] * scalar,
|
|
p[3] * scalar);
|
|
}
|
|
|
|
Quad2<T> operator/(T scalar) {
|
|
return Quad2<T>(
|
|
p[0] / scalar,
|
|
p[1] / scalar,
|
|
p[2] / scalar,
|
|
p[3] / scalar);
|
|
}
|
|
|
|
bool operator <(const Quad2<T> &v) const {
|
|
if (p[0] < v.p[0]) {
|
|
return true;
|
|
}
|
|
if (p[1] < v.p[1]) {
|
|
return true;
|
|
}
|
|
if (p[2] < v.p[2]) {
|
|
return true;
|
|
}
|
|
if (p[3] < v.p[3]) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool operator !=(const Quad2<T> &v) const {
|
|
if (p[0] != v.p[0]) {
|
|
return true;
|
|
}
|
|
if (p[1] != v.p[1]) {
|
|
return true;
|
|
}
|
|
if (p[2] != v.p[2]) {
|
|
return true;
|
|
}
|
|
if (p[3] != v.p[3]) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Rect2<T> computeBoundingRect() const {
|
|
return Rect2i(
|
|
#ifdef WIN32
|
|
min(p[0].x, p[1].x),
|
|
min(p[0].y, p[2].y),
|
|
max(p[2].x, p[3].x),
|
|
max(p[1].y, p[3].y));
|
|
#else
|
|
std::min(p[0].x, p[1].x),
|
|
std::min(p[0].y, p[2].y),
|
|
std::max(p[2].x, p[3].x),
|
|
std::max(p[1].y, p[3].y));
|
|
#endif
|
|
}
|
|
|
|
bool isInside(const Vec2<T> &pt) const {
|
|
|
|
if (!computeBoundingRect().isInside(pt))
|
|
return false;
|
|
|
|
bool left[4];
|
|
|
|
left[0] = (pt.y - p[0].y)*(p[1].x - p[0].x) - (pt.x - p[0].x)*(p[1].y - p[0].y) < 0;
|
|
left[1] = (pt.y - p[1].y)*(p[3].x - p[1].x) - (pt.x - p[1].x)*(p[3].y - p[1].y) < 0;
|
|
left[2] = (pt.y - p[3].y)*(p[2].x - p[3].x) - (pt.x - p[3].x)*(p[2].y - p[3].y) < 0;
|
|
left[3] = (pt.y - p[2].y)*(p[0].x - p[2].x) - (pt.x - p[2].x)*(p[0].y - p[2].y) < 0;
|
|
|
|
return left[0] && left[1] && left[2] && left[3];
|
|
}
|
|
|
|
void clamp(T minX, T minY, T maxX, T maxY) {
|
|
for (int i = 0; i < 4; ++i) {
|
|
if (p[i].x < minX) {
|
|
p[i].x = minX;
|
|
}
|
|
if (p[i].y < minY) {
|
|
p[i].y = minY;
|
|
}
|
|
if (p[i].x > maxX) {
|
|
p[i].x = maxX;
|
|
}
|
|
if (p[i].y > maxY) {
|
|
p[i].y = maxY;
|
|
}
|
|
}
|
|
}
|
|
|
|
float area() {
|
|
Vec2i v0 = p[3] - p[0];
|
|
Vec2i v1 = p[1] - p[2];
|
|
|
|
return 0.5f * ((v0.x * v1.y) - (v0.y * v1.x));
|
|
}
|
|
|
|
std::string getString() const {
|
|
std::ostringstream streamOut;
|
|
streamOut << "#1: " << this->p[0].getString();
|
|
streamOut << "#2: " << this->p[1].getString();
|
|
streamOut << "#3: " << this->p[2].getString();
|
|
streamOut << "#4: " << this->p[3].getString();
|
|
std::string result = streamOut.str();
|
|
streamOut.str(std::string());
|
|
return result;
|
|
}
|
|
|
|
};
|
|
|
|
typedef Quad2<int> Quad2i;
|
|
typedef Quad2<char> Quad2c;
|
|
typedef Quad2<float> Quad2f;
|
|
typedef Quad2<double> Quad2d;
|
|
|
|
// =====================================================
|
|
// Misc
|
|
// =====================================================
|
|
|
|
inline int next2Power(int n) {
|
|
int i;
|
|
for (i = 1; i < n; i *= 2);
|
|
return i;
|
|
}
|
|
|
|
template<typename T>
|
|
inline T degToRad(T deg) {
|
|
return (deg * 2 * pi) / 360;
|
|
}
|
|
|
|
template<typename T>
|
|
inline T radToDeg(T rad) {
|
|
return (rad * 360) / (2 * pi);
|
|
}
|
|
|
|
// ====================================================================================================================
|
|
// ====================================================================================================================
|
|
// Inline implementation
|
|
// ====================================================================================================================
|
|
// ====================================================================================================================
|
|
//#if _xs_BigEndian_
|
|
// #define _xs_iexp_ 0
|
|
// #define _xs_iman_ 1
|
|
//#else
|
|
// #define _xs_iexp_ 1 //intel is little endian
|
|
// #define _xs_iman_ 0
|
|
//#endif //BigEndian_
|
|
//
|
|
////#define finline __forceinline
|
|
//#define finline inline
|
|
//
|
|
//#ifndef _xs_DEFAULT_CONVERSION
|
|
//#define _xs_DEFAULT_CONVERSION 0
|
|
//#endif
|
|
//
|
|
////typedef long int32;
|
|
//typedef double real64;
|
|
//const real64 _xs_doublemagic = real64 (6755399441055744.0); //2^52 * 1.5, uses limited precisicion to floor
|
|
//
|
|
//finline int32 xs_CRoundToInt(real64 val, real64 dmr = _xs_doublemagic) {
|
|
//#if _xs_DEFAULT_CONVERSION==0
|
|
// val = val + dmr;
|
|
// return ((int32*)&val)[_xs_iman_];
|
|
// //return 0;
|
|
//#else
|
|
// return int32(floor(val+.5));
|
|
//#endif
|
|
//}
|
|
|
|
|
|
}
|
|
}//end namespace
|
|
|
|
#endif
|