drewcassidy/nvidia-texture-tools
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge private branch.

Browse Source
This commit is contained in:
castano
2010-05-27 23:19:24 +00:00
parent 51a4fe7e2d
commit c09067e477
13 changed files with 2701 additions and 2622 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
src/nvmath/Box.cpp Executable file
View File

@ -0,0 +1,30 @@
// This code is in the public domain -- castanyo@yahoo.es
#include "nvmath/Box.h"
#include "nvmath/Sphere.h"
using namespace nv;
float nv::distanceSquared(const Box &box, const Vector3 &point) {
Vector3 closest;
if (point.x < box.minCorner.x) closest.x = box.minCorner.x;
else if (point.x > box.maxCorner.x) closest.x = box.maxCorner.x;
else closest.x = point.x;
if (point.y < box.minCorner.y) closest.y = box.minCorner.y;
else if (point.y > box.maxCorner.y) closest.y = box.maxCorner.y;
else closest.y = point.y;
if (point.z < box.minCorner.z) closest.z = box.minCorner.z;
else if (point.z > box.maxCorner.z) closest.z = box.maxCorner.z;
else closest.z = point.z;
return lengthSquared(point - closest);
}
bool nv::overlap(const Box &box, const Sphere &sphere) {
return distanceSquared(box, sphere.center) < sphere.radius * sphere.radius;
}

86
src/nvmath/Box.h
View File

@ -1,15 +1,17 @@
// This code is in the public domain -- castanyo@yahoo.es
#pragma once
#ifndef NV_MATH_BOX_H
#define NV_MATH_BOX_H
#include <nvmath/Vector.h>
#include "Vector.h"
#include <float.h> // FLT_MAX
namespace nv
{
class Stream;
class Sphere;
/// Axis Aligned Bounding Box.
class Box
@ -20,27 +22,19 @@ public:
Box() { };
/// Copy ctor.
Box( const Box & b ) : m_mins(b.m_mins), m_maxs(b.m_maxs) { }
Box(const Box & b) : minCorner(b.minCorner), maxCorner(b.maxCorner) { }
/// Init ctor.
Box( Vector3::Arg mins, Vector3::Arg maxs ) : m_mins(mins), m_maxs(maxs) { }
Box(Vector3::Arg mins, Vector3::Arg maxs) : minCorner(mins), maxCorner(maxs) { }
// Cast operators.
operator const float * () const { return reinterpret_cast<const float *>(this); }
// Min corner of the box.
Vector3 minCorner() const { return m_mins; }
Vector3 & minCorner() { return m_mins; }
// Max corner of the box.
Vector3 maxCorner() const { return m_maxs; }
Vector3 & maxCorner() { return m_maxs; }
/// Clear the bounds.
void clearBounds()
{
m_mins.set(FLT_MAX, FLT_MAX, FLT_MAX);
m_maxs.set(-FLT_MAX, -FLT_MAX, -FLT_MAX);
minCorner.set(FLT_MAX, FLT_MAX, FLT_MAX);
maxCorner.set(-FLT_MAX, -FLT_MAX, -FLT_MAX);
}
/// Build a cube centered on center and with edge = 2*dist
@ -52,29 +46,29 @@ public:
/// Build a box, given center and extents.
void setCenterExtents(Vector3::Arg center, Vector3::Arg extents)
{
m_mins = center - extents;
m_maxs = center + extents;
minCorner = center - extents;
maxCorner = center + extents;
}
/// Get box center.
Vector3 center() const
{
return (m_mins + m_maxs) * 0.5f;
return (minCorner + maxCorner) * 0.5f;
}
/// Return extents of the box.
Vector3 extents() const
{
return (m_maxs - m_mins) * 0.5f;
return (maxCorner - minCorner) * 0.5f;
}
/// Return extents of the box.
scalar extents(uint axis) const
{
nvDebugCheck(axis < 3);
if (axis == 0) return (m_maxs.x() - m_mins.x()) * 0.5f;
if (axis == 1) return (m_maxs.y() - m_mins.y()) * 0.5f;
if (axis == 2) return (m_maxs.z() - m_mins.z()) * 0.5f;
if (axis == 0) return (maxCorner.x - minCorner.x) * 0.5f;
if (axis == 1) return (maxCorner.y - minCorner.y) * 0.5f;
if (axis == 2) return (maxCorner.z - minCorner.z) * 0.5f;
nvAssume(false);
return 0.0f;
}
@ -82,61 +76,81 @@ public:
/// Add a point to this box.
void addPointToBounds(Vector3::Arg p)
{
m_mins = min(m_mins, p);
m_maxs = max(m_maxs, p);
minCorner = min(minCorner, p);
maxCorner = max(maxCorner, p);
}
/// Add a box to this box.
void addBoxToBounds(const Box & b)
{
m_mins = min(m_mins, b.m_mins);
m_maxs = max(m_maxs, b.m_maxs);
minCorner = min(minCorner, b.minCorner);
maxCorner = max(maxCorner, b.maxCorner);
}
/// Translate box.
void translate(Vector3::Arg v)
{
m_mins += v;
m_maxs += v;
minCorner += v;
maxCorner += v;
}
/// Scale the box.
void scale(float s)
{
m_mins *= s;
m_maxs *= s;
minCorner *= s;
maxCorner *= s;
}
// Expand the box by a fixed amount.
void expand(float r) {
minCorner -= Vector3(r,r,r);
maxCorner += Vector3(r,r,r);
}
/// Get the area of the box.
float area() const
{
const Vector3 d = extents();
return 8.0f * (d.x()*d.y() + d.x()*d.z() + d.y()*d.z());
return 8.0f * (d.x*d.y + d.x*d.z + d.y*d.z);
}
/// Get the volume of the box.
float volume() const
{
Vector3 d = extents();
return 8.0f * (d.x() * d.y() * d.z());
return 8.0f * (d.x * d.y * d.z);
}
/// Return true if the box contains the given point.
bool contains(Vector3::Arg p) const
{
return
m_mins.x() < p.x() && m_mins.y() < p.y() && m_mins.z() < p.z() &&
m_maxs.x() > p.x() && m_maxs.y() > p.y() && m_maxs.z() > p.z();
minCorner.x < p.x && minCorner.y < p.y && minCorner.z < p.z &&
maxCorner.x > p.x && maxCorner.y > p.y && maxCorner.z > p.z;
}
/// Split the given box in 8 octants and assign the ith one to this box.
void setOctant(const Box & box, Vector3::Arg center, int i)
{
minCorner = box.minCorner;
maxCorner = box.maxCorner;
if (i & 4) minCorner.x = center.x;
else maxCorner.x = center.x;
if (i & 2) minCorner.y = center.y;
else maxCorner.y = center.y;
if (i & 1) minCorner.z = center.z;
else maxCorner.z = center.z;
}
friend Stream & operator<< (Stream & s, Box & box);
private:
Vector3 m_mins;
Vector3 m_maxs;
Vector3 minCorner;
Vector3 maxCorner;
};
float distanceSquared(const Box &box, const Vector3 &point);
bool overlap(const Box &box, const Sphere &sphere);
} // nv namespace

2
src/nvmath/CMakeLists.txt
View File

@ -5,7 +5,7 @@ SET(MATH_SRCS
Vector.h
Matrix.h
Plane.h Plane.cpp
Box.h
Box.h Box.cpp
Color.h
Half.h Half.cpp
Fitting.h Fitting.cpp)

13
src/nvmath/Color.h
View File

@ -1,10 +1,11 @@
// This code is in the public domain -- castanyo@yahoo.es
#pragma once
#ifndef NV_MATH_COLOR_H
#define NV_MATH_COLOR_H
#include <nvcore/Debug.h>
#include <nvmath/Vector.h>
#include "nvcore/Debug.h"
#include "nvmath/Vector.h"
namespace nv
{
@ -122,16 +123,16 @@ public:
/// Clamp color components.
inline Vector3 colorClamp(Vector3::Arg c)
{
return Vector3(clamp(c.x(), 0.0f, 1.0f), clamp(c.y(), 0.0f, 1.0f), clamp(c.z(), 0.0f, 1.0f));
return Vector3(clamp(c.x, 0.0f, 1.0f), clamp(c.y, 0.0f, 1.0f), clamp(c.z, 0.0f, 1.0f));
}
/// Clamp without allowing the hue to change.
inline Vector3 colorNormalize(Vector3::Arg c)
{
float scale = 1.0f;
if (c.x() > scale) scale = c.x();
if (c.y() > scale) scale = c.y();
if (c.z() > scale) scale = c.z();
if (c.x > scale) scale = c.x;
if (c.y > scale) scale = c.y;
if (c.z > scale) scale = c.z;
return c / scale;
}

38
src/nvmath/Fitting.cpp
View File

@ -1,9 +1,7 @@
// This code is in the public domain -- icastano@gmail.com
#include "Fitting.h"
#include <nvcore/Algorithms.h> // max
#include <nvcore/Containers.h> // swap
#include "nvcore/Utils.h" // max, swap
#include <float.h> // FLT_MAX
@ -12,7 +10,7 @@ using namespace nv;
// @@ Move to EigenSolver.h
static inline Vector3 firstEigenVector_PowerMethod(const float *__restrict matrix)
{
if (matrix[0] == 0 || matrix[3] == 0 || matrix[5] == 0)
if (matrix[0] == 0 && matrix[3] == 0 && matrix[5] == 0)
{
return Vector3(zero);
}
@ -22,9 +20,9 @@ static inline Vector3 firstEigenVector_PowerMethod(const float *__restrict matri
Vector3 v(1, 1, 1);
for (int i = 0; i < NUM; i++)
{
float x = v.x() * matrix[0] + v.y() * matrix[1] + v.z() * matrix[2];
float y = v.x() * matrix[1] + v.y() * matrix[3] + v.z() * matrix[4];
float z = v.x() * matrix[2] + v.y() * matrix[4] + v.z() * matrix[5];
float x = v.x * matrix[0] + v.y * matrix[1] + v.z * matrix[2];
float y = v.x * matrix[1] + v.y * matrix[3] + v.z * matrix[4];
float z = v.x * matrix[2] + v.y * matrix[4] + v.z * matrix[5];
float norm = max(max(x, y), z);
@ -79,12 +77,12 @@ Vector3 nv::Fit::computeCovariance(int n, const Vector3 *__restrict points, floa
{
Vector3 v = points[i] - centroid;
covariance[0] += v.x() * v.x();
covariance[1] += v.x() * v.y();
covariance[2] += v.x() * v.z();
covariance[3] += v.y() * v.y();
covariance[4] += v.y() * v.z();
covariance[5] += v.z() * v.z();
covariance[0] += v.x * v.x;
covariance[1] += v.x * v.y;
covariance[2] += v.x * v.z;
covariance[3] += v.y * v.y;
covariance[4] += v.y * v.z;
covariance[5] += v.z * v.z;
}
return centroid;
@ -106,12 +104,12 @@ Vector3 nv::Fit::computeCovariance(int n, const Vector3 *__restrict points, cons
Vector3 a = (points[i] - centroid) * metric;
Vector3 b = weights[i]*a;
covariance[0] += a.x()*b.x();
covariance[1] += a.x()*b.y();
covariance[2] += a.x()*b.z();
covariance[3] += a.y()*b.y();
covariance[4] += a.y()*b.z();
covariance[5] += a.z()*b.z();
covariance[0] += a.x * b.x;
covariance[1] += a.x * b.y;
covariance[2] += a.x * b.z;
covariance[3] += a.y * b.y;
covariance[4] += a.y * b.z;
covariance[5] += a.z * b.z;
}
return centroid;
@ -204,7 +202,7 @@ int nv::Fit::compute4Means(int n, const Vector3 *__restrict points, const float
float mindist = FLT_MAX;
for (int j = 0; j < 4; j++)
{
float dist = length_squared((cluster[j] - points[i]) * metric);
float dist = lengthSquared((cluster[j] - points[i]) * metric);
if (dist < mindist)
{
mindist = dist;

1
src/nvmath/Fitting.h
View File

@ -1,5 +1,6 @@
// This code is in the public domain -- icastano@gmail.com
#pragma once
#ifndef NV_MATH_FITTING_H
#define NV_MATH_FITTING_H

280
src/nvmath/Half.cpp
View File

@ -88,6 +88,12 @@ static inline uint32 _uint32_dec( uint32 a )
return (a - 1);
}
// Increment
static inline uint32 _uint32_inc( uint32 a )
{
return (a + 1);
}
// Complement
static inline uint32 _uint32_not( uint32 a )
{
@ -97,12 +103,9 @@ static inline uint32 _uint32_not( uint32 a )
// Negate
static inline uint32 _uint32_neg( uint32 a )
{
#if NV_CC_MSVC
// prevent msvc warning.
return ~a + 1;
#else
#pragma warning(disable : 4146) // unary minus operator applied to unsigned type, result still unsigned
return (-a);
#endif
#pragma warning(default : 4146)
}
// Extend sign
@ -272,14 +275,33 @@ static inline uint16 _uint16_sels( uint16 test, uint16 a, uint16 b )
return (result);
}
#if NV_CC_MSVC
#include <intrin.h>
#pragma intrinsic(_BitScanReverse)
uint32 _uint32_nlz( uint32 x ) {
unsigned long index;
_BitScanReverse(&index, x);
return 31 - index;
}
#endif
// Count Leading Zeros
static inline uint32 _uint32_cntlz( uint32 x )
{
#ifdef __GNUC__
#if NV_CC_GCC
/* On PowerPC, this will map to insn: cntlzw */
/* On Pentium, this will map to insn: clz */
uint32 is_x_nez_msb = _uint32_neg( x );
uint32 nlz = __builtin_clz( x );
return (nlz);
uint32 result = _uint32_sels( is_x_nez_msb, nlz, 0x00000020 );
return (result);
#elif NV_CC_MSVC
uint32 is_x_nez_msb = _uint32_neg( x );
uint32 nlz = _uint32_nlz( x );
uint32 result = _uint32_sels( is_x_nez_msb, nlz, 0x00000020 );
return (result);
#else
const uint32 x0 = _uint32_srl( x, 1 );
const uint32 x1 = _uint32_or( x, x0 );
@ -317,8 +339,8 @@ static inline uint16 _uint16_cntlz( uint16 x )
#ifdef __GNUC__
/* On PowerPC, this will map to insn: cntlzw */
/* On Pentium, this will map to insn: clz */
uint32 x32 = _uint32_sll( x, 16 );
uint16 nlz = (uint16)__builtin_clz( x32 );
uint16 nlz32 = (uint16)_uint32_cntlz( (uint32)x );
uint32 nlz = _uint32_sub( nlz32, 16 );
return (nlz);
#else
const uint16 x0 = _uint16_srl( x, 1 );
@ -344,63 +366,72 @@ static inline uint16 _uint16_cntlz( uint16 x )
}
uint16
half_from_float( uint32 f )
nv::half_from_float( uint32 f )
{
const uint32 one = _uint32_li( 0x00000001 );
const uint32 f_s_mask = _uint32_li( 0x80000000 );
const uint32 f_e_mask = _uint32_li( 0x7f800000 );
const uint32 f_m_mask = _uint32_li( 0x007fffff );
const uint32 f_s_mask = _uint32_li( 0x80000000 );
const uint32 h_e_mask = _uint32_li( 0x00007c00 );
const uint32 f_e_pos = _uint32_li( 0x00000017 );
const uint32 f_m_round_bit = _uint32_li( 0x00001000 );
const uint32 h_nan_em_min = _uint32_li( 0x00007c01 );
const uint32 f_h_s_pos_offset = _uint32_li( 0x00000010 );
const uint32 f_m_hidden_bit = _uint32_li( 0x00800000 );
const uint32 f_m_round_bit = _uint32_li( 0x00001000 );
const uint32 f_snan_mask = _uint32_li( 0x7fc00000 );
const uint32 f_e_pos = _uint32_li( 0x00000017 );
const uint32 h_e_pos = _uint32_li( 0x0000000a );
const uint32 h_e_mask = _uint32_li( 0x00007c00 );
const uint32 h_snan_mask = _uint32_li( 0x00007e00 );
const uint32 h_e_mask_value = _uint32_li( 0x0000001f );
const uint32 f_h_s_pos_offset = _uint32_li( 0x00000010 );
const uint32 f_h_bias_offset = _uint32_li( 0x00000070 );
const uint32 f_h_m_pos_offset = _uint32_li( 0x0000000d );
const uint32 f_h_bias_offset = _uint32_li( 0x38000000 );
const uint32 f_m_snan_mask = _uint32_li( 0x003fffff );
const uint16 h_snan_mask = _uint32_li( 0x00007e00 );
const uint32 f_e = _uint32_and( f, f_e_mask );
const uint32 f_m = _uint32_and( f, f_m_mask );
const uint32 h_nan_min = _uint32_li( 0x00007c01 );
const uint32 f_h_e_biased_flag = _uint32_li( 0x0000008f );
const uint32 f_s = _uint32_and( f, f_s_mask );
const uint32 f_e_h_bias = _uint32_sub( f_e, f_h_bias_offset );
const uint32 f_e_h_bias_amount = _uint32_srl( f_e_h_bias, f_e_pos );
const uint32 f_e = _uint32_and( f, f_e_mask );
const uint16 h_s = _uint32_srl( f_s, f_h_s_pos_offset );
const uint32 f_m = _uint32_and( f, f_m_mask );
const uint16 f_e_amount = _uint32_srl( f_e, f_e_pos );
const uint32 f_e_half_bias = _uint32_sub( f_e_amount, f_h_bias_offset );
const uint32 f_snan = _uint32_and( f, f_snan_mask );
const uint32 f_m_round_mask = _uint32_and( f_m, f_m_round_bit );
const uint32 f_m_round_offset = _uint32_sll( f_m_round_mask, one );
const uint32 f_m_rounded = _uint32_add( f_m, f_m_round_offset );
const uint32 f_m_rounded_overflow = _uint32_and( f_m_rounded, f_m_hidden_bit );
const uint32 f_m_denorm_sa = _uint32_sub( one, f_e_h_bias_amount );
const uint32 f_m_denorm_sa = _uint32_sub( one, f_e_half_bias );
const uint32 f_m_with_hidden = _uint32_or( f_m_rounded, f_m_hidden_bit );
const uint32 f_m_denorm = _uint32_srl( f_m_with_hidden, f_m_denorm_sa );
const uint32 f_em_norm_packed = _uint32_or( f_e_h_bias, f_m_rounded );
const uint32 f_e_overflow = _uint32_add( f_e_h_bias, f_m_hidden_bit );
const uint32 h_s = _uint32_srl( f_s, f_h_s_pos_offset );
const uint32 h_m_nan = _uint32_srl( f_m, f_h_m_pos_offset );
const uint32 h_m_denorm = _uint32_srl( f_m_denorm, f_h_m_pos_offset );
const uint32 h_em_norm = _uint32_srl( f_em_norm_packed, f_h_m_pos_offset );
const uint32 h_em_overflow = _uint32_srl( f_e_overflow, f_h_m_pos_offset );
const uint32 is_e_eqz_msb = _uint32_dec( f_e );
const uint32 is_m_nez_msb = _uint32_neg( f_m );
const uint32 is_h_m_nan_nez_msb = _uint32_neg( h_m_nan );
const uint32 is_e_nflagged_msb = _uint32_sub( f_e, f_e_mask );
const uint32 is_ninf_msb = _uint32_or( is_e_nflagged_msb, is_m_nez_msb );
const uint32 is_underflow_msb = _uint32_sub( is_e_eqz_msb, f_h_bias_offset );
const uint32 is_nan_nunderflow_msb = _uint32_or( is_h_m_nan_nez_msb, is_e_nflagged_msb );
const uint32 is_m_snan_msb = _uint32_sub( f_m_snan_mask, f_m );
const uint32 is_snan_msb = _uint32_andc( is_m_snan_msb, is_e_nflagged_msb );
const uint32 is_overflow_msb = _uint32_neg( f_m_rounded_overflow );
const uint32 h_nan_underflow_result = _uint32_sels( is_nan_nunderflow_msb, h_em_norm, h_nan_em_min );
const uint32 h_inf_result = _uint32_sels( is_ninf_msb, h_nan_underflow_result, h_e_mask );
const uint32 h_underflow_result = _uint32_sels( is_underflow_msb, h_m_denorm, h_inf_result );
const uint32 h_overflow_result = _uint32_sels( is_overflow_msb, h_em_overflow, h_underflow_result );
const uint32 h_em_result = _uint32_sels( is_snan_msb, h_snan_mask, h_overflow_result );
const uint32 h_result = _uint32_or( h_em_result, h_s );
const uint32 f_m_rounded_overflow = _uint32_and( f_m_rounded, f_m_hidden_bit );
const uint32 m_nan = _uint32_srl( f_m, f_h_m_pos_offset );
const uint32 h_em_nan = _uint32_or( h_e_mask, m_nan );
const uint32 h_e_norm_overflow_offset = _uint32_inc( f_e_half_bias );
const uint32 h_e_norm_overflow = _uint32_sll( h_e_norm_overflow_offset, h_e_pos );
const uint32 h_e_norm = _uint32_sll( f_e_half_bias, h_e_pos );
const uint32 h_m_norm = _uint32_srl( f_m_rounded, f_h_m_pos_offset );
const uint32 h_em_norm = _uint32_or( h_e_norm, h_m_norm );
const uint32 is_h_ndenorm_msb = _uint32_sub( f_h_bias_offset, f_e_amount );
const uint32 is_f_e_flagged_msb = _uint32_sub( f_h_e_biased_flag, f_e_half_bias );
const uint32 is_h_denorm_msb = _uint32_not( is_h_ndenorm_msb );
const uint32 is_f_m_eqz_msb = _uint32_dec( f_m );
const uint32 is_h_nan_eqz_msb = _uint32_dec( m_nan );
const uint32 is_f_inf_msb = _uint32_and( is_f_e_flagged_msb, is_f_m_eqz_msb );
const uint32 is_f_nan_underflow_msb = _uint32_and( is_f_e_flagged_msb, is_h_nan_eqz_msb );
const uint32 is_e_overflow_msb = _uint32_sub( h_e_mask_value, f_e_half_bias );
const uint32 is_h_inf_msb = _uint32_or( is_e_overflow_msb, is_f_inf_msb );
const uint32 is_f_nsnan_msb = _uint32_sub( f_snan, f_snan_mask );
const uint32 is_m_norm_overflow_msb = _uint32_neg( f_m_rounded_overflow );
const uint32 is_f_snan_msb = _uint32_not( is_f_nsnan_msb );
const uint32 h_em_overflow_result = _uint32_sels( is_m_norm_overflow_msb, h_e_norm_overflow, h_em_norm );
const uint32 h_em_nan_result = _uint32_sels( is_f_e_flagged_msb, h_em_nan, h_em_overflow_result );
const uint32 h_em_nan_underflow_result = _uint32_sels( is_f_nan_underflow_msb, h_nan_min, h_em_nan_result );
const uint32 h_em_inf_result = _uint32_sels( is_h_inf_msb, h_e_mask, h_em_nan_underflow_result );
const uint32 h_em_denorm_result = _uint32_sels( is_h_denorm_msb, h_m_denorm, h_em_inf_result );
const uint32 h_em_snan_result = _uint32_sels( is_f_snan_msb, h_snan_mask, h_em_denorm_result );
const uint32 h_result = _uint32_or( h_s, h_em_snan_result );
return (h_result);
return (uint16)(h_result);
}
uint32
half_to_float( uint16 h )
nv::half_to_float( uint16 h )
{
const uint32 h_e_mask = _uint32_li( 0x00007c00 );
const uint32 h_m_mask = _uint32_li( 0x000003ff );
@ -447,117 +478,46 @@ half_to_float( uint16 h )
return (f_result);
}
uint16
half_add( uint16 x, uint16 y )
uint32
nv::fast_half_to_float( uint16 h )
{
const uint16 one = _uint16_li( 0x0001 );
const uint16 msb_to_lsb_sa = _uint16_li( 0x000f );
const uint16 h_s_mask = _uint16_li( 0x8000 );
const uint16 h_e_mask = _uint16_li( 0x7c00 );
const uint16 h_m_mask = _uint16_li( 0x03ff );
const uint16 h_m_msb_mask = _uint16_li( 0x2000 );
const uint16 h_m_msb_sa = _uint16_li( 0x000d );
const uint16 h_m_hidden = _uint16_li( 0x0400 );
const uint16 h_e_pos = _uint16_li( 0x000a );
const uint16 h_e_bias_minus_one = _uint16_li( 0x000e );
const uint16 h_m_grs_carry = _uint16_li( 0x4000 );
const uint16 h_m_grs_carry_pos = _uint16_li( 0x000e );
const uint16 h_grs_size = _uint16_li( 0x0003 );
const uint16 h_snan = _uint16_li( 0xfe00 );
const uint16 h_e_mask_minus_one = _uint16_li( 0x7bff );
const uint16 h_grs_round_carry = _uint16_sll( one, h_grs_size );
const uint16 h_grs_round_mask = _uint16_sub( h_grs_round_carry, one );
const uint16 x_e = _uint16_and( x, h_e_mask );
const uint16 y_e = _uint16_and( y, h_e_mask );
const uint16 is_y_e_larger_msb = _uint16_sub( x_e, y_e );
const uint16 a = _uint16_sels( is_y_e_larger_msb, y, x);
const uint16 a_s = _uint16_and( a, h_s_mask );
const uint16 a_e = _uint16_and( a, h_e_mask );
const uint16 a_m_no_hidden_bit = _uint16_and( a, h_m_mask );
const uint16 a_em_no_hidden_bit = _uint16_or( a_e, a_m_no_hidden_bit );
const uint16 b = _uint16_sels( is_y_e_larger_msb, x, y);
const uint16 b_s = _uint16_and( b, h_s_mask );
const uint16 b_e = _uint16_and( b, h_e_mask );
const uint16 b_m_no_hidden_bit = _uint16_and( b, h_m_mask );
const uint16 b_em_no_hidden_bit = _uint16_or( b_e, b_m_no_hidden_bit );
const uint16 is_diff_sign_msb = _uint16_xor( a_s, b_s );
const uint16 is_a_inf_msb = _uint16_sub( h_e_mask_minus_one, a_em_no_hidden_bit );
const uint16 is_b_inf_msb = _uint16_sub( h_e_mask_minus_one, b_em_no_hidden_bit );
const uint16 is_undenorm_msb = _uint16_dec( a_e );
const uint16 is_undenorm = _uint16_ext( is_undenorm_msb );
const uint16 is_both_inf_msb = _uint16_and( is_a_inf_msb, is_b_inf_msb );
const uint16 is_invalid_inf_op_msb = _uint16_and( is_both_inf_msb, b_s );
const uint16 is_a_e_nez_msb = _uint16_neg( a_e );
const uint16 is_b_e_nez_msb = _uint16_neg( b_e );
const uint16 is_a_e_nez = _uint16_ext( is_a_e_nez_msb );
const uint16 is_b_e_nez = _uint16_ext( is_b_e_nez_msb );
const uint16 a_m_hidden_bit = _uint16_and( is_a_e_nez, h_m_hidden );
const uint16 b_m_hidden_bit = _uint16_and( is_b_e_nez, h_m_hidden );
const uint16 a_m_no_grs = _uint16_or( a_m_no_hidden_bit, a_m_hidden_bit );
const uint16 b_m_no_grs = _uint16_or( b_m_no_hidden_bit, b_m_hidden_bit );
const uint16 diff_e = _uint16_sub( a_e, b_e );
const uint16 a_e_unbias = _uint16_sub( a_e, h_e_bias_minus_one );
const uint16 a_m = _uint16_sll( a_m_no_grs, h_grs_size );
const uint16 a_e_biased = _uint16_srl( a_e, h_e_pos );
const uint16 m_sa_unbias = _uint16_srl( a_e_unbias, h_e_pos );
const uint16 m_sa_default = _uint16_srl( diff_e, h_e_pos );
const uint16 m_sa_unbias_mask = _uint16_andc( is_a_e_nez_msb, is_b_e_nez_msb );
const uint16 m_sa = _uint16_sels( m_sa_unbias_mask, m_sa_unbias, m_sa_default );
const uint16 b_m_no_sticky = _uint16_sll( b_m_no_grs, h_grs_size );
const uint16 sh_m = _uint16_srl( b_m_no_sticky, m_sa );
const uint16 sticky_overflow = _uint16_sll( one, m_sa );
const uint16 sticky_mask = _uint16_dec( sticky_overflow );
const uint16 sticky_collect = _uint16_and( b_m_no_sticky, sticky_mask );
const uint16 is_sticky_set_msb = _uint16_neg( sticky_collect );
const uint16 sticky = _uint16_srl( is_sticky_set_msb, msb_to_lsb_sa);
const uint16 b_m = _uint16_or( sh_m, sticky );
const uint16 is_c_m_ab_pos_msb = _uint16_sub( b_m, a_m );
const uint16 c_inf = _uint16_or( a_s, h_e_mask );
const uint16 c_m_sum = _uint16_add( a_m, b_m );
const uint16 c_m_diff_ab = _uint16_sub( a_m, b_m );
const uint16 c_m_diff_ba = _uint16_sub( b_m, a_m );
const uint16 c_m_smag_diff = _uint16_sels( is_c_m_ab_pos_msb, c_m_diff_ab, c_m_diff_ba );
const uint16 c_s_diff = _uint16_sels( is_c_m_ab_pos_msb, a_s, b_s );
const uint16 c_s = _uint16_sels( is_diff_sign_msb, c_s_diff, a_s );
const uint16 c_m_smag_diff_nlz = _uint16_cntlz( c_m_smag_diff );
const uint16 diff_norm_sa = _uint16_sub( c_m_smag_diff_nlz, one );
const uint16 is_diff_denorm_msb = _uint16_sub( a_e_biased, diff_norm_sa );
const uint16 is_diff_denorm = _uint16_ext( is_diff_denorm_msb );
const uint16 is_a_or_b_norm_msb = _uint16_neg( a_e_biased );
const uint16 diff_denorm_sa = _uint16_dec( a_e_biased );
const uint16 c_m_diff_denorm = _uint16_sll( c_m_smag_diff, diff_denorm_sa );
const uint16 c_m_diff_norm = _uint16_sll( c_m_smag_diff, diff_norm_sa );
const uint16 c_e_diff_norm = _uint16_sub( a_e_biased, diff_norm_sa );
const uint16 c_m_diff_ab_norm = _uint16_sels( is_diff_denorm_msb, c_m_diff_denorm, c_m_diff_norm );
const uint16 c_e_diff_ab_norm = _uint16_andc( c_e_diff_norm, is_diff_denorm );
const uint16 c_m_diff = _uint16_sels( is_a_or_b_norm_msb, c_m_diff_ab_norm, c_m_smag_diff );
const uint16 c_e_diff = _uint16_sels( is_a_or_b_norm_msb, c_e_diff_ab_norm, a_e_biased );
const uint16 is_diff_eqz_msb = _uint16_dec( c_m_diff );
const uint16 is_diff_exactly_zero_msb = _uint16_and( is_diff_sign_msb, is_diff_eqz_msb );
const uint16 is_diff_exactly_zero = _uint16_ext( is_diff_exactly_zero_msb );
const uint16 c_m_added = _uint16_sels( is_diff_sign_msb, c_m_diff, c_m_sum );
const uint16 c_e_added = _uint16_sels( is_diff_sign_msb, c_e_diff, a_e_biased );
const uint16 c_m_carry = _uint16_and( c_m_added, h_m_grs_carry );
const uint16 is_c_m_carry_msb = _uint16_neg( c_m_carry );
const uint16 c_e_hidden_offset = _uint16_andsrl( c_m_added, h_m_grs_carry, h_m_grs_carry_pos );
const uint16 c_m_sub_hidden = _uint16_srl( c_m_added, one );
const uint16 c_m_no_hidden = _uint16_sels( is_c_m_carry_msb, c_m_sub_hidden, c_m_added );
const uint16 c_e_no_hidden = _uint16_add( c_e_added, c_e_hidden_offset );
const uint16 c_m_no_hidden_msb = _uint16_and( c_m_no_hidden, h_m_msb_mask );
const uint16 undenorm_m_msb_odd = _uint16_srl( c_m_no_hidden_msb, h_m_msb_sa );
const uint16 undenorm_fix_e = _uint16_and( is_undenorm, undenorm_m_msb_odd );
const uint16 c_e_fixed = _uint16_add( c_e_no_hidden, undenorm_fix_e );
const uint16 c_m_round_amount = _uint16_and( c_m_no_hidden, h_grs_round_mask );
const uint16 c_m_rounded = _uint16_add( c_m_no_hidden, c_m_round_amount );
const uint16 c_m_round_overflow = _uint16_andsrl( c_m_rounded, h_m_grs_carry, h_m_grs_carry_pos );
const uint16 c_e_rounded = _uint16_add( c_e_fixed, c_m_round_overflow );
const uint16 c_m_no_grs = _uint16_srlm( c_m_rounded, h_grs_size, h_m_mask );
const uint16 c_e = _uint16_sll( c_e_rounded, h_e_pos );
const uint16 c_em = _uint16_or( c_e, c_m_no_grs );
const uint16 c_normal = _uint16_or( c_s, c_em );
const uint16 c_inf_result = _uint16_sels( is_a_inf_msb, c_inf, c_normal );
const uint16 c_zero_result = _uint16_andc( c_inf_result, is_diff_exactly_zero );
const uint16 c_result = _uint16_sels( is_invalid_inf_op_msb, h_snan, c_zero_result );
const uint32 h_e_mask = _uint32_li( 0x00007c00 );
const uint32 h_m_mask = _uint32_li( 0x000003ff );
const uint32 h_s_mask = _uint32_li( 0x00008000 );
const uint32 h_f_s_pos_offset = _uint32_li( 0x00000010 );
const uint32 h_f_e_pos_offset = _uint32_li( 0x0000000d );
const uint32 h_f_bias_offset = _uint32_li( 0x0001c000 );
const uint32 f_e_mask = _uint32_li( 0x7f800000 );
const uint32 f_m_mask = _uint32_li( 0x007fffff );
const uint32 h_f_e_denorm_bias = _uint32_li( 0x0000007e );
const uint32 h_f_m_denorm_sa_bias = _uint32_li( 0x00000008 );
const uint32 f_e_pos = _uint32_li( 0x00000017 );
const uint32 h_e_mask_minus_one = _uint32_li( 0x00007bff );
const uint32 h_e = _uint32_and( h, h_e_mask );
const uint32 h_m = _uint32_and( h, h_m_mask );
const uint32 h_s = _uint32_and( h, h_s_mask );
const uint32 h_e_f_bias = _uint32_add( h_e, h_f_bias_offset );
const uint32 h_m_nlz = _uint32_cntlz( h_m );
const uint32 f_s = _uint32_sll( h_s, h_f_s_pos_offset );
const uint32 f_e = _uint32_sll( h_e_f_bias, h_f_e_pos_offset );
const uint32 f_m = _uint32_sll( h_m, h_f_e_pos_offset );
const uint32 f_em = _uint32_or( f_e, f_m );
const uint32 h_f_m_sa = _uint32_sub( h_m_nlz, h_f_m_denorm_sa_bias );
const uint32 f_e_denorm_unpacked = _uint32_sub( h_f_e_denorm_bias, h_f_m_sa );
const uint32 h_f_m = _uint32_sll( h_m, h_f_m_sa );
const uint32 f_m_denorm = _uint32_and( h_f_m, f_m_mask );
const uint32 f_e_denorm = _uint32_sll( f_e_denorm_unpacked, f_e_pos );
const uint32 f_em_denorm = _uint32_or( f_e_denorm, f_m_denorm );
const uint32 f_em_nan = _uint32_or( f_e_mask, f_m );
const uint32 is_e_eqz_msb = _uint32_dec( h_e );
const uint32 is_m_nez_msb = _uint32_neg( h_m );
const uint32 is_e_flagged_msb = _uint32_sub( h_e_mask_minus_one, h_e );
const uint32 is_zero_msb = _uint32_andc( is_e_eqz_msb, is_m_nez_msb );
const uint32 is_denorm_msb = _uint32_and( is_m_nez_msb, is_e_eqz_msb );
const uint32 is_zero = _uint32_ext( is_zero_msb );
const uint32 f_zero_result = _uint32_andc( f_em, is_zero );
const uint32 f_denorm_result = _uint32_sels( is_denorm_msb, f_em_denorm, f_zero_result );
const uint32 f_result = _uint32_or( f_s, f_denorm_result );
return (c_result);
return (f_result);
}

12
src/nvmath/Half.h
View File

@ -1,9 +1,17 @@
#pragma once
#ifndef NV_MATH_HALF_H
#define NV_MATH_HALF_H
#include <nvmath/nvmath.h>
#include "nvmath.h"
namespace nv {
uint32 half_to_float( uint16 h );
uint16 half_from_float( uint32 f );
#endif /* NV_MATH_HALF_H */
// Does not handle NaN or infinity.
uint32 fast_half_to_float( uint16 h );
} // nv namespace
#endif // NV_MATH_HALF_H

224
src/nvmath/Matrix.h
View File

@ -1,5 +1,6 @@
// This code is in the public domain -- castanyo@yahoo.es
#pragma once
#ifndef NV_MATH_MATRIX_H
#define NV_MATH_MATRIX_H
@ -9,7 +10,174 @@
namespace nv
{
// @@ Use scalar defined in Vector.h, but should use a template instead.
class NVMATH_CLASS Matrix3
{
public:
Matrix3();
Matrix3(zero_t);
Matrix3(identity_t);
Matrix3(const Matrix3 & m);
Matrix3(Vector3::Arg v0, Vector3::Arg v1, Vector3::Arg v2);
scalar get(uint row, uint col) const;
scalar operator()(uint row, uint col) const;
scalar & operator()(uint row, uint col);
Vector3 row(uint i) const;
Vector3 column(uint i) const;
void operator*=(float s);
void operator/=(float s);
void operator+=(const Matrix3 & m);
void operator-=(const Matrix3 & m);
private:
scalar m_data[9];
};
inline Matrix3::Matrix3() {}
inline Matrix3::Matrix3(zero_t)
{
for(int i = 0; i < 9; i++) {
m_data[i] = 0.0f;
}
}
inline Matrix3::Matrix3(identity_t)
{
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
m_data[3*j+i] = (i == j) ? 1.0f : 0.0f;
}
}
}
inline Matrix3::Matrix3(const Matrix3 & m)
{
for(int i = 0; i < 9; i++) {
m_data[i] = m.m_data[i];
}
}
inline Matrix3::Matrix3(Vector3::Arg v0, Vector3::Arg v1, Vector3::Arg v2)
{
m_data[0] = v0.x; m_data[1] = v0.y; m_data[2] = v0.z;
m_data[3] = v1.x; m_data[4] = v1.y; m_data[5] = v1.z;
m_data[6] = v2.x; m_data[7] = v2.y; m_data[8] = v2.z;
}
inline scalar Matrix3::get(uint row, uint col) const
{
nvDebugCheck(row < 3 && col < 3);
return m_data[col * 3 + row];
}
inline scalar Matrix3::operator()(uint row, uint col) const
{
nvDebugCheck(row < 3 && col < 3);
return m_data[col * 3 + row];
}
inline scalar & Matrix3::operator()(uint row, uint col)
{
nvDebugCheck(row < 3 && col < 3);
return m_data[col * 3 + row];
}
inline Vector3 Matrix3::row(uint i) const
{
nvDebugCheck(i < 3);
return Vector3(get(i, 0), get(i, 1), get(i, 2));
}
inline Vector3 Matrix3::column(uint i) const
{
nvDebugCheck(i < 3);
return Vector3(get(0, i), get(1, i), get(2, i));
}
inline void Matrix3::operator*=(float s)
{
for(int i = 0; i < 9; i++) {
m_data[i] *= s;
}
}
inline void Matrix3::operator/=(float s)
{
float is = 1.0f /s;
for(int i = 0; i < 9; i++) {
m_data[i] *= is;
}
}
inline void Matrix3::operator+=(const Matrix3 & m)
{
for(int i = 0; i < 9; i++) {
m_data[i] += m.m_data[i];
}
}
inline void Matrix3::operator-=(const Matrix3 & m)
{
for(int i = 0; i < 9; i++) {
m_data[i] -= m.m_data[i];
}
}
inline Matrix3 operator+(const Matrix3 & a, const Matrix3 & b)
{
Matrix3 m = a;
m += b;
return m;
}
inline Matrix3 operator-(const Matrix3 & a, const Matrix3 & b)
{
Matrix3 m = a;
m -= b;
return m;
}
inline Matrix3 operator*(const Matrix3 & a, float s)
{
Matrix3 m = a;
m *= s;
return m;
}
inline Matrix3 operator*(float s, const Matrix3 & a)
{
Matrix3 m = a;
m *= s;
return m;
}
inline Matrix3 operator/(const Matrix3 & a, float s)
{
Matrix3 m = a;
m /= s;
return m;
}
inline Matrix3 mul(const Matrix3 & a, const Matrix3 & b)
{
Matrix3 m;
for(int i = 0; i < 3; i++) {
const scalar ai0 = a(i,0), ai1 = a(i,1), ai2 = a(i,2);
m(i, 0) = ai0 * b(0,0) + ai1 * b(1,0) + ai2 * b(2,0);
m(i, 1) = ai0 * b(0,1) + ai1 * b(1,1) + ai2 * b(2,1);
m(i, 2) = ai0 * b(0,2) + ai1 * b(1,2) + ai2 * b(2,2);
}
return m;
}
inline Matrix3 operator*(const Matrix3 & a, const Matrix3 & b)
{
return mul(a, b);
}
/// 4x4 transformation matrix.
/// -# Matrices are stored in memory in column major order.
@ -79,10 +247,10 @@ inline Matrix::Matrix(const Matrix & m)
inline Matrix::Matrix(Vector4::Arg v0, Vector4::Arg v1, Vector4::Arg v2, Vector4::Arg v3)
{
m_data[ 0] = v0.x(); m_data[ 1] = v0.y(); m_data[ 2] = v0.z(); m_data[ 3] = v0.w();
m_data[ 4] = v1.x(); m_data[ 5] = v1.y(); m_data[ 6] = v1.z(); m_data[ 7] = v1.w();
m_data[ 8] = v2.x(); m_data[ 9] = v2.y(); m_data[10] = v2.z(); m_data[11] = v2.w();
m_data[12] = v3.x(); m_data[13] = v3.y(); m_data[14] = v3.z(); m_data[15] = v3.w();
m_data[ 0] = v0.x; m_data[ 1] = v0.y; m_data[ 2] = v0.z; m_data[ 3] = v0.w;
m_data[ 4] = v1.x; m_data[ 5] = v1.y; m_data[ 6] = v1.z; m_data[ 7] = v1.w;
m_data[ 8] = v2.x; m_data[ 9] = v2.y; m_data[10] = v2.z; m_data[11] = v2.w;
m_data[12] = v3.x; m_data[13] = v3.y; m_data[14] = v3.z; m_data[15] = v3.w;
}
inline Matrix::Matrix(const scalar m[])
@ -149,18 +317,18 @@ inline void Matrix::scale(scalar s)
/// Apply scale.
inline void Matrix::scale(Vector3::Arg s)
{
m_data[0] *= s.x(); m_data[1] *= s.x(); m_data[2] *= s.x(); m_data[3] *= s.x();
m_data[4] *= s.y(); m_data[5] *= s.y(); m_data[6] *= s.y(); m_data[7] *= s.y();
m_data[8] *= s.z(); m_data[9] *= s.z(); m_data[10] *= s.z(); m_data[11] *= s.z();
m_data[0] *= s.x; m_data[1] *= s.x; m_data[2] *= s.x; m_data[3] *= s.x;
m_data[4] *= s.y; m_data[5] *= s.y; m_data[6] *= s.y; m_data[7] *= s.y;
m_data[8] *= s.z; m_data[9] *= s.z; m_data[10] *= s.z; m_data[11] *= s.z;
}
/// Apply translation.
inline void Matrix::translate(Vector3::Arg t)
{
m_data[12] = m_data[0] * t.x() + m_data[4] * t.y() + m_data[8] * t.z() + m_data[12];
m_data[13] = m_data[1] * t.x() + m_data[5] * t.y() + m_data[9] * t.z() + m_data[13];
m_data[14] = m_data[2] * t.x() + m_data[6] * t.y() + m_data[10] * t.z() + m_data[14];
m_data[15] = m_data[3] * t.x() + m_data[7] * t.y() + m_data[11] * t.z() + m_data[15];
m_data[12] = m_data[0] * t.x + m_data[4] * t.y + m_data[8] * t.z + m_data[12];
m_data[13] = m_data[1] * t.x + m_data[5] * t.y + m_data[9] * t.z + m_data[13];
m_data[14] = m_data[2] * t.x + m_data[6] * t.y + m_data[10] * t.z + m_data[14];
m_data[15] = m_data[3] * t.x + m_data[7] * t.y + m_data[11] * t.z + m_data[15];
}
Matrix rotation(scalar theta, scalar v0, scalar v1, scalar v2);
@ -190,9 +358,9 @@ inline void Matrix::apply(Matrix::Arg m)
inline Matrix scale(Vector3::Arg s)
{
Matrix m(identity);
m(0,0) = s.x();
m(1,1) = s.y();
m(2,2) = s.z();
m(0,0) = s.x;
m(1,1) = s.y;
m(2,2) = s.z;
return m;
}
@ -208,9 +376,9 @@ inline Matrix scale(scalar s)
inline Matrix translation(Vector3::Arg t)
{
Matrix m(identity);
m(0,3) = t.x();
m(1,3) = t.y();
m(2,3) = t.z();
m(0,3) = t.x;
m(1,3) = t.y;
m(2,3) = t.z;
return m;
}
@ -405,28 +573,28 @@ inline Matrix isometryInverse(Matrix::Arg m)
inline Vector3 transformPoint(Matrix::Arg m, Vector3::Arg p)
{
return Vector3(
p.x() * m(0,0) + p.y() * m(0,1) + p.z() * m(0,2) + m(0,3),
p.x() * m(1,0) + p.y() * m(1,1) + p.z() * m(1,2) + m(1,3),
p.x() * m(2,0) + p.y() * m(2,1) + p.z() * m(2,2) + m(2,3));
p.x * m(0,0) + p.y * m(0,1) + p.z * m(0,2) + m(0,3),
p.x * m(1,0) + p.y * m(1,1) + p.z * m(1,2) + m(1,3),
p.x * m(2,0) + p.y * m(2,1) + p.z * m(2,2) + m(2,3));
}
/// Transform the given 3d vector with the given matrix.
inline Vector3 transformVector(Matrix::Arg m, Vector3::Arg p)
{
return Vector3(
p.x() * m(0,0) + p.y() * m(0,1) + p.z() * m(0,2),
p.x() * m(1,0) + p.y() * m(1,1) + p.z() * m(1,2),
p.x() * m(2,0) + p.y() * m(2,1) + p.z() * m(2,2));
p.x * m(0,0) + p.y * m(0,1) + p.z * m(0,2),
p.x * m(1,0) + p.y * m(1,1) + p.z * m(1,2),
p.x * m(2,0) + p.y * m(2,1) + p.z * m(2,2));
}
/// Transform the given 4d vector with the given matrix.
inline Vector4 transform(Matrix::Arg m, Vector4::Arg p)
{
return Vector4(
p.x() * m(0,0) + p.y() * m(0,1) + p.z() * m(0,2) + p.w() * m(0,3),
p.x() * m(1,0) + p.y() * m(1,1) + p.z() * m(1,2) + p.w() * m(1,3),
p.x() * m(2,0) + p.y() * m(2,1) + p.z() * m(2,2) + p.w() * m(2,3),
p.x() * m(3,0) + p.y() * m(3,1) + p.z() * m(3,2) + p.w() * m(3,3));
p.x * m(0,0) + p.y * m(0,1) + p.z * m(0,2) + p.w * m(0,3),
p.x * m(1,0) + p.y * m(1,1) + p.z * m(1,2) + p.w * m(1,3),
p.x * m(2,0) + p.y * m(2,1) + p.z * m(2,2) + p.w * m(2,3),
p.x * m(3,0) + p.y * m(3,1) + p.z * m(3,2) + p.w * m(3,3));
}
inline Matrix mul(Matrix::Arg a, Matrix::Arg b)

9
src/nvmath/Plane.cpp
View File

@ -14,4 +14,13 @@ namespace nv
return Plane(newVec, ptInPlane);
}
Vector3 planeIntersection(Plane::Arg a, Plane::Arg b, Plane::Arg c)
{
return dot(a.vector(), cross(b.vector(), c.vector())) * (
a.offset() * cross(b.vector(), c.vector()) +
c.offset() * cross(a.vector(), b.vector()) +
b.offset() * cross(c.vector(), a.vector()));
}
} // nv namespace

10
src/nvmath/Plane.h
View File

@ -1,10 +1,11 @@
// This code is in the public domain -- castanyo@yahoo.es
#pragma once
#ifndef NV_MATH_PLANE_H
#define NV_MATH_PLANE_H
#include "nvmath.h"
#include "Vector.h"
#include <nvmath/nvmath.h>
#include <nvmath/Vector.h>
namespace nv
{
@ -45,7 +46,7 @@ namespace nv
inline const Plane & Plane::operator=(Plane::Arg v) { p = v.p; return *this; }
inline Vector3 Plane::vector() const { return p.xyz(); }
inline scalar Plane::offset() const { return p.w(); }
inline scalar Plane::offset() const { return p.w; }
inline const Vector4 & Plane::asVector() const { return p; }
inline Vector4 & Plane::asVector() { return p; }
@ -72,6 +73,9 @@ namespace nv
Plane transformPlane(const Matrix&, Plane::Arg);
Vector3 planeIntersection(Plane::Arg a, Plane::Arg b, Plane::Arg c);
} // nv namespace
#endif // NV_MATH_PLANE_H

435
src/nvmath/Vector.h
View File

@ -1,10 +1,11 @@
// This code is in the public domain -- castanyo@yahoo.es
#pragma once
#ifndef NV_MATH_VECTOR_H
#define NV_MATH_VECTOR_H
#include <nvmath/nvmath.h>
#include <nvcore/Algorithms.h> // min, max
#include "nvmath.h"
#include "nvcore/Utils.h" // min, max
namespace nv
{
@ -27,12 +28,6 @@ public:
Vector2(Vector2::Arg v);
const Vector2 & operator=(Vector2::Arg v);
void setComponent(uint idx, scalar f);
scalar x() const;
scalar y() const;
scalar component(uint idx) const;
const scalar * ptr() const;
@ -47,8 +42,12 @@ public:
friend bool operator==(Vector2::Arg a, Vector2::Arg b);
friend bool operator!=(Vector2::Arg a, Vector2::Arg b);
private:
scalar m_x, m_y;
union {
struct {
scalar x, y;
};
scalar component[2];
};
};
@ -65,15 +64,8 @@ public:
const Vector3 & operator=(Vector3::Arg v);
scalar x() const;
scalar y() const;
scalar z() const;
const Vector2 & xy() const;
scalar component(uint idx) const;
void setComponent(uint idx, scalar f);
const scalar * ptr() const;
void set(scalar x, scalar y, scalar z);
@ -88,8 +80,12 @@ public:
friend bool operator==(Vector3::Arg a, Vector3::Arg b);
friend bool operator!=(Vector3::Arg a, Vector3::Arg b);
private:
scalar m_x, m_y, m_z;
union {
struct {
scalar x, y, z;
};
scalar component[3];
};
};
@ -108,17 +104,9 @@ public:
const Vector4 & operator=(Vector4::Arg v);
scalar x() const;
scalar y() const;
scalar z() const;
scalar w() const;
const Vector2 & xy() const;
const Vector3 & xyz() const;
scalar component(uint idx) const;
void setComponent(uint idx, scalar f);
const scalar * ptr() const;
void set(scalar x, scalar y, scalar z, scalar w);
@ -132,225 +120,183 @@ public:
friend bool operator==(Vector4::Arg a, Vector4::Arg b);
friend bool operator!=(Vector4::Arg a, Vector4::Arg b);
private:
scalar m_x, m_y, m_z, m_w;
union {
struct {
scalar x, y, z, w;
};
scalar component[4];
};
};
// Vector2
inline Vector2::Vector2() {}
inline Vector2::Vector2(zero_t) : m_x(0.0f), m_y(0.0f) {}
inline Vector2::Vector2(scalar f) : m_x(f), m_y(f) {}
inline Vector2::Vector2(scalar x, scalar y) : m_x(x), m_y(y) {}
inline Vector2::Vector2(Vector2::Arg v) : m_x(v.x()), m_y(v.y()) {}
inline Vector2::Vector2(zero_t) : x(0.0f), y(0.0f) {}
inline Vector2::Vector2(scalar f) : x(f), y(f) {}
inline Vector2::Vector2(scalar x, scalar y) : x(x), y(y) {}
inline Vector2::Vector2(Vector2::Arg v) : x(v.x), y(v.y) {}
inline const Vector2 & Vector2::operator=(Vector2::Arg v)
{
m_x = v.x();
m_y = v.y();
x = v.x;
y = v.y;
return *this;
}
inline scalar Vector2::x() const { return m_x; }
inline scalar Vector2::y() const { return m_y; }
inline scalar Vector2::component(uint idx) const
{
nvDebugCheck(idx < 2);
if (idx == 0) return x();
if (idx == 1) return y();
nvAssume(false);
return 0.0f;
}
inline void Vector2::setComponent(uint idx, float f)
{
nvDebugCheck(idx < 2);
if (idx == 0) m_x = f;
else if (idx == 1) m_y = f;
}
inline const scalar * Vector2::ptr() const
{
return &m_x;
return &x;
}
inline void Vector2::set(scalar x, scalar y)
{
m_x = x;
m_y = y;
this->x = x;
this->y = y;
}
inline Vector2 Vector2::operator-() const
{
return Vector2(-m_x, -m_y);
return Vector2(-x, -y);
}
inline void Vector2::operator+=(Vector2::Arg v)
{
m_x += v.m_x;
m_y += v.m_y;
x += v.x;
y += v.y;
}
inline void Vector2::operator-=(Vector2::Arg v)
{
m_x -= v.m_x;
m_y -= v.m_y;
x -= v.x;
y -= v.y;
}
inline void Vector2::operator*=(scalar s)
{
m_x *= s;
m_y *= s;
x *= s;
y *= s;
}
inline void Vector2::operator*=(Vector2::Arg v)
{
m_x *= v.m_x;
m_y *= v.m_y;
x *= v.x;
y *= v.y;
}
inline bool operator==(Vector2::Arg a, Vector2::Arg b)
{
return a.m_x == b.m_x && a.m_y == b.m_y;
return a.x == b.x && a.y == b.y;
}
inline bool operator!=(Vector2::Arg a, Vector2::Arg b)
{
return a.m_x != b.m_x || a.m_y != b.m_y;
return a.x != b.x || a.y != b.y;
}
// Vector3
inline Vector3::Vector3() {}
inline Vector3::Vector3(zero_t) : m_x(0.0f), m_y(0.0f), m_z(0.0f) {}
inline Vector3::Vector3(scalar x, scalar y, scalar z) : m_x(x), m_y(y), m_z(z) {}
inline Vector3::Vector3(Vector2::Arg v, scalar z) : m_x(v.x()), m_y(v.y()), m_z(z) {}
inline Vector3::Vector3(Vector3::Arg v) : m_x(v.x()), m_y(v.y()), m_z(v.z()) {}
inline Vector3::Vector3(zero_t) : x(0.0f), y(0.0f), z(0.0f) {}
inline Vector3::Vector3(scalar x, scalar y, scalar z) : x(x), y(y), z(z) {}
inline Vector3::Vector3(Vector2::Arg v, scalar z) : x(v.x), y(v.y), z(z) {}
inline Vector3::Vector3(Vector3::Arg v) : x(v.x), y(v.y), z(v.z) {}
inline const Vector3 & Vector3::operator=(Vector3::Arg v)
{
m_x = v.m_x;
m_y = v.m_y;
m_z = v.m_z;
x = v.x;
y = v.y;
z = v.z;
return *this;
}
inline scalar Vector3::x() const { return m_x; }
inline scalar Vector3::y() const { return m_y; }
inline scalar Vector3::z() const { return m_z; }
inline const Vector2 & Vector3::xy() const
{
return *(Vector2 *)this;
}
inline scalar Vector3::component(uint idx) const
{
nvDebugCheck(idx < 3);
if (idx == 0) return m_x;
if (idx == 1) return m_y;
if (idx == 2) return m_z;
nvAssume(false);
return 0.0f;
}
inline void Vector3::setComponent(uint idx, float f)
{
nvDebugCheck(idx < 3);
if (idx == 0) m_x = f;
else if (idx == 1) m_y = f;
else if (idx == 2) m_z = f;
}
inline const scalar * Vector3::ptr() const
{
return &m_x;
return &x;
}
inline void Vector3::set(scalar x, scalar y, scalar z)
{
m_x = x;
m_y = y;
m_z = z;
this->x = x;
this->y = y;
this->z = z;
}
inline Vector3 Vector3::operator-() const
{
return Vector3(-m_x, -m_y, -m_z);
return Vector3(-x, -y, -z);
}
inline void Vector3::operator+=(Vector3::Arg v)
{
m_x += v.m_x;
m_y += v.m_y;
m_z += v.m_z;
x += v.x;
y += v.y;
z += v.z;
}
inline void Vector3::operator-=(Vector3::Arg v)
{
m_x -= v.m_x;
m_y -= v.m_y;
m_z -= v.m_z;
x -= v.x;
y -= v.y;
z -= v.z;
}
inline void Vector3::operator*=(scalar s)
{
m_x *= s;
m_y *= s;
m_z *= s;
x *= s;
y *= s;
z *= s;
}
inline void Vector3::operator/=(scalar s)
{
float is = 1.0f / s;
m_x *= is;
m_y *= is;
m_z *= is;
x *= is;
y *= is;
z *= is;
}
inline void Vector3::operator*=(Vector3::Arg v)
{
m_x *= v.m_x;
m_y *= v.m_y;
m_z *= v.m_z;
x *= v.x;
y *= v.y;
z *= v.z;
}
inline bool operator==(Vector3::Arg a, Vector3::Arg b)
{
return a.m_x == b.m_x && a.m_y == b.m_y && a.m_z == b.m_z;
return a.x == b.x && a.y == b.y && a.z == b.z;
}
inline bool operator!=(Vector3::Arg a, Vector3::Arg b)
{
return a.m_x != b.m_x || a.m_y != b.m_y || a.m_z != b.m_z;
return a.x != b.x || a.y != b.y || a.z != b.z;
}
// Vector4
inline Vector4::Vector4() {}
inline Vector4::Vector4(zero_t) : m_x(0.0f), m_y(0.0f), m_z(0.0f), m_w(0.0f) {}
inline Vector4::Vector4(scalar x, scalar y, scalar z, scalar w) : m_x(x), m_y(y), m_z(z), m_w(w) {}
inline Vector4::Vector4(Vector2::Arg v, scalar z, scalar w) : m_x(v.x()), m_y(v.y()), m_z(z), m_w(w) {}
inline Vector4::Vector4(Vector3::Arg v, scalar w) : m_x(v.x()), m_y(v.y()), m_z(v.z()), m_w(w) {}
inline Vector4::Vector4(Vector4::Arg v) : m_x(v.x()), m_y(v.y()), m_z(v.z()), m_w(v.w()) {}
inline Vector4::Vector4(zero_t) : x(0.0f), y(0.0f), z(0.0f), w(0.0f) {}
inline Vector4::Vector4(scalar x, scalar y, scalar z, scalar w) : x(x), y(y), z(z), w(w) {}
inline Vector4::Vector4(Vector2::Arg v, scalar z, scalar w) : x(v.x), y(v.y), z(z), w(w) {}
inline Vector4::Vector4(Vector3::Arg v, scalar w) : x(v.x), y(v.y), z(v.z), w(w) {}
inline Vector4::Vector4(Vector4::Arg v) : x(v.x), y(v.y), z(v.z), w(v.w) {}
inline const Vector4 & Vector4::operator=(const Vector4 & v)
{
m_x = v.m_x;
m_y = v.m_y;
m_z = v.m_z;
m_w = v.m_w;
x = v.x;
y = v.y;
z = v.z;
w = v.w;
return *this;
}
inline scalar Vector4::x() const { return m_x; }
inline scalar Vector4::y() const { return m_y; }
inline scalar Vector4::z() const { return m_z; }
inline scalar Vector4::w() const { return m_w; }
inline const Vector2 & Vector4::xy() const
{
return *(Vector2 *)this;
@ -361,83 +307,63 @@ inline const Vector3 & Vector4::xyz() const
return *(Vector3 *)this;
}
inline scalar Vector4::component(uint idx) const
{
nvDebugCheck(idx < 4);
if (idx == 0) return x();
if (idx == 1) return y();
if (idx == 2) return z();
if (idx == 3) return w();
nvAssume(false);
return 0.0f;
}
inline void Vector4::setComponent(uint idx, float f)
{
nvDebugCheck(idx < 4);
if (idx == 0) m_x = f;
else if (idx == 1) m_y = f;
else if (idx == 2) m_z = f;
else if (idx == 3) m_w = f;
}
inline const scalar * Vector4::ptr() const
{
return &m_x;
return &x;
}
inline void Vector4::set(scalar x, scalar y, scalar z, scalar w)
{
m_x = x;
m_y = y;
m_z = z;
m_w = w;
this->x = x;
this->y = y;
this->z = z;
this->w = w;
}
inline Vector4 Vector4::operator-() const
{
return Vector4(-m_x, -m_y, -m_z, -m_w);
return Vector4(-x, -y, -z, -w);
}
inline void Vector4::operator+=(Vector4::Arg v)
{
m_x += v.m_x;
m_y += v.m_y;
m_z += v.m_z;
m_w += v.m_w;
x += v.x;
y += v.y;
z += v.z;
w += v.w;
}
inline void Vector4::operator-=(Vector4::Arg v)
{
m_x -= v.m_x;
m_y -= v.m_y;
m_z -= v.m_z;
m_w -= v.m_w;
x -= v.x;
y -= v.y;
z -= v.z;
w -= v.w;
}
inline void Vector4::operator*=(scalar s)
{
m_x *= s;
m_y *= s;
m_z *= s;
m_w *= s;
x *= s;
y *= s;
z *= s;
w *= s;
}
inline void Vector4::operator*=(Vector4::Arg v)
{
m_x *= v.m_x;
m_y *= v.m_y;
m_z *= v.m_z;
m_w *= v.m_w;
x *= v.x;
y *= v.y;
z *= v.z;
w *= v.w;
}
inline bool operator==(Vector4::Arg a, Vector4::Arg b)
{
return a.m_x == b.m_x && a.m_y == b.m_y && a.m_z == b.m_z && a.m_w == b.m_w;
return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w;
}
inline bool operator!=(Vector4::Arg a, Vector4::Arg b)
{
return a.m_x != b.m_x || a.m_y != b.m_y || a.m_z != b.m_z || a.m_w != b.m_w;
return a.x != b.x || a.y != b.y || a.z != b.z || a.w != b.w;
}
@ -449,7 +375,7 @@ inline bool operator!=(Vector4::Arg a, Vector4::Arg b)
inline Vector2 add(Vector2::Arg a, Vector2::Arg b)
{
return Vector2(a.x() + b.x(), a.y() + b.y());
return Vector2(a.x + b.x, a.y + b.y);
}
inline Vector2 operator+(Vector2::Arg a, Vector2::Arg b)
{
@ -458,7 +384,7 @@ inline Vector2 operator+(Vector2::Arg a, Vector2::Arg b)
inline Vector2 sub(Vector2::Arg a, Vector2::Arg b)
{
return Vector2(a.x() - b.x(), a.y() - b.y());
return Vector2(a.x - b.x, a.y - b.y);
}
inline Vector2 operator-(Vector2::Arg a, Vector2::Arg b)
{
@ -467,12 +393,12 @@ inline Vector2 operator-(Vector2::Arg a, Vector2::Arg b)
inline Vector2 scale(Vector2::Arg v, scalar s)
{
return Vector2(v.x() * s, v.y() * s);
return Vector2(v.x * s, v.y * s);
}
inline Vector2 scale(Vector2::Arg v, Vector2::Arg s)
{
return Vector2(v.x() * s.x(), v.y() * s.y());
return Vector2(v.x * s.x, v.y * s.y);
}
inline Vector2 operator*(Vector2::Arg v, scalar s)
@ -482,7 +408,7 @@ inline Vector2 operator*(Vector2::Arg v, scalar s)
inline Vector2 operator*(Vector2::Arg v1, Vector2::Arg v2)
{
return Vector2(v1.x()*v2.x(), v1.y()*v2.y());
return Vector2(v1.x*v2.x, v1.y*v2.y);
}
inline Vector2 operator*(scalar s, Vector2::Arg v)
@ -490,24 +416,29 @@ inline Vector2 operator*(scalar s, Vector2::Arg v)
return scale(v, s);
}
inline scalar dot(Vector2::Arg a, Vector2::Arg b)
inline Vector2 operator/(Vector2::Arg v, scalar s)
{
return a.x() * b.x() + a.y() * b.y();
return scale(v, 1.0f/s);
}
inline scalar length_squared(Vector2::Arg v)
inline scalar dot(Vector2::Arg a, Vector2::Arg b)
{
return v.x() * v.x() + v.y() * v.y();
return a.x * b.x + a.y * b.y;
}
inline scalar lengthSquared(Vector2::Arg v)
{
return v.x * v.x + v.y * v.y;
}
inline scalar length(Vector2::Arg v)
{
return sqrtf(length_squared(v));
return sqrtf(lengthSquared(v));
}
inline scalar inverse_length(Vector2::Arg v)
inline scalar inverseLength(Vector2::Arg v)
{
return 1.0f / sqrtf(length_squared(v));
return 1.0f / sqrtf(lengthSquared(v));
}
inline bool isNormalized(Vector2::Arg v, float epsilon = NV_NORMAL_EPSILON)
@ -536,22 +467,22 @@ inline Vector2 normalizeSafe(Vector2::Arg v, Vector2::Arg fallback, float epsilo
inline bool equal(Vector2::Arg v1, Vector2::Arg v2, float epsilon = NV_EPSILON)
{
return equal(v1.x(), v2.x(), epsilon) && equal(v1.y(), v2.y(), epsilon);
return equal(v1.x, v2.x, epsilon) && equal(v1.y, v2.y, epsilon);
}
inline Vector2 min(Vector2::Arg a, Vector2::Arg b)
{
return Vector2(min(a.x(), b.x()), min(a.y(), b.y()));
return Vector2(min(a.x, b.x), min(a.y, b.y));
}
inline Vector2 max(Vector2::Arg a, Vector2::Arg b)
{
return Vector2(max(a.x(), b.x()), max(a.y(), b.y()));
return Vector2(max(a.x, b.x), max(a.y, b.y));
}
inline bool isValid(Vector2::Arg v)
{
return isFinite(v.x()) && isFinite(v.y());
return isFinite(v.x) && isFinite(v.y);
}
@ -559,11 +490,11 @@ inline bool isValid(Vector2::Arg v)
inline Vector3 add(Vector3::Arg a, Vector3::Arg b)
{
return Vector3(a.x() + b.x(), a.y() + b.y(), a.z() + b.z());
return Vector3(a.x + b.x, a.y + b.y, a.z + b.z);
}
inline Vector3 add(Vector3::Arg a, float b)
{
return Vector3(a.x() + b, a.y() + b, a.z() + b);
return Vector3(a.x + b, a.y + b, a.z + b);
}
inline Vector3 operator+(Vector3::Arg a, Vector3::Arg b)
{
@ -576,11 +507,11 @@ inline Vector3 operator+(Vector3::Arg a, float b)
inline Vector3 sub(Vector3::Arg a, Vector3::Arg b)
{
return Vector3(a.x() - b.x(), a.y() - b.y(), a.z() - b.z());
return Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
}
inline Vector3 sub(Vector3::Arg a, float b)
{
return Vector3(a.x() - b, a.y() - b, a.z() - b);
return Vector3(a.x - b, a.y - b, a.z - b);
}
inline Vector3 operator-(Vector3::Arg a, Vector3::Arg b)
{
@ -593,17 +524,17 @@ inline Vector3 operator-(Vector3::Arg a, float b)
inline Vector3 cross(Vector3::Arg a, Vector3::Arg b)
{
return Vector3(a.y() * b.z() - a.z() * b.y(), a.z() * b.x() - a.x() * b.z(), a.x() * b.y() - a.y() * b.x());
return Vector3(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
}
inline Vector3 scale(Vector3::Arg v, scalar s)
{
return Vector3(v.x() * s, v.y() * s, v.z() * s);
return Vector3(v.x * s, v.y * s, v.z * s);
}
inline Vector3 scale(Vector3::Arg v, Vector3::Arg s)
{
return Vector3(v.x() * s.x(), v.y() * s.y(), v.z() * s.z());
return Vector3(v.x * s.x, v.y * s.y, v.z * s.z);
}
inline Vector3 operator*(Vector3::Arg v, scalar s)
@ -628,33 +559,33 @@ inline Vector3 operator/(Vector3::Arg v, scalar s)
inline Vector3 add_scaled(Vector3::Arg a, Vector3::Arg b, scalar s)
{
return Vector3(a.x() + b.x() * s, a.y() + b.y() * s, a.z() + b.z() * s);
return Vector3(a.x + b.x * s, a.y + b.y * s, a.z + b.z * s);
}
inline Vector3 lerp(Vector3::Arg v1, Vector3::Arg v2, scalar t)
{
const scalar s = 1.0f - t;
return Vector3(v1.x() * s + t * v2.x(), v1.y() * s + t * v2.y(), v1.z() * s + t * v2.z());
return Vector3(v1.x * s + t * v2.x, v1.y * s + t * v2.y, v1.z * s + t * v2.z);
}
inline scalar dot(Vector3::Arg a, Vector3::Arg b)
{
return a.x() * b.x() + a.y() * b.y() + a.z() * b.z();
return a.x * b.x + a.y * b.y + a.z * b.z;
}
inline scalar length_squared(Vector3::Arg v)
inline scalar lengthSquared(Vector3::Arg v)
{
return v.x() * v.x() + v.y() * v.y() + v.z() * v.z();
return v.x * v.x + v.y * v.y + v.z * v.z;
}
inline scalar length(Vector3::Arg v)
{
return sqrtf(length_squared(v));
return sqrtf(lengthSquared(v));
}
inline scalar inverse_length(Vector3::Arg v)
inline scalar inverseLength(Vector3::Arg v)
{
return 1.0f / sqrtf(length_squared(v));
return 1.0f / sqrtf(lengthSquared(v));
}
inline bool isNormalized(Vector3::Arg v, float epsilon = NV_NORMAL_EPSILON)
@ -682,42 +613,35 @@ inline Vector3 normalizeSafe(Vector3::Arg v, Vector3::Arg fallback, float epsilo
inline bool equal(Vector3::Arg v1, Vector3::Arg v2, float epsilon = NV_EPSILON)
{
return equal(v1.x(), v2.x(), epsilon) && equal(v1.y(), v2.y(), epsilon) && equal(v1.z(), v2.z(), epsilon);
return equal(v1.x, v2.x, epsilon) && equal(v1.y, v2.y, epsilon) && equal(v1.z, v2.z, epsilon);
}
inline Vector3 min(Vector3::Arg a, Vector3::Arg b)
{
return Vector3(min(a.x(), b.x()), min(a.y(), b.y()), min(a.z(), b.z()));
return Vector3(min(a.x, b.x), min(a.y, b.y), min(a.z, b.z));
}
inline Vector3 max(Vector3::Arg a, Vector3::Arg b)
{
return Vector3(max(a.x(), b.x()), max(a.y(), b.y()), max(a.z(), b.z()));
return Vector3(max(a.x, b.x), max(a.y, b.y), max(a.z, b.z));
}
inline Vector3 clamp(Vector3::Arg v, float min, float max)
{
return Vector3(clamp(v.x(), min, max), clamp(v.y(), min, max), clamp(v.z(), min, max));
return Vector3(clamp(v.x, min, max), clamp(v.y, min, max), clamp(v.z, min, max));
}
inline bool isValid(Vector3::Arg v)
{
return isFinite(v.x()) && isFinite(v.y()) && isFinite(v.z());
return isFinite(v.x) && isFinite(v.y) && isFinite(v.z);
}
/*
Vector3 transform(Quaternion, vector3);
Vector3 transform_point(matrix34, vector3);
Vector3 transform_vector(matrix34, vector3);
Vector3 transform_point(matrix44, vector3);
Vector3 transform_vector(matrix44, vector3);
*/
// Vector4
inline Vector4 add(Vector4::Arg a, Vector4::Arg b)
{
return Vector4(a.x() + b.x(), a.y() + b.y(), a.z() + b.z(), a.w() + b.w());
return Vector4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
}
inline Vector4 operator+(Vector4::Arg a, Vector4::Arg b)
{
@ -726,7 +650,7 @@ inline Vector4 operator+(Vector4::Arg a, Vector4::Arg b)
inline Vector4 sub(Vector4::Arg a, Vector4::Arg b)
{
return Vector4(a.x() - b.x(), a.y() - b.y(), a.z() - b.z(), a.w() - b.w());
return Vector4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
}
inline Vector4 operator-(Vector4::Arg a, Vector4::Arg b)
{
@ -735,12 +659,12 @@ inline Vector4 operator-(Vector4::Arg a, Vector4::Arg b)
inline Vector4 scale(Vector4::Arg v, scalar s)
{
return Vector4(v.x() * s, v.y() * s, v.z() * s, v.w() * s);
return Vector4(v.x * s, v.y * s, v.z * s, v.w * s);
}
inline Vector4 scale(Vector4::Arg v, Vector4::Arg s)
{
return Vector4(v.x() * s.x(), v.y() * s.y(), v.z() * s.z(), v.w() * s.w());
return Vector4(v.x * s.x, v.y * s.y, v.z * s.z, v.w * s.w);
}
inline Vector4 operator*(Vector4::Arg v, scalar s)
@ -760,27 +684,27 @@ inline Vector4 operator/(Vector4::Arg v, scalar s)
inline Vector4 add_scaled(Vector4::Arg a, Vector4::Arg b, scalar s)
{
return Vector4(a.x() + b.x() * s, a.y() + b.y() * s, a.z() + b.z() * s, a.w() + b.w() * s);
return Vector4(a.x + b.x * s, a.y + b.y * s, a.z + b.z * s, a.w + b.w * s);
}
inline scalar dot(Vector4::Arg a, Vector4::Arg b)
{
return a.x() * b.x() + a.y() * b.y() + a.z() * b.z() + a.w() * b.w();
return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
}
inline scalar length_squared(Vector4::Arg v)
inline scalar lengthSquared(Vector4::Arg v)
{
return v.x() * v.x() + v.y() * v.y() + v.z() * v.z() + v.w() * v.w();
return v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w;
}
inline scalar length(Vector4::Arg v)
{
return sqrtf(length_squared(v));
return sqrtf(lengthSquared(v));
}
inline scalar inverse_length(Vector4::Arg v)
inline scalar inverseLength(Vector4::Arg v)
{
return 1.0f / sqrtf(length_squared(v));
return 1.0f / sqrtf(lengthSquared(v));
}
inline bool isNormalized(Vector4::Arg v, float epsilon = NV_NORMAL_EPSILON)
@ -808,65 +732,24 @@ inline Vector4 normalizeSafe(Vector4::Arg v, Vector4::Arg fallback, float epsilo
inline bool equal(Vector4::Arg v1, Vector4::Arg v2, float epsilon = NV_EPSILON)
{
return equal(v1.x(), v2.x(), epsilon) && equal(v1.y(), v2.y(), epsilon) && equal(v1.z(), v2.z(), epsilon) && equal(v1.w(), v2.w(), epsilon);
return equal(v1.x, v2.x, epsilon) && equal(v1.y, v2.y, epsilon) && equal(v1.z, v2.z, epsilon) && equal(v1.w, v2.w, epsilon);
}
inline Vector4 min(Vector4::Arg a, Vector4::Arg b)
{
return Vector4(min(a.x(), b.x()), min(a.y(), b.y()), min(a.z(), b.z()), min(a.w(), b.w()));
return Vector4(min(a.x, b.x), min(a.y, b.y), min(a.z, b.z), min(a.w, b.w));
}
inline Vector4 max(Vector4::Arg a, Vector4::Arg b)
{
return Vector4(max(a.x(), b.x()), max(a.y(), b.y()), max(a.z(), b.z()), max(a.w(), b.w()));
return Vector4(max(a.x, b.x), max(a.y, b.y), max(a.z, b.z), max(a.w, b.w));
}
inline bool isValid(Vector4::Arg v)
{
return isFinite(v.x()) && isFinite(v.y()) && isFinite(v.z()) && isFinite(v.w());
return isFinite(v.x) && isFinite(v.y) && isFinite(v.z) && isFinite(v.w);
}
/*
vector4 transform(matrix34, vector4);
vector4 transform(matrix44, vector4);
*/
/*
Quaternion mul(Quaternion, Quaternion); // rotational composition
Quaternion conjugate(Quaternion);
Quaternion inverse(Quaternion);
Quaternion axis_angle(const Vector3 & v, scalar s);
*/
/*
matrix34 add(matrix34, matrix34); // note: implicit '1' stays as '1'
matrix34 operator+(matrix34, matrix34);
matrix34 sub(matrix34, matrix34); // note: implicit '1' stays as '1'
matrix34 operator-(matrix34, matrix34);
matrix34 mul(matrix34, matrix34);
matrix34 operator*(matrix34, matrix34);
matrix34 mul(matrix34, quaternion4); // rotation multiplication
matrix34 operator*(matrix34, quaternion4); // rotation multiplication
matrix34 translation(vector3);
matrix34 rotation(quaternion4);
matrix34 rotation(vector3, scalar); // axis/angle
matrix44 add(matrix44, matrix44);
matrix44 operator+(matrix44, matrix44);
matrix44 sub(matrix44, matrix44);
matrix44 operator-(matrix44, matrix44);
matrix44 mul(matrix44, matrix44);
matrix44 operator*(matrix44, matrix44);
matrix44 mul(matrix44, quaternion4); // rotation multiplication
matrix44 operator*(matrix44, quaternion4); // rotation multiplication
matrix44 invert(matrix34);
matrix44 invert(matrix44);
matrix44 transpose(matrix34);
matrix44 transpose(matrix44);
*/
} // nv namespace
#endif // NV_MATH_VECTOR_H

11
src/nvmath/nvmath.h
View File

@ -1,5 +1,6 @@
// This code is in the public domain -- castanyo@yahoo.es
#pragma once
#ifndef NV_MATH_H
#define NV_MATH_H
@ -97,6 +98,7 @@ inline float asinf_assert(const float f)
#define asin asin_assert
#define asinf asinf_assert
namespace nv
{
inline float toRadian(float degree) { return degree * (PI / 180.0f); }
@ -161,10 +163,11 @@ namespace nv
return f0 * s + f1 * t;
}
inline float square(float f)
{
return f * f;
}
inline float square(float f) { return f * f; }
inline int square(int i) { return i * i; }
inline float cube(float f) { return f * f; }
inline int cube(int i) { return i * i; }
// @@ Float to int conversions to be optimized at some point. See:
// http://cbloomrants.blogspot.com/2009/01/01-17-09-float-to-int.html