/usr/include/sc/util/render/algebra3.h is in libsc-dev 2.3.1-16ubuntu5.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 | /****************************************************************
* *
* C++ Vector and Matrix Algebra routines *
* Author: Jean-Francois DOUE *
* Version 3.1 --- October 1993 *
* *
****************************************************************/
#ifndef _util_misc_algebra_h
#define _util_misc_algebra_h
#include <iostream>
#include <stdlib.h>
namespace sc {
// this line defines a new type: pointer to a function which returns a
// double and takes as argument a double
typedef double (*V_FCT_PTR)(double);
class vec2;
class vec3;
class vec4;
class mat3;
class mat4;
enum {VX, VY, VZ, VW}; // axes
enum {PA, PB, PC, PD}; // planes
enum {RED, GREEN, BLUE}; // colors
/****************************************************************
* *
* 2D Vector *
* *
****************************************************************/
class vec2
{
protected:
double n[2];
public:
// Constructors
vec2();
vec2(const double x, const double y);
vec2(const double d);
vec2(const vec2& v); // copy constructor
vec2(const vec3& v); // cast v3 to v2
vec2(const vec3& v, int dropAxis); // cast v3 to v2
// Assignment operators
vec2& operator = ( const vec2& v ); // assignment of a vec2
vec2& operator += ( const vec2& v ); // incrementation by a vec2
vec2& operator -= ( const vec2& v ); // decrementation by a vec2
vec2& operator *= ( const double d ); // multiplication by a constant
vec2& operator /= ( const double d ); // division by a constant
double& operator [] ( int i); // indexing
const double& operator[](int i) const; // indexing
// special functions
double length(); // length of a vec2
double length2(); // squared length of a vec2
vec2& normalize(); // normalize a vec2
vec2& apply(V_FCT_PTR fct); // apply a func. to each component
// friends
friend vec2 operator - (const vec2& v); // -v1
friend vec2 operator + (const vec2& a, const vec2& b); // v1 + v2
friend vec2 operator - (const vec2& a, const vec2& b); // v1 - v2
friend vec2 operator * (const vec2& a, const double d); // v1 * 3.0
friend vec2 operator * (const double d, const vec2& a); // 3.0 * v1
friend vec2 operator * (const mat3& a, const vec2& v); // M . v
friend vec2 operator * (const vec2& v, mat3& a); // v . M
friend double operator * (const vec2& a, const vec2& b); // dot product
friend vec2 operator / (const vec2& a, const double d); // v1 / 3.0
friend vec3 operator ^ (const vec2& a, const vec2& b); // cross product
friend int operator == (const vec2& a, const vec2& b); // v1 == v2 ?
friend int operator != (const vec2& a, const vec2& b); // v1 != v2 ?
friend std::ostream& operator << (std::ostream& s, vec2& v);// output to stream
friend std::istream& operator >> (std::istream& s, vec2& v);// input from strm.
friend void swap(vec2& a, vec2& b); // swap v1 & v2
friend vec2 min(const vec2& a, const vec2& b); // min(v1, v2)
friend vec2 max(const vec2& a, const vec2& b); // max(v1, v2)
friend vec2 prod(const vec2& a, const vec2& b); // term by term *
// necessary friend declarations
friend class vec3;
};
/****************************************************************
* *
* 3D Vector *
* *
****************************************************************/
class vec3
{
protected:
double n[3];
public:
// Constructors
vec3();
vec3(const double x, const double y, const double z);
vec3(const double d);
vec3(const vec3& v); // copy constructor
vec3(const vec2& v); // cast v2 to v3
vec3(const vec2& v, double d); // cast v2 to v3
vec3(const vec4& v); // cast v4 to v3
vec3(const vec4& v, int dropAxis); // cast v4 to v3
// Assignment operators
vec3& operator = ( const vec3& v ); // assignment of a vec3
vec3& operator += ( const vec3& v ); // incrementation by a vec3
vec3& operator -= ( const vec3& v ); // decrementation by a vec3
vec3& operator *= ( const double d ); // multiplication by a constant
vec3& operator /= ( const double d ); // division by a constant
double& operator [] ( int i); // indexing
const double& operator[](int i) const; // indexing
// special functions
double length(); // length of a vec3
double length2(); // squared length of a vec3
vec3& normalize(); // normalize a vec3
vec3& apply(V_FCT_PTR fct); // apply a func. to each component
// friends
friend vec3 operator - (const vec3& v); // -v1
friend vec3 operator + (const vec3& a, const vec3& b); // v1 + v2
friend vec3 operator - (const vec3& a, const vec3& b); // v1 - v2
friend vec3 operator * (const vec3& a, const double d); // v1 * 3.0
friend vec3 operator * (const double d, const vec3& a); // 3.0 * v1
friend vec3 operator * (const mat4& a, const vec3& v); // M . v
friend vec3 operator * (const vec3& v, const mat4& a); // v . M
friend double operator * (const vec3& a, const vec3& b); // dot product
friend vec3 operator / (const vec3& a, const double d); // v1 / 3.0
friend vec3 operator ^ (const vec3& a, const vec3& b); // cross product
friend int operator == (const vec3& a, const vec3& b); // v1 == v2 ?
friend int operator != (const vec3& a, const vec3& b); // v1 != v2 ?
friend std::ostream& operator << (std::ostream& s, vec3& v);// output to stream
friend std::istream& operator >> (std::istream& s, vec3& v);// input from strm.
friend void swap(vec3& a, vec3& b); // swap v1 & v2
friend vec3 min(const vec3& a, const vec3& b); // min(v1, v2)
friend vec3 max(const vec3& a, const vec3& b); // max(v1, v2)
friend vec3 prod(const vec3& a, const vec3& b); // term by term *
// necessary friend declarations
friend class vec2;
friend class vec4;
friend class mat3;
friend vec2 operator * (const mat3& a, const vec2& v); // linear transform
friend mat3 operator * (const mat3& a, const mat3& b); // matrix 3 product
};
/****************************************************************
* *
* 4D Vector *
* *
****************************************************************/
class vec4
{
protected:
double n[4];
public:
// Constructors
vec4();
vec4(const double x, const double y, const double z, const double w);
vec4(const double d);
vec4(const vec4& v); // copy constructor
vec4(const vec3& v); // cast vec3 to vec4
vec4(const vec3& v, const double d); // cast vec3 to vec4
// Assignment operators
vec4& operator = ( const vec4& v ); // assignment of a vec4
vec4& operator += ( const vec4& v ); // incrementation by a vec4
vec4& operator -= ( const vec4& v ); // decrementation by a vec4
vec4& operator *= ( const double d ); // multiplication by a constant
vec4& operator /= ( const double d ); // division by a constant
double& operator [] ( int i); // indexing
const double& operator [] ( int i) const; // indexing
// special functions
double length(); // length of a vec4
double length2(); // squared length of a vec4
vec4& normalize(); // normalize a vec4
vec4& apply(V_FCT_PTR fct); // apply a func. to each component
// friends
friend vec4 operator - (const vec4& v); // -v1
friend vec4 operator + (const vec4& a, const vec4& b); // v1 + v2
friend vec4 operator - (const vec4& a, const vec4& b); // v1 - v2
friend vec4 operator * (const vec4& a, const double d); // v1 * 3.0
friend vec4 operator * (const double d, const vec4& a); // 3.0 * v1
friend vec4 operator * (const mat4& a, const vec4& v); // M . v
friend vec4 operator * (const vec4& v, const mat4& a); // v . M
friend double operator * (const vec4& a, const vec4& b); // dot product
friend vec4 operator / (const vec4& a, const double d); // v1 / 3.0
friend int operator == (const vec4& a, const vec4& b); // v1 == v2 ?
friend int operator != (const vec4& a, const vec4& b); // v1 != v2 ?
friend std::ostream& operator << (std::ostream& s, vec4& v);// output to stream
friend std::istream& operator >> (std::istream& s, vec4& v);// input from strm.
friend void swap(vec4& a, vec4& b); // swap v1 & v2
friend vec4 min(const vec4& a, const vec4& b); // min(v1, v2)
friend vec4 max(const vec4& a, const vec4& b); // max(v1, v2)
friend vec4 prod(const vec4& a, const vec4& b); // term by term *
// necessary friend declarations
friend class vec3;
friend class mat4;
friend vec3 operator * (const mat4& a, const vec3& v); // linear transform
friend mat4 operator * (const mat4& a, const mat4& b); // matrix 4 product
};
/****************************************************************
* *
* 3x3 Matrix *
* *
****************************************************************/
class mat3
{
protected:
vec3 v[3];
public:
// Constructors
mat3();
mat3(const vec3& v0, const vec3& v1, const vec3& v2);
mat3(const double d);
mat3(const mat3& m);
// Assignment operators
mat3& operator = ( const mat3& m ); // assignment of a mat3
mat3& operator += ( const mat3& m ); // incrementation by a mat3
mat3& operator -= ( const mat3& m ); // decrementation by a mat3
mat3& operator *= ( const double d ); // multiplication by a constant
mat3& operator /= ( const double d ); // division by a constant
vec3& operator [] ( int i); // indexing
const vec3& operator [] ( int i) const; // indexing
// special functions
mat3 transpose() const; // transpose
mat3 inverse(); // inverse
mat3& apply(V_FCT_PTR fct); // apply a func. to each element
// friends
friend mat3 operator - (const mat3& a); // -m1
friend mat3 operator + (const mat3& a, const mat3& b); // m1 + m2
friend mat3 operator - (const mat3& a, const mat3& b); // m1 - m2
friend mat3 operator * (const mat3& a, const mat3& b); // m1 * m2
friend mat3 operator * (const mat3& a, const double d); // m1 * 3.0
friend mat3 operator * (const double d, const mat3& a); // 3.0 * m1
friend mat3 operator / (const mat3& a, const double d); // m1 / 3.0
friend int operator == (const mat3& a, const mat3& b); // m1 == m2 ?
friend int operator != (const mat3& a, const mat3& b); // m1 != m2 ?
friend std::ostream& operator << (std::ostream& s, mat3& m);// output to stream
friend std::istream& operator >> (std::istream& s, mat3& m);// input from strm.
friend void swap(mat3& a, mat3& b); // swap m1 & m2
// necessary friend declarations
friend vec3 operator * (const mat3& a, const vec3& v); // linear transform
friend vec2 operator * (const mat3& a, const vec2& v); // linear transform
};
/****************************************************************
* *
* 4x4 Matrix *
* *
****************************************************************/
class mat4
{
protected:
vec4 v[4];
public:
// Constructors
mat4();
mat4(const vec4& v0, const vec4& v1, const vec4& v2, const vec4& v3);
mat4(const double d);
mat4(const mat4& m);
// Assignment operators
mat4& operator = ( const mat4& m ); // assignment of a mat4
mat4& operator += ( const mat4& m ); // incrementation by a mat4
mat4& operator -= ( const mat4& m ); // decrementation by a mat4
mat4& operator *= ( const double d ); // multiplication by a constant
mat4& operator /= ( const double d ); // division by a constant
vec4& operator [] ( int i); // indexing
const vec4& operator [] ( int i) const; // indexing
// special functions
mat4 transpose() const; // transpose
mat4 inverse(); // inverse
mat4& apply(V_FCT_PTR fct); // apply a func. to each element
// friends
friend mat4 operator - (const mat4& a); // -m1
friend mat4 operator + (const mat4& a, const mat4& b); // m1 + m2
friend mat4 operator - (const mat4& a, const mat4& b); // m1 - m2
friend mat4 operator * (const mat4& a, const mat4& b); // m1 * m2
friend mat4 operator * (const mat4& a, const double d); // m1 * 4.0
friend mat4 operator * (const double d, const mat4& a); // 4.0 * m1
friend mat4 operator / (const mat4& a, const double d); // m1 / 3.0
friend int operator == (const mat4& a, const mat4& b); // m1 == m2 ?
friend int operator != (const mat4& a, const mat4& b); // m1 != m2 ?
friend std::ostream& operator << (std::ostream& s, mat4& m);// output to stream
friend std::istream& operator >> (std::istream& s, mat4& m);// input from strm.
friend void swap(mat4& a, mat4& b); // swap m1 & m2
// necessary friend declarations
friend vec4 operator * (const mat4& a, const vec4& v); // linear transform
friend vec3 operator * (const mat4& a, const vec3& v); // linear transform
};
/****************************************************************
* *
* 2D functions and 3D functions *
* *
****************************************************************/
mat3 identity2D(); // identity 2D
mat3 translation2D(const vec2& v); // translation 2D
mat3 rotation2D(const vec2& Center, const double angleDeg); // rotation 2D
mat3 scaling2D(const vec2& scaleVector); // scaling 2D
mat4 identity3D(); // identity 3D
mat4 translation3D(const vec3& v); // translation 3D
mat4 rotation3D(const vec3& Axis, const double angleDeg); // rotation 3D
mat4 scaling3D(const vec3& scaleVector); // scaling 3D
mat4 perspective3D(const double d); // perspective 3D
}
#endif
|