cleanup and refactoring
This commit is contained in:
parent
2302158928
commit
76f6bf62a4
GPG key ID:
223391B52FAD4463
1285 changed files with 757994 additions and 8 deletions
0
raytracer/nvpro_core/nvmath/README.md
Normal file
0
raytracer/nvpro_core/nvmath/README.md
Normal file
408
raytracer/nvpro_core/nvmath/nvmath.h
Normal file
408
raytracer/nvpro_core/nvmath/nvmath.h
Normal file
|
|
@ -0,0 +1,408 @@
|
|||
/*
|
||||
* Copyright (c) 2002-2021, NVIDIA CORPORATION. All rights reserved.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
* SPDX-FileCopyrightText: Copyright (c) 2002-2021 NVIDIA CORPORATION
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/// @DOC_SKIP (keyword to exclude this file from automatic README.md generation)
|
||||
|
||||
#ifndef _nvmath_h_
|
||||
#define _nvmath_h_
|
||||
|
||||
#pragma message("Note: nvmath is about to be replaced by GLM and might be deprecated soon")
|
||||
#ifndef NVMATH_SUPPORTS_GLM
|
||||
#define NVMATH_SUPPORTS_GLM
|
||||
#endif
|
||||
|
||||
#include "nvmath_types.h"
|
||||
#include <type_traits>
|
||||
|
||||
namespace nvmath {
|
||||
// clang-format off
|
||||
template<class T> const vector2<T> operator+(const vector2<T>& u, const vector2<T>& v);
|
||||
template<class T> const vector2<T> operator+(const vector2<T>& u, const T s);
|
||||
template<class T> const vector2<T> operator-(const vector2<T>& u, const vector2<T>& v);
|
||||
template<class T> const vector2<T> operator-(const vector2<T>& u, const T s);
|
||||
template<class T> const vector2<T> operator*(const T s, const vector2<T>& u);
|
||||
template<class T> const vector2<T> operator*(const vector2<T>& u, const T s);
|
||||
template<class T> const vector2<T> operator/(const vector2<T>& u, const T s);
|
||||
template<class T> const vector2<T> operator*(const vector2<T>&u, const vector2<T>&v);
|
||||
template<class T> const vector2<T> operator/(const vector2<T>&u, const vector2<T>&v);
|
||||
|
||||
template<class T> vector3<T> mult(const matrix3<T>& M, const vector3<T>& v);
|
||||
template<class T> vector3<T> mult(const matrix4<T>& M, const vector3<T>& v);
|
||||
|
||||
template<class T> const vector3<T> operator+(const vector3<T>& u, const vector3<T>& v);
|
||||
template<class T> const vector3<T> operator-(const vector3<T>& u, const vector3<T>& v);
|
||||
template<class T> const vector3<T> operator+(const vector3<T>& u, const T v);
|
||||
template<class T> const vector3<T> operator-(const vector3<T>& u, const T v);
|
||||
template<class T> const vector3<T> operator^(const vector3<T>& u, const vector3<T>& v);
|
||||
template<class T> const vector3<T> operator*(const T s, const vector3<T>& u);
|
||||
template<class T> const vector3<T> operator*(const vector3<T>& u, const T s);
|
||||
template<class T> const vector3<T> operator/(const vector3<T>& u, const T s);
|
||||
template<class T> const vector3<T> operator*(const vector3<T>& u, const vector3<T>& v);
|
||||
template<class T> const vector3<T> operator/(const vector3<T>& u, const vector3<T>& v);
|
||||
|
||||
template<class T> const vector4<T> operator+(const vector4<T>& u, const vector4<T>& v);
|
||||
template<class T> const vector4<T> operator-(const vector4<T>& u, const vector4<T>& v);
|
||||
template<class T> const vector4<T> operator+(const vector4<T>& u, const T s);
|
||||
template<class T> const vector4<T> operator-(const vector4<T>& u, const T s);
|
||||
template<class T> const vector4<T> operator*(const T s, const vector4<T>& u);
|
||||
template<class T> const vector4<T> operator*(const vector4<T>& u, const T s);
|
||||
template<class T> const vector4<T> operator/(const vector4<T>& u, const T s);
|
||||
|
||||
template<class T> const vector4<T> operator*(const vector4<T>& u, const vector4<T>& v);
|
||||
template<class T> const vector4<T> operator/(const vector4<T>& u, const vector4<T>& v);
|
||||
template<class T> const vector3<T> operator*(const matrix3<T>&, const vector3<T>&);
|
||||
template<class T> const vector3<T> operator*(const vector3<T>&, const matrix3<T>&);
|
||||
|
||||
template<class T> matrix4<T> mult(const matrix4<T>& A, const matrix4<T>& B);
|
||||
|
||||
template<class T> const vector4<T> operator*(const matrix4<T>&, const vector4<T>&);
|
||||
template<class T> const vector4<T> operator*(const matrix4<T>&, const vector3<T>&);
|
||||
template<class T> const vector4<T> operator*(const vector4<T>&, const matrix4<T>&);
|
||||
|
||||
template<class T> matrix4<T> scale_mat4(const vector3<T> &t);
|
||||
template<class T> matrix4<T> translation_mat4(const vector3<T> &t);
|
||||
template<class T> matrix4<T> translation_mat4(T x, T y, T z);
|
||||
template<class T> matrix4<T> rotation_mat4_x(T a);
|
||||
template<class T> matrix4<T> rotation_mat4_y(T a);
|
||||
template<class T> matrix4<T> rotation_mat4_z(T a);
|
||||
|
||||
|
||||
template<class T> const quaternion<T> operator*(const quaternion<T>&, const quaternion<T>&);
|
||||
template<class T> const quaternion<T> mul(const quaternion<T>&, const quaternion<T>&);
|
||||
template<class T> quaternion<T> add_quats(const quaternion<T> & q1, const quaternion<T> & q2);
|
||||
template<class T> T dot(const quaternion<T> & p, const quaternion<T> & q);
|
||||
template<class T> quaternion<T> slerp_quats(T s, const quaternion<T> & q1, const quaternion<T> & q2);
|
||||
template<class T> quaternion<T> axis_to_quat(const vector3<T> & a, const T phi);
|
||||
template<class T> quaternion<T> mat_2_quat(const matrix3<T> &M);
|
||||
template<class T> quaternion<T> normalize(const quaternion<T> & p);
|
||||
template<class T> quaternion<T> conj(const quaternion<T> & q);
|
||||
template<class T> matrix3<T> quat_2_mat(const quaternion<T> &q );
|
||||
template<class T> quaternion<T> mat_2_quat(const matrix4<T> &M);
|
||||
|
||||
// constant algebraic values
|
||||
|
||||
static const nv_scalar array16_id[] = { nv_one, nv_zero, nv_zero, nv_zero,
|
||||
nv_zero, nv_one, nv_zero, nv_zero,
|
||||
nv_zero, nv_zero, nv_one, nv_zero,
|
||||
nv_zero, nv_zero, nv_zero, nv_one};
|
||||
|
||||
static const nv_scalar array16_zero[] = { nv_zero, nv_zero, nv_zero, nv_zero,
|
||||
nv_zero, nv_zero, nv_zero, nv_zero,
|
||||
nv_zero, nv_zero, nv_zero, nv_zero,
|
||||
nv_zero, nv_zero, nv_zero, nv_zero};
|
||||
|
||||
static const nv_scalar array16_scale_bias[] = { nv_one_half, nv_zero, nv_zero, nv_zero,
|
||||
nv_zero, nv_one_half, nv_zero, nv_zero,
|
||||
nv_zero, nv_zero, nv_one_half, nv_zero,
|
||||
nv_one_half, nv_one_half, nv_one_half, nv_one};
|
||||
|
||||
static const nv_scalar array9_id[] = { nv_one, nv_zero, nv_zero,
|
||||
nv_zero, nv_one, nv_zero,
|
||||
nv_zero, nv_zero, nv_one};
|
||||
|
||||
static const vector2<nv_scalar> vec2f_zero(nv_zero,nv_zero);
|
||||
static const vector4<nv_scalar> vec4f_one(nv_one,nv_one,nv_one,nv_one);
|
||||
static const vector3<nv_scalar> vec3f_one(nv_one,nv_one,nv_one);
|
||||
static const vector3<nv_scalar> vec3f_zero(nv_zero,nv_zero,nv_zero);
|
||||
static const vector3<nv_scalar> vec3f_x(nv_one,nv_zero,nv_zero);
|
||||
static const vector3<nv_scalar> vec3f_y(nv_zero,nv_one,nv_zero);
|
||||
static const vector3<nv_scalar> vec3f_z(nv_zero,nv_zero,nv_one);
|
||||
static const vector3<nv_scalar> vec3f_neg_x(-nv_one,nv_zero,nv_zero);
|
||||
static const vector3<nv_scalar> vec3f_neg_y(nv_zero,-nv_one,nv_zero);
|
||||
static const vector3<nv_scalar> vec3f_neg_z(nv_zero,nv_zero,-nv_one);
|
||||
static const vector4<nv_scalar> vec4f_zero(nv_zero,nv_zero,nv_zero,nv_zero);
|
||||
static const vector4<nv_scalar> vec4f_x(nv_one,nv_zero,nv_zero,nv_zero);
|
||||
static const vector4<nv_scalar> vec4f_neg_x(-nv_one,nv_zero,nv_zero,nv_zero);
|
||||
static const vector4<nv_scalar> vec4f_y(nv_zero,nv_one,nv_zero,nv_zero);
|
||||
static const vector4<nv_scalar> vec4f_neg_y(nv_zero,-nv_one,nv_zero,nv_zero);
|
||||
static const vector4<nv_scalar> vec4f_z(nv_zero,nv_zero,nv_one,nv_zero);
|
||||
static const vector4<nv_scalar> vec4f_neg_z(nv_zero,nv_zero,-nv_one,nv_zero);
|
||||
static const vector4<nv_scalar> vec4f_w(nv_zero,nv_zero,nv_zero,nv_one);
|
||||
static const vector4<nv_scalar> vec4f_neg_w(nv_zero,nv_zero,nv_zero,-nv_one);
|
||||
static const quaternion<nv_scalar> quat_id(nv_zero,nv_zero,nv_zero,nv_one);
|
||||
static const matrix4<nv_scalar> mat4f_id(array16_id);
|
||||
static const matrix3<nv_scalar> mat3f_id(array9_id);
|
||||
static const matrix4<nv_scalar> mat4f_zero(array16_zero);
|
||||
static const matrix4<nv_scalar> mat4f_scale_bias(array16_scale_bias);
|
||||
|
||||
// normalizes a vector
|
||||
template<class T> vector2<T> normalize(const vector2<T> & u);
|
||||
template<class T> vector3<T> normalize(const vector3<T> & u);
|
||||
template<class T> vector4<T> normalize(const vector4<T> & u);
|
||||
|
||||
// Computes the squared magnitude
|
||||
template<class T> T nv_sq_norm(const vector2<T> & n);
|
||||
template<class T> T nv_sq_norm(const vector3<T> & n);
|
||||
template<class T> T nv_sq_norm(const vector4<T> & n);
|
||||
|
||||
// Computes the magnitude
|
||||
template<class T> T nv_norm(const vector2<T> & n);
|
||||
template<class T> T nv_norm(const vector3<T> & n);
|
||||
template<class T> T nv_norm(const vector4<T> & n);
|
||||
template<class T> T length(const vector2<T> & n);
|
||||
template<class T> T length(const vector3<T> & n);
|
||||
template<class T> T length(const vector4<T> & n);
|
||||
|
||||
// computes the cross product ( v cross w) and stores the result in u
|
||||
// i.e. u = v cross w
|
||||
template<class T> vector3<T> cross(const vector3<T> & v, const vector3<T> & w);
|
||||
|
||||
// computes the dot product ( v dot w) and stores the result in u
|
||||
// i.e. u = v dot w
|
||||
template<class T> T dot(const vector3<T> & v, const vector3<T> & w);
|
||||
template<class T> T dot(const vector4<T> & v, const vector4<T> & w);
|
||||
template<class T> T dot(const vector3<T> & v, const vector4<T> & w);
|
||||
template<class T> T dot(const vector4<T> & v, const vector3<T> & w);
|
||||
template<class T> T dot(const vector2<T> & v, const vector2<T> & w);
|
||||
|
||||
// clamp
|
||||
template<class T> T clamp(T x, T minVal, T maxVal);
|
||||
template<class T> vector3<T> clamp(const vector3<T>& x, const vector3<T>& minVal, const vector3<T>& maxVal);
|
||||
|
||||
// min / max
|
||||
template<class T> T min(T minVal, T maxVal);
|
||||
template<class T> T max(T minVal, T maxVal);
|
||||
template<class T> vector3<T> max(const vector3<T>& minVal, const vector3<T>& maxVal);
|
||||
|
||||
// mix
|
||||
template<class T> T mix(T x, T y, T a);
|
||||
template<class T> vector3<T> mix(const vector3<T>& x, const vector3<T>& y, T a);
|
||||
template<class T> vector3<T> mix(const vector3<T>& x, const vector3<T>& y, const vector3<T>& a);
|
||||
|
||||
// Pow
|
||||
template<class T> vector3<T> pow(const vector3<T>& base, const vector3<T>& exponent);
|
||||
|
||||
// sqrt
|
||||
template<class T> vector3<T> sqrt(const vector3<T>& x);
|
||||
|
||||
// radians
|
||||
template<class T> T radians(T x);
|
||||
|
||||
// sin
|
||||
template<class T> vector3<T> sin(const vector3<T>& x);
|
||||
|
||||
// mod
|
||||
template<class T> T mod(T a, T b);
|
||||
template<class T> vector2<T> mod(const vector2<T>& a, T b);
|
||||
|
||||
// fract
|
||||
template<class T> T fract(T x);
|
||||
|
||||
|
||||
|
||||
// compute the reflected vector R of L w.r.t N - vectors need to be
|
||||
// normalized
|
||||
//
|
||||
// R N L
|
||||
// _ _
|
||||
// |\ ^ /|
|
||||
// \ | /
|
||||
// \ | /
|
||||
// \|/
|
||||
// +
|
||||
template<class T> vector3<T> reflect(const vector3<T> & n, const vector3<T> & l);
|
||||
|
||||
// Computes u = v * lambda + u
|
||||
template<class T> vector3<T> madd(const vector3<T> & v, const T & lambda);
|
||||
// Computes u = v * lambda
|
||||
template<class T> vector3<T> mult(const vector3<T> & v, const T & lambda);
|
||||
// Computes u = v * w
|
||||
template<class T> vector3<T> mult(const vector3<T> & v, const vector3<T> & w);
|
||||
// Computes u = v + w
|
||||
template<class T> vector3<T> add(const vector3<T> & v, const vector3<T> & w);
|
||||
// Computes u = v - w
|
||||
template<class T> vector3<T> sub(const vector3<T> & v, const vector3<T> & w);
|
||||
|
||||
// Computes u = pow(v, exponemt)
|
||||
template <class T> vector3<T> pow(const vector3<T>& v, const T & e);
|
||||
|
||||
// Computes u = u * s
|
||||
template<class T> vector2<T> scale(const vector2<T> & u, const T s);
|
||||
template<class T> vector3<T> scale(const vector3<T> & u, const T s);
|
||||
template<class T> vector4<T> scale(const vector4<T> & u, const T s);
|
||||
|
||||
// Computes u = M * v
|
||||
template<class T> vector3<T> mult(const matrix3<T> & M, const vector3<T> & v);
|
||||
template<class T> vector4<T> mult(const matrix4<T> & M, const vector4<T> & v);
|
||||
|
||||
// Computes u = v * M
|
||||
template<class T> vector3<T> mult(const vector3<T> & v, const matrix3<T> & M);
|
||||
template<class T> vector4<T> mult(const vector4<T> & v, const matrix4<T> & M);
|
||||
|
||||
// Computes u = M(4x4) * v and divides by w
|
||||
template<class T> vector3<T> mult_pos(const matrix4<T> & M, const vector3<T> & v);
|
||||
// Computes u = M(4x4) * v
|
||||
template<class T> vector3<T> mult_dir(const matrix4<T> & M, const vector3<T> & v);
|
||||
// Computes u = M(4x4) * v and does not divide by w (assumed to be 1)
|
||||
template<class T> vector3<T> mult(const matrix4<T>& M, const vector3<T>& v);
|
||||
|
||||
// Computes u = v * M(4x4) and divides by w
|
||||
template<class T> vector3<T> mult_pos(const vector3<T> & v, const matrix4<T> & M);
|
||||
// Computes u = v * M(4x4)
|
||||
template<class T> vector3<T> mult_dir(const vector3<T> & v, const matrix4<T> & M);
|
||||
// Computes u = v * M(4x4) and does not divide by w (assumed to be 1)
|
||||
template<class T> vector3<T> mult(const vector3<T>& v, const matrix4<T>& M);
|
||||
|
||||
// Computes C = A + B
|
||||
template<class T> matrix4<T> add(const matrix4<T> & A, const matrix4<T> & B);
|
||||
template<class T> matrix3<T> add(const matrix3<T> & A, const matrix3<T> & B);
|
||||
|
||||
// Computes C = A * B
|
||||
template<class T> matrix4<T> mult(const matrix4<T> & A, const matrix4<T> & B);
|
||||
template<class T> matrix3<T> mult(const matrix3<T> & A, const matrix3<T> & B);
|
||||
|
||||
// Compute M = -M
|
||||
template<class T> matrix4<T> negate(const matrix4<T> & M);
|
||||
template<class T> matrix3<T> negate(const matrix3<T> & M);
|
||||
|
||||
// Computes B = Transpose(A)
|
||||
// T
|
||||
// B = A
|
||||
template<class T> matrix3<T> transpose(const matrix3<T> & A);
|
||||
template<class T> matrix4<T> transpose(const matrix4<T> & A);
|
||||
|
||||
// Computes B = inverse(A)
|
||||
// -1
|
||||
// B = A
|
||||
template<class T> matrix4<T> invert(const matrix4<T> & A, bool& valid);
|
||||
template<class T> matrix4<T> invert(const matrix4<T> & A);
|
||||
template<class T> matrix3<T> invert(const matrix3<T> & A);
|
||||
template<class T> matrix4<T> inverse(const matrix4<T>& A);
|
||||
template<class T> matrix3<T> inverse(const matrix3<T>& A);
|
||||
|
||||
// Computes B = inverse(A)
|
||||
// T T
|
||||
// (R t) (R -R t)
|
||||
// assuming that A = (0 1) so that B = (0 1)
|
||||
// B = A
|
||||
template<class T> matrix4<T> invert_rot_trans(const matrix4<T> & A);
|
||||
|
||||
template<class T> matrix4<T> look_at(const vector3<T> & eye, const vector3<T> & center, const vector3<T> & up);
|
||||
|
||||
template<class T> matrix4<T> frustum(const T l, const T r, const T b, const T t, const T n, const T f);
|
||||
template<class T> matrix4<T> frustum01(const T l, const T r, const T b, const T t, const T n, const T f);
|
||||
template<class T> matrix4<T> frustum01Rev(const T l, const T r, const T b, const T t, const T n, const T f);
|
||||
|
||||
template<class T> matrix4<T> perspective(const T fovy, const T aspect, const T n, const T f);
|
||||
template<class T> matrix4<T> perspective01(const T fovy, const T aspect, const T n, const T f);
|
||||
template<class T> matrix4<T> perspective01Rev(const T fovy, const T aspect, const T n, const T f);
|
||||
|
||||
template<class T> matrix4<T> ortho(const T left,
|
||||
const T right,
|
||||
const T bottom,
|
||||
const T top,
|
||||
const T n,
|
||||
const T f);
|
||||
|
||||
/* Decompose Affine Matrix
|
||||
* A = TQS, where
|
||||
* A is the affine transform
|
||||
* T is the translation vector
|
||||
* Q is the rotation (quaternion)
|
||||
* S is the scale vector
|
||||
* f is the sign of the determinant
|
||||
*/
|
||||
template<class T> void decomp_affine(const matrix4<T> & A, vector3<T> & v3, quaternion<T> & Q, quaternion<T> & U, vector3<T> & S, T & f);
|
||||
|
||||
|
||||
// surface properties
|
||||
template<class T> matrix3<T> & tangent_basis(const vector3<T> & v0,const vector3<T> & v1,const vector3<T> & v2,const vector2<T> & t0,const vector2<T> & t1,const vector2<T> & t2, const vector3<T> & n);
|
||||
|
||||
// linear interpolation
|
||||
#ifdef NVP_SUPPORTS_OPTIX
|
||||
#pragma message("**WARNING** nvmath.h : Canceling the lerp() function here : already declared in OptiX")
|
||||
#else
|
||||
template<class T> T lerp(const T t, const T a, const T b);
|
||||
template<class T> vector2<T> lerp(const T & t, const vector2<T> & u, const vector2<T> & v);
|
||||
template<class T> vector3<T> lerp(const T & t, const vector3<T> & u, const vector3<T> & v);
|
||||
template<class T> vector4<T> lerp(const T & t, const vector4<T> & u, const vector4<T> & v);
|
||||
#endif
|
||||
|
||||
// utilities
|
||||
template<class T> T nv_random();
|
||||
|
||||
template<class T> quaternion<T> trackball(vector2<T> & pt1, vector2<T> & pt2, T trackballsize);
|
||||
|
||||
template<class T> vector3<T> cube_map_normal(int i, int x, int y, int cubesize, const vector3<T> & v);
|
||||
|
||||
// Componentwise
|
||||
|
||||
template<class T> T nv_min(const T & lambda, const T & n);
|
||||
template<class T> vector2<T> nv_min(const vector2<T> & vFirst, const vector2<T> & vSecond);
|
||||
template<class T> vector3<T> nv_min(const vector3<T> & vFirst, const vector3<T> & vSecond);
|
||||
template<class T> vector4<T> nv_min(const vector4<T> & vFirst, const vector4<T> & vSecond);
|
||||
|
||||
template<class T> T nv_max(const T & lambda, const T & n);
|
||||
template<class T> vector3<T> nv_max(const vector3<T> & vFirst, const vector3<T> & vSecond);
|
||||
template<class T> vector2<T> nv_max(const vector2<T> & vFirst, const vector2<T> & vSecond);
|
||||
template<class T> vector4<T> nv_max(const vector4<T> & vFirst, const vector4<T> & vSecond);
|
||||
|
||||
template<class T> T nv_clamp(const T u, const T min, const T max);
|
||||
template<class T> vector2<T> nv_clamp(const vector2<T>& u, const T min, const T max);
|
||||
template<class T> vector3<T> nv_clamp(const vector3<T>& u, const T min, const T max);
|
||||
template<class T> vector4<T> nv_clamp(const vector4<T>& u, const T min, const T max);
|
||||
|
||||
template<class T> vector2<T> nv_floor(const vector2<T>& u);
|
||||
template<class T> vector3<T> nv_floor(const vector3<T>& u);
|
||||
template<class T> vector4<T> nv_floor(const vector4<T>& u);
|
||||
|
||||
|
||||
template<class T> T nv_abs(const T u);
|
||||
template<class T> vector2<T> nv_abs(const vector2<T> & u);
|
||||
template<class T> vector3<T> nv_abs(const vector3<T> & u);
|
||||
template<class T> vector4<T> nv_abs(const vector4<T> & u);
|
||||
|
||||
template<class T> T smoothstep(T edge0, T edge1, T x);
|
||||
|
||||
|
||||
|
||||
// geometry
|
||||
// computes the area of a triangle
|
||||
template<class T> T nv_area(const vector3<T> & v1, const vector3<T> & v2, const vector3<T> &v3);
|
||||
// computes the perimeter of a triangle
|
||||
template<class T> T nv_perimeter(const vector3<T> & v1, const vector3<T> & v2, const vector3<T> &v3);
|
||||
// find the inscribed circle
|
||||
template<class T> T nv_find_in_circle( vector3<T> & center, const vector3<T> & v1, const vector3<T> & v2, const vector3<T> &v3);
|
||||
// find the circumscribed circle
|
||||
template<class T> T nv_find_circ_circle( vector3<T> & center, const vector3<T> & v1, const vector3<T> & v2, const vector3<T> &v3);
|
||||
|
||||
// fast cosine functions
|
||||
template<class T> T fast_cos(const T x);
|
||||
template<class T> T ffast_cos(const T x);
|
||||
|
||||
// determinant
|
||||
template<class T> T det(const matrix3<T> & A);
|
||||
template<class T> T det(const matrix4<T> & A);
|
||||
|
||||
template<class T> void nv_is_valid(const vector3<T>& v);
|
||||
template<class T> void nv_is_valid(T lambda);
|
||||
|
||||
// TL : v1 and v2 MUST be normalized. Not done inot this to avoid redundant work...
|
||||
template<class T> T get_angle(const vector3<T> & v1, const vector3<T> & v2);
|
||||
template<class T> vector3<T> rotate_by(const vector3<T> & src, const quaternion<T>& q);
|
||||
|
||||
template<class T>
|
||||
matrix4<T> rotation_yaw_pitch_roll( const T yaw , const T pitch , const T roll );
|
||||
|
||||
// clang-format on
|
||||
} //namespace nvmath
|
||||
|
||||
#include "nvmath.inl"
|
||||
|
||||
#endif //_nvmath_h_
|
||||
2842
raytracer/nvpro_core/nvmath/nvmath.inl
Normal file
2842
raytracer/nvpro_core/nvmath/nvmath.inl
Normal file
File diff suppressed because it is too large
Load diff
93
raytracer/nvpro_core/nvmath/nvmath_glsltypes.h
Normal file
93
raytracer/nvpro_core/nvmath/nvmath_glsltypes.h
Normal file
|
|
@ -0,0 +1,93 @@
|
|||
/*
|
||||
* Copyright (c) 2012-2021, NVIDIA CORPORATION. All rights reserved.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
* SPDX-FileCopyrightText: Copyright (c) 2012-2021 NVIDIA CORPORATION
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/// @DOC_SKIP (keyword to exclude this file from automatic README.md generation)
|
||||
|
||||
#ifndef NV_SHADER_TYPES_H
|
||||
#define NV_SHADER_TYPES_H
|
||||
|
||||
#include "NvFoundation.h"
|
||||
#include "nvmath_types.h"
|
||||
|
||||
namespace nvmath {
|
||||
|
||||
#if defined(__amd64__) || defined(__x86_64__) || defined(_M_X64) || defined(__AMD64__)
|
||||
// Matrices, must align to 4 vector (16 bytes)
|
||||
NV_ALIGN(16, typedef mat3f mat3);
|
||||
NV_ALIGN(16, typedef mat4f mat4);
|
||||
|
||||
// vectors, 4-tuples and 3-tuples must align to 16 bytes
|
||||
// 2-vectors must align to 8 bytes
|
||||
NV_ALIGN(16, typedef vec4f vec4);
|
||||
NV_ALIGN(16, typedef vec3f vec3);
|
||||
NV_ALIGN(8, typedef vec2f vec2);
|
||||
|
||||
NV_ALIGN(16, typedef vec4i ivec4);
|
||||
NV_ALIGN(16, typedef vec3i ivec3);
|
||||
NV_ALIGN(8, typedef vec2i ivec2);
|
||||
|
||||
NV_ALIGN(16, typedef vec4ui uvec4);
|
||||
NV_ALIGN(16, typedef vec3ui uvec3);
|
||||
NV_ALIGN(8, typedef vec2ui uvec2);
|
||||
#else
|
||||
// Matrices, must align to 4 vector (16 bytes)
|
||||
typedef mat3f mat3;
|
||||
typedef mat4f mat4;
|
||||
|
||||
// vectors, 4-tuples and 3-tuples must align to 16 bytes
|
||||
// 2-vectors must align to 8 bytes
|
||||
typedef vec4f vec4;
|
||||
typedef vec3f vec3;
|
||||
typedef vec2f vec2;
|
||||
|
||||
typedef vec4i ivec4;
|
||||
typedef vec3i ivec3;
|
||||
typedef vec2i ivec2;
|
||||
|
||||
typedef vec4ui uvec4;
|
||||
typedef vec3ui uvec3;
|
||||
typedef vec2ui uvec2;
|
||||
#endif
|
||||
|
||||
//class to make uint look like bool to make GLSL packing rules happy
|
||||
struct boolClass
|
||||
{
|
||||
unsigned int _rep;
|
||||
|
||||
boolClass()
|
||||
: _rep(false)
|
||||
{
|
||||
}
|
||||
boolClass(bool b)
|
||||
: _rep(b)
|
||||
{
|
||||
}
|
||||
operator bool() { return _rep == 0 ? false : true; }
|
||||
boolClass& operator=(bool b)
|
||||
{
|
||||
_rep = b;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
NV_ALIGN(4, typedef boolClass bool32);
|
||||
|
||||
} // namespace nvmath
|
||||
|
||||
#endif
|
||||
91
raytracer/nvpro_core/nvmath/nvmath_hlsltypes.h
Normal file
91
raytracer/nvpro_core/nvmath/nvmath_hlsltypes.h
Normal file
|
|
@ -0,0 +1,91 @@
|
|||
/*
|
||||
* Copyright (c) 2012-2021, NVIDIA CORPORATION. All rights reserved.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
* SPDX-FileCopyrightText: Copyright (c) 2012-2021 NVIDIA CORPORATION
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/// @DOC_SKIP (keyword to exclude this file from automatic README.md generation)
|
||||
|
||||
#ifndef NV_HLSLSHADER_TYPES_H
|
||||
#define NV_HLSLSHADER_TYPES_H
|
||||
|
||||
#include "nvmath_types.h"
|
||||
#include <NvFoundation.h>
|
||||
|
||||
namespace nvmath {
|
||||
|
||||
#if defined(__amd64__) || defined(__x86_64__) || defined(_M_X64) || defined(__AMD64__)
|
||||
// Matrices, must align to 4 vector (16 bytes)
|
||||
NV_ALIGN(16, typedef mat4f float4x4);
|
||||
|
||||
// vectors, 4-tuples and 3-tuples must align to 16 bytes
|
||||
// 2-vectors must align to 8 bytes
|
||||
NV_ALIGN(16, typedef vec4f float4);
|
||||
NV_ALIGN(16, typedef vec3f float3);
|
||||
NV_ALIGN(8, typedef vec2f float2);
|
||||
|
||||
NV_ALIGN(16, typedef vec4i int4);
|
||||
NV_ALIGN(16, typedef vec3i int3);
|
||||
NV_ALIGN(8, typedef vec2i int2);
|
||||
|
||||
NV_ALIGN(16, typedef vec4ui uint4);
|
||||
NV_ALIGN(16, typedef vec3ui uint3);
|
||||
NV_ALIGN(8, typedef vec2ui uint2);
|
||||
#else
|
||||
// Matrices, must align to 4 vector (16 bytes)
|
||||
typedef mat4f float4x4;
|
||||
|
||||
// vectors, 4-tuples and 3-tuples must align to 16 bytes
|
||||
// 2-vectors must align to 8 bytes
|
||||
typedef vec4f float4;
|
||||
typedef vec3f float3;
|
||||
typedef vec2f float2;
|
||||
|
||||
typedef vec4i int4;
|
||||
typedef vec3i int3;
|
||||
typedef vec2i int2;
|
||||
|
||||
typedef vec4ui uint4;
|
||||
typedef vec3ui uint3;
|
||||
typedef vec2ui uint2;
|
||||
#endif
|
||||
|
||||
//class to make uint look like bool to make GLSL packing rules happy
|
||||
struct boolClass
|
||||
{
|
||||
unsigned int _rep;
|
||||
|
||||
boolClass()
|
||||
: _rep(false)
|
||||
{
|
||||
}
|
||||
boolClass(bool b)
|
||||
: _rep(b)
|
||||
{
|
||||
}
|
||||
operator bool() { return _rep == 0 ? false : true; }
|
||||
boolClass& operator=(bool b)
|
||||
{
|
||||
_rep = b;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
NV_ALIGN(4, typedef boolClass bool32);
|
||||
|
||||
} // namespace nvmath
|
||||
|
||||
#endif
|
||||
1160
raytracer/nvpro_core/nvmath/nvmath_types.h
Normal file
1160
raytracer/nvpro_core/nvmath/nvmath_types.h
Normal file
File diff suppressed because it is too large
Load diff
Loading…
Add table
Add a link
Reference in a new issue