ioquake
/
gtkradiant
mirror of https://github.com/TTimo/GtkRadiant.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactored vector classes to avoid reinterpret_cast 

git-svn-id: svn://svn.icculus.org/gtkradiant/GtkRadiant/trunk@60 8a3a26a2-13c4-0310-b231-cf6edde360e5
This commit is contained in:
spog 2006-05-09 22:07:29 +00:00
parent 3591d7dc01
commit 0d98822b3c
21 changed files with 428 additions and 396 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/ibrush.h
View File

@ -24,7 +24,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#include "generic/constant.h"
#include "generic/callback.h"
#include "math/vector.h"
#include "generic/vector.h"
#include "itexdef.h"
namespace scene

2
include/iglrender.h
View File

@ -23,7 +23,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#define INCLUDED_IGLRENDER_H
#include "igl.h"
#include "math/vector.h"
#include "generic/vector.h"
class AABB;
class Matrix4;

2
include/ipatch.h
View File

@ -23,7 +23,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#define INCLUDED_IPATCH_H
#include "generic/constant.h"
#include "math/vector.h"
#include "generic/vector.h"
namespace scene
{

2
include/irender.h
View File

@ -116,7 +116,7 @@ class Matrix4;
struct qtexture_t;
class ModuleObserver;
#include "math/vector.h"
#include "generic/vector.h"
class Shader
{

2
include/qerplugin.h
View File

@ -99,7 +99,7 @@ class ModuleObserver;
#include "signal/signalfwd.h"
#include "windowobserver.h"
#include "math/vector.h"
#include "generic/vector.h"
typedef SignalHandler3<const WindowVector&, ButtonIdentifier, ModifierFlags> MouseEventHandler;
typedef SignalFwd<MouseEventHandler>::handler_id_type MouseEventHandlerId;

2
include/selectable.h
View File

@ -24,7 +24,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#include <cstddef>
#include "math/vector.h"
#include "generic/vector.h"
#include "scenelib.h"
#include "generic/callbackfwd.h"

3
libs/generic/vector.cpp Normal file
View File

@ -0,0 +1,3 @@
#include "vector.h"

259
libs/generic/vector.h Normal file
View File

@ -0,0 +1,259 @@
#if !defined(INCLUDED_VECTOR_H)
#define INCLUDED_VECTOR_H
#include <cstddef>
template <typename Element>
class BasicVector2
{
Element m_elements[2];
public:
BasicVector2()
{
}
BasicVector2(const Element& x_, const Element& y_)
{
x() = x_;
y() = y_;
}
Element& x()
{
return m_elements[0];
}
const Element& x() const
{
return m_elements[0];
}
Element& y()
{
return m_elements[1];
}
const Element& y() const
{
return m_elements[1];
}
const Element& operator[](std::size_t i) const
{
return m_elements[i];
}
Element& operator[](std::size_t i)
{
return m_elements[i];
}
Element* data()
{
return m_elements;
}
const Element* data() const
{
return m_elements;
}
};
/// \brief A 3-element vector.
template<typename Element>
class BasicVector3
{
Element m_elements[3];
public:
BasicVector3()
{
}
template<typename OtherElement>
BasicVector3(const BasicVector3<OtherElement>& other)
{
x() = static_cast<Element>(other.x());
y() = static_cast<Element>(other.y());
z() = static_cast<Element>(other.z());
}
BasicVector3(const Element& x_, const Element& y_, const Element& z_)
{
x() = x_;
y() = y_;
z() = z_;
}
Element& x()
{
return m_elements[0];
}
const Element& x() const
{
return m_elements[0];
}
Element& y()
{
return m_elements[1];
}
const Element& y() const
{
return m_elements[1];
}
Element& z()
{
return m_elements[2];
}
const Element& z() const
{
return m_elements[2];
}
const Element& operator[](std::size_t i) const
{
return m_elements[i];
}
Element& operator[](std::size_t i)
{
return m_elements[i];
}
Element* data()
{
return m_elements;
}
const Element* data() const
{
return m_elements;
}
};
/// \brief A 4-element vector.
template<typename Element>
class BasicVector4
{
Element m_elements[4];
public:
BasicVector4()
{
}
BasicVector4(Element x_, Element y_, Element z_, Element w_)
{
x() = x_;
y() = y_;
z() = z_;
w() = w_;
}
BasicVector4(const BasicVector3<Element>& self, Element w_)
{
x() = self.x();
y() = self.y();
z() = self.z();
w() = w_;
}
Element& x()
{
return m_elements[0];
}
const Element& x() const
{
return m_elements[0];
}
Element& y()
{
return m_elements[1];
}
const Element& y() const
{
return m_elements[1];
}
Element& z()
{
return m_elements[2];
}
const Element& z() const
{
return m_elements[2];
}
Element& w()
{
return m_elements[3];
}
const Element& w() const
{
return m_elements[3];
}
Element index(std::size_t i) const
{
return m_elements[i];
}
Element& index(std::size_t i)
{
return m_elements[i];
}
Element operator[](std::size_t i) const
{
return m_elements[i];
}
Element& operator[](std::size_t i)
{
return m_elements[i];
}
Element* data()
{
return m_elements;
}
const Element* data() const
{
return m_elements;
}
};
template<typename Element>
inline BasicVector3<Element> vector3_from_array(const Element* array)
{
return BasicVector3<Element>(array[0], array[1], array[2]);
}
template<typename Element>
inline Element* vector3_to_array(BasicVector3<Element>& self)
{
return self.data();
}
template<typename Element>
inline const Element* vector3_to_array(const BasicVector3<Element>& self)
{
return self.data();
}
template<typename Element>
inline Element* vector4_to_array(BasicVector4<Element>& self)
{
return self.data();
}
template<typename Element>
inline const Element* vector4_to_array(const BasicVector4<Element>& self)
{
return self.data();
}
template<typename Element>
inline BasicVector3<Element>& vector4_to_vector3(BasicVector4<Element>& self)
{
return *reinterpret_cast<BasicVector3<Element>*>(vector4_to_array(self));
}
template<typename Element>
inline const BasicVector3<Element>& vector4_to_vector3(const BasicVector4<Element>& self)
{
return *reinterpret_cast<const BasicVector3<Element>*>(vector4_to_array(self));
}
/// \brief A 2-element vector stored in single-precision floating-point.
typedef BasicVector2<float> Vector2;
/// \brief A 3-element vector stored in single-precision floating-point.
typedef BasicVector3<float> Vector3;
/// \brief A 4-element vector stored in single-precision floating-point.
typedef BasicVector4<float> Vector4;
#endif

18
libs/libs.vcproj
View File

@ -427,6 +427,24 @@
<File
RelativePath=".\generic\static.h">
</File>
<File
RelativePath=".\generic\vector.cpp">
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
ObjectFile="$(IntDir)/$(InputName)1.obj"/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
ObjectFile="$(IntDir)/$(InputName)1.obj"/>
</FileConfiguration>
</File>
<File
RelativePath=".\generic\vector.h">
</File>
</Filter>
<Filter
Name="memory"

24
libs/math/aabb.h
View File

@ -243,9 +243,9 @@ inline void aabb_corners(const AABB& aabb, Vector3 corners[8])
inline void aabb_corners_oriented(const AABB& aabb, const Matrix4& rotation, Vector3 corners[8])
{
Vector3 x = Vector3(rotation.x()) * aabb.extents.x();
Vector3 y = Vector3(rotation.y()) * aabb.extents.y();
Vector3 z = Vector3(rotation.z()) * aabb.extents.z();
Vector3 x = vector4_to_vector3(rotation.x()) * aabb.extents.x();
Vector3 y = vector4_to_vector3(rotation.y()) * aabb.extents.y();
Vector3 z = vector4_to_vector3(rotation.z()) * aabb.extents.z();
corners[0] = aabb.origin + -x + y + z;
corners[1] = aabb.origin + x + y + z;
@ -269,16 +269,16 @@ inline void aabb_planes(const AABB& aabb, Plane3 planes[6])
inline void aabb_planes_oriented(const AABB& aabb, const Matrix4& rotation, Plane3 planes[6])
{
double x = vector3_dot(Vector3(rotation.x()), aabb.origin);
double y = vector3_dot(Vector3(rotation.y()), aabb.origin);
double z = vector3_dot(Vector3(rotation.z()), aabb.origin);
double x = vector3_dot(vector4_to_vector3(rotation.x()), aabb.origin);
double y = vector3_dot(vector4_to_vector3(rotation.y()), aabb.origin);
double z = vector3_dot(vector4_to_vector3(rotation.z()), aabb.origin);
planes[0] = Plane3(Vector3(rotation.x()), x + aabb.extents[0]);
planes[1] = Plane3(-Vector3(rotation.x()), -(x - aabb.extents[0]));
planes[2] = Plane3(Vector3(rotation.y()), y + aabb.extents[1]);
planes[3] = Plane3(-Vector3(rotation.y()), -(y - aabb.extents[1]));
planes[4] = Plane3(Vector3(rotation.z()), z + aabb.extents[2]);
planes[5] = Plane3(-Vector3(rotation.z()), -(z - aabb.extents[2]));
planes[0] = Plane3(vector4_to_vector3(rotation.x()), x + aabb.extents[0]);
planes[1] = Plane3(-vector4_to_vector3(rotation.x()), -(x - aabb.extents[0]));
planes[2] = Plane3(vector4_to_vector3(rotation.y()), y + aabb.extents[1]);
planes[3] = Plane3(-vector4_to_vector3(rotation.y()), -(y - aabb.extents[1]));
planes[4] = Plane3(vector4_to_vector3(rotation.z()), z + aabb.extents[2]);
planes[5] = Plane3(-vector4_to_vector3(rotation.z()), -(z - aabb.extents[2]));
}
const Vector3 aabb_normals[6] = {

252
libs/math/vector.h
View File

@ -25,6 +25,8 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/// \file
/// \brief Vector data types and related operations.
#include "generic/vector.h"
#if 0
#define lrint(dbl) ((int)((dbl) + 0.5))
@ -58,7 +60,6 @@ inline int lrint (double flt)
#endif
#include <cmath>
#include <cstddef>
#include <float.h>
#include <algorithm>
@ -115,48 +116,6 @@ inline Element float_mod(const Element& self, const ModulusElement& modulus)
}
template<typename Element>
class BasicVector2
{
Element m_elements[2];
public:
BasicVector2()
{
}
BasicVector2(const Element& x_, const Element& y_)
{
x() = x_;
y() = y_;
}
Element& x()
{
return m_elements[0];
}
const Element& x() const
{
return m_elements[0];
}
Element& y()
{
return m_elements[1];
}
const Element& y() const
{
return m_elements[1];
}
const Element& operator[](std::size_t i) const
{
return m_elements[i];
}
Element& operator[](std::size_t i)
{
return m_elements[i];
}
};
template<typename Element, typename OtherElement>
inline BasicVector2<Element> vector2_added(const BasicVector2<Element>& self, const BasicVector2<OtherElement>& other)
{
@ -335,79 +294,6 @@ inline double vector2_cross(const BasicVector2<Element>& self, const BasicVector
return self.x() * other.y() - self.y() * other.x();
}
typedef BasicVector2<float> Vector2;
/// \brief A 3-element vector.
template<typename Element>
class BasicVector3
{
Element m_elements[3];
public:
BasicVector3()
{
}
template<typename OtherElement>
BasicVector3(const BasicVector3<OtherElement>& other)
{
x() = static_cast<Element>(other.x());
y() = static_cast<Element>(other.y());
z() = static_cast<Element>(other.z());
}
BasicVector3(const Element& x_, const Element& y_, const Element& z_)
{
x() = x_;
y() = y_;
z() = z_;
}
Element& x()
{
return m_elements[0];
}
const Element& x() const
{
return m_elements[0];
}
Element& y()
{
return m_elements[1];
}
const Element& y() const
{
return m_elements[1];
}
Element& z()
{
return m_elements[2];
}
const Element& z() const
{
return m_elements[2];
}
const Element& operator[](std::size_t i) const
{
return m_elements[i];
}
Element& operator[](std::size_t i)
{
return m_elements[i];
}
operator BasicVector2<Element>&()
{
return reinterpret_cast<BasicVector2<Element>&>(*this);
}
operator const BasicVector2<Element>&() const
{
return reinterpret_cast<const BasicVector2<Element>&>(*this);
}
};
/// \brief A 3-element vector stored in single-precision floating-point.
typedef BasicVector3<float> Vector3;
const Vector3 g_vector3_identity(0, 0, 0);
const Vector3 g_vector3_max = Vector3(FLT_MAX, FLT_MAX, FLT_MAX);
const Vector3 g_vector3_axis_x(1, 0, 0);
@ -416,26 +302,6 @@ const Vector3 g_vector3_axis_z(0, 0, 1);
const Vector3 g_vector3_axes[3] = { g_vector3_axis_x, g_vector3_axis_y, g_vector3_axis_z };
inline Vector3& vector3_from_array(float* array)
{
return *reinterpret_cast<Vector3*>(array);
}
inline const Vector3& vector3_from_array(const float* array)
{
return *reinterpret_cast<const Vector3*>(array);
}
template<typename Element>
inline Element* vector3_to_array(BasicVector3<Element>& self)
{
return reinterpret_cast<Element*>(&self);
}
template<typename Element>
inline const Element* vector3_to_array(const BasicVector3<Element>& self)
{
return reinterpret_cast<const Element*>(&self);
}
template<typename Element, typename OtherElement>
inline void vector3_swap(BasicVector3<Element>& self, BasicVector3<OtherElement>& other)
{
@ -743,98 +609,6 @@ inline Vector3 vector3_for_spherical(double theta, double phi)
}
/// \brief A 4-element vector.
template<typename Element>
class BasicVector4
{
Element m_elements[4];
public:
BasicVector4()
{
}
BasicVector4(Element x_, Element y_, Element z_, Element w_)
{
x() = x_;
y() = y_;
z() = z_;
w() = w_;
}
BasicVector4(const BasicVector3<Element>& self, Element w_)
{
x() = self.x();
y() = self.y();
z() = self.z();
w() = w_;
}
Element& x()
{
return m_elements[0];
}
Element x() const
{
return m_elements[0];
}
Element& y()
{
return m_elements[1];
}
Element y() const
{
return m_elements[1];
}
Element& z()
{
return m_elements[2];
}
Element z() const
{
return m_elements[2];
}
Element& w()
{
return m_elements[3];
}
Element w() const
{
return m_elements[3];
}
Element index(std::size_t i) const
{
return m_elements[i];
}
Element& index(std::size_t i)
{
return m_elements[i];
}
Element operator[](std::size_t i) const
{
return m_elements[i];
}
Element& operator[](std::size_t i)
{
return m_elements[i];
}
operator BasicVector3<Element>&()
{
return reinterpret_cast<BasicVector3<Element>&>(*this);
}
operator const BasicVector3<Element>&() const
{
return reinterpret_cast<const BasicVector3<Element>&>(*this);
}
bool operator==(const BasicVector4& other) const
{
return x() == other.x() && y() == other.y() && z() == other.z() && w() == other.w();
}
};
/// \brief A 4-element vector stored in single-precision floating-point.
typedef BasicVector4<float> Vector4;
template<typename Element, typename OtherElement>
@ -862,28 +636,6 @@ inline bool vector4_equal_epsilon(const BasicVector4<Element>& self, const Basic
&& float_equal_epsilon(self.w(), other.w(), epsilon);
}
template<typename Element>
inline Element* vector4_to_array(BasicVector4<Element>& self)
{
return reinterpret_cast<Element*>(&self);
}
template<typename Element>
inline const float* vector4_to_array(const BasicVector4<Element>& self)
{
return reinterpret_cast<const Element*>(&self);
}
template<typename Element>
inline Vector3& vector4_to_vector3(BasicVector4<Element>& self)
{
return reinterpret_cast<BasicVector3<Element>&>(self);
}
template<typename Element>
inline const Vector3& vector4_to_vector3(const BasicVector4<Element>& self)
{
return reinterpret_cast<const BasicVector3<Element>&>(self);
}
template<typename Element, typename OtherElement>
inline BasicVector4<Element> vector4_added(const BasicVector4<Element>& self, const BasicVector4<OtherElement>& other)
{

183
libs/render.h
View File

@ -360,40 +360,38 @@ inline bool operator!=(const Colour4b& self, const Colour4b& other)
}
/// \brief A 3-float vertex.
struct Vertex3f
struct Vertex3f : public Vector3
{
float x, y, z;
Vertex3f()
{
}
Vertex3f(float _x, float _y, float _z)
: x(_x), y(_y), z(_z)
: Vector3(_x, _y, _z)
{
}
};
inline bool operator<(const Vertex3f& self, const Vertex3f& other)
{
if(self.x != other.x)
if(self.x() != other.x())
{
return self.x < other.x;
return self.x() < other.x();
}
if(self.y != other.y)
if(self.y() != other.y())
{
return self.y < other.y;
return self.y() < other.y();
}
if(self.z != other.z)
if(self.z() != other.z())
{
return self.z < other.z;
return self.z() < other.z();
}
return false;
}
inline bool operator==(const Vertex3f& self, const Vertex3f& other)
{
return self.x == other.x && self.y == other.y && self.z == other.z;
return self.x() == other.x() && self.y() == other.y() && self.z() == other.z();
}
inline bool operator!=(const Vertex3f& self, const Vertex3f& other)
@ -402,9 +400,9 @@ inline bool operator!=(const Vertex3f& self, const Vertex3f& other)
}
inline const Vertex3f& vertex3f_from_array(const float* array)
inline Vertex3f vertex3f_from_array(const float* array)
{
return *reinterpret_cast<const Vertex3f*>(array);
return Vertex3f(array[0], array[1], array[2]);
}
inline float* vertex3f_to_array(Vertex3f& vertex)
@ -426,50 +424,48 @@ inline Vertex3f vertex3f_for_vector3(const Vector3& vector3)
inline const Vector3& vertex3f_to_vector3(const Vertex3f& vertex)
{
return reinterpret_cast<const Vector3&>(vertex);
return vertex;
}
inline Vector3& vertex3f_to_vector3(Vertex3f& vertex)
{
return reinterpret_cast<Vector3&>(vertex);
return vertex;
}
/// \brief A 3-float normal.
struct Normal3f
struct Normal3f : public Vector3
{
float x, y, z;
Normal3f()
{
}
Normal3f(float _x, float _y, float _z)
: x(_x), y(_y), z(_z)
: Vector3(_x, _y, _z)
{
}
};
inline bool operator<(const Normal3f& self, const Normal3f& other)
{
if(self.x != other.x)
if(self.x() != other.x())
{
return self.x < other.x;
return self.x() < other.x();
}
if(self.y != other.y)
if(self.y() != other.y())
{
return self.y < other.y;
return self.y() < other.y();
}
if(self.z != other.z)
if(self.z() != other.z())
{
return self.z < other.z;
return self.z() < other.z();
}
return false;
}
inline bool operator==(const Normal3f& self, const Normal3f& other)
{
return self.x == other.x && self.y == other.y && self.z == other.z;
return self.x() == other.x() && self.y() == other.y() && self.z() == other.z();
}
inline bool operator!=(const Normal3f& self, const Normal3f& other)
@ -500,46 +496,61 @@ inline Normal3f normal3f_for_vector3(const Vector3& vector3)
inline const Vector3& normal3f_to_vector3(const Normal3f& normal)
{
return reinterpret_cast<const Vector3&>(normal);
return normal;
}
inline Vector3& normal3f_to_vector3(Normal3f& normal)
{
return reinterpret_cast<Vector3&>(normal);
return normal;
}
/// \brief A 2-float texture-coordinate set.
struct TexCoord2f
struct TexCoord2f : public Vector2
{
float s, t;
TexCoord2f()
{
}
TexCoord2f(float _s, float _t)
: s(_s), t(_t)
: Vector2(_s, _t)
{
}
float& s()
{
return x();
}
const float& s() const
{
return x();
}
float& t()
{
return y();
}
const float& t() const
{
return y();
}
};
inline bool operator<(const TexCoord2f& self, const TexCoord2f& other)
{
if(self.s != other.s)
if(self.s() != other.s())
{
return self.s < other.s;
return self.s() < other.s();
}
if(self.t != other.t)
if(self.t() != other.t())
{
return self.t < other.t;
return self.t() < other.t();
}
return false;
}
inline bool operator==(const TexCoord2f& self, const TexCoord2f& other)
{
return self.s == other.s && self.t == other.t;
return self.s() == other.s() && self.t() == other.t();
}
inline bool operator!=(const TexCoord2f& self, const TexCoord2f& other)
@ -570,12 +581,12 @@ inline TexCoord2f texcoord2f_for_vector2(const Vector2& vector2)
inline const Vector2& texcoord2f_to_vector2(const TexCoord2f& vertex)
{
return reinterpret_cast<const Vector2&>(vertex);
return vertex;
}
inline Vector2& texcoord2f_to_vector2(TexCoord2f& vertex)
{
return reinterpret_cast<Vector2&>(vertex);
return vertex;
}
/// \brief Returns \p normal rescaled to be unit-length.
@ -600,7 +611,7 @@ enum UnitSphereOctant
inline UnitSphereOctant normal3f_classify_octant(const Normal3f& normal)
{
return static_cast<UnitSphereOctant>(
((normal.x > 0) << 0) | ((normal.y > 0) << 1) | ((normal.z > 0) << 2)
((normal.x() > 0) << 0) | ((normal.y() > 0) << 1) | ((normal.z() > 0) << 2)
);
}
@ -610,21 +621,21 @@ inline Normal3f normal3f_fold_octant(const Normal3f& normal, UnitSphereOctant oc
switch(octant)
{
case UNITSPHEREOCTANT_000:
return Normal3f(-normal.x, -normal.y, -normal.z);
return Normal3f(-normal.x(), -normal.y(), -normal.z());
case UNITSPHEREOCTANT_001:
return Normal3f(normal.x, -normal.y, -normal.z);
return Normal3f(normal.x(), -normal.y(), -normal.z());
case UNITSPHEREOCTANT_010:
return Normal3f(-normal.x, normal.y, -normal.z);
return Normal3f(-normal.x(), normal.y(), -normal.z());
case UNITSPHEREOCTANT_011:
return Normal3f(normal.x, normal.y, -normal.z);
return Normal3f(normal.x(), normal.y(), -normal.z());
case UNITSPHEREOCTANT_100:
return Normal3f(-normal.x, -normal.y, normal.z);
return Normal3f(-normal.x(), -normal.y(), normal.z());
case UNITSPHEREOCTANT_101:
return Normal3f(normal.x, -normal.y, normal.z);
return Normal3f(normal.x(), -normal.y(), normal.z());
case UNITSPHEREOCTANT_110:
return Normal3f(-normal.x, normal.y, normal.z);
return Normal3f(-normal.x(), normal.y(), normal.z());
case UNITSPHEREOCTANT_111:
return Normal3f(normal.x, normal.y, normal.z);
return Normal3f(normal.x(), normal.y(), normal.z());
}
return Normal3f();
}
@ -653,14 +664,14 @@ enum UnitSphereSextant
inline UnitSphereSextant normal3f_classify_sextant(const Normal3f& normal)
{
return
normal.x >= normal.y
? normal.x >= normal.z
? normal.y >= normal.z
normal.x() >= normal.y()
? normal.x() >= normal.z()
? normal.y() >= normal.z()
? UNITSPHERESEXTANT_XYZ
: UNITSPHERESEXTANT_XZY
: UNITSPHERESEXTANT_ZXY
: normal.y >= normal.z
? normal.x >= normal.z
: normal.y() >= normal.z()
? normal.x() >= normal.z()
? UNITSPHERESEXTANT_YXZ
: UNITSPHERESEXTANT_YZX
: UNITSPHERESEXTANT_ZYX;
@ -674,17 +685,17 @@ inline Normal3f normal3f_fold_sextant(const Normal3f& normal, UnitSphereSextant
switch(sextant)
{
case UNITSPHERESEXTANT_XYZ:
return Normal3f(normal.x, normal.y, normal.z);
return Normal3f(normal.x(), normal.y(), normal.z());
case UNITSPHERESEXTANT_XZY:
return Normal3f(normal.x, normal.z, normal.y);
return Normal3f(normal.x(), normal.z(), normal.y());
case UNITSPHERESEXTANT_YXZ:
return Normal3f(normal.y, normal.x, normal.z);
return Normal3f(normal.y(), normal.x(), normal.z());
case UNITSPHERESEXTANT_YZX:
return Normal3f(normal.y, normal.z, normal.x);
return Normal3f(normal.y(), normal.z(), normal.x());
case UNITSPHERESEXTANT_ZXY:
return Normal3f(normal.z, normal.x, normal.y);
return Normal3f(normal.z(), normal.x(), normal.y());
case UNITSPHERESEXTANT_ZYX:
return Normal3f(normal.z, normal.y, normal.x);
return Normal3f(normal.z(), normal.y(), normal.x());
}
return Normal3f();
}
@ -703,9 +714,9 @@ const std::size_t c_quantise_normal = 1 << 6;
inline Normal3f normal3f_folded_quantised(const Normal3f& folded)
{
// compress
double scale = static_cast<float>(c_quantise_normal) / (folded.x + folded.y + folded.z);
unsigned int zbits = static_cast<unsigned int>(folded.z * scale);
unsigned int ybits = static_cast<unsigned int>(folded.y * scale);
double scale = static_cast<float>(c_quantise_normal) / (folded.x() + folded.y() + folded.z());
unsigned int zbits = static_cast<unsigned int>(folded.z() * scale);
unsigned int ybits = static_cast<unsigned int>(folded.y() * scale);
// decompress
return normal3f_normalised(Normal3f(
@ -762,7 +773,7 @@ struct uniformspherical_t
inline spherical_t spherical_from_normal3f(const Normal3f& normal)
{
return spherical_t(normal.x == 0 ? c_pi / 2 : normal.x > 0 ? atan(normal.y / normal.x) : atan(normal.y / normal.x) + c_pi, acos(normal.z));
return spherical_t(normal.x() == 0 ? c_pi / 2 : normal.x() > 0 ? atan(normal.y() / normal.x()) : atan(normal.y() / normal.x()) + c_pi, acos(normal.z()));
}
inline Normal3f normal3f_from_spherical(const spherical_t& spherical)
@ -820,7 +831,7 @@ inline uniformspherical_t uniformspherical_quantised(const uniformspherical_t& u
/// \brief Returns a \p vertex quantised to \p precision.
inline Vertex3f vertex3f_quantised(const Vertex3f& vertex, float precision)
{
return Vertex3f(float_quantise(vertex.x, precision), float_quantise(vertex.y, precision), float_quantise(vertex.z, precision));
return Vertex3f(float_quantise(vertex.x(), precision), float_quantise(vertex.y(), precision), float_quantise(vertex.z(), precision));
}
/// \brief Returns a \p normal quantised to a fixed precision.
@ -835,7 +846,7 @@ inline Normal3f normal3f_quantised(const Normal3f& normal)
/// \brief Returns a \p texcoord quantised to \p precision.
inline TexCoord2f texcoord2f_quantised(const TexCoord2f& texcoord, float precision)
{
return TexCoord2f(float_quantise(texcoord.s, precision), float_quantise(texcoord.t, precision));
return TexCoord2f(float_quantise(texcoord.s(), precision), float_quantise(texcoord.t(), precision));
}
/// \brief Standard vertex type for lines and points.
@ -1071,9 +1082,9 @@ class RemapXYZ
public:
static void set(Vertex3f& vertex, float x, float y, float z)
{
vertex.x = x;
vertex.y = y;
vertex.z = z;
vertex.x() = x;
vertex.y() = y;
vertex.z() = z;
}
};
@ -1082,9 +1093,9 @@ class RemapYZX
public:
static void set(Vertex3f& vertex, float x, float y, float z)
{
vertex.x = z;
vertex.y = x;
vertex.z = y;
vertex.x() = z;
vertex.y() = x;
vertex.z() = y;
}
};
@ -1093,9 +1104,9 @@ class RemapZXY
public:
static void set(Vertex3f& vertex, float x, float y, float z)
{
vertex.x = y;
vertex.y = z;
vertex.z = x;
vertex.x() = y;
vertex.y() = z;
vertex.z() = x;
}
};
@ -1267,12 +1278,12 @@ inline void ArbitraryMeshTriangle_calcTangents(const ArbitraryMeshVertex& a, con
Vector3 cross(
vector3_cross(
vector3_subtracted(
Vector3(b.vertex.x, b.texcoord.s, b.texcoord.t),
Vector3(a.vertex.x, a.texcoord.s, a.texcoord.t)
Vector3(b.vertex.x(), b.texcoord.s(), b.texcoord.t()),
Vector3(a.vertex.x(), a.texcoord.s(), a.texcoord.t())
),
vector3_subtracted(
Vector3(c.vertex.x, c.texcoord.s, c.texcoord.t),
Vector3(a.vertex.x, a.texcoord.s, a.texcoord.t)
Vector3(c.vertex.x(), c.texcoord.s(), c.texcoord.t()),
Vector3(a.vertex.x(), a.texcoord.s(), a.texcoord.t())
)
)
);
@ -1292,12 +1303,12 @@ inline void ArbitraryMeshTriangle_calcTangents(const ArbitraryMeshVertex& a, con
Vector3 cross(
vector3_cross(
vector3_subtracted(
Vector3(b.vertex.y, b.texcoord.s, b.texcoord.t),
Vector3(a.vertex.y, a.texcoord.s, a.texcoord.t)
Vector3(b.vertex.y(), b.texcoord.s(), b.texcoord.t()),
Vector3(a.vertex.y(), a.texcoord.s(), a.texcoord.t())
),
vector3_subtracted(
Vector3(c.vertex.y, c.texcoord.s, c.texcoord.t),
Vector3(a.vertex.y, a.texcoord.s, a.texcoord.t)
Vector3(c.vertex.y(), c.texcoord.s(), c.texcoord.t()),
Vector3(a.vertex.y(), a.texcoord.s(), a.texcoord.t())
)
)
);
@ -1317,12 +1328,12 @@ inline void ArbitraryMeshTriangle_calcTangents(const ArbitraryMeshVertex& a, con
Vector3 cross(
vector3_cross(
vector3_subtracted(
Vector3(b.vertex.z, b.texcoord.s, b.texcoord.t),
Vector3(a.vertex.z, a.texcoord.s, a.texcoord.t)
Vector3(b.vertex.z(), b.texcoord.s(), b.texcoord.t()),
Vector3(a.vertex.z(), a.texcoord.s(), a.texcoord.t())
),
vector3_subtracted(
Vector3(c.vertex.z, c.texcoord.s, c.texcoord.t),
Vector3(a.vertex.z, a.texcoord.s, a.texcoord.t)
Vector3(c.vertex.z(), c.texcoord.s(), c.texcoord.t()),
Vector3(a.vertex.z(), a.texcoord.s(), a.texcoord.t())
)
)
);

2
libs/stringio.h
View File

@ -25,7 +25,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#include <stdlib.h>
#include <cctype>
#include "math/vector.h"
#include "generic/vector.h"
#include "iscriplib.h"
#include "string/string.h"
#include "generic/callback.h"

2
libs/texturelib.h
View File

@ -22,7 +22,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#if !defined (INCLUDED_TEXTURELIB_H)
#define INCLUDED_TEXTURELIB_H
#include "math/vector.h"
#include "generic/vector.h"
typedef Vector3 Colour3;
typedef unsigned int GLuint;
class LoadImageCallback;

2
plugins/entity/targetable.h
View File

@ -398,7 +398,7 @@ public:
return childBounds.origin;
}
#endif
return localToWorld().t();
return vector4_to_vector3(localToWorld().t());
}
void render(Renderer& renderer, const VolumeTest& volume) const

2
plugins/md3model/md5.cpp
View File

@ -298,7 +298,7 @@ bool MD5Model_parse(Model& model, Tokeniser& tokeniser)
MD5_RETURN_FALSE_IF_FAIL(MD5_parseString(tokeniser, jointName));
MD5_RETURN_FALSE_IF_FAIL(MD5_parseInteger(tokeniser, (*i).parent));
MD5_RETURN_FALSE_IF_FAIL(MD5_parseVector3(tokeniser, (*i).position));
MD5_RETURN_FALSE_IF_FAIL(MD5_parseVector3(tokeniser, (*i).rotation));
MD5_RETURN_FALSE_IF_FAIL(MD5_parseVector3(tokeniser, vector4_to_vector3((*i).rotation)));
(*i).rotation.w() = -static_cast<float>(sqrt(1.0f - (float_squared((*i).rotation.x()) + float_squared((*i).rotation.y()) + float_squared((*i).rotation.z()))));
tokeniser.nextLine();
}

14
radiant/brush_primit.cpp
View File

@ -255,17 +255,17 @@ void Texdef_basisForNormal(const TextureProjection& projection, const Vector3& n
if(g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES)
{
basis = g_matrix4_identity;
ComputeAxisBase(normal, basis.x(), basis.y());
static_cast<Vector3&>(basis.z()) = normal;
ComputeAxisBase(normal, vector4_to_vector3(basis.x()), vector4_to_vector3(basis.y()));
vector4_to_vector3(basis.z()) = normal;
matrix4_transpose(basis);
//DebugAxisBase(normal);
}
else if(g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_HALFLIFE)
{
basis = g_matrix4_identity;
static_cast<Vector3&>(basis.x()) = projection.m_basis_s;
static_cast<Vector3&>(basis.y()) = vector3_negated(projection.m_basis_t);
static_cast<Vector3&>(basis.z()) = vector3_normalised(vector3_cross(static_cast<Vector3&>(basis.x()), static_cast<Vector3&>(basis.y())));
vector4_to_vector3(basis.x()) = projection.m_basis_s;
vector4_to_vector3(basis.y()) = vector3_negated(projection.m_basis_t);
vector4_to_vector3(basis.z()) = vector3_normalised(vector3_cross(vector4_to_vector3(basis.x()), vector4_to_vector3(basis.y())));
matrix4_multiply_by_matrix4(basis, matrix4_rotation_for_z_degrees(-projection.m_texdef.rotate));
//globalOutputStream() << "debug: " << projection.m_basis_s << projection.m_basis_t << normal << "\n";
matrix4_transpose(basis);
@ -1447,8 +1447,8 @@ void BP_from_matrix(brushprimit_texdef_t& bp_texdef, const Vector3& normal, cons
{
Matrix4 basis;
basis = g_matrix4_identity;
ComputeAxisBase(normal, basis.x(), basis.y());
static_cast<Vector3&>(basis.z()) = normal;
ComputeAxisBase(normal, vector4_to_vector3(basis.x()), vector4_to_vector3(basis.y()));
vector4_to_vector3(basis.z()) = normal;
matrix4_transpose(basis);
matrix4_affine_invert(basis);

19
radiant/patch.cpp
View File

@ -2212,24 +2212,15 @@ void Patch::BuildTesselationCurves(EMatrixMajor major)
inline void vertex_assign_ctrl(ArbitraryMeshVertex& vertex, const PatchControl& ctrl)
{
vertex.vertex.x = ctrl.m_vertex[0];
vertex.vertex.y = ctrl.m_vertex[1];
vertex.vertex.z = ctrl.m_vertex[2];
vertex.texcoord.s = ctrl.m_texcoord[0];
vertex.texcoord.t = ctrl.m_texcoord[1];
vertex.vertex = vertex3f_for_vector3(ctrl.m_vertex);
vertex.texcoord = texcoord2f_for_vector2(ctrl.m_texcoord);
}
inline void vertex_clear_normal(ArbitraryMeshVertex& vertex)
{
vertex.normal.x = 0;
vertex.normal.y = 0;
vertex.normal.z = 0;
vertex.tangent.x = 0;
vertex.tangent.y = 0;
vertex.tangent.z = 0;
vertex.bitangent.x = 0;
vertex.bitangent.y = 0;
vertex.bitangent.z = 0;
vertex.normal = Normal3f(0, 0, 0);
vertex.tangent = Normal3f(0, 0, 0);
vertex.bitangent = Normal3f(0, 0, 0);
}
inline void tangents_remove_degenerate(Vector3 tangents[6], Vector2 textureTangents[6], unsigned int flags)

2
radiant/patch.h
View File

@ -1720,7 +1720,7 @@ public:
if(m_dragPlanes.isSelected()) // this should only be true when the transform is a pure translation.
{
m_patch.transform(m_dragPlanes.evaluateTransform(matrix.t()));
m_patch.transform(m_dragPlanes.evaluateTransform(vector4_to_vector3(matrix.t())));
}
}

28
radiant/selection.cpp
View File

@ -476,9 +476,7 @@ public:
for(std::size_t i=0; i<count; ++i)
{
Vector3 world_point(vector4_projected(matrix4_transformed_vector4(m_inverse, clipped[i])));
m_primitives.back().m_points[i].vertex.x = world_point[0];
m_primitives.back().m_points[i].vertex.y = world_point[1];
m_primitives.back().m_points[i].vertex.z = world_point[2];
m_primitives.back().m_points[i].vertex = vertex3f_for_vector3(world_point);
}
}
@ -640,7 +638,7 @@ void BestPoint(std::size_t count, Vector4 clipped[9], SelectionIntersection& bes
Point3D point = segment_closest_point_to_point(segment, Vector3(0, 0, 0));
assign_if_closer(best, SelectionIntersection(point.z(), 0));
}
else if(count > 2 && !point_test_polygon_2d(Vector4(0, 0, 0, 0), normalised, normalised + count))
else if(count > 2 && !point_test_polygon_2d(Vector3(0, 0, 0), normalised, normalised + count))
{
point_iterator_t end = normalised + count;
for(point_iterator_t previous = end-1, current = normalised; current != end; previous = current, ++current)
@ -1252,15 +1250,15 @@ class TripleRemapXYZ
public:
static float& x(Triple& triple)
{
return triple.x;
return triple.x();
}
static float& y(Triple& triple)
{
return triple.y;
return triple.y();
}
static float& z(Triple& triple)
{
return triple.z;
return triple.z();
}
};
@ -1270,15 +1268,15 @@ class TripleRemapYZX
public:
static float& x(Triple& triple)
{
return triple.y;
return triple.y();
}
static float& y(Triple& triple)
{
return triple.z;
return triple.z();
}
static float& z(Triple& triple)
{
return triple.x;
return triple.x();
}
};
@ -1288,15 +1286,15 @@ class TripleRemapZXY
public:
static float& x(Triple& triple)
{
return triple.z;
return triple.z();
}
static float& y(Triple& triple)
{
return triple.x;
return triple.x();
}
static float& z(Triple& triple)
{
return triple.y;
return triple.y();
}
};
@ -3580,11 +3578,11 @@ inline AABB Instance_getPivotBounds(scene::Instance& instance)
Editable* editable = Node_getEditable(instance.path().top());
if(editable != 0)
{
return AABB(matrix4_multiplied_by_matrix4(instance.localToWorld(), editable->getLocalPivot()).t(), Vector3(0, 0, 0));
return AABB(vector4_to_vector3(matrix4_multiplied_by_matrix4(instance.localToWorld(), editable->getLocalPivot()).t()), Vector3(0, 0, 0));
}
else
{
return AABB(instance.localToWorld().t(), Vector3(0, 0, 0));
return AABB(vector4_to_vector3(instance.localToWorld().t()), Vector3(0, 0, 0));
}
}

2
radiant/view.h
View File

@ -204,7 +204,7 @@ public:
}
const Vector3& getViewer() const
{
return m_viewer;
return vector4_to_vector3(m_viewer);
}
};