[SCM] A client for connecting to 3D metaverses such as Linden Labs Secondlife(tm) and OpenSim grids branch, master, updated. upstream/1.21.1-87-g0abdc08
Robin Cornelius
robin.cornelius at gmail.com
Mon Sep 22 11:04:44 UTC 2008
The following commit has been merged in the master branch:
commit 0abdc0838ad63ede53daa458cbc47bdde355725d
Author: Robin Cornelius <robin.cornelius at gmail.com>
Date: Sun Sep 21 17:24:03 2008 +0100
Patch rebase for 1.21.2 build
diff --git a/debian/changelog b/debian/changelog
index 0da9d5e..63a5c16 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,14 @@
+omvviewer (1.21.2-1) unstable; urgency=low
+
+ * New Upstream Version
+ + Import glh_linear.h as a patch
+ + Add replacment viewer pixmap as a patch
+ + rebase 24_always_test_vectorize.diff
+ + remove --as-needed on gcc line, works around broken cmake 2.6.X < 2.6.2
+ + drop add_find_curl_cmake.patch, not needed
+
+ -- Robin Cornelius <robin.cornelius at gmail.com> Sun, 14 Sep 2008 17:00:28 +0100
+
omvviewer (1.21.1-1) unstable; urgency=low
* New Upstream Version
@@ -570,4 +581,4 @@ slviewer (1.16.0.5-1) unstable; urgency=low
* Initial release (Closes: #406335, #406185)
- -- Paul "TBBle" Hampson <Paul.Hampson at Pobox.com> Fri, 25 May 2007 00:02:48 +1000rename_binary_cmake.patch
\ No newline at end of file
+ -- Paul "TBBle" Hampson <Paul.Hampson at Pobox.com> Fri, 25 May 2007 00:02:48 +1000rename_binary_cmake.patch
diff --git a/debian/control b/debian/control
index fb62d07..c639724 100644
--- a/debian/control
+++ b/debian/control
@@ -9,7 +9,7 @@ XS-Vcs-Git: http://git.debian.org/git/pkg-games/slviewer.git
Package: omvviewer
Architecture: i386 amd64 powerpc
-Depends: ${misc:Depends}, ${shlibs:Depends}, omvviewer-data (= ${source:Version}), omvviewer-artwork (>= 1.21.1), ttf-kochi-mincho, ttf-dejavu, libc-ares1
+Depends: ${misc:Depends}, ${shlibs:Depends}, omvviewer-data (= ${source:Version}), omvviewer-artwork (>= 1.21.0), ttf-kochi-mincho, ttf-dejavu, libc-ares1
Recommends: libgstreamer0.10-0, libgstreamer-plugins-base0.10-0
Replaces: slviewer
Description: Open Metaverse Viewer
diff --git a/debian/patches/24_always_test_vectorize.diff b/debian/patches/24_always_test_vectorize.diff
index 684951b..ec8d8b7 100644
--- a/debian/patches/24_always_test_vectorize.diff
+++ b/debian/patches/24_always_test_vectorize.diff
@@ -6,19 +6,19 @@
@DPATCH@
-Index: ./indra/newview/llappviewer.cpp
+Index: slviewer/indra/newview/llappviewer.cpp
===================================================================
---- ./indra/newview/llappviewer.cpp (revision 319)
-+++ ./indra/newview/llappviewer.cpp (working copy)
-@@ -415,7 +415,6 @@
- LLVOSurfacePatch::sLODFactor *= LLVOSurfacePatch::sLODFactor; //sqaure lod factor to get exponential range of [1,4]
- gGL.setClever(gSavedSettings.getBOOL("RenderUseCleverUI"));
+--- slviewer.orig/indra/newview/llappviewer.cpp 2008-09-14 17:04:46.000000000 +0100
++++ slviewer/indra/newview/llappviewer.cpp 2008-09-14 17:06:56.000000000 +0100
+@@ -432,7 +432,6 @@
+ gDebugGL = gSavedSettings.getBOOL("RenderDebugGL");
+ gDebugPipeline = gSavedSettings.getBOOL("RenderDebugPipeline");
-#if LL_VECTORIZE
if (gSysCPU.hasAltivec())
{
gSavedSettings.setBOOL("VectorizeEnable", TRUE );
-@@ -441,13 +440,6 @@
+@@ -458,13 +457,6 @@
gSavedSettings.setU32("VectorizeProcessor", 0 );
gSavedSettings.setBOOL("VectorizeSkin", FALSE);
}
@@ -29,6 +29,6 @@ Index: ./indra/newview/llappviewer.cpp
- gSavedSettings.setU32("VectorizeProcessor", 0 );
- gSavedSettings.setBOOL("VectorizeSkin", FALSE);
-#endif
+ }
- // propagate push to talk preference to current status
- gSavedSettings.setBOOL("PTTCurrentlyEnabled", TRUE); //gSavedSettings.getBOOL("EnablePushToTalk"));
+ void LLAppViewer::initGridChoice()
diff --git a/debian/patches/glh_linear.patch b/debian/patches/glh_linear.patch
new file mode 100644
index 0000000..bd15af8
--- /dev/null
+++ b/debian/patches/glh_linear.patch
@@ -0,0 +1,1627 @@
+diff --git a/indra/llwindow/glh/glh_linear.h b/indra/llwindow/glh/glh_linear.h
+new file mode 100755
+index 0000000..04ae1bd
+--- /dev/null
++++ b/indra/llwindow/glh/glh_linear.h
+@@ -0,0 +1,1621 @@
++/*
++ glh - is a platform-indepenedent C++ OpenGL helper library
++
++
++ Copyright (c) 2000 Cass Everitt
++ Copyright (c) 2000 NVIDIA Corporation
++ All rights reserved.
++
++ Redistribution and use in source and binary forms, with or
++ without modification, are permitted provided that the following
++ conditions are met:
++
++ * Redistributions of source code must retain the above
++ copyright notice, this list of conditions and the following
++ disclaimer.
++
++ * Redistributions in binary form must reproduce the above
++ copyright notice, this list of conditions and the following
++ disclaimer in the documentation and/or other materials
++ provided with the distribution.
++
++ * The names of contributors to this software may not be used
++ to endorse or promote products derived from this software
++ without specific prior written permission.
++
++ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
++ ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
++ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
++ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
++ REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
++ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
++ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
++ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
++ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
++ ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++ POSSIBILITY OF SUCH DAMAGE.
++
++
++ Cass Everitt - cass at r3.nu
++*/
++
++/*
++glh_linear.h
++*/
++
++// Author: Cass W. Everitt
++
++#ifndef GLH_LINEAR_H
++#define GLH_LINEAR_H
++
++#include <memory.h>
++#include <math.h>
++#include <assert.h>
++
++// only supports float for now...
++#define GLH_REAL_IS_FLOAT
++
++#ifdef GLH_REAL_IS_FLOAT
++# define GLH_REAL float
++# define GLH_REAL_NAMESPACE ns_float
++#endif
++
++#define GLH_QUATERNION_NORMALIZATION_THRESHOLD 64
++
++#define GLH_RAD_TO_DEG GLH_REAL(57.2957795130823208767981548141052)
++#define GLH_DEG_TO_RAD GLH_REAL(0.0174532925199432957692369076848861)
++#define GLH_ZERO GLH_REAL(0.0)
++#define GLH_ONE GLH_REAL(1.0)
++#define GLH_TWO GLH_REAL(2.0)
++#define GLH_EPSILON GLH_REAL(10e-6)
++#define GLH_PI GLH_REAL(3.1415926535897932384626433832795)
++
++#define equivalent(a,b) (((a < b + GLH_EPSILON) && (a > b - GLH_EPSILON)) ? true : false)
++
++namespace glh
++{
++
++ inline GLH_REAL to_degrees(GLH_REAL radians) { return radians*GLH_RAD_TO_DEG; }
++ inline GLH_REAL to_radians(GLH_REAL degrees) { return degrees*GLH_DEG_TO_RAD; }
++
++ // forward declarations for friend template functions.
++ template <int N, class T> class vec;
++
++ // forward declarations for friend template functions.
++ template <int N, class T>
++ bool operator == ( const vec<N,T> & v1, const vec<N,T> & v2 );
++
++ // forward declarations for friend template functions.
++ template <int N, class T>
++ bool operator != ( const vec<N,T> & v1, const vec<N,T> & v2 );
++
++ template <int N, class T>
++ class vec
++ {
++ public:
++ int size() const { return N; }
++
++ vec(const T & t = T())
++ { for(int i = 0; i < N; i++) v[i] = t; }
++ vec(const T * tp)
++ { for(int i = 0; i < N; i++) v[i] = tp[i]; }
++
++ const T * get_value() const
++ { return v; }
++
++
++ T dot( const vec<N,T> & rhs ) const
++ {
++ T r = 0;
++ for(int i = 0; i < N; i++) r += v[i]*rhs.v[i];
++ return r;
++ }
++
++ T length() const
++ {
++ T r = 0;
++ for(int i = 0; i < N; i++) r += v[i]*v[i];
++ return T(sqrt(r));
++ }
++
++ T square_norm() const
++ {
++ T r = 0;
++ for(int i = 0; i < N; i++) r += v[i]*v[i];
++ return r;
++ }
++
++ void negate()
++ { for(int i = 0; i < N; i++) v[i] = -v[i]; }
++
++
++ T normalize()
++ {
++ T sum(0);
++ for(int i = 0; i < N; i++)
++ sum += v[i]*v[i];
++ sum = T(sqrt(sum));
++ if (sum > GLH_EPSILON)
++ for(int i = 0; i < N; i++)
++ v[i] /= sum;
++ return sum;
++ }
++
++
++ vec<N,T> & set_value( const T * rhs )
++ { for(int i = 0; i < N; i++) v[i] = rhs[i]; return *this; }
++
++ T & operator [] ( int i )
++ { return v[i]; }
++
++ const T & operator [] ( int i ) const
++ { return v[i]; }
++
++ vec<N,T> & operator *= ( T d )
++ { for(int i = 0; i < N; i++) v[i] *= d; return *this;}
++
++ vec<N,T> & operator *= ( const vec<N,T> & u )
++ { for(int i = 0; i < N; i++) v[i] *= u[i]; return *this;}
++
++ vec<N,T> & operator /= ( T d )
++ { if(d == 0) return *this; for(int i = 0; i < N; i++) v[i] /= d; return *this;}
++
++ vec<N,T> & operator += ( const vec<N,T> & u )
++ { for(int i = 0; i < N; i++) v[i] += u.v[i]; return *this;}
++
++ vec<N,T> & operator -= ( const vec<N,T> & u )
++ { for(int i = 0; i < N; i++) v[i] -= u.v[i]; return *this;}
++
++
++ vec<N,T> operator - () const
++ { vec<N,T> rv = v; rv.negate(); return rv; }
++
++ vec<N,T> operator + ( const vec<N,T> &v) const
++ { vec<N,T> rt(*this); return rt += v; }
++
++ vec<N,T> operator - ( const vec<N,T> &v) const
++ { vec<N,T> rt(*this); return rt -= v; }
++
++ vec<N,T> operator * ( T d) const
++ { vec<N,T> rt(*this); return rt *= d; }
++
++ friend bool operator == <> ( const vec<N,T> &v1, const vec<N,T> &v2 );
++ friend bool operator != <> ( const vec<N,T> &v1, const vec<N,T> &v2 );
++
++
++ //protected:
++ T v[N];
++ };
++
++
++
++ // vector friend operators
++
++ template <int N, class T> inline
++ vec<N,T> operator * ( const vec<N,T> & b, T d )
++ {
++ vec<N,T> rt(b);
++ return rt *= d;
++ }
++
++ template <int N, class T> inline
++ vec<N,T> operator * ( T d, const vec<N,T> & b )
++ { return b*d; }
++
++ template <int N, class T> inline
++ vec<N,T> operator * ( const vec<N,T> & b, const vec<N,T> & d )
++ {
++ vec<N,T> rt(b);
++ return rt *= d;
++ }
++
++ template <int N, class T> inline
++ vec<N,T> operator / ( const vec<N,T> & b, T d )
++ { vec<N,T> rt(b); return rt /= d; }
++
++ template <int N, class T> inline
++ vec<N,T> operator + ( const vec<N,T> & v1, const vec<N,T> & v2 )
++ { vec<N,T> rt(v1); return rt += v2; }
++
++ template <int N, class T> inline
++ vec<N,T> operator - ( const vec<N,T> & v1, const vec<N,T> & v2 )
++ { vec<N,T> rt(v1); return rt -= v2; }
++
++
++ template <int N, class T> inline
++ bool operator == ( const vec<N,T> & v1, const vec<N,T> & v2 )
++ {
++ for(int i = 0; i < N; i++)
++ if(v1.v[i] != v2.v[i])
++ return false;
++ return true;
++ }
++
++ template <int N, class T> inline
++ bool operator != ( const vec<N,T> & v1, const vec<N,T> & v2 )
++ { return !(v1 == v2); }
++
++
++ typedef vec<3,unsigned char> vec3ub;
++ typedef vec<4,unsigned char> vec4ub;
++
++
++
++
++
++ namespace GLH_REAL_NAMESPACE
++ {
++ typedef GLH_REAL real;
++
++ class line;
++ class plane;
++ class matrix4;
++ class quaternion;
++ typedef quaternion rotation;
++
++ class vec2 : public vec<2,real>
++ {
++ public:
++ vec2(const real & t = real()) : vec<2,real>(t)
++ {}
++ vec2(const vec<2,real> & t) : vec<2,real>(t)
++ {}
++ vec2(const real * tp) : vec<2,real>(tp)
++ {}
++
++ vec2(real x, real y )
++ { v[0] = x; v[1] = y; }
++
++ void get_value(real & x, real & y) const
++ { x = v[0]; y = v[1]; }
++
++ vec2 & set_value( const real & x, const real & y)
++ { v[0] = x; v[1] = y; return *this; }
++
++ };
++
++
++ class vec3 : public vec<3,real>
++ {
++ public:
++ vec3(const real & t = real()) : vec<3,real>(t)
++ {}
++ vec3(const vec<3,real> & t) : vec<3,real>(t)
++ {}
++ vec3(const real * tp) : vec<3,real>(tp)
++ {}
++
++ vec3(real x, real y, real z)
++ { v[0] = x; v[1] = y; v[2] = z; }
++
++ void get_value(real & x, real & y, real & z) const
++ { x = v[0]; y = v[1]; z = v[2]; }
++
++ vec3 cross( const vec3 &rhs ) const
++ {
++ vec3 rt;
++ rt.v[0] = v[1]*rhs.v[2]-v[2]*rhs.v[1];
++ rt.v[1] = v[2]*rhs.v[0]-v[0]*rhs.v[2];
++ rt.v[2] = v[0]*rhs.v[1]-v[1]*rhs.v[0];
++ return rt;
++ }
++
++ vec3 & set_value( const real & x, const real & y, const real & z)
++ { v[0] = x; v[1] = y; v[2] = z; return *this; }
++
++ };
++
++
++ class vec4 : public vec<4,real>
++ {
++ public:
++ vec4(const real & t = real()) : vec<4,real>(t)
++ {}
++ vec4(const vec<4,real> & t) : vec<4,real>(t)
++ {}
++
++ vec4(const vec<3,real> & t, real fourth)
++
++ { v[0] = t.v[0]; v[1] = t.v[1]; v[2] = t.v[2]; v[3] = fourth; }
++ vec4(const real * tp) : vec<4,real>(tp)
++ {}
++ vec4(real x, real y, real z, real w)
++ { v[0] = x; v[1] = y; v[2] = z; v[3] = w; }
++
++ void get_value(real & x, real & y, real & z, real & w) const
++ { x = v[0]; y = v[1]; z = v[2]; w = v[3]; }
++
++ vec4 & set_value( const real & x, const real & y, const real & z, const real & w)
++ { v[0] = x; v[1] = y; v[2] = z; v[3] = w; return *this; }
++ };
++
++ inline
++ vec3 homogenize(const vec4 & v)
++ {
++ vec3 rt;
++ assert(v.v[3] != GLH_ZERO);
++ rt.v[0] = v.v[0]/v.v[3];
++ rt.v[1] = v.v[1]/v.v[3];
++ rt.v[2] = v.v[2]/v.v[3];
++ return rt;
++ }
++
++
++
++ class line
++ {
++ public:
++
++ line()
++ { set_value(vec3(0,0,0),vec3(0,0,1)); }
++
++ line( const vec3 & p0, const vec3 &p1)
++ { set_value(p0,p1); }
++
++ void set_value( const vec3 &p0, const vec3 &p1)
++ {
++ position = p0;
++ direction = p1-p0;
++ direction.normalize();
++ }
++
++ bool get_closest_points(const line &line2,
++ vec3 &pointOnThis,
++ vec3 &pointOnThat)
++ {
++
++ // quick check to see if parallel -- if so, quit.
++ if(fabs(direction.dot(line2.direction)) == 1.0)
++ return 0;
++ line l2 = line2;
++
++ // Algorithm: Brian Jean
++ //
++ register real u;
++ register real v;
++ vec3 Vr = direction;
++ vec3 Vs = l2.direction;
++ register real Vr_Dot_Vs = Vr.dot(Vs);
++ register real detA = real(1.0 - (Vr_Dot_Vs * Vr_Dot_Vs));
++ vec3 C = l2.position - position;
++ register real C_Dot_Vr = C.dot(Vr);
++ register real C_Dot_Vs = C.dot(Vs);
++
++ u = (C_Dot_Vr - Vr_Dot_Vs * C_Dot_Vs)/detA;
++ v = (C_Dot_Vr * Vr_Dot_Vs - C_Dot_Vs)/detA;
++
++ pointOnThis = position;
++ pointOnThis += direction * u;
++ pointOnThat = l2.position;
++ pointOnThat += l2.direction * v;
++
++ return 1;
++ }
++
++ vec3 get_closest_point(const vec3 &point)
++ {
++ vec3 np = point - position;
++ vec3 rp = direction*direction.dot(np)+position;
++ return rp;
++ }
++
++ const vec3 & get_position() const {return position;}
++
++ const vec3 & get_direction() const {return direction;}
++
++ //protected:
++ vec3 position;
++ vec3 direction;
++ };
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++ // matrix
++
++
++ class matrix4
++ {
++
++ public:
++
++ matrix4() { make_identity(); }
++
++ matrix4( real r )
++ { set_value(r); }
++
++ matrix4( real * m )
++ { set_value(m); }
++
++ matrix4( real a00, real a01, real a02, real a03,
++ real a10, real a11, real a12, real a13,
++ real a20, real a21, real a22, real a23,
++ real a30, real a31, real a32, real a33 )
++ {
++ element(0,0) = a00;
++ element(0,1) = a01;
++ element(0,2) = a02;
++ element(0,3) = a03;
++
++ element(1,0) = a10;
++ element(1,1) = a11;
++ element(1,2) = a12;
++ element(1,3) = a13;
++
++ element(2,0) = a20;
++ element(2,1) = a21;
++ element(2,2) = a22;
++ element(2,3) = a23;
++
++ element(3,0) = a30;
++ element(3,1) = a31;
++ element(3,2) = a32;
++ element(3,3) = a33;
++ }
++
++
++ void get_value( real * mp ) const
++ {
++ int c = 0;
++ for(int j=0; j < 4; j++)
++ for(int i=0; i < 4; i++)
++ mp[c++] = element(i,j);
++ }
++
++
++ const real * get_value() const
++ { return m; }
++
++ void set_value( real * mp)
++ {
++ int c = 0;
++ for(int j=0; j < 4; j++)
++ for(int i=0; i < 4; i++)
++ element(i,j) = mp[c++];
++ }
++
++ void set_value( real r )
++ {
++ for(int i=0; i < 4; i++)
++ for(int j=0; j < 4; j++)
++ element(i,j) = r;
++ }
++
++ void make_identity()
++ {
++ element(0,0) = 1.0;
++ element(0,1) = 0.0;
++ element(0,2) = 0.0;
++ element(0,3) = 0.0;
++
++ element(1,0) = 0.0;
++ element(1,1) = 1.0;
++ element(1,2) = 0.0;
++ element(1,3) = 0.0;
++
++ element(2,0) = 0.0;
++ element(2,1) = 0.0;
++ element(2,2) = 1.0;
++ element(2,3) = 0.0;
++
++ element(3,0) = 0.0;
++ element(3,1) = 0.0;
++ element(3,2) = 0.0;
++ element(3,3) = 1.0;
++ }
++
++
++ static matrix4 identity()
++ {
++ static matrix4 mident (
++ 1.0, 0.0, 0.0, 0.0,
++ 0.0, 1.0, 0.0, 0.0,
++ 0.0, 0.0, 1.0, 0.0,
++ 0.0, 0.0, 0.0, 1.0 );
++ return mident;
++ }
++
++
++ void set_scale( real s )
++ {
++ element(0,0) = s;
++ element(1,1) = s;
++ element(2,2) = s;
++ }
++
++ void set_scale( const vec3 & s )
++ {
++ element(0,0) = s.v[0];
++ element(1,1) = s.v[1];
++ element(2,2) = s.v[2];
++ }
++
++
++ void set_translate( const vec3 & t )
++ {
++ element(0,3) = t.v[0];
++ element(1,3) = t.v[1];
++ element(2,3) = t.v[2];
++ }
++
++ void set_row(int r, const vec4 & t)
++ {
++ element(r,0) = t.v[0];
++ element(r,1) = t.v[1];
++ element(r,2) = t.v[2];
++ element(r,3) = t.v[3];
++ }
++
++ void set_column(int c, const vec4 & t)
++ {
++ element(0,c) = t.v[0];
++ element(1,c) = t.v[1];
++ element(2,c) = t.v[2];
++ element(3,c) = t.v[3];
++ }
++
++
++ void get_row(int r, vec4 & t) const
++ {
++ t.v[0] = element(r,0);
++ t.v[1] = element(r,1);
++ t.v[2] = element(r,2);
++ t.v[3] = element(r,3);
++ }
++
++ vec4 get_row(int r) const
++ {
++ vec4 v; get_row(r, v);
++ return v;
++ }
++
++ void get_column(int c, vec4 & t) const
++ {
++ t.v[0] = element(0,c);
++ t.v[1] = element(1,c);
++ t.v[2] = element(2,c);
++ t.v[3] = element(3,c);
++ }
++
++ vec4 get_column(int c) const
++ {
++ vec4 v; get_column(c, v);
++ return v;
++ }
++
++ matrix4 inverse() const
++ {
++ matrix4 minv;
++
++ real r1[8], r2[8], r3[8], r4[8];
++ real *s[4], *tmprow;
++
++ s[0] = &r1[0];
++ s[1] = &r2[0];
++ s[2] = &r3[0];
++ s[3] = &r4[0];
++
++ register int i,j,p,jj;
++ for(i=0;i<4;i++)
++ {
++ for(j=0;j<4;j++)
++ {
++ s[i][j] = element(i,j);
++ if(i==j) s[i][j+4] = 1.0;
++ else s[i][j+4] = 0.0;
++ }
++ }
++ real scp[4];
++ for(i=0;i<4;i++)
++ {
++ scp[i] = real(fabs(s[i][0]));
++ for(j=1;j<4;j++)
++ if(real(fabs(s[i][j])) > scp[i]) scp[i] = real(fabs(s[i][j]));
++ if(scp[i] == 0.0) return minv; // singular matrix!
++ }
++
++ int pivot_to;
++ real scp_max;
++ for(i=0;i<4;i++)
++ {
++ // select pivot row
++ pivot_to = i;
++ scp_max = real(fabs(s[i][i]/scp[i]));
++ // find out which row should be on top
++ for(p=i+1;p<4;p++)
++ if(real(fabs(s[p][i]/scp[p])) > scp_max)
++ { scp_max = real(fabs(s[p][i]/scp[p])); pivot_to = p; }
++ // Pivot if necessary
++ if(pivot_to != i)
++ {
++ tmprow = s[i];
++ s[i] = s[pivot_to];
++ s[pivot_to] = tmprow;
++ real tmpscp;
++ tmpscp = scp[i];
++ scp[i] = scp[pivot_to];
++ scp[pivot_to] = tmpscp;
++ }
++
++ real mji;
++ // perform gaussian elimination
++ for(j=i+1;j<4;j++)
++ {
++ mji = s[j][i]/s[i][i];
++ s[j][i] = 0.0;
++ for(jj=i+1;jj<8;jj++)
++ s[j][jj] -= mji*s[i][jj];
++ }
++ }
++ if(s[3][3] == 0.0) return minv; // singular matrix!
++
++ //
++ // Now we have an upper triangular matrix.
++ //
++ // x x x x | y y y y
++ // 0 x x x | y y y y
++ // 0 0 x x | y y y y
++ // 0 0 0 x | y y y y
++ //
++ // we'll back substitute to get the inverse
++ //
++ // 1 0 0 0 | z z z z
++ // 0 1 0 0 | z z z z
++ // 0 0 1 0 | z z z z
++ // 0 0 0 1 | z z z z
++ //
++
++ real mij;
++ for(i=3;i>0;i--)
++ {
++ for(j=i-1;j > -1; j--)
++ {
++ mij = s[j][i]/s[i][i];
++ for(jj=j+1;jj<8;jj++)
++ s[j][jj] -= mij*s[i][jj];
++ }
++ }
++
++ for(i=0;i<4;i++)
++ for(j=0;j<4;j++)
++ minv(i,j) = s[i][j+4] / s[i][i];
++
++ return minv;
++ }
++
++
++ matrix4 transpose() const
++ {
++ matrix4 mtrans;
++
++ for(int i=0;i<4;i++)
++ for(int j=0;j<4;j++)
++ mtrans(i,j) = element(j,i);
++ return mtrans;
++ }
++
++ matrix4 & mult_right( const matrix4 & b )
++ {
++ matrix4 mt(*this);
++ set_value(real(0));
++
++ for(int i=0; i < 4; i++)
++ for(int j=0; j < 4; j++)
++ for(int c=0; c < 4; c++)
++ element(i,j) += mt(i,c) * b(c,j);
++ return *this;
++ }
++
++ matrix4 & mult_left( const matrix4 & b )
++ {
++ matrix4 mt(*this);
++ set_value(real(0));
++
++ for(int i=0; i < 4; i++)
++ for(int j=0; j < 4; j++)
++ for(int c=0; c < 4; c++)
++ element(i,j) += b(i,c) * mt(c,j);
++ return *this;
++ }
++
++ // dst = M * src
++ void mult_matrix_vec( const vec3 &src, vec3 &dst ) const
++ {
++ real w = (
++ src.v[0] * element(3,0) +
++ src.v[1] * element(3,1) +
++ src.v[2] * element(3,2) +
++ element(3,3) );
++
++ assert(w != GLH_ZERO);
++
++ dst.v[0] = (
++ src.v[0] * element(0,0) +
++ src.v[1] * element(0,1) +
++ src.v[2] * element(0,2) +
++ element(0,3) ) / w;
++ dst.v[1] = (
++ src.v[0] * element(1,0) +
++ src.v[1] * element(1,1) +
++ src.v[2] * element(1,2) +
++ element(1,3) ) / w;
++ dst.v[2] = (
++ src.v[0] * element(2,0) +
++ src.v[1] * element(2,1) +
++ src.v[2] * element(2,2) +
++ element(2,3) ) / w;
++ }
++
++ void mult_matrix_vec( vec3 & src_and_dst) const
++ { mult_matrix_vec(vec3(src_and_dst), src_and_dst); }
++
++
++ // dst = src * M
++ void mult_vec_matrix( const vec3 &src, vec3 &dst ) const
++ {
++ real w = (
++ src.v[0] * element(0,3) +
++ src.v[1] * element(1,3) +
++ src.v[2] * element(2,3) +
++ element(3,3) );
++
++ assert(w != GLH_ZERO);
++
++ dst.v[0] = (
++ src.v[0] * element(0,0) +
++ src.v[1] * element(1,0) +
++ src.v[2] * element(2,0) +
++ element(3,0) ) / w;
++ dst.v[1] = (
++ src.v[0] * element(0,1) +
++ src.v[1] * element(1,1) +
++ src.v[2] * element(2,1) +
++ element(3,1) ) / w;
++ dst.v[2] = (
++ src.v[0] * element(0,2) +
++ src.v[1] * element(1,2) +
++ src.v[2] * element(2,2) +
++ element(3,2) ) / w;
++ }
++
++
++ void mult_vec_matrix( vec3 & src_and_dst) const
++ { mult_vec_matrix(vec3(src_and_dst), src_and_dst); }
++
++ // dst = M * src
++ void mult_matrix_vec( const vec4 &src, vec4 &dst ) const
++ {
++ dst.v[0] = (
++ src.v[0] * element(0,0) +
++ src.v[1] * element(0,1) +
++ src.v[2] * element(0,2) +
++ src.v[3] * element(0,3));
++ dst.v[1] = (
++ src.v[0] * element(1,0) +
++ src.v[1] * element(1,1) +
++ src.v[2] * element(1,2) +
++ src.v[3] * element(1,3));
++ dst.v[2] = (
++ src.v[0] * element(2,0) +
++ src.v[1] * element(2,1) +
++ src.v[2] * element(2,2) +
++ src.v[3] * element(2,3));
++ dst.v[3] = (
++ src.v[0] * element(3,0) +
++ src.v[1] * element(3,1) +
++ src.v[2] * element(3,2) +
++ src.v[3] * element(3,3));
++ }
++
++ void mult_matrix_vec( vec4 & src_and_dst) const
++ { mult_matrix_vec(vec4(src_and_dst), src_and_dst); }
++
++
++ // dst = src * M
++ void mult_vec_matrix( const vec4 &src, vec4 &dst ) const
++ {
++ dst.v[0] = (
++ src.v[0] * element(0,0) +
++ src.v[1] * element(1,0) +
++ src.v[2] * element(2,0) +
++ src.v[3] * element(3,0));
++ dst.v[1] = (
++ src.v[0] * element(0,1) +
++ src.v[1] * element(1,1) +
++ src.v[2] * element(2,1) +
++ src.v[3] * element(3,1));
++ dst.v[2] = (
++ src.v[0] * element(0,2) +
++ src.v[1] * element(1,2) +
++ src.v[2] * element(2,2) +
++ src.v[3] * element(3,2));
++ dst.v[3] = (
++ src.v[0] * element(0,3) +
++ src.v[1] * element(1,3) +
++ src.v[2] * element(2,3) +
++ src.v[3] * element(3,3));
++ }
++
++
++ void mult_vec_matrix( vec4 & src_and_dst) const
++ { mult_vec_matrix(vec4(src_and_dst), src_and_dst); }
++
++
++ // dst = M * src
++ void mult_matrix_dir( const vec3 &src, vec3 &dst ) const
++ {
++ dst.v[0] = (
++ src.v[0] * element(0,0) +
++ src.v[1] * element(0,1) +
++ src.v[2] * element(0,2) ) ;
++ dst.v[1] = (
++ src.v[0] * element(1,0) +
++ src.v[1] * element(1,1) +
++ src.v[2] * element(1,2) ) ;
++ dst.v[2] = (
++ src.v[0] * element(2,0) +
++ src.v[1] * element(2,1) +
++ src.v[2] * element(2,2) ) ;
++ }
++
++
++ void mult_matrix_dir( vec3 & src_and_dst) const
++ { mult_matrix_dir(vec3(src_and_dst), src_and_dst); }
++
++
++ // dst = src * M
++ void mult_dir_matrix( const vec3 &src, vec3 &dst ) const
++ {
++ dst.v[0] = (
++ src.v[0] * element(0,0) +
++ src.v[1] * element(1,0) +
++ src.v[2] * element(2,0) ) ;
++ dst.v[1] = (
++ src.v[0] * element(0,1) +
++ src.v[1] * element(1,1) +
++ src.v[2] * element(2,1) ) ;
++ dst.v[2] = (
++ src.v[0] * element(0,2) +
++ src.v[1] * element(1,2) +
++ src.v[2] * element(2,2) ) ;
++ }
++
++
++ void mult_dir_matrix( vec3 & src_and_dst) const
++ { mult_dir_matrix(vec3(src_and_dst), src_and_dst); }
++
++
++ real & operator () (int row, int col)
++ { return element(row,col); }
++
++ const real & operator () (int row, int col) const
++ { return element(row,col); }
++
++ real & element (int row, int col)
++ { return m[row | (col<<2)]; }
++
++ const real & element (int row, int col) const
++ { return m[row | (col<<2)]; }
++
++ matrix4 & operator *= ( const matrix4 & mat )
++ {
++ mult_right( mat );
++ return *this;
++ }
++
++ matrix4 & operator *= ( const real & r )
++ {
++ for (int i = 0; i < 4; ++i)
++ {
++ element(0,i) *= r;
++ element(1,i) *= r;
++ element(2,i) *= r;
++ element(3,i) *= r;
++ }
++ return *this;
++ }
++
++ matrix4 & operator += ( const matrix4 & mat )
++ {
++ for (int i = 0; i < 4; ++i)
++ {
++ element(0,i) += mat.element(0,i);
++ element(1,i) += mat.element(1,i);
++ element(2,i) += mat.element(2,i);
++ element(3,i) += mat.element(3,i);
++ }
++ return *this;
++ }
++
++ friend matrix4 operator * ( const matrix4 & m1, const matrix4 & m2 );
++ friend bool operator == ( const matrix4 & m1, const matrix4 & m2 );
++ friend bool operator != ( const matrix4 & m1, const matrix4 & m2 );
++
++ //protected:
++ real m[16];
++ };
++
++ inline
++ matrix4 operator * ( const matrix4 & m1, const matrix4 & m2 )
++ {
++ matrix4 product;
++
++ product = m1;
++ product.mult_right(m2);
++
++ return product;
++ }
++
++ inline
++ bool operator ==( const matrix4 &m1, const matrix4 &m2 )
++ {
++ return (
++ m1(0,0) == m2(0,0) &&
++ m1(0,1) == m2(0,1) &&
++ m1(0,2) == m2(0,2) &&
++ m1(0,3) == m2(0,3) &&
++ m1(1,0) == m2(1,0) &&
++ m1(1,1) == m2(1,1) &&
++ m1(1,2) == m2(1,2) &&
++ m1(1,3) == m2(1,3) &&
++ m1(2,0) == m2(2,0) &&
++ m1(2,1) == m2(2,1) &&
++ m1(2,2) == m2(2,2) &&
++ m1(2,3) == m2(2,3) &&
++ m1(3,0) == m2(3,0) &&
++ m1(3,1) == m2(3,1) &&
++ m1(3,2) == m2(3,2) &&
++ m1(3,3) == m2(3,3) );
++ }
++
++ inline
++ bool operator != ( const matrix4 & m1, const matrix4 & m2 )
++ { return !( m1 == m2 ); }
++
++
++
++
++
++
++
++
++
++
++
++
++
++ class quaternion
++ {
++ public:
++
++ quaternion()
++ {
++ *this = identity();
++ }
++
++ quaternion( const real v[4] )
++ {
++ set_value( v );
++ }
++
++
++ quaternion( real q0, real q1, real q2, real q3 )
++ {
++ set_value( q0, q1, q2, q3 );
++ }
++
++
++ quaternion( const matrix4 & m )
++ {
++ set_value( m );
++ }
++
++
++ quaternion( const vec3 &axis, real radians )
++ {
++ set_value( axis, radians );
++ }
++
++
++ quaternion( const vec3 &rotateFrom, const vec3 &rotateTo )
++ {
++ set_value( rotateFrom, rotateTo );
++ }
++
++ quaternion( const vec3 & from_look, const vec3 & from_up,
++ const vec3 & to_look, const vec3& to_up)
++ {
++ set_value(from_look, from_up, to_look, to_up);
++ }
++
++ const real * get_value() const
++ {
++ return &q[0];
++ }
++
++ void get_value( real &q0, real &q1, real &q2, real &q3 ) const
++ {
++ q0 = q[0];
++ q1 = q[1];
++ q2 = q[2];
++ q3 = q[3];
++ }
++
++ quaternion & set_value( real q0, real q1, real q2, real q3 )
++ {
++ q[0] = q0;
++ q[1] = q1;
++ q[2] = q2;
++ q[3] = q3;
++ counter = 0;
++ return *this;
++ }
++
++ void get_value( vec3 &axis, real &radians ) const
++ {
++ radians = real(acos( q[3] ) * GLH_TWO);
++ if ( radians == GLH_ZERO )
++ axis = vec3( 0.0, 0.0, 1.0 );
++ else
++ {
++ axis.v[0] = q[0];
++ axis.v[1] = q[1];
++ axis.v[2] = q[2];
++ axis.normalize();
++ }
++ }
++
++ void get_value( matrix4 & m ) const
++ {
++ real s, xs, ys, zs, wx, wy, wz, xx, xy, xz, yy, yz, zz;
++
++ real norm = q[0] * q[0] + q[1] * q[1] + q[2] * q[2] + q[3] * q[3];
++
++ s = (equivalent(norm,GLH_ZERO)) ? GLH_ZERO : ( GLH_TWO / norm );
++
++ xs = q[0] * s;
++ ys = q[1] * s;
++ zs = q[2] * s;
++
++ wx = q[3] * xs;
++ wy = q[3] * ys;
++ wz = q[3] * zs;
++
++ xx = q[0] * xs;
++ xy = q[0] * ys;
++ xz = q[0] * zs;
++
++ yy = q[1] * ys;
++ yz = q[1] * zs;
++ zz = q[2] * zs;
++
++ m(0,0) = real( GLH_ONE - ( yy + zz ));
++ m(1,0) = real ( xy + wz );
++ m(2,0) = real ( xz - wy );
++
++ m(0,1) = real ( xy - wz );
++ m(1,1) = real ( GLH_ONE - ( xx + zz ));
++ m(2,1) = real ( yz + wx );
++
++ m(0,2) = real ( xz + wy );
++ m(1,2) = real ( yz - wx );
++ m(2,2) = real ( GLH_ONE - ( xx + yy ));
++
++ m(3,0) = m(3,1) = m(3,2) = m(0,3) = m(1,3) = m(2,3) = GLH_ZERO;
++ m(3,3) = GLH_ONE;
++ }
++
++ quaternion & set_value( const real * qp )
++ {
++ memcpy(q,qp,sizeof(real) * 4);
++
++ counter = 0;
++ return *this;
++ }
++
++ quaternion & set_value( const matrix4 & m )
++ {
++ real tr, s;
++ int i, j, k;
++ const int nxt[3] = { 1, 2, 0 };
++
++ tr = m(0,0) + m(1,1) + m(2,2);
++
++ if ( tr > GLH_ZERO )
++ {
++ s = real(sqrt( tr + m(3,3) ));
++ q[3] = real ( s * 0.5 );
++ s = real(0.5) / s;
++
++ q[0] = real ( ( m(1,2) - m(2,1) ) * s );
++ q[1] = real ( ( m(2,0) - m(0,2) ) * s );
++ q[2] = real ( ( m(0,1) - m(1,0) ) * s );
++ }
++ else
++ {
++ i = 0;
++ if ( m(1,1) > m(0,0) )
++ i = 1;
++
++ if ( m(2,2) > m(i,i) )
++ i = 2;
++
++ j = nxt[i];
++ k = nxt[j];
++
++ s = real(sqrt( ( m(i,j) - ( m(j,j) + m(k,k) )) + GLH_ONE ));
++
++ q[i] = real ( s * 0.5 );
++ s = real(0.5 / s);
++
++ q[3] = real ( ( m(j,k) - m(k,j) ) * s );
++ q[j] = real ( ( m(i,j) + m(j,i) ) * s );
++ q[k] = real ( ( m(i,k) + m(k,i) ) * s );
++ }
++
++ counter = 0;
++ return *this;
++ }
++
++ quaternion & set_value( const vec3 &axis, real theta )
++ {
++ real sqnorm = axis.square_norm();
++
++ if (sqnorm <= GLH_EPSILON)
++ {
++ // axis too small.
++ x = y = z = 0.0;
++ w = 1.0;
++ }
++ else
++ {
++ theta *= real(0.5);
++ real sin_theta = real(sin(theta));
++
++ if (!equivalent(sqnorm,GLH_ONE))
++ sin_theta /= real(sqrt(sqnorm));
++ x = sin_theta * axis.v[0];
++ y = sin_theta * axis.v[1];
++ z = sin_theta * axis.v[2];
++ w = real(cos(theta));
++ }
++ return *this;
++ }
++
++ quaternion & set_value( const vec3 & rotateFrom, const vec3 & rotateTo )
++ {
++ vec3 p1, p2;
++ real alpha;
++
++ p1 = rotateFrom;
++ p1.normalize();
++ p2 = rotateTo;
++ p2.normalize();
++
++ alpha = p1.dot(p2);
++
++ if(equivalent(alpha,GLH_ONE))
++ {
++ *this = identity();
++ return *this;
++ }
++
++ // ensures that the anti-parallel case leads to a positive dot
++ if(equivalent(alpha,-GLH_ONE))
++ {
++ vec3 v;
++
++ if(p1.v[0] != p1.v[1] || p1.v[0] != p1.v[2])
++ v = vec3(p1.v[1], p1.v[2], p1.v[0]);
++ else
++ v = vec3(-p1.v[0], p1.v[1], p1.v[2]);
++
++ v -= p1 * p1.dot(v);
++ v.normalize();
++
++ set_value(v, GLH_PI);
++ return *this;
++ }
++
++ p1 = p1.cross(p2);
++ p1.normalize();
++ set_value(p1,real(acos(alpha)));
++
++ counter = 0;
++ return *this;
++ }
++
++ quaternion & set_value( const vec3 & from_look, const vec3 & from_up,
++ const vec3 & to_look, const vec3 & to_up)
++ {
++ quaternion r_look = quaternion(from_look, to_look);
++
++ vec3 rotated_from_up(from_up);
++ r_look.mult_vec(rotated_from_up);
++
++ quaternion r_twist = quaternion(rotated_from_up, to_up);
++
++ *this = r_twist;
++ *this *= r_look;
++ return *this;
++ }
++
++ quaternion & operator *= ( const quaternion & qr )
++ {
++ quaternion ql(*this);
++
++ w = ql.w * qr.w - ql.x * qr.x - ql.y * qr.y - ql.z * qr.z;
++ x = ql.w * qr.x + ql.x * qr.w + ql.y * qr.z - ql.z * qr.y;
++ y = ql.w * qr.y + ql.y * qr.w + ql.z * qr.x - ql.x * qr.z;
++ z = ql.w * qr.z + ql.z * qr.w + ql.x * qr.y - ql.y * qr.x;
++
++ counter += qr.counter;
++ counter++;
++ counter_normalize();
++ return *this;
++ }
++
++ void normalize()
++ {
++ real rnorm = GLH_ONE / real(sqrt(w * w + x * x + y * y + z * z));
++ if (equivalent(rnorm, GLH_ZERO))
++ return;
++ x *= rnorm;
++ y *= rnorm;
++ z *= rnorm;
++ w *= rnorm;
++ counter = 0;
++ }
++
++ friend bool operator == ( const quaternion & q1, const quaternion & q2 );
++
++ friend bool operator != ( const quaternion & q1, const quaternion & q2 );
++
++ friend quaternion operator * ( const quaternion & q1, const quaternion & q2 );
++
++ bool equals( const quaternion & r, real tolerance ) const
++ {
++ real t;
++
++ t = (
++ (q[0]-r.q[0])*(q[0]-r.q[0]) +
++ (q[1]-r.q[1])*(q[1]-r.q[1]) +
++ (q[2]-r.q[2])*(q[2]-r.q[2]) +
++ (q[3]-r.q[3])*(q[3]-r.q[3]) );
++ if(t > GLH_EPSILON)
++ return false;
++ return 1;
++ }
++
++ quaternion & conjugate()
++ {
++ q[0] *= -GLH_ONE;
++ q[1] *= -GLH_ONE;
++ q[2] *= -GLH_ONE;
++ return *this;
++ }
++
++ quaternion & invert()
++ {
++ return conjugate();
++ }
++
++ quaternion inverse() const
++ {
++ quaternion r = *this;
++ return r.invert();
++ }
++
++ //
++ // Quaternion multiplication with cartesian vector
++ // v' = q*v*q(star)
++ //
++ void mult_vec( const vec3 &src, vec3 &dst ) const
++ {
++ real v_coef = w * w - x * x - y * y - z * z;
++ real u_coef = GLH_TWO * (src.v[0] * x + src.v[1] * y + src.v[2] * z);
++ real c_coef = GLH_TWO * w;
++
++ dst.v[0] = v_coef * src.v[0] + u_coef * x + c_coef * (y * src.v[2] - z * src.v[1]);
++ dst.v[1] = v_coef * src.v[1] + u_coef * y + c_coef * (z * src.v[0] - x * src.v[2]);
++ dst.v[2] = v_coef * src.v[2] + u_coef * z + c_coef * (x * src.v[1] - y * src.v[0]);
++ }
++
++ void mult_vec( vec3 & src_and_dst) const
++ {
++ mult_vec(vec3(src_and_dst), src_and_dst);
++ }
++
++ void scale_angle( real scaleFactor )
++ {
++ vec3 axis;
++ real radians;
++
++ get_value(axis, radians);
++ radians *= scaleFactor;
++ set_value(axis, radians);
++ }
++
++ static quaternion slerp( const quaternion & p, const quaternion & q, real alpha )
++ {
++ quaternion r;
++
++ real cos_omega = p.x * q.x + p.y * q.y + p.z * q.z + p.w * q.w;
++ // if B is on opposite hemisphere from A, use -B instead
++
++ int bflip;
++ if ( ( bflip = (cos_omega < GLH_ZERO)) )
++ cos_omega = -cos_omega;
++
++ // complementary interpolation parameter
++ real beta = GLH_ONE - alpha;
++
++ if(cos_omega <= GLH_ONE - GLH_EPSILON)
++ return p;
++
++ real omega = real(acos(cos_omega));
++ real one_over_sin_omega = GLH_ONE / real(sin(omega));
++
++ beta = real(sin(omega*beta) * one_over_sin_omega);
++ alpha = real(sin(omega*alpha) * one_over_sin_omega);
++
++ if (bflip)
++ alpha = -alpha;
++
++ r.x = beta * p.q[0]+ alpha * q.q[0];
++ r.y = beta * p.q[1]+ alpha * q.q[1];
++ r.z = beta * p.q[2]+ alpha * q.q[2];
++ r.w = beta * p.q[3]+ alpha * q.q[3];
++ return r;
++ }
++
++ static quaternion identity()
++ {
++ static quaternion ident( vec3( 0.0, 0.0, 0.0 ), GLH_ONE );
++ return ident;
++ }
++
++ real & operator []( int i )
++ {
++ assert(i < 4);
++ return q[i];
++ }
++
++ const real & operator []( int i ) const
++ {
++ assert(i < 4);
++ return q[i];
++ }
++
++ protected:
++
++ void counter_normalize()
++ {
++ if (counter > GLH_QUATERNION_NORMALIZATION_THRESHOLD)
++ normalize();
++ }
++
++ union
++ {
++ struct
++ {
++ real q[4];
++ };
++ struct
++ {
++ real x;
++ real y;
++ real z;
++ real w;
++ };
++ };
++
++ // renormalization counter
++ unsigned char counter;
++ };
++
++ inline
++ bool operator == ( const quaternion & q1, const quaternion & q2 )
++ {
++ return (equivalent(q1.x, q2.x) &&
++ equivalent(q1.y, q2.y) &&
++ equivalent(q1.z, q2.z) &&
++ equivalent(q1.w, q2.w) );
++ }
++
++ inline
++ bool operator != ( const quaternion & q1, const quaternion & q2 )
++ {
++ return ! ( q1 == q2 );
++ }
++
++ inline
++ quaternion operator * ( const quaternion & q1, const quaternion & q2 )
++ {
++ quaternion r(q1);
++ r *= q2;
++ return r;
++ }
++
++
++
++
++
++
++
++
++
++
++ class plane
++ {
++ public:
++
++ plane()
++ {
++ planedistance = 0.0;
++ planenormal.set_value( 0.0, 0.0, 1.0 );
++ }
++
++
++ plane( const vec3 &p0, const vec3 &p1, const vec3 &p2 )
++ {
++ vec3 v0 = p1 - p0;
++ vec3 v1 = p2 - p0;
++ planenormal = v0.cross(v1);
++ planenormal.normalize();
++ planedistance = p0.dot(planenormal);
++ }
++
++ plane( const vec3 &normal, real distance )
++ {
++ planedistance = distance;
++ planenormal = normal;
++ planenormal.normalize();
++ }
++
++ plane( const vec3 &normal, const vec3 &point )
++ {
++ planenormal = normal;
++ planenormal.normalize();
++ planedistance = point.dot(planenormal);
++ }
++
++ void offset( real d )
++ {
++ planedistance += d;
++ }
++
++ bool intersect( const line &l, vec3 &intersection ) const
++ {
++ vec3 pos, dir;
++ vec3 pn = planenormal;
++ real pd = planedistance;
++
++ pos = l.get_position();
++ dir = l.get_direction();
++
++ if(dir.dot(pn) == 0.0) return 0;
++ pos -= pn*pd;
++ // now we're talking about a plane passing through the origin
++ if(pos.dot(pn) < 0.0) pn.negate();
++ if(dir.dot(pn) > 0.0) dir.negate();
++ vec3 ppos = pn * pos.dot(pn);
++ pos = (ppos.length()/dir.dot(-pn))*dir;
++ intersection = l.get_position();
++ intersection += pos;
++ return 1;
++ }
++ void transform( const matrix4 &matrix )
++ {
++ matrix4 invtr = matrix.inverse();
++ invtr = invtr.transpose();
++
++ vec3 pntOnplane = planenormal * planedistance;
++ vec3 newPntOnplane;
++ vec3 newnormal;
++
++ invtr.mult_dir_matrix(planenormal, newnormal);
++ matrix.mult_vec_matrix(pntOnplane, newPntOnplane);
++
++ newnormal.normalize();
++ planenormal = newnormal;
++ planedistance = newPntOnplane.dot(planenormal);
++ }
++
++ bool is_in_half_space( const vec3 &point ) const
++ {
++
++ if(( point.dot(planenormal) - planedistance) < 0.0)
++ return 0;
++ return 1;
++ }
++
++
++ real distance( const vec3 & point ) const
++ {
++ return planenormal.dot(point - planenormal*planedistance);
++ }
++
++ const vec3 &get_normal() const
++ {
++ return planenormal;
++ }
++
++
++ real get_distance_from_origin() const
++ {
++ return planedistance;
++ }
++
++
++ friend bool operator == ( const plane & p1, const plane & p2 );
++
++
++ friend bool operator != ( const plane & p1, const plane & p2 );
++
++ //protected:
++ vec3 planenormal;
++ real planedistance;
++ };
++
++ inline
++ bool operator == (const plane & p1, const plane & p2 )
++ {
++ return ( p1.planedistance == p2.planedistance && p1.planenormal == p2.planenormal);
++ }
++
++ inline
++ bool operator != ( const plane & p1, const plane & p2 )
++ { return ! (p1 == p2); }
++
++
++
++ } // "ns_##GLH_REAL"
++
++ // make common typedefs...
++#ifdef GLH_REAL_IS_FLOAT
++ typedef GLH_REAL_NAMESPACE::vec2 vec2f;
++ typedef GLH_REAL_NAMESPACE::vec3 vec3f;
++ typedef GLH_REAL_NAMESPACE::vec4 vec4f;
++ typedef GLH_REAL_NAMESPACE::quaternion quaternionf;
++ typedef GLH_REAL_NAMESPACE::quaternion rotationf;
++ typedef GLH_REAL_NAMESPACE::line linef;
++ typedef GLH_REAL_NAMESPACE::plane planef;
++ typedef GLH_REAL_NAMESPACE::matrix4 matrix4f;
++#endif
++
++
++
++
++} // namespace glh
++
++
++
++#endif
++
diff --git a/debian/patches/remove_as_needed.patch b/debian/patches/remove_as_needed.patch
new file mode 100644
index 0000000..9039d9f
--- /dev/null
+++ b/debian/patches/remove_as_needed.patch
@@ -0,0 +1,21 @@
+--- ./indra/linux_crash_logger/CMakeLists.txt.orig 2008-09-06 23:49:39.623979478 +0200
++++ ./indra/linux_crash_logger/CMakeLists.txt 2008-09-06 23:50:11.919980168 +0200
+@@ -41,8 +41,6 @@
+ ${linux_crash_logger_HEADER_FILES}
+ )
+
+-list(APPEND CMAKE_EXE_LINKER_FLAGS -Wl,--as-needed)
+-
+ add_executable(linux-crash-logger ${linux_crash_logger_SOURCE_FILES})
+
+ target_link_libraries(linux-crash-logger
+--- ./indra/newview/CMakeLists.txt.orig 2008-09-06 23:49:31.719981203 +0200
++++ ./indra/newview/CMakeLists.txt 2008-09-06 23:50:22.575979620 +0200
+@@ -874,7 +874,6 @@
+
+ if (LINUX)
+ LIST(APPEND viewer_SOURCE_FILES llappviewerlinux.cpp)
+- LIST(APPEND CMAKE_EXE_LINKER_FLAGS -Wl,--as-needed)
+
+ set(viewer_LIBRARIES
+ Xinerama
diff --git a/debian/patches/series b/debian/patches/series
index 980358f..6cafbb5 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1,3 +1,6 @@
+remove_as_needed.patch
+glh_linear.patch
+viewericon.patch
rename_binary_cmake.patch
24_always_test_vectorize.diff
50_get_cpu_clock_count_for_more_than_just_i386.diff
diff --git a/debian/patches/viewericon.patch b/debian/patches/viewericon.patch
new file mode 100644
index 0000000..819c0c2
--- /dev/null
+++ b/debian/patches/viewericon.patch
@@ -0,0 +1,703 @@
+diff --git a/indra/newview/res/viewericon.xpm b/indra/newview/res/viewericon.xpm
+new file mode 100644
+index 0000000..7cf88ad
+--- /dev/null
++++ b/indra/newview/res/viewericon.xpm
+@@ -0,0 +1,697 @@
++/* XPM */
++static char * viewericon_xpm[] = {
++"32 32 662 2",
++" c None",
++". c #2594FF",
++"+ c #2693FF",
++"@ c #2894FF",
++"# c #2996FF",
++"$ c #2B98FF",
++"% c #2C9AFF",
++"& c #2E99FF",
++"* c #319AFF",
++"= c #319BFF",
++"- c #329CFF",
++"; c #339EFF",
++"> c #349EFF",
++", c #329DFF",
++"' c #3099FF",
++") c #2D99FF",
++"! c #2A97FF",
++"~ c #2191FF",
++"{ c #2692FF",
++"] c #2994FF",
++"^ c #2A96FF",
++"/ c #2B9AFF",
++"( c #329BFF",
++"_ c #359FFF",
++": c #35A0FF",
++"< c #36A0FF",
++"[ c #359EFF",
++"} c #2E98FF",
++"| c #2293FF",
++"1 c #2995FF",
++"2 c #339DFF",
++"3 c #369FFF",
++"4 c #2D9AFF",
++"5 c #2394FF",
++"6 c #2F98FF",
++"7 c #38A2FF",
++"8 c #39A2FF",
++"9 c #3BA4FF",
++"0 c #3AA3FF",
++"a c #38A1FF",
++"b c #37A1FF",
++"c c #309AFF",
++"d c #2593FF",
++"e c #2997FF",
++"f c #349FFF",
++"g c #3BA3FF",
++"h c #3CA4FF",
++"i c #3EA6FF",
++"j c #3EA7FF",
++"k c #3FA7FF",
++"l c #2D91FE",
++"m c #298BFC",
++"n c #298AFA",
++"o c #2989FA",
++"p c #2889FA",
++"q c #2688F8",
++"r c #2486F8",
++"s c #2386F8",
++"t c #2488FA",
++"u c #2E96FE",
++"v c #2893FF",
++"w c #3DA5FF",
++"x c #3FA8FF",
++"y c #2F96FE",
++"z c #1978F4",
++"A c #136DEE",
++"B c #126AEB",
++"C c #1269EA",
++"D c #116AE9",
++"E c #106AE8",
++"F c #1069E6",
++"G c #1068E6",
++"H c #116AEA",
++"I c #1C7BF7",
++"J c #2A94FF",
++"K c #3AA2FF",
++"L c #3DA6FF",
++"M c #40ADFF",
++"N c #41AEFF",
++"O c #43B0FF",
++"P c #2D95FD",
++"Q c #1472EF",
++"R c #0F69E6",
++"S c #0D67E2",
++"T c #0D66E1",
++"U c #0C65E0",
++"V c #0C64E0",
++"W c #0C63E0",
++"X c #0E64E2",
++"Y c #1874F2",
++"Z c #2C96FF",
++"` c #2E97FE",
++" . c #2A91FE",
++".. c #2C93FE",
++"+. c #2F94FE",
++"@. c #3097FE",
++"#. c #3098FE",
++"$. c #3197FE",
++"%. c #359BFE",
++"&. c #40ACFF",
++"*. c #44B1FF",
++"=. c #45B2FF",
++"-. c #46B2FF",
++";. c #47B3FF",
++">. c #3098FD",
++",. c #1475EE",
++"'. c #0E6AE6",
++"). c #0C69E2",
++"!. c #0C68E1",
++"~. c #0C67E0",
++"{. c #0C66E0",
++"]. c #0B63E0",
++"^. c #0E65E2",
++"/. c #1876F2",
++"(. c #2C97FF",
++"_. c #309BFF",
++":. c #1473F6",
++"<. c #1069F3",
++"[. c #106CF3",
++"}. c #1069F4",
++"|. c #1068F8",
++"1. c #106CF8",
++"2. c #106DF6",
++"3. c #116EF6",
++"4. c #1475F8",
++"5. c #39A3FE",
++"6. c #3099FE",
++"7. c #1478F0",
++"8. c #0E6CE7",
++"9. c #0C6AE4",
++"0. c #0E67E2",
++"a. c #1878F3",
++"b. c #319BFE",
++"c. c #116DF4",
++"d. c #106AF3",
++"e. c #106AF4",
++"f. c #1067F7",
++"g. c #106BF8",
++"h. c #106DF8",
++"i. c #106DF5",
++"j. c #1271F7",
++"k. c #1577F8",
++"l. c #36A0FE",
++"m. c #319AFE",
++"n. c #147AF0",
++"o. c #0E6EE8",
++"p. c #0C6CE6",
++"q. c #0C68E2",
++"r. c #0E68E4",
++"s. c #1A7BF4",
++"t. c #2D97FF",
++"u. c #329CFE",
++"v. c #126EF4",
++"w. c #1068F5",
++"x. c #1069F8",
++"y. c #106EF8",
++"z. c #106EF4",
++"A. c #1270F7",
++"B. c #1477F8",
++"C. c #1578F8",
++"D. c #369FFE",
++"E. c #319BFD",
++"F. c #1479EF",
++"G. c #0E6EE7",
++"H. c #0C6BE5",
++"I. c #0F6AE6",
++"J. c #1B7CF5",
++"K. c #1270F4",
++"L. c #106BF3",
++"M. c #1374F8",
++"N. c #369EFE",
++"O. c #3099FB",
++"P. c #1272E8",
++"Q. c #0C6ADF",
++"R. c #0C6AE0",
++"S. c #0C6CE4",
++"T. c #0F6AE7",
++"U. c #1C7CF5",
++"V. c #3EA5FF",
++"W. c #329DFE",
++"X. c #106DF7",
++"Y. c #106EF5",
++"Z. c #1271F8",
++"`. c #116DF0",
++" + c #0D62DE",
++".+ c #0D60DB",
++"++ c #257DF0",
++"@+ c #318CF6",
++"#+ c #318EF9",
++"$+ c #328EF9",
++"%+ c #2079EA",
++"&+ c #0B5ACA",
++"*+ c #0857C6",
++"=+ c #0A61D3",
++"-+ c #0C6CE5",
++";+ c #1C7AF5",
++">+ c #3A91FA",
++",+ c #3D94FA",
++"'+ c #3A92FA",
++")+ c #1969EC",
++"!+ c #1761EE",
++"~+ c #1764F0",
++"{+ c #1767EE",
++"]+ c #1868ED",
++"^+ c #1A6AEE",
++"/+ c #0D48BD",
++"(+ c #0A42AC",
++"_+ c #0B40AB",
++":+ c #164DCE",
++"<+ c #1D54DB",
++"[+ c #1D54DC",
++"}+ c #134AC5",
++"|+ c #083B9F",
++"1+ c #083CA2",
++"2+ c #0C4BB6",
++"3+ c #1261D4",
++"4+ c #1465DD",
++"5+ c #1365DE",
++"6+ c #1564DE",
++"7+ c #1766E2",
++"8+ c #2476EF",
++"9+ c #4599FC",
++"0+ c #469BFC",
++"a+ c #3A93FC",
++"b+ c #5273EE",
++"c+ c #5574EE",
++"d+ c #5272EC",
++"e+ c #2F53D4",
++"f+ c #2C4ED6",
++"g+ c #2C52D7",
++"h+ c #2C52D5",
++"i+ c #2E54D6",
++"j+ c #3053D4",
++"k+ c #1E3BA8",
++"l+ c #1C38A3",
++"m+ c #1D38A3",
++"n+ c #2C40BC",
++"o+ c #3545C6",
++"p+ c #3544C6",
++"q+ c #283EB6",
++"r+ c #1A349B",
++"s+ c #193398",
++"t+ c #1E3AA3",
++"u+ c #2A4FC1",
++"v+ c #2C55CA",
++"w+ c #2B55CC",
++"x+ c #2C55CC",
++"y+ c #2C55CD",
++"z+ c #2F56CF",
++"A+ c #3E61DA",
++"B+ c #5C78F0",
++"C+ c #5E79F2",
++"D+ c #5272F5",
++"E+ c #5573EE",
++"F+ c #5271EC",
++"G+ c #2C4ED5",
++"H+ c #2D52D3",
++"I+ c #2E55D4",
++"J+ c #3154D3",
++"K+ c #1E3AA7",
++"L+ c #1C39A2",
++"M+ c #1C38A2",
++"N+ c #2C42BC",
++"O+ c #3444C4",
++"P+ c #3344C3",
++"Q+ c #2D42BF",
++"R+ c #203AA9",
++"S+ c #1C36A2",
++"T+ c #2440B0",
++"U+ c #385DD0",
++"V+ c #3C63D6",
++"W+ c #3B62D6",
++"X+ c #3C62D7",
++"Y+ c #3D64D8",
++"Z+ c #4C6FE4",
++"`+ c #5C78EE",
++" @ c #5170F2",
++".@ c #5272EB",
++"+@ c #5273EB",
++"@@ c #5172EA",
++"#@ c #385CD9",
++"$@ c #2E51D4",
++"%@ c #2E54D4",
++"&@ c #2F54D2",
++"*@ c #3056D4",
++"=@ c #3256D2",
++"-@ c #1E3AA6",
++";@ c #1D39A2",
++">@ c #1F3BA9",
++",@ c #2C43BE",
++"'@ c #3244C2",
++")@ c #3244C1",
++"!@ c #3247C5",
++"~@ c #314CCA",
++"{@ c #385AD4",
++"]@ c #557DEF",
++"^@ c #557EEF",
++"/@ c #547DEE",
++"(@ c #517EEE",
++"_@ c #507EEE",
++":@ c #4C7AEC",
++"<@ c #4C78EA",
++"[@ c #4770EE",
++"}@ c #5072E7",
++"|@ c #5173E7",
++"1@ c #5474E6",
++"2@ c #5574E7",
++"3@ c #5575E8",
++"4@ c #5776E8",
++"5@ c #5978E9",
++"6@ c #5B78EA",
++"7@ c #3147C2",
++"8@ c #2D42BD",
++"9@ c #2C42BE",
++"0@ c #3043BE",
++"a@ c #3144BE",
++"b@ c #3144BF",
++"c@ c #3153CC",
++"d@ c #3058CD",
++"e@ c #3661D5",
++"f@ c #4F7DEC",
++"g@ c #507EEC",
++"h@ c #4D7EEB",
++"i@ c #4C7EEB",
++"j@ c #4B7FEA",
++"k@ c #4B7FE9",
++"l@ c #4A7EEA",
++"m@ c #467BE9",
++"n@ c #467AE5",
++"o@ c #4370E8",
++"p@ c #4E72E2",
++"q@ c #4F72E2",
++"r@ c #5072E2",
++"s@ c #5574E2",
++"t@ c #5877E5",
++"u@ c #5878E5",
++"v@ c #5978E6",
++"w@ c #5C7DE8",
++"x@ c #5D7CE9",
++"y@ c #2F48C0",
++"z@ c #2A42BA",
++"A@ c #2D41BA",
++"B@ c #3042BA",
++"C@ c #3043BA",
++"D@ c #3043B9",
++"E@ c #3046BD",
++"F@ c #2E57C8",
++"G@ c #2E58C8",
++"H@ c #3460D0",
++"I@ c #4F7DE8",
++"J@ c #4C7EE6",
++"K@ c #4A7FE6",
++"L@ c #4A7FE5",
++"M@ c #4A7FE4",
++"N@ c #477CE4",
++"O@ c #457AE4",
++"P@ c #4478DE",
++"Q@ c #406FE4",
++"R@ c #4B70DE",
++"S@ c #4D72DE",
++"T@ c #4E72DE",
++"U@ c #5073DD",
++"V@ c #5675DF",
++"W@ c #5676E1",
++"X@ c #587AE2",
++"Y@ c #5A7CE4",
++"Z@ c #2E48BB",
++"`@ c #2942B6",
++" # c #2A42B6",
++".# c #2E42B5",
++"+# c #2E43B5",
++"@# c #2E42B4",
++"## c #2D44B6",
++"$# c #2C56C4",
++"%# c #2C58C4",
++"&# c #3260CC",
++"*# c #4B7DE2",
++"=# c #497DE0",
++"-# c #477DE0",
++";# c #487DE0",
++"># c #467EE0",
++",# c #467EDF",
++"'# c #457DDE",
++")# c #437ADD",
++"!# c #4279DD",
++"~# c #4177D9",
++"{# c #3E6EDE",
++"]# c #486ED8",
++"^# c #4B71D9",
++"/# c #4B72D9",
++"(# c #4D72D8",
++"_# c #5374DA",
++":# c #5475DB",
++"<# c #5578DC",
++"[# c #567ADD",
++"}# c #2C48B7",
++"|# c #2742B1",
++"1# c #2A42B1",
++"2# c #2C42B1",
++"3# c #2C42B0",
++"4# c #2B44B2",
++"5# c #2A56BF",
++"6# c #2A57BF",
++"7# c #315EC7",
++"8# c #467CDC",
++"9# c #457CDA",
++"0# c #447CDA",
++"a# c #437CDA",
++"b# c #437CD8",
++"c# c #427CD8",
++"d# c #427AD8",
++"e# c #4077D7",
++"f# c #3F76D5",
++"g# c #3F75D4",
++"h# c #3C6FD8",
++"i# c #466ED2",
++"j# c #486ED4",
++"k# c #4A70D4",
++"l# c #4A70D3",
++"m# c #4E72D4",
++"n# c #5174D6",
++"o# c #5074D6",
++"p# c #5276D6",
++"q# c #5277D6",
++"r# c #2A46B2",
++"s# c #2540AC",
++"t# c #2840AC",
++"u# c #2A42AC",
++"v# c #2A41AC",
++"w# c #2A44AE",
++"x# c #2955BA",
++"y# c #2856BA",
++"z# c #2E5EC2",
++"A# c #447AD6",
++"B# c #437AD5",
++"C# c #417AD4",
++"D# c #407AD2",
++"E# c #3F79D1",
++"F# c #3E78D0",
++"G# c #3E76D1",
++"H# c #3E75D2",
++"I# c #3C74CF",
++"J# c #3B73CE",
++"K# c #3A6FD5",
++"L# c #436CCC",
++"M# c #456ECE",
++"N# c #466FCE",
++"O# c #4A71CE",
++"P# c #4E73D0",
++"Q# c #4E74D0",
++"R# c #4F74D0",
++"S# c #4E74CF",
++"T# c #2846AD",
++"U# c #2440A8",
++"V# c #2340A8",
++"W# c #2640A7",
++"X# c #2740A7",
++"Y# c #2841A7",
++"Z# c #2843A9",
++"`# c #2652B5",
++" $ c #2552B5",
++".$ c #2B5CBC",
++"+$ c #417AD0",
++"@$ c #3F79CE",
++"#$ c #3E78CC",
++"$$ c #3C76CA",
++"%$ c #3B76C8",
++"&$ c #3B74C9",
++"*$ c #3B74CC",
++"=$ c #3A73CD",
++"-$ c #3871CA",
++";$ c #3870C9",
++">$ c #386ED0",
++",$ c #426CC7",
++"'$ c #426CC9",
++")$ c #446EC9",
++"!$ c #466FC9",
++"~$ c #4A72CA",
++"{$ c #4C73CC",
++"]$ c #4B72CB",
++"^$ c #2E4FB0",
++"/$ c #2340A4",
++"($ c #223FA4",
++"_$ c #223FA3",
++":$ c #233FA3",
++"<$ c #2442A5",
++"[$ c #224FB0",
++"}$ c #2350B2",
++"|$ c #2E62BC",
++"1$ c #3E79CB",
++"2$ c #3B77C8",
++"3$ c #3A76C5",
++"4$ c #3873C2",
++"5$ c #3771C2",
++"6$ c #3771C5",
++"7$ c #3771C8",
++"8$ c #3770C6",
++"9$ c #3670C5",
++"0$ c #366FC6",
++"a$ c #346CCD",
++"b$ c #3F6BC2",
++"c$ c #406BC2",
++"d$ c #426DC4",
++"e$ c #426EC4",
++"f$ c #456FC4",
++"g$ c #4A72C6",
++"h$ c #4A73C7",
++"i$ c #4A72C7",
++"j$ c #466EC3",
++"k$ c #3E65BC",
++"l$ c #4065BD",
++"m$ c #4166BD",
++"n$ c #4066BD",
++"o$ c #4066BC",
++"p$ c #3F66BD",
++"q$ c #346BBF",
++"r$ c #356DC0",
++"s$ c #3B76C6",
++"t$ c #3B78C4",
++"u$ c #3874C1",
++"v$ c #3672BE",
++"w$ c #3570BD",
++"x$ c #346EBF",
++"y$ c #346EC1",
++"z$ c #346DC1",
++"A$ c #346CC0",
++"B$ c #346DC0",
++"C$ c #346EC2",
++"D$ c #316AC9",
++"E$ c #3C6ABE",
++"F$ c #3D6BBE",
++"G$ c #3F6CC0",
++"H$ c #416CC0",
++"I$ c #426DC0",
++"J$ c #4570C0",
++"K$ c #4872C2",
++"L$ c #4A76C4",
++"M$ c #4E79C7",
++"N$ c #4F7AC7",
++"O$ c #507AC8",
++"P$ c #4E79C8",
++"Q$ c #3D79C4",
++"R$ c #3C7AC4",
++"S$ c #3A79C2",
++"T$ c #3776BF",
++"U$ c #3572BB",
++"V$ c #336FBA",
++"W$ c #326DBB",
++"X$ c #326CBD",
++"Y$ c #326ABD",
++"Z$ c #3169BB",
++"`$ c #3169BA",
++" % c #316ABB",
++".% c #2E66C3",
++"+% c #396ABA",
++"@% c #3C6BBA",
++"#% c #3C6ABB",
++"$% c #3E6CBD",
++"%% c #406CBD",
++"&% c #406DBD",
++"*% c #426EBD",
++"=% c #456FBD",
++"-% c #4672BF",
++";% c #4672C0",
++">% c #4874C0",
++",% c #4976C1",
++"'% c #4B78C2",
++")% c #4C78C3",
++"!% c #4E78C3",
++"~% c #4B78C3",
++"{% c #3C78C1",
++"]% c #3A79C1",
++"^% c #3778BE",
++"/% c #3673BA",
++"(% c #326EB8",
++"_% c #326DBA",
++":% c #326BBB",
++"<% c #316ABA",
++"[% c #2F68B9",
++"}% c #2E66B8",
++"|% c #3067BB",
++"1% c #2C63BF",
++"2% c #3769B8",
++"3% c #3969B8",
++"4% c #3B6AB8",
++"5% c #3C6AB8",
++"6% c #3E6CBA",
++"7% c #3F6DBA",
++"8% c #416DBA",
++"9% c #446FBB",
++"0% c #4672BC",
++"a% c #4672BD",
++"b% c #4674BC",
++"c% c #4674BD",
++"d% c #4775BE",
++"e% c #4575BE",
++"f% c #3A76C0",
++"g% c #3776BE",
++"h% c #3573BB",
++"i% c #326EB6",
++"j% c #306CB7",
++"k% c #316CBB",
++"l% c #3068B8",
++"m% c #2E66B9",
++"n% c #2E66BA",
++"o% c #3068BE",
++"p% c #2B62C0",
++"q% c #3769B6",
++"r% c #3A68B6",
++"s% c #3B69B6",
++"t% c #406DBA",
++"u% c #436EBA",
++"v% c #4571BB",
++"w% c #4372BC",
++"x% c #3774BE",
++"y% c #3875C3",
++"z% c #316DB6",
++"A% c #2F6BB5",
++"B% c #306BB9",
++"C% c #326ABB",
++"D% c #3169BD",
++"E% c #3169BF",
++"F% c #3169C0",
++"G% c #3067BE",
++"H% c #2E66BC",
++"I% c #285FBC",
++"J% c #3667B5",
++"K% c #3768B6",
++"L% c #3C6BB9",
++"M% c #416EBA",
++"N% c #4470BA",
++"O% c #4570BB",
++"P% c #3873BD",
++"Q% c #3A76C6",
++"R% c #3974C3",
++"S% c #336FBC",
++"T% c #316CB9",
++"U% c #326CBB",
++"V% c #336CBD",
++"W% c #346CC2",
++"X% c #326AC2",
++"Y% c #3068C1",
++"Z% c #2B64B8",
++"`% c #245AB6",
++" & c #3466B5",
++".& c #3668B5",
++"+& c #3868B6",
++"@& c #3F6CBA",
++"#& c #426FBA",
++"$& c #436FBA",
++"%& c #4271BA",
++"&& c #3772BB",
++"*& c #3975C3",
++"=& c #3974C4",
++"-& c #3772C2",
++";& c #346FBF",
++">& c #326CBC",
++",& c #3169BC",
++"'& c #2D65BC",
++")& c #2961B5",
++"!& c #2861B4",
++"~& c #2056B2",
++". . + @ # $ % % & * * * = - - ; ; > > ; , - - * * * ' ) % % ! ~ ",
++". { ] ^ / % ) ' * * ( , > > _ : < < < : : [ > ; - * * * } % % | ",
++"+ 1 ^ % % & * * ( 2 > 3 < < < < < < < < < < < 3 _ > - * * ' 4 5 ",
++"@ ^ % % 6 * * - > 3 < < < < 7 8 9 9 0 0 a b < < < < [ ; = * c d ",
++"e / % ' * * , f < < < 7 g h i j j j j j i i 9 8 b < < 3 > - * + ",
++"$ % & * * ; [ < < a 9 i j k k k k h l m n o p p q r s t u > - v ",
++"% ) * * , _ < < 8 w k k k k k k x y z A B C D E F G G H I [ > J ",
++"% ' * , [ < < K L k k k k x M N O P Q R S T U U V W W X Y > < Z ",
++"& * = ` . ...+. at .#.$.%.&.*.=.-.;.>.,.'.).!.~.{.U ].].^./.< < (.",
++"c * _.:.<.[.}.|.1.2.3.4.5.;.;.;.;.6.7.8.9.).).!.{.U V 0.a.8 b (.",
++"* ( b.c.d.e.f.g.h.i.j.k.l.;.;.;.;.m.n.o.p.p.9.).q.{.{.r.s.h b t.",
++"* , u.v.[.w.x.y.z.A.B.C.D.;.;.;.;.E.F.G.p.p.p.H.).q.~.I.J.w 9 } ",
++"* > u.K.L.f.1.2.3.M.C.C.N.;.;.;.;.O.P.Q.R.S.p.p.H.).).T.U.V.w 6 ",
++"- > W.K.w.|.X.Y.Z.`. +.+++ at +@+#+$+%+&+*+=+Q.-+p.p.9.).E ;+V.i - ",
++">+,+'+)+!+~+{+]+^+/+(+_+:+<+<+[+[+}+|+1+2+3+4+5+5+5+6+7+8+9+0+a+",
++"b+c+d+e+f+g+h+i+j+k+l+m+n+o+o+o+p+q+r+s+t+u+v+w+w+x+y+z+A+B+C+D+",
++"b+E+F+e+G+h+H+I+J+K+L+M+N+O+O+P+P+Q+R+S+T+U+V+V+W+W+X+Y+Z+`+`+ @",
++". at +@@@#@$@%@&@*@=@-@;@>@,@'@)@)@)@)@!@~@{@]@^@/@(@(@_ at _@_@:@<@[@",
++"}@|@|@1 at 2@3 at 4@5 at 6@7 at 8@9 at 0@a at a@a at a@b at c@d at e@f at g@h at i@j at j@k at l@m at n@o@",
++"p at q@r at s@t at u@v at w@x at y@z at A@B at C@D at D@D at E@F at G@H at I@J at K@L at L@L at M@N at O@P at Q@",
++"R at S@T at U@V at W@W at X@Y at Z@`@ #.#+#+#+#@###$#%#&#*#=#-#;#>#,#'#)#!#~#{#",
++"]#^#/#(#_#:#:#<#[#}#|#|#1#2#2#3#3#4#5#6#7#8#9#0#a#b#c#d#e#f#g#h#",
++"i#j#k#l#m#n#o#p#q#r#s#s#s#t#u#v#u#w#x#y#z#A#B#C#D#E#F#G#H#I#J#K#",
++"L#M#N#N#O#P#Q#R#S#T#U#U#V#V#W#X#Y#Z#`# $.$+$@$#$$$%$&$*$=$-$;$>$",
++",$'$)$)$!$~${${$]$^$/$($_$_$_$_$:$<$[$}$|$1$2$3$4$5$6$7$8$9$0$a$",
++"b$c$d$e$e$f$g$h$i$j$k$l$m$m$n$n$o$p$q$r$s$t$u$v$w$x$y$z$A$B$C$D$",
++"E$F$G$H$I$I$J$K$K$K$K$L$M$N$O$O$O$P$Q$R$S$T$U$V$W$X$Y$Z$`$ %Y$.%",
++"+%@%#%$%%%&%*%=%-%;%;%;%>%,%'%)%!%~%{%]%^%/%(%_%:%<%[%}%}%}%|%1%",
++"2%3%4%5%6%7%7%8%9%0%a%a%0%0%b%c%d%e%f%g%h%i%j%k%<%l%}%m%m%n%o%p%",
++"q%q%r%s%5%6%7%7%t%u%v%0%0%0%0%0%0%w%x%y%v$z%A%B%C%Z$D%E%F%G%H%I%",
++"J%q%K%s%s%L%6%7%7%7%M%N%O%0%0%0%0%w%P%Q%R%S%T%U%V%A$W%X%Y%H%Z%`%",
++" &.&q%+&s%s%5%6%@&7%7%t%t%#&$&N%N%%&&&*&=&-&;&>&C%,&o%'&)&!&!&~&"};
diff --git a/indra/llwindow/glh/glh_linear.h b/indra/llwindow/glh/glh_linear.h
deleted file mode 100755
index 04ae1bd..0000000
--- a/indra/llwindow/glh/glh_linear.h
+++ /dev/null
@@ -1,1621 +0,0 @@
-/*
- glh - is a platform-indepenedent C++ OpenGL helper library
-
-
- Copyright (c) 2000 Cass Everitt
- Copyright (c) 2000 NVIDIA Corporation
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or
- without modification, are permitted provided that the following
- conditions are met:
-
- * Redistributions of source code must retain the above
- copyright notice, this list of conditions and the following
- disclaimer.
-
- * Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the following
- disclaimer in the documentation and/or other materials
- provided with the distribution.
-
- * The names of contributors to this software may not be used
- to endorse or promote products derived from this software
- without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- POSSIBILITY OF SUCH DAMAGE.
-
-
- Cass Everitt - cass at r3.nu
-*/
-
-/*
-glh_linear.h
-*/
-
-// Author: Cass W. Everitt
-
-#ifndef GLH_LINEAR_H
-#define GLH_LINEAR_H
-
-#include <memory.h>
-#include <math.h>
-#include <assert.h>
-
-// only supports float for now...
-#define GLH_REAL_IS_FLOAT
-
-#ifdef GLH_REAL_IS_FLOAT
-# define GLH_REAL float
-# define GLH_REAL_NAMESPACE ns_float
-#endif
-
-#define GLH_QUATERNION_NORMALIZATION_THRESHOLD 64
-
-#define GLH_RAD_TO_DEG GLH_REAL(57.2957795130823208767981548141052)
-#define GLH_DEG_TO_RAD GLH_REAL(0.0174532925199432957692369076848861)
-#define GLH_ZERO GLH_REAL(0.0)
-#define GLH_ONE GLH_REAL(1.0)
-#define GLH_TWO GLH_REAL(2.0)
-#define GLH_EPSILON GLH_REAL(10e-6)
-#define GLH_PI GLH_REAL(3.1415926535897932384626433832795)
-
-#define equivalent(a,b) (((a < b + GLH_EPSILON) && (a > b - GLH_EPSILON)) ? true : false)
-
-namespace glh
-{
-
- inline GLH_REAL to_degrees(GLH_REAL radians) { return radians*GLH_RAD_TO_DEG; }
- inline GLH_REAL to_radians(GLH_REAL degrees) { return degrees*GLH_DEG_TO_RAD; }
-
- // forward declarations for friend template functions.
- template <int N, class T> class vec;
-
- // forward declarations for friend template functions.
- template <int N, class T>
- bool operator == ( const vec<N,T> & v1, const vec<N,T> & v2 );
-
- // forward declarations for friend template functions.
- template <int N, class T>
- bool operator != ( const vec<N,T> & v1, const vec<N,T> & v2 );
-
- template <int N, class T>
- class vec
- {
- public:
- int size() const { return N; }
-
- vec(const T & t = T())
- { for(int i = 0; i < N; i++) v[i] = t; }
- vec(const T * tp)
- { for(int i = 0; i < N; i++) v[i] = tp[i]; }
-
- const T * get_value() const
- { return v; }
-
-
- T dot( const vec<N,T> & rhs ) const
- {
- T r = 0;
- for(int i = 0; i < N; i++) r += v[i]*rhs.v[i];
- return r;
- }
-
- T length() const
- {
- T r = 0;
- for(int i = 0; i < N; i++) r += v[i]*v[i];
- return T(sqrt(r));
- }
-
- T square_norm() const
- {
- T r = 0;
- for(int i = 0; i < N; i++) r += v[i]*v[i];
- return r;
- }
-
- void negate()
- { for(int i = 0; i < N; i++) v[i] = -v[i]; }
-
-
- T normalize()
- {
- T sum(0);
- for(int i = 0; i < N; i++)
- sum += v[i]*v[i];
- sum = T(sqrt(sum));
- if (sum > GLH_EPSILON)
- for(int i = 0; i < N; i++)
- v[i] /= sum;
- return sum;
- }
-
-
- vec<N,T> & set_value( const T * rhs )
- { for(int i = 0; i < N; i++) v[i] = rhs[i]; return *this; }
-
- T & operator [] ( int i )
- { return v[i]; }
-
- const T & operator [] ( int i ) const
- { return v[i]; }
-
- vec<N,T> & operator *= ( T d )
- { for(int i = 0; i < N; i++) v[i] *= d; return *this;}
-
- vec<N,T> & operator *= ( const vec<N,T> & u )
- { for(int i = 0; i < N; i++) v[i] *= u[i]; return *this;}
-
- vec<N,T> & operator /= ( T d )
- { if(d == 0) return *this; for(int i = 0; i < N; i++) v[i] /= d; return *this;}
-
- vec<N,T> & operator += ( const vec<N,T> & u )
- { for(int i = 0; i < N; i++) v[i] += u.v[i]; return *this;}
-
- vec<N,T> & operator -= ( const vec<N,T> & u )
- { for(int i = 0; i < N; i++) v[i] -= u.v[i]; return *this;}
-
-
- vec<N,T> operator - () const
- { vec<N,T> rv = v; rv.negate(); return rv; }
-
- vec<N,T> operator + ( const vec<N,T> &v) const
- { vec<N,T> rt(*this); return rt += v; }
-
- vec<N,T> operator - ( const vec<N,T> &v) const
- { vec<N,T> rt(*this); return rt -= v; }
-
- vec<N,T> operator * ( T d) const
- { vec<N,T> rt(*this); return rt *= d; }
-
- friend bool operator == <> ( const vec<N,T> &v1, const vec<N,T> &v2 );
- friend bool operator != <> ( const vec<N,T> &v1, const vec<N,T> &v2 );
-
-
- //protected:
- T v[N];
- };
-
-
-
- // vector friend operators
-
- template <int N, class T> inline
- vec<N,T> operator * ( const vec<N,T> & b, T d )
- {
- vec<N,T> rt(b);
- return rt *= d;
- }
-
- template <int N, class T> inline
- vec<N,T> operator * ( T d, const vec<N,T> & b )
- { return b*d; }
-
- template <int N, class T> inline
- vec<N,T> operator * ( const vec<N,T> & b, const vec<N,T> & d )
- {
- vec<N,T> rt(b);
- return rt *= d;
- }
-
- template <int N, class T> inline
- vec<N,T> operator / ( const vec<N,T> & b, T d )
- { vec<N,T> rt(b); return rt /= d; }
-
- template <int N, class T> inline
- vec<N,T> operator + ( const vec<N,T> & v1, const vec<N,T> & v2 )
- { vec<N,T> rt(v1); return rt += v2; }
-
- template <int N, class T> inline
- vec<N,T> operator - ( const vec<N,T> & v1, const vec<N,T> & v2 )
- { vec<N,T> rt(v1); return rt -= v2; }
-
-
- template <int N, class T> inline
- bool operator == ( const vec<N,T> & v1, const vec<N,T> & v2 )
- {
- for(int i = 0; i < N; i++)
- if(v1.v[i] != v2.v[i])
- return false;
- return true;
- }
-
- template <int N, class T> inline
- bool operator != ( const vec<N,T> & v1, const vec<N,T> & v2 )
- { return !(v1 == v2); }
-
-
- typedef vec<3,unsigned char> vec3ub;
- typedef vec<4,unsigned char> vec4ub;
-
-
-
-
-
- namespace GLH_REAL_NAMESPACE
- {
- typedef GLH_REAL real;
-
- class line;
- class plane;
- class matrix4;
- class quaternion;
- typedef quaternion rotation;
-
- class vec2 : public vec<2,real>
- {
- public:
- vec2(const real & t = real()) : vec<2,real>(t)
- {}
- vec2(const vec<2,real> & t) : vec<2,real>(t)
- {}
- vec2(const real * tp) : vec<2,real>(tp)
- {}
-
- vec2(real x, real y )
- { v[0] = x; v[1] = y; }
-
- void get_value(real & x, real & y) const
- { x = v[0]; y = v[1]; }
-
- vec2 & set_value( const real & x, const real & y)
- { v[0] = x; v[1] = y; return *this; }
-
- };
-
-
- class vec3 : public vec<3,real>
- {
- public:
- vec3(const real & t = real()) : vec<3,real>(t)
- {}
- vec3(const vec<3,real> & t) : vec<3,real>(t)
- {}
- vec3(const real * tp) : vec<3,real>(tp)
- {}
-
- vec3(real x, real y, real z)
- { v[0] = x; v[1] = y; v[2] = z; }
-
- void get_value(real & x, real & y, real & z) const
- { x = v[0]; y = v[1]; z = v[2]; }
-
- vec3 cross( const vec3 &rhs ) const
- {
- vec3 rt;
- rt.v[0] = v[1]*rhs.v[2]-v[2]*rhs.v[1];
- rt.v[1] = v[2]*rhs.v[0]-v[0]*rhs.v[2];
- rt.v[2] = v[0]*rhs.v[1]-v[1]*rhs.v[0];
- return rt;
- }
-
- vec3 & set_value( const real & x, const real & y, const real & z)
- { v[0] = x; v[1] = y; v[2] = z; return *this; }
-
- };
-
-
- class vec4 : public vec<4,real>
- {
- public:
- vec4(const real & t = real()) : vec<4,real>(t)
- {}
- vec4(const vec<4,real> & t) : vec<4,real>(t)
- {}
-
- vec4(const vec<3,real> & t, real fourth)
-
- { v[0] = t.v[0]; v[1] = t.v[1]; v[2] = t.v[2]; v[3] = fourth; }
- vec4(const real * tp) : vec<4,real>(tp)
- {}
- vec4(real x, real y, real z, real w)
- { v[0] = x; v[1] = y; v[2] = z; v[3] = w; }
-
- void get_value(real & x, real & y, real & z, real & w) const
- { x = v[0]; y = v[1]; z = v[2]; w = v[3]; }
-
- vec4 & set_value( const real & x, const real & y, const real & z, const real & w)
- { v[0] = x; v[1] = y; v[2] = z; v[3] = w; return *this; }
- };
-
- inline
- vec3 homogenize(const vec4 & v)
- {
- vec3 rt;
- assert(v.v[3] != GLH_ZERO);
- rt.v[0] = v.v[0]/v.v[3];
- rt.v[1] = v.v[1]/v.v[3];
- rt.v[2] = v.v[2]/v.v[3];
- return rt;
- }
-
-
-
- class line
- {
- public:
-
- line()
- { set_value(vec3(0,0,0),vec3(0,0,1)); }
-
- line( const vec3 & p0, const vec3 &p1)
- { set_value(p0,p1); }
-
- void set_value( const vec3 &p0, const vec3 &p1)
- {
- position = p0;
- direction = p1-p0;
- direction.normalize();
- }
-
- bool get_closest_points(const line &line2,
- vec3 &pointOnThis,
- vec3 &pointOnThat)
- {
-
- // quick check to see if parallel -- if so, quit.
- if(fabs(direction.dot(line2.direction)) == 1.0)
- return 0;
- line l2 = line2;
-
- // Algorithm: Brian Jean
- //
- register real u;
- register real v;
- vec3 Vr = direction;
- vec3 Vs = l2.direction;
- register real Vr_Dot_Vs = Vr.dot(Vs);
- register real detA = real(1.0 - (Vr_Dot_Vs * Vr_Dot_Vs));
- vec3 C = l2.position - position;
- register real C_Dot_Vr = C.dot(Vr);
- register real C_Dot_Vs = C.dot(Vs);
-
- u = (C_Dot_Vr - Vr_Dot_Vs * C_Dot_Vs)/detA;
- v = (C_Dot_Vr * Vr_Dot_Vs - C_Dot_Vs)/detA;
-
- pointOnThis = position;
- pointOnThis += direction * u;
- pointOnThat = l2.position;
- pointOnThat += l2.direction * v;
-
- return 1;
- }
-
- vec3 get_closest_point(const vec3 &point)
- {
- vec3 np = point - position;
- vec3 rp = direction*direction.dot(np)+position;
- return rp;
- }
-
- const vec3 & get_position() const {return position;}
-
- const vec3 & get_direction() const {return direction;}
-
- //protected:
- vec3 position;
- vec3 direction;
- };
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- // matrix
-
-
- class matrix4
- {
-
- public:
-
- matrix4() { make_identity(); }
-
- matrix4( real r )
- { set_value(r); }
-
- matrix4( real * m )
- { set_value(m); }
-
- matrix4( real a00, real a01, real a02, real a03,
- real a10, real a11, real a12, real a13,
- real a20, real a21, real a22, real a23,
- real a30, real a31, real a32, real a33 )
- {
- element(0,0) = a00;
- element(0,1) = a01;
- element(0,2) = a02;
- element(0,3) = a03;
-
- element(1,0) = a10;
- element(1,1) = a11;
- element(1,2) = a12;
- element(1,3) = a13;
-
- element(2,0) = a20;
- element(2,1) = a21;
- element(2,2) = a22;
- element(2,3) = a23;
-
- element(3,0) = a30;
- element(3,1) = a31;
- element(3,2) = a32;
- element(3,3) = a33;
- }
-
-
- void get_value( real * mp ) const
- {
- int c = 0;
- for(int j=0; j < 4; j++)
- for(int i=0; i < 4; i++)
- mp[c++] = element(i,j);
- }
-
-
- const real * get_value() const
- { return m; }
-
- void set_value( real * mp)
- {
- int c = 0;
- for(int j=0; j < 4; j++)
- for(int i=0; i < 4; i++)
- element(i,j) = mp[c++];
- }
-
- void set_value( real r )
- {
- for(int i=0; i < 4; i++)
- for(int j=0; j < 4; j++)
- element(i,j) = r;
- }
-
- void make_identity()
- {
- element(0,0) = 1.0;
- element(0,1) = 0.0;
- element(0,2) = 0.0;
- element(0,3) = 0.0;
-
- element(1,0) = 0.0;
- element(1,1) = 1.0;
- element(1,2) = 0.0;
- element(1,3) = 0.0;
-
- element(2,0) = 0.0;
- element(2,1) = 0.0;
- element(2,2) = 1.0;
- element(2,3) = 0.0;
-
- element(3,0) = 0.0;
- element(3,1) = 0.0;
- element(3,2) = 0.0;
- element(3,3) = 1.0;
- }
-
-
- static matrix4 identity()
- {
- static matrix4 mident (
- 1.0, 0.0, 0.0, 0.0,
- 0.0, 1.0, 0.0, 0.0,
- 0.0, 0.0, 1.0, 0.0,
- 0.0, 0.0, 0.0, 1.0 );
- return mident;
- }
-
-
- void set_scale( real s )
- {
- element(0,0) = s;
- element(1,1) = s;
- element(2,2) = s;
- }
-
- void set_scale( const vec3 & s )
- {
- element(0,0) = s.v[0];
- element(1,1) = s.v[1];
- element(2,2) = s.v[2];
- }
-
-
- void set_translate( const vec3 & t )
- {
- element(0,3) = t.v[0];
- element(1,3) = t.v[1];
- element(2,3) = t.v[2];
- }
-
- void set_row(int r, const vec4 & t)
- {
- element(r,0) = t.v[0];
- element(r,1) = t.v[1];
- element(r,2) = t.v[2];
- element(r,3) = t.v[3];
- }
-
- void set_column(int c, const vec4 & t)
- {
- element(0,c) = t.v[0];
- element(1,c) = t.v[1];
- element(2,c) = t.v[2];
- element(3,c) = t.v[3];
- }
-
-
- void get_row(int r, vec4 & t) const
- {
- t.v[0] = element(r,0);
- t.v[1] = element(r,1);
- t.v[2] = element(r,2);
- t.v[3] = element(r,3);
- }
-
- vec4 get_row(int r) const
- {
- vec4 v; get_row(r, v);
- return v;
- }
-
- void get_column(int c, vec4 & t) const
- {
- t.v[0] = element(0,c);
- t.v[1] = element(1,c);
- t.v[2] = element(2,c);
- t.v[3] = element(3,c);
- }
-
- vec4 get_column(int c) const
- {
- vec4 v; get_column(c, v);
- return v;
- }
-
- matrix4 inverse() const
- {
- matrix4 minv;
-
- real r1[8], r2[8], r3[8], r4[8];
- real *s[4], *tmprow;
-
- s[0] = &r1[0];
- s[1] = &r2[0];
- s[2] = &r3[0];
- s[3] = &r4[0];
-
- register int i,j,p,jj;
- for(i=0;i<4;i++)
- {
- for(j=0;j<4;j++)
- {
- s[i][j] = element(i,j);
- if(i==j) s[i][j+4] = 1.0;
- else s[i][j+4] = 0.0;
- }
- }
- real scp[4];
- for(i=0;i<4;i++)
- {
- scp[i] = real(fabs(s[i][0]));
- for(j=1;j<4;j++)
- if(real(fabs(s[i][j])) > scp[i]) scp[i] = real(fabs(s[i][j]));
- if(scp[i] == 0.0) return minv; // singular matrix!
- }
-
- int pivot_to;
- real scp_max;
- for(i=0;i<4;i++)
- {
- // select pivot row
- pivot_to = i;
- scp_max = real(fabs(s[i][i]/scp[i]));
- // find out which row should be on top
- for(p=i+1;p<4;p++)
- if(real(fabs(s[p][i]/scp[p])) > scp_max)
- { scp_max = real(fabs(s[p][i]/scp[p])); pivot_to = p; }
- // Pivot if necessary
- if(pivot_to != i)
- {
- tmprow = s[i];
- s[i] = s[pivot_to];
- s[pivot_to] = tmprow;
- real tmpscp;
- tmpscp = scp[i];
- scp[i] = scp[pivot_to];
- scp[pivot_to] = tmpscp;
- }
-
- real mji;
- // perform gaussian elimination
- for(j=i+1;j<4;j++)
- {
- mji = s[j][i]/s[i][i];
- s[j][i] = 0.0;
- for(jj=i+1;jj<8;jj++)
- s[j][jj] -= mji*s[i][jj];
- }
- }
- if(s[3][3] == 0.0) return minv; // singular matrix!
-
- //
- // Now we have an upper triangular matrix.
- //
- // x x x x | y y y y
- // 0 x x x | y y y y
- // 0 0 x x | y y y y
- // 0 0 0 x | y y y y
- //
- // we'll back substitute to get the inverse
- //
- // 1 0 0 0 | z z z z
- // 0 1 0 0 | z z z z
- // 0 0 1 0 | z z z z
- // 0 0 0 1 | z z z z
- //
-
- real mij;
- for(i=3;i>0;i--)
- {
- for(j=i-1;j > -1; j--)
- {
- mij = s[j][i]/s[i][i];
- for(jj=j+1;jj<8;jj++)
- s[j][jj] -= mij*s[i][jj];
- }
- }
-
- for(i=0;i<4;i++)
- for(j=0;j<4;j++)
- minv(i,j) = s[i][j+4] / s[i][i];
-
- return minv;
- }
-
-
- matrix4 transpose() const
- {
- matrix4 mtrans;
-
- for(int i=0;i<4;i++)
- for(int j=0;j<4;j++)
- mtrans(i,j) = element(j,i);
- return mtrans;
- }
-
- matrix4 & mult_right( const matrix4 & b )
- {
- matrix4 mt(*this);
- set_value(real(0));
-
- for(int i=0; i < 4; i++)
- for(int j=0; j < 4; j++)
- for(int c=0; c < 4; c++)
- element(i,j) += mt(i,c) * b(c,j);
- return *this;
- }
-
- matrix4 & mult_left( const matrix4 & b )
- {
- matrix4 mt(*this);
- set_value(real(0));
-
- for(int i=0; i < 4; i++)
- for(int j=0; j < 4; j++)
- for(int c=0; c < 4; c++)
- element(i,j) += b(i,c) * mt(c,j);
- return *this;
- }
-
- // dst = M * src
- void mult_matrix_vec( const vec3 &src, vec3 &dst ) const
- {
- real w = (
- src.v[0] * element(3,0) +
- src.v[1] * element(3,1) +
- src.v[2] * element(3,2) +
- element(3,3) );
-
- assert(w != GLH_ZERO);
-
- dst.v[0] = (
- src.v[0] * element(0,0) +
- src.v[1] * element(0,1) +
- src.v[2] * element(0,2) +
- element(0,3) ) / w;
- dst.v[1] = (
- src.v[0] * element(1,0) +
- src.v[1] * element(1,1) +
- src.v[2] * element(1,2) +
- element(1,3) ) / w;
- dst.v[2] = (
- src.v[0] * element(2,0) +
- src.v[1] * element(2,1) +
- src.v[2] * element(2,2) +
- element(2,3) ) / w;
- }
-
- void mult_matrix_vec( vec3 & src_and_dst) const
- { mult_matrix_vec(vec3(src_and_dst), src_and_dst); }
-
-
- // dst = src * M
- void mult_vec_matrix( const vec3 &src, vec3 &dst ) const
- {
- real w = (
- src.v[0] * element(0,3) +
- src.v[1] * element(1,3) +
- src.v[2] * element(2,3) +
- element(3,3) );
-
- assert(w != GLH_ZERO);
-
- dst.v[0] = (
- src.v[0] * element(0,0) +
- src.v[1] * element(1,0) +
- src.v[2] * element(2,0) +
- element(3,0) ) / w;
- dst.v[1] = (
- src.v[0] * element(0,1) +
- src.v[1] * element(1,1) +
- src.v[2] * element(2,1) +
- element(3,1) ) / w;
- dst.v[2] = (
- src.v[0] * element(0,2) +
- src.v[1] * element(1,2) +
- src.v[2] * element(2,2) +
- element(3,2) ) / w;
- }
-
-
- void mult_vec_matrix( vec3 & src_and_dst) const
- { mult_vec_matrix(vec3(src_and_dst), src_and_dst); }
-
- // dst = M * src
- void mult_matrix_vec( const vec4 &src, vec4 &dst ) const
- {
- dst.v[0] = (
- src.v[0] * element(0,0) +
- src.v[1] * element(0,1) +
- src.v[2] * element(0,2) +
- src.v[3] * element(0,3));
- dst.v[1] = (
- src.v[0] * element(1,0) +
- src.v[1] * element(1,1) +
- src.v[2] * element(1,2) +
- src.v[3] * element(1,3));
- dst.v[2] = (
- src.v[0] * element(2,0) +
- src.v[1] * element(2,1) +
- src.v[2] * element(2,2) +
- src.v[3] * element(2,3));
- dst.v[3] = (
- src.v[0] * element(3,0) +
- src.v[1] * element(3,1) +
- src.v[2] * element(3,2) +
- src.v[3] * element(3,3));
- }
-
- void mult_matrix_vec( vec4 & src_and_dst) const
- { mult_matrix_vec(vec4(src_and_dst), src_and_dst); }
-
-
- // dst = src * M
- void mult_vec_matrix( const vec4 &src, vec4 &dst ) const
- {
- dst.v[0] = (
- src.v[0] * element(0,0) +
- src.v[1] * element(1,0) +
- src.v[2] * element(2,0) +
- src.v[3] * element(3,0));
- dst.v[1] = (
- src.v[0] * element(0,1) +
- src.v[1] * element(1,1) +
- src.v[2] * element(2,1) +
- src.v[3] * element(3,1));
- dst.v[2] = (
- src.v[0] * element(0,2) +
- src.v[1] * element(1,2) +
- src.v[2] * element(2,2) +
- src.v[3] * element(3,2));
- dst.v[3] = (
- src.v[0] * element(0,3) +
- src.v[1] * element(1,3) +
- src.v[2] * element(2,3) +
- src.v[3] * element(3,3));
- }
-
-
- void mult_vec_matrix( vec4 & src_and_dst) const
- { mult_vec_matrix(vec4(src_and_dst), src_and_dst); }
-
-
- // dst = M * src
- void mult_matrix_dir( const vec3 &src, vec3 &dst ) const
- {
- dst.v[0] = (
- src.v[0] * element(0,0) +
- src.v[1] * element(0,1) +
- src.v[2] * element(0,2) ) ;
- dst.v[1] = (
- src.v[0] * element(1,0) +
- src.v[1] * element(1,1) +
- src.v[2] * element(1,2) ) ;
- dst.v[2] = (
- src.v[0] * element(2,0) +
- src.v[1] * element(2,1) +
- src.v[2] * element(2,2) ) ;
- }
-
-
- void mult_matrix_dir( vec3 & src_and_dst) const
- { mult_matrix_dir(vec3(src_and_dst), src_and_dst); }
-
-
- // dst = src * M
- void mult_dir_matrix( const vec3 &src, vec3 &dst ) const
- {
- dst.v[0] = (
- src.v[0] * element(0,0) +
- src.v[1] * element(1,0) +
- src.v[2] * element(2,0) ) ;
- dst.v[1] = (
- src.v[0] * element(0,1) +
- src.v[1] * element(1,1) +
- src.v[2] * element(2,1) ) ;
- dst.v[2] = (
- src.v[0] * element(0,2) +
- src.v[1] * element(1,2) +
- src.v[2] * element(2,2) ) ;
- }
-
-
- void mult_dir_matrix( vec3 & src_and_dst) const
- { mult_dir_matrix(vec3(src_and_dst), src_and_dst); }
-
-
- real & operator () (int row, int col)
- { return element(row,col); }
-
- const real & operator () (int row, int col) const
- { return element(row,col); }
-
- real & element (int row, int col)
- { return m[row | (col<<2)]; }
-
- const real & element (int row, int col) const
- { return m[row | (col<<2)]; }
-
- matrix4 & operator *= ( const matrix4 & mat )
- {
- mult_right( mat );
- return *this;
- }
-
- matrix4 & operator *= ( const real & r )
- {
- for (int i = 0; i < 4; ++i)
- {
- element(0,i) *= r;
- element(1,i) *= r;
- element(2,i) *= r;
- element(3,i) *= r;
- }
- return *this;
- }
-
- matrix4 & operator += ( const matrix4 & mat )
- {
- for (int i = 0; i < 4; ++i)
- {
- element(0,i) += mat.element(0,i);
- element(1,i) += mat.element(1,i);
- element(2,i) += mat.element(2,i);
- element(3,i) += mat.element(3,i);
- }
- return *this;
- }
-
- friend matrix4 operator * ( const matrix4 & m1, const matrix4 & m2 );
- friend bool operator == ( const matrix4 & m1, const matrix4 & m2 );
- friend bool operator != ( const matrix4 & m1, const matrix4 & m2 );
-
- //protected:
- real m[16];
- };
-
- inline
- matrix4 operator * ( const matrix4 & m1, const matrix4 & m2 )
- {
- matrix4 product;
-
- product = m1;
- product.mult_right(m2);
-
- return product;
- }
-
- inline
- bool operator ==( const matrix4 &m1, const matrix4 &m2 )
- {
- return (
- m1(0,0) == m2(0,0) &&
- m1(0,1) == m2(0,1) &&
- m1(0,2) == m2(0,2) &&
- m1(0,3) == m2(0,3) &&
- m1(1,0) == m2(1,0) &&
- m1(1,1) == m2(1,1) &&
- m1(1,2) == m2(1,2) &&
- m1(1,3) == m2(1,3) &&
- m1(2,0) == m2(2,0) &&
- m1(2,1) == m2(2,1) &&
- m1(2,2) == m2(2,2) &&
- m1(2,3) == m2(2,3) &&
- m1(3,0) == m2(3,0) &&
- m1(3,1) == m2(3,1) &&
- m1(3,2) == m2(3,2) &&
- m1(3,3) == m2(3,3) );
- }
-
- inline
- bool operator != ( const matrix4 & m1, const matrix4 & m2 )
- { return !( m1 == m2 ); }
-
-
-
-
-
-
-
-
-
-
-
-
-
- class quaternion
- {
- public:
-
- quaternion()
- {
- *this = identity();
- }
-
- quaternion( const real v[4] )
- {
- set_value( v );
- }
-
-
- quaternion( real q0, real q1, real q2, real q3 )
- {
- set_value( q0, q1, q2, q3 );
- }
-
-
- quaternion( const matrix4 & m )
- {
- set_value( m );
- }
-
-
- quaternion( const vec3 &axis, real radians )
- {
- set_value( axis, radians );
- }
-
-
- quaternion( const vec3 &rotateFrom, const vec3 &rotateTo )
- {
- set_value( rotateFrom, rotateTo );
- }
-
- quaternion( const vec3 & from_look, const vec3 & from_up,
- const vec3 & to_look, const vec3& to_up)
- {
- set_value(from_look, from_up, to_look, to_up);
- }
-
- const real * get_value() const
- {
- return &q[0];
- }
-
- void get_value( real &q0, real &q1, real &q2, real &q3 ) const
- {
- q0 = q[0];
- q1 = q[1];
- q2 = q[2];
- q3 = q[3];
- }
-
- quaternion & set_value( real q0, real q1, real q2, real q3 )
- {
- q[0] = q0;
- q[1] = q1;
- q[2] = q2;
- q[3] = q3;
- counter = 0;
- return *this;
- }
-
- void get_value( vec3 &axis, real &radians ) const
- {
- radians = real(acos( q[3] ) * GLH_TWO);
- if ( radians == GLH_ZERO )
- axis = vec3( 0.0, 0.0, 1.0 );
- else
- {
- axis.v[0] = q[0];
- axis.v[1] = q[1];
- axis.v[2] = q[2];
- axis.normalize();
- }
- }
-
- void get_value( matrix4 & m ) const
- {
- real s, xs, ys, zs, wx, wy, wz, xx, xy, xz, yy, yz, zz;
-
- real norm = q[0] * q[0] + q[1] * q[1] + q[2] * q[2] + q[3] * q[3];
-
- s = (equivalent(norm,GLH_ZERO)) ? GLH_ZERO : ( GLH_TWO / norm );
-
- xs = q[0] * s;
- ys = q[1] * s;
- zs = q[2] * s;
-
- wx = q[3] * xs;
- wy = q[3] * ys;
- wz = q[3] * zs;
-
- xx = q[0] * xs;
- xy = q[0] * ys;
- xz = q[0] * zs;
-
- yy = q[1] * ys;
- yz = q[1] * zs;
- zz = q[2] * zs;
-
- m(0,0) = real( GLH_ONE - ( yy + zz ));
- m(1,0) = real ( xy + wz );
- m(2,0) = real ( xz - wy );
-
- m(0,1) = real ( xy - wz );
- m(1,1) = real ( GLH_ONE - ( xx + zz ));
- m(2,1) = real ( yz + wx );
-
- m(0,2) = real ( xz + wy );
- m(1,2) = real ( yz - wx );
- m(2,2) = real ( GLH_ONE - ( xx + yy ));
-
- m(3,0) = m(3,1) = m(3,2) = m(0,3) = m(1,3) = m(2,3) = GLH_ZERO;
- m(3,3) = GLH_ONE;
- }
-
- quaternion & set_value( const real * qp )
- {
- memcpy(q,qp,sizeof(real) * 4);
-
- counter = 0;
- return *this;
- }
-
- quaternion & set_value( const matrix4 & m )
- {
- real tr, s;
- int i, j, k;
- const int nxt[3] = { 1, 2, 0 };
-
- tr = m(0,0) + m(1,1) + m(2,2);
-
- if ( tr > GLH_ZERO )
- {
- s = real(sqrt( tr + m(3,3) ));
- q[3] = real ( s * 0.5 );
- s = real(0.5) / s;
-
- q[0] = real ( ( m(1,2) - m(2,1) ) * s );
- q[1] = real ( ( m(2,0) - m(0,2) ) * s );
- q[2] = real ( ( m(0,1) - m(1,0) ) * s );
- }
- else
- {
- i = 0;
- if ( m(1,1) > m(0,0) )
- i = 1;
-
- if ( m(2,2) > m(i,i) )
- i = 2;
-
- j = nxt[i];
- k = nxt[j];
-
- s = real(sqrt( ( m(i,j) - ( m(j,j) + m(k,k) )) + GLH_ONE ));
-
- q[i] = real ( s * 0.5 );
- s = real(0.5 / s);
-
- q[3] = real ( ( m(j,k) - m(k,j) ) * s );
- q[j] = real ( ( m(i,j) + m(j,i) ) * s );
- q[k] = real ( ( m(i,k) + m(k,i) ) * s );
- }
-
- counter = 0;
- return *this;
- }
-
- quaternion & set_value( const vec3 &axis, real theta )
- {
- real sqnorm = axis.square_norm();
-
- if (sqnorm <= GLH_EPSILON)
- {
- // axis too small.
- x = y = z = 0.0;
- w = 1.0;
- }
- else
- {
- theta *= real(0.5);
- real sin_theta = real(sin(theta));
-
- if (!equivalent(sqnorm,GLH_ONE))
- sin_theta /= real(sqrt(sqnorm));
- x = sin_theta * axis.v[0];
- y = sin_theta * axis.v[1];
- z = sin_theta * axis.v[2];
- w = real(cos(theta));
- }
- return *this;
- }
-
- quaternion & set_value( const vec3 & rotateFrom, const vec3 & rotateTo )
- {
- vec3 p1, p2;
- real alpha;
-
- p1 = rotateFrom;
- p1.normalize();
- p2 = rotateTo;
- p2.normalize();
-
- alpha = p1.dot(p2);
-
- if(equivalent(alpha,GLH_ONE))
- {
- *this = identity();
- return *this;
- }
-
- // ensures that the anti-parallel case leads to a positive dot
- if(equivalent(alpha,-GLH_ONE))
- {
- vec3 v;
-
- if(p1.v[0] != p1.v[1] || p1.v[0] != p1.v[2])
- v = vec3(p1.v[1], p1.v[2], p1.v[0]);
- else
- v = vec3(-p1.v[0], p1.v[1], p1.v[2]);
-
- v -= p1 * p1.dot(v);
- v.normalize();
-
- set_value(v, GLH_PI);
- return *this;
- }
-
- p1 = p1.cross(p2);
- p1.normalize();
- set_value(p1,real(acos(alpha)));
-
- counter = 0;
- return *this;
- }
-
- quaternion & set_value( const vec3 & from_look, const vec3 & from_up,
- const vec3 & to_look, const vec3 & to_up)
- {
- quaternion r_look = quaternion(from_look, to_look);
-
- vec3 rotated_from_up(from_up);
- r_look.mult_vec(rotated_from_up);
-
- quaternion r_twist = quaternion(rotated_from_up, to_up);
-
- *this = r_twist;
- *this *= r_look;
- return *this;
- }
-
- quaternion & operator *= ( const quaternion & qr )
- {
- quaternion ql(*this);
-
- w = ql.w * qr.w - ql.x * qr.x - ql.y * qr.y - ql.z * qr.z;
- x = ql.w * qr.x + ql.x * qr.w + ql.y * qr.z - ql.z * qr.y;
- y = ql.w * qr.y + ql.y * qr.w + ql.z * qr.x - ql.x * qr.z;
- z = ql.w * qr.z + ql.z * qr.w + ql.x * qr.y - ql.y * qr.x;
-
- counter += qr.counter;
- counter++;
- counter_normalize();
- return *this;
- }
-
- void normalize()
- {
- real rnorm = GLH_ONE / real(sqrt(w * w + x * x + y * y + z * z));
- if (equivalent(rnorm, GLH_ZERO))
- return;
- x *= rnorm;
- y *= rnorm;
- z *= rnorm;
- w *= rnorm;
- counter = 0;
- }
-
- friend bool operator == ( const quaternion & q1, const quaternion & q2 );
-
- friend bool operator != ( const quaternion & q1, const quaternion & q2 );
-
- friend quaternion operator * ( const quaternion & q1, const quaternion & q2 );
-
- bool equals( const quaternion & r, real tolerance ) const
- {
- real t;
-
- t = (
- (q[0]-r.q[0])*(q[0]-r.q[0]) +
- (q[1]-r.q[1])*(q[1]-r.q[1]) +
- (q[2]-r.q[2])*(q[2]-r.q[2]) +
- (q[3]-r.q[3])*(q[3]-r.q[3]) );
- if(t > GLH_EPSILON)
- return false;
- return 1;
- }
-
- quaternion & conjugate()
- {
- q[0] *= -GLH_ONE;
- q[1] *= -GLH_ONE;
- q[2] *= -GLH_ONE;
- return *this;
- }
-
- quaternion & invert()
- {
- return conjugate();
- }
-
- quaternion inverse() const
- {
- quaternion r = *this;
- return r.invert();
- }
-
- //
- // Quaternion multiplication with cartesian vector
- // v' = q*v*q(star)
- //
- void mult_vec( const vec3 &src, vec3 &dst ) const
- {
- real v_coef = w * w - x * x - y * y - z * z;
- real u_coef = GLH_TWO * (src.v[0] * x + src.v[1] * y + src.v[2] * z);
- real c_coef = GLH_TWO * w;
-
- dst.v[0] = v_coef * src.v[0] + u_coef * x + c_coef * (y * src.v[2] - z * src.v[1]);
- dst.v[1] = v_coef * src.v[1] + u_coef * y + c_coef * (z * src.v[0] - x * src.v[2]);
- dst.v[2] = v_coef * src.v[2] + u_coef * z + c_coef * (x * src.v[1] - y * src.v[0]);
- }
-
- void mult_vec( vec3 & src_and_dst) const
- {
- mult_vec(vec3(src_and_dst), src_and_dst);
- }
-
- void scale_angle( real scaleFactor )
- {
- vec3 axis;
- real radians;
-
- get_value(axis, radians);
- radians *= scaleFactor;
- set_value(axis, radians);
- }
-
- static quaternion slerp( const quaternion & p, const quaternion & q, real alpha )
- {
- quaternion r;
-
- real cos_omega = p.x * q.x + p.y * q.y + p.z * q.z + p.w * q.w;
- // if B is on opposite hemisphere from A, use -B instead
-
- int bflip;
- if ( ( bflip = (cos_omega < GLH_ZERO)) )
- cos_omega = -cos_omega;
-
- // complementary interpolation parameter
- real beta = GLH_ONE - alpha;
-
- if(cos_omega <= GLH_ONE - GLH_EPSILON)
- return p;
-
- real omega = real(acos(cos_omega));
- real one_over_sin_omega = GLH_ONE / real(sin(omega));
-
- beta = real(sin(omega*beta) * one_over_sin_omega);
- alpha = real(sin(omega*alpha) * one_over_sin_omega);
-
- if (bflip)
- alpha = -alpha;
-
- r.x = beta * p.q[0]+ alpha * q.q[0];
- r.y = beta * p.q[1]+ alpha * q.q[1];
- r.z = beta * p.q[2]+ alpha * q.q[2];
- r.w = beta * p.q[3]+ alpha * q.q[3];
- return r;
- }
-
- static quaternion identity()
- {
- static quaternion ident( vec3( 0.0, 0.0, 0.0 ), GLH_ONE );
- return ident;
- }
-
- real & operator []( int i )
- {
- assert(i < 4);
- return q[i];
- }
-
- const real & operator []( int i ) const
- {
- assert(i < 4);
- return q[i];
- }
-
- protected:
-
- void counter_normalize()
- {
- if (counter > GLH_QUATERNION_NORMALIZATION_THRESHOLD)
- normalize();
- }
-
- union
- {
- struct
- {
- real q[4];
- };
- struct
- {
- real x;
- real y;
- real z;
- real w;
- };
- };
-
- // renormalization counter
- unsigned char counter;
- };
-
- inline
- bool operator == ( const quaternion & q1, const quaternion & q2 )
- {
- return (equivalent(q1.x, q2.x) &&
- equivalent(q1.y, q2.y) &&
- equivalent(q1.z, q2.z) &&
- equivalent(q1.w, q2.w) );
- }
-
- inline
- bool operator != ( const quaternion & q1, const quaternion & q2 )
- {
- return ! ( q1 == q2 );
- }
-
- inline
- quaternion operator * ( const quaternion & q1, const quaternion & q2 )
- {
- quaternion r(q1);
- r *= q2;
- return r;
- }
-
-
-
-
-
-
-
-
-
-
- class plane
- {
- public:
-
- plane()
- {
- planedistance = 0.0;
- planenormal.set_value( 0.0, 0.0, 1.0 );
- }
-
-
- plane( const vec3 &p0, const vec3 &p1, const vec3 &p2 )
- {
- vec3 v0 = p1 - p0;
- vec3 v1 = p2 - p0;
- planenormal = v0.cross(v1);
- planenormal.normalize();
- planedistance = p0.dot(planenormal);
- }
-
- plane( const vec3 &normal, real distance )
- {
- planedistance = distance;
- planenormal = normal;
- planenormal.normalize();
- }
-
- plane( const vec3 &normal, const vec3 &point )
- {
- planenormal = normal;
- planenormal.normalize();
- planedistance = point.dot(planenormal);
- }
-
- void offset( real d )
- {
- planedistance += d;
- }
-
- bool intersect( const line &l, vec3 &intersection ) const
- {
- vec3 pos, dir;
- vec3 pn = planenormal;
- real pd = planedistance;
-
- pos = l.get_position();
- dir = l.get_direction();
-
- if(dir.dot(pn) == 0.0) return 0;
- pos -= pn*pd;
- // now we're talking about a plane passing through the origin
- if(pos.dot(pn) < 0.0) pn.negate();
- if(dir.dot(pn) > 0.0) dir.negate();
- vec3 ppos = pn * pos.dot(pn);
- pos = (ppos.length()/dir.dot(-pn))*dir;
- intersection = l.get_position();
- intersection += pos;
- return 1;
- }
- void transform( const matrix4 &matrix )
- {
- matrix4 invtr = matrix.inverse();
- invtr = invtr.transpose();
-
- vec3 pntOnplane = planenormal * planedistance;
- vec3 newPntOnplane;
- vec3 newnormal;
-
- invtr.mult_dir_matrix(planenormal, newnormal);
- matrix.mult_vec_matrix(pntOnplane, newPntOnplane);
-
- newnormal.normalize();
- planenormal = newnormal;
- planedistance = newPntOnplane.dot(planenormal);
- }
-
- bool is_in_half_space( const vec3 &point ) const
- {
-
- if(( point.dot(planenormal) - planedistance) < 0.0)
- return 0;
- return 1;
- }
-
-
- real distance( const vec3 & point ) const
- {
- return planenormal.dot(point - planenormal*planedistance);
- }
-
- const vec3 &get_normal() const
- {
- return planenormal;
- }
-
-
- real get_distance_from_origin() const
- {
- return planedistance;
- }
-
-
- friend bool operator == ( const plane & p1, const plane & p2 );
-
-
- friend bool operator != ( const plane & p1, const plane & p2 );
-
- //protected:
- vec3 planenormal;
- real planedistance;
- };
-
- inline
- bool operator == (const plane & p1, const plane & p2 )
- {
- return ( p1.planedistance == p2.planedistance && p1.planenormal == p2.planenormal);
- }
-
- inline
- bool operator != ( const plane & p1, const plane & p2 )
- { return ! (p1 == p2); }
-
-
-
- } // "ns_##GLH_REAL"
-
- // make common typedefs...
-#ifdef GLH_REAL_IS_FLOAT
- typedef GLH_REAL_NAMESPACE::vec2 vec2f;
- typedef GLH_REAL_NAMESPACE::vec3 vec3f;
- typedef GLH_REAL_NAMESPACE::vec4 vec4f;
- typedef GLH_REAL_NAMESPACE::quaternion quaternionf;
- typedef GLH_REAL_NAMESPACE::quaternion rotationf;
- typedef GLH_REAL_NAMESPACE::line linef;
- typedef GLH_REAL_NAMESPACE::plane planef;
- typedef GLH_REAL_NAMESPACE::matrix4 matrix4f;
-#endif
-
-
-
-
-} // namespace glh
-
-
-
-#endif
-
diff --git a/indra/newview/res/viewericon.xpm b/indra/newview/res/viewericon.xpm
deleted file mode 100644
index 7cf88ad..0000000
--- a/indra/newview/res/viewericon.xpm
+++ /dev/null
@@ -1,697 +0,0 @@
-/* XPM */
-static char * viewericon_xpm[] = {
-"32 32 662 2",
-" c None",
-". c #2594FF",
-"+ c #2693FF",
-"@ c #2894FF",
-"# c #2996FF",
-"$ c #2B98FF",
-"% c #2C9AFF",
-"& c #2E99FF",
-"* c #319AFF",
-"= c #319BFF",
-"- c #329CFF",
-"; c #339EFF",
-"> c #349EFF",
-", c #329DFF",
-"' c #3099FF",
-") c #2D99FF",
-"! c #2A97FF",
-"~ c #2191FF",
-"{ c #2692FF",
-"] c #2994FF",
-"^ c #2A96FF",
-"/ c #2B9AFF",
-"( c #329BFF",
-"_ c #359FFF",
-": c #35A0FF",
-"< c #36A0FF",
-"[ c #359EFF",
-"} c #2E98FF",
-"| c #2293FF",
-"1 c #2995FF",
-"2 c #339DFF",
-"3 c #369FFF",
-"4 c #2D9AFF",
-"5 c #2394FF",
-"6 c #2F98FF",
-"7 c #38A2FF",
-"8 c #39A2FF",
-"9 c #3BA4FF",
-"0 c #3AA3FF",
-"a c #38A1FF",
-"b c #37A1FF",
-"c c #309AFF",
-"d c #2593FF",
-"e c #2997FF",
-"f c #349FFF",
-"g c #3BA3FF",
-"h c #3CA4FF",
-"i c #3EA6FF",
-"j c #3EA7FF",
-"k c #3FA7FF",
-"l c #2D91FE",
-"m c #298BFC",
-"n c #298AFA",
-"o c #2989FA",
-"p c #2889FA",
-"q c #2688F8",
-"r c #2486F8",
-"s c #2386F8",
-"t c #2488FA",
-"u c #2E96FE",
-"v c #2893FF",
-"w c #3DA5FF",
-"x c #3FA8FF",
-"y c #2F96FE",
-"z c #1978F4",
-"A c #136DEE",
-"B c #126AEB",
-"C c #1269EA",
-"D c #116AE9",
-"E c #106AE8",
-"F c #1069E6",
-"G c #1068E6",
-"H c #116AEA",
-"I c #1C7BF7",
-"J c #2A94FF",
-"K c #3AA2FF",
-"L c #3DA6FF",
-"M c #40ADFF",
-"N c #41AEFF",
-"O c #43B0FF",
-"P c #2D95FD",
-"Q c #1472EF",
-"R c #0F69E6",
-"S c #0D67E2",
-"T c #0D66E1",
-"U c #0C65E0",
-"V c #0C64E0",
-"W c #0C63E0",
-"X c #0E64E2",
-"Y c #1874F2",
-"Z c #2C96FF",
-"` c #2E97FE",
-" . c #2A91FE",
-".. c #2C93FE",
-"+. c #2F94FE",
-"@. c #3097FE",
-"#. c #3098FE",
-"$. c #3197FE",
-"%. c #359BFE",
-"&. c #40ACFF",
-"*. c #44B1FF",
-"=. c #45B2FF",
-"-. c #46B2FF",
-";. c #47B3FF",
-">. c #3098FD",
-",. c #1475EE",
-"'. c #0E6AE6",
-"). c #0C69E2",
-"!. c #0C68E1",
-"~. c #0C67E0",
-"{. c #0C66E0",
-"]. c #0B63E0",
-"^. c #0E65E2",
-"/. c #1876F2",
-"(. c #2C97FF",
-"_. c #309BFF",
-":. c #1473F6",
-"<. c #1069F3",
-"[. c #106CF3",
-"}. c #1069F4",
-"|. c #1068F8",
-"1. c #106CF8",
-"2. c #106DF6",
-"3. c #116EF6",
-"4. c #1475F8",
-"5. c #39A3FE",
-"6. c #3099FE",
-"7. c #1478F0",
-"8. c #0E6CE7",
-"9. c #0C6AE4",
-"0. c #0E67E2",
-"a. c #1878F3",
-"b. c #319BFE",
-"c. c #116DF4",
-"d. c #106AF3",
-"e. c #106AF4",
-"f. c #1067F7",
-"g. c #106BF8",
-"h. c #106DF8",
-"i. c #106DF5",
-"j. c #1271F7",
-"k. c #1577F8",
-"l. c #36A0FE",
-"m. c #319AFE",
-"n. c #147AF0",
-"o. c #0E6EE8",
-"p. c #0C6CE6",
-"q. c #0C68E2",
-"r. c #0E68E4",
-"s. c #1A7BF4",
-"t. c #2D97FF",
-"u. c #329CFE",
-"v. c #126EF4",
-"w. c #1068F5",
-"x. c #1069F8",
-"y. c #106EF8",
-"z. c #106EF4",
-"A. c #1270F7",
-"B. c #1477F8",
-"C. c #1578F8",
-"D. c #369FFE",
-"E. c #319BFD",
-"F. c #1479EF",
-"G. c #0E6EE7",
-"H. c #0C6BE5",
-"I. c #0F6AE6",
-"J. c #1B7CF5",
-"K. c #1270F4",
-"L. c #106BF3",
-"M. c #1374F8",
-"N. c #369EFE",
-"O. c #3099FB",
-"P. c #1272E8",
-"Q. c #0C6ADF",
-"R. c #0C6AE0",
-"S. c #0C6CE4",
-"T. c #0F6AE7",
-"U. c #1C7CF5",
-"V. c #3EA5FF",
-"W. c #329DFE",
-"X. c #106DF7",
-"Y. c #106EF5",
-"Z. c #1271F8",
-"`. c #116DF0",
-" + c #0D62DE",
-".+ c #0D60DB",
-"++ c #257DF0",
-"@+ c #318CF6",
-"#+ c #318EF9",
-"$+ c #328EF9",
-"%+ c #2079EA",
-"&+ c #0B5ACA",
-"*+ c #0857C6",
-"=+ c #0A61D3",
-"-+ c #0C6CE5",
-";+ c #1C7AF5",
-">+ c #3A91FA",
-",+ c #3D94FA",
-"'+ c #3A92FA",
-")+ c #1969EC",
-"!+ c #1761EE",
-"~+ c #1764F0",
-"{+ c #1767EE",
-"]+ c #1868ED",
-"^+ c #1A6AEE",
-"/+ c #0D48BD",
-"(+ c #0A42AC",
-"_+ c #0B40AB",
-":+ c #164DCE",
-"<+ c #1D54DB",
-"[+ c #1D54DC",
-"}+ c #134AC5",
-"|+ c #083B9F",
-"1+ c #083CA2",
-"2+ c #0C4BB6",
-"3+ c #1261D4",
-"4+ c #1465DD",
-"5+ c #1365DE",
-"6+ c #1564DE",
-"7+ c #1766E2",
-"8+ c #2476EF",
-"9+ c #4599FC",
-"0+ c #469BFC",
-"a+ c #3A93FC",
-"b+ c #5273EE",
-"c+ c #5574EE",
-"d+ c #5272EC",
-"e+ c #2F53D4",
-"f+ c #2C4ED6",
-"g+ c #2C52D7",
-"h+ c #2C52D5",
-"i+ c #2E54D6",
-"j+ c #3053D4",
-"k+ c #1E3BA8",
-"l+ c #1C38A3",
-"m+ c #1D38A3",
-"n+ c #2C40BC",
-"o+ c #3545C6",
-"p+ c #3544C6",
-"q+ c #283EB6",
-"r+ c #1A349B",
-"s+ c #193398",
-"t+ c #1E3AA3",
-"u+ c #2A4FC1",
-"v+ c #2C55CA",
-"w+ c #2B55CC",
-"x+ c #2C55CC",
-"y+ c #2C55CD",
-"z+ c #2F56CF",
-"A+ c #3E61DA",
-"B+ c #5C78F0",
-"C+ c #5E79F2",
-"D+ c #5272F5",
-"E+ c #5573EE",
-"F+ c #5271EC",
-"G+ c #2C4ED5",
-"H+ c #2D52D3",
-"I+ c #2E55D4",
-"J+ c #3154D3",
-"K+ c #1E3AA7",
-"L+ c #1C39A2",
-"M+ c #1C38A2",
-"N+ c #2C42BC",
-"O+ c #3444C4",
-"P+ c #3344C3",
-"Q+ c #2D42BF",
-"R+ c #203AA9",
-"S+ c #1C36A2",
-"T+ c #2440B0",
-"U+ c #385DD0",
-"V+ c #3C63D6",
-"W+ c #3B62D6",
-"X+ c #3C62D7",
-"Y+ c #3D64D8",
-"Z+ c #4C6FE4",
-"`+ c #5C78EE",
-" @ c #5170F2",
-".@ c #5272EB",
-"+@ c #5273EB",
-"@@ c #5172EA",
-"#@ c #385CD9",
-"$@ c #2E51D4",
-"%@ c #2E54D4",
-"&@ c #2F54D2",
-"*@ c #3056D4",
-"=@ c #3256D2",
-"-@ c #1E3AA6",
-";@ c #1D39A2",
-">@ c #1F3BA9",
-",@ c #2C43BE",
-"'@ c #3244C2",
-")@ c #3244C1",
-"!@ c #3247C5",
-"~@ c #314CCA",
-"{@ c #385AD4",
-"]@ c #557DEF",
-"^@ c #557EEF",
-"/@ c #547DEE",
-"(@ c #517EEE",
-"_@ c #507EEE",
-":@ c #4C7AEC",
-"<@ c #4C78EA",
-"[@ c #4770EE",
-"}@ c #5072E7",
-"|@ c #5173E7",
-"1@ c #5474E6",
-"2@ c #5574E7",
-"3@ c #5575E8",
-"4@ c #5776E8",
-"5@ c #5978E9",
-"6@ c #5B78EA",
-"7@ c #3147C2",
-"8@ c #2D42BD",
-"9@ c #2C42BE",
-"0@ c #3043BE",
-"a@ c #3144BE",
-"b@ c #3144BF",
-"c@ c #3153CC",
-"d@ c #3058CD",
-"e@ c #3661D5",
-"f@ c #4F7DEC",
-"g@ c #507EEC",
-"h@ c #4D7EEB",
-"i@ c #4C7EEB",
-"j@ c #4B7FEA",
-"k@ c #4B7FE9",
-"l@ c #4A7EEA",
-"m@ c #467BE9",
-"n@ c #467AE5",
-"o@ c #4370E8",
-"p@ c #4E72E2",
-"q@ c #4F72E2",
-"r@ c #5072E2",
-"s@ c #5574E2",
-"t@ c #5877E5",
-"u@ c #5878E5",
-"v@ c #5978E6",
-"w@ c #5C7DE8",
-"x@ c #5D7CE9",
-"y@ c #2F48C0",
-"z@ c #2A42BA",
-"A@ c #2D41BA",
-"B@ c #3042BA",
-"C@ c #3043BA",
-"D@ c #3043B9",
-"E@ c #3046BD",
-"F@ c #2E57C8",
-"G@ c #2E58C8",
-"H@ c #3460D0",
-"I@ c #4F7DE8",
-"J@ c #4C7EE6",
-"K@ c #4A7FE6",
-"L@ c #4A7FE5",
-"M@ c #4A7FE4",
-"N@ c #477CE4",
-"O@ c #457AE4",
-"P@ c #4478DE",
-"Q@ c #406FE4",
-"R@ c #4B70DE",
-"S@ c #4D72DE",
-"T@ c #4E72DE",
-"U@ c #5073DD",
-"V@ c #5675DF",
-"W@ c #5676E1",
-"X@ c #587AE2",
-"Y@ c #5A7CE4",
-"Z@ c #2E48BB",
-"`@ c #2942B6",
-" # c #2A42B6",
-".# c #2E42B5",
-"+# c #2E43B5",
-"@# c #2E42B4",
-"## c #2D44B6",
-"$# c #2C56C4",
-"%# c #2C58C4",
-"&# c #3260CC",
-"*# c #4B7DE2",
-"=# c #497DE0",
-"-# c #477DE0",
-";# c #487DE0",
-"># c #467EE0",
-",# c #467EDF",
-"'# c #457DDE",
-")# c #437ADD",
-"!# c #4279DD",
-"~# c #4177D9",
-"{# c #3E6EDE",
-"]# c #486ED8",
-"^# c #4B71D9",
-"/# c #4B72D9",
-"(# c #4D72D8",
-"_# c #5374DA",
-":# c #5475DB",
-"<# c #5578DC",
-"[# c #567ADD",
-"}# c #2C48B7",
-"|# c #2742B1",
-"1# c #2A42B1",
-"2# c #2C42B1",
-"3# c #2C42B0",
-"4# c #2B44B2",
-"5# c #2A56BF",
-"6# c #2A57BF",
-"7# c #315EC7",
-"8# c #467CDC",
-"9# c #457CDA",
-"0# c #447CDA",
-"a# c #437CDA",
-"b# c #437CD8",
-"c# c #427CD8",
-"d# c #427AD8",
-"e# c #4077D7",
-"f# c #3F76D5",
-"g# c #3F75D4",
-"h# c #3C6FD8",
-"i# c #466ED2",
-"j# c #486ED4",
-"k# c #4A70D4",
-"l# c #4A70D3",
-"m# c #4E72D4",
-"n# c #5174D6",
-"o# c #5074D6",
-"p# c #5276D6",
-"q# c #5277D6",
-"r# c #2A46B2",
-"s# c #2540AC",
-"t# c #2840AC",
-"u# c #2A42AC",
-"v# c #2A41AC",
-"w# c #2A44AE",
-"x# c #2955BA",
-"y# c #2856BA",
-"z# c #2E5EC2",
-"A# c #447AD6",
-"B# c #437AD5",
-"C# c #417AD4",
-"D# c #407AD2",
-"E# c #3F79D1",
-"F# c #3E78D0",
-"G# c #3E76D1",
-"H# c #3E75D2",
-"I# c #3C74CF",
-"J# c #3B73CE",
-"K# c #3A6FD5",
-"L# c #436CCC",
-"M# c #456ECE",
-"N# c #466FCE",
-"O# c #4A71CE",
-"P# c #4E73D0",
-"Q# c #4E74D0",
-"R# c #4F74D0",
-"S# c #4E74CF",
-"T# c #2846AD",
-"U# c #2440A8",
-"V# c #2340A8",
-"W# c #2640A7",
-"X# c #2740A7",
-"Y# c #2841A7",
-"Z# c #2843A9",
-"`# c #2652B5",
-" $ c #2552B5",
-".$ c #2B5CBC",
-"+$ c #417AD0",
-"@$ c #3F79CE",
-"#$ c #3E78CC",
-"$$ c #3C76CA",
-"%$ c #3B76C8",
-"&$ c #3B74C9",
-"*$ c #3B74CC",
-"=$ c #3A73CD",
-"-$ c #3871CA",
-";$ c #3870C9",
-">$ c #386ED0",
-",$ c #426CC7",
-"'$ c #426CC9",
-")$ c #446EC9",
-"!$ c #466FC9",
-"~$ c #4A72CA",
-"{$ c #4C73CC",
-"]$ c #4B72CB",
-"^$ c #2E4FB0",
-"/$ c #2340A4",
-"($ c #223FA4",
-"_$ c #223FA3",
-":$ c #233FA3",
-"<$ c #2442A5",
-"[$ c #224FB0",
-"}$ c #2350B2",
-"|$ c #2E62BC",
-"1$ c #3E79CB",
-"2$ c #3B77C8",
-"3$ c #3A76C5",
-"4$ c #3873C2",
-"5$ c #3771C2",
-"6$ c #3771C5",
-"7$ c #3771C8",
-"8$ c #3770C6",
-"9$ c #3670C5",
-"0$ c #366FC6",
-"a$ c #346CCD",
-"b$ c #3F6BC2",
-"c$ c #406BC2",
-"d$ c #426DC4",
-"e$ c #426EC4",
-"f$ c #456FC4",
-"g$ c #4A72C6",
-"h$ c #4A73C7",
-"i$ c #4A72C7",
-"j$ c #466EC3",
-"k$ c #3E65BC",
-"l$ c #4065BD",
-"m$ c #4166BD",
-"n$ c #4066BD",
-"o$ c #4066BC",
-"p$ c #3F66BD",
-"q$ c #346BBF",
-"r$ c #356DC0",
-"s$ c #3B76C6",
-"t$ c #3B78C4",
-"u$ c #3874C1",
-"v$ c #3672BE",
-"w$ c #3570BD",
-"x$ c #346EBF",
-"y$ c #346EC1",
-"z$ c #346DC1",
-"A$ c #346CC0",
-"B$ c #346DC0",
-"C$ c #346EC2",
-"D$ c #316AC9",
-"E$ c #3C6ABE",
-"F$ c #3D6BBE",
-"G$ c #3F6CC0",
-"H$ c #416CC0",
-"I$ c #426DC0",
-"J$ c #4570C0",
-"K$ c #4872C2",
-"L$ c #4A76C4",
-"M$ c #4E79C7",
-"N$ c #4F7AC7",
-"O$ c #507AC8",
-"P$ c #4E79C8",
-"Q$ c #3D79C4",
-"R$ c #3C7AC4",
-"S$ c #3A79C2",
-"T$ c #3776BF",
-"U$ c #3572BB",
-"V$ c #336FBA",
-"W$ c #326DBB",
-"X$ c #326CBD",
-"Y$ c #326ABD",
-"Z$ c #3169BB",
-"`$ c #3169BA",
-" % c #316ABB",
-".% c #2E66C3",
-"+% c #396ABA",
-"@% c #3C6BBA",
-"#% c #3C6ABB",
-"$% c #3E6CBD",
-"%% c #406CBD",
-"&% c #406DBD",
-"*% c #426EBD",
-"=% c #456FBD",
-"-% c #4672BF",
-";% c #4672C0",
-">% c #4874C0",
-",% c #4976C1",
-"'% c #4B78C2",
-")% c #4C78C3",
-"!% c #4E78C3",
-"~% c #4B78C3",
-"{% c #3C78C1",
-"]% c #3A79C1",
-"^% c #3778BE",
-"/% c #3673BA",
-"(% c #326EB8",
-"_% c #326DBA",
-":% c #326BBB",
-"<% c #316ABA",
-"[% c #2F68B9",
-"}% c #2E66B8",
-"|% c #3067BB",
-"1% c #2C63BF",
-"2% c #3769B8",
-"3% c #3969B8",
-"4% c #3B6AB8",
-"5% c #3C6AB8",
-"6% c #3E6CBA",
-"7% c #3F6DBA",
-"8% c #416DBA",
-"9% c #446FBB",
-"0% c #4672BC",
-"a% c #4672BD",
-"b% c #4674BC",
-"c% c #4674BD",
-"d% c #4775BE",
-"e% c #4575BE",
-"f% c #3A76C0",
-"g% c #3776BE",
-"h% c #3573BB",
-"i% c #326EB6",
-"j% c #306CB7",
-"k% c #316CBB",
-"l% c #3068B8",
-"m% c #2E66B9",
-"n% c #2E66BA",
-"o% c #3068BE",
-"p% c #2B62C0",
-"q% c #3769B6",
-"r% c #3A68B6",
-"s% c #3B69B6",
-"t% c #406DBA",
-"u% c #436EBA",
-"v% c #4571BB",
-"w% c #4372BC",
-"x% c #3774BE",
-"y% c #3875C3",
-"z% c #316DB6",
-"A% c #2F6BB5",
-"B% c #306BB9",
-"C% c #326ABB",
-"D% c #3169BD",
-"E% c #3169BF",
-"F% c #3169C0",
-"G% c #3067BE",
-"H% c #2E66BC",
-"I% c #285FBC",
-"J% c #3667B5",
-"K% c #3768B6",
-"L% c #3C6BB9",
-"M% c #416EBA",
-"N% c #4470BA",
-"O% c #4570BB",
-"P% c #3873BD",
-"Q% c #3A76C6",
-"R% c #3974C3",
-"S% c #336FBC",
-"T% c #316CB9",
-"U% c #326CBB",
-"V% c #336CBD",
-"W% c #346CC2",
-"X% c #326AC2",
-"Y% c #3068C1",
-"Z% c #2B64B8",
-"`% c #245AB6",
-" & c #3466B5",
-".& c #3668B5",
-"+& c #3868B6",
-"@& c #3F6CBA",
-"#& c #426FBA",
-"$& c #436FBA",
-"%& c #4271BA",
-"&& c #3772BB",
-"*& c #3975C3",
-"=& c #3974C4",
-"-& c #3772C2",
-";& c #346FBF",
-">& c #326CBC",
-",& c #3169BC",
-"'& c #2D65BC",
-")& c #2961B5",
-"!& c #2861B4",
-"~& c #2056B2",
-". . + @ # $ % % & * * * = - - ; ; > > ; , - - * * * ' ) % % ! ~ ",
-". { ] ^ / % ) ' * * ( , > > _ : < < < : : [ > ; - * * * } % % | ",
-"+ 1 ^ % % & * * ( 2 > 3 < < < < < < < < < < < 3 _ > - * * ' 4 5 ",
-"@ ^ % % 6 * * - > 3 < < < < 7 8 9 9 0 0 a b < < < < [ ; = * c d ",
-"e / % ' * * , f < < < 7 g h i j j j j j i i 9 8 b < < 3 > - * + ",
-"$ % & * * ; [ < < a 9 i j k k k k h l m n o p p q r s t u > - v ",
-"% ) * * , _ < < 8 w k k k k k k x y z A B C D E F G G H I [ > J ",
-"% ' * , [ < < K L k k k k x M N O P Q R S T U U V W W X Y > < Z ",
-"& * = ` . ...+. at .#.$.%.&.*.=.-.;.>.,.'.).!.~.{.U ].].^./.< < (.",
-"c * _.:.<.[.}.|.1.2.3.4.5.;.;.;.;.6.7.8.9.).).!.{.U V 0.a.8 b (.",
-"* ( b.c.d.e.f.g.h.i.j.k.l.;.;.;.;.m.n.o.p.p.9.).q.{.{.r.s.h b t.",
-"* , u.v.[.w.x.y.z.A.B.C.D.;.;.;.;.E.F.G.p.p.p.H.).q.~.I.J.w 9 } ",
-"* > u.K.L.f.1.2.3.M.C.C.N.;.;.;.;.O.P.Q.R.S.p.p.H.).).T.U.V.w 6 ",
-"- > W.K.w.|.X.Y.Z.`. +.+++ at +@+#+$+%+&+*+=+Q.-+p.p.9.).E ;+V.i - ",
-">+,+'+)+!+~+{+]+^+/+(+_+:+<+<+[+[+}+|+1+2+3+4+5+5+5+6+7+8+9+0+a+",
-"b+c+d+e+f+g+h+i+j+k+l+m+n+o+o+o+p+q+r+s+t+u+v+w+w+x+y+z+A+B+C+D+",
-"b+E+F+e+G+h+H+I+J+K+L+M+N+O+O+P+P+Q+R+S+T+U+V+V+W+W+X+Y+Z+`+`+ @",
-". at +@@@#@$@%@&@*@=@-@;@>@,@'@)@)@)@)@!@~@{@]@^@/@(@(@_ at _@_@:@<@[@",
-"}@|@|@1 at 2@3 at 4@5 at 6@7 at 8@9 at 0@a at a@a at a@b at c@d at e@f at g@h at i@j at j@k at l@m at n@o@",
-"p at q@r at s@t at u@v at w@x at y@z at A@B at C@D at D@D at E@F at G@H at I@J at K@L at L@L at M@N at O@P at Q@",
-"R at S@T at U@V at W@W at X@Y at Z@`@ #.#+#+#+#@###$#%#&#*#=#-#;#>#,#'#)#!#~#{#",
-"]#^#/#(#_#:#:#<#[#}#|#|#1#2#2#3#3#4#5#6#7#8#9#0#a#b#c#d#e#f#g#h#",
-"i#j#k#l#m#n#o#p#q#r#s#s#s#t#u#v#u#w#x#y#z#A#B#C#D#E#F#G#H#I#J#K#",
-"L#M#N#N#O#P#Q#R#S#T#U#U#V#V#W#X#Y#Z#`# $.$+$@$#$$$%$&$*$=$-$;$>$",
-",$'$)$)$!$~${${$]$^$/$($_$_$_$_$:$<$[$}$|$1$2$3$4$5$6$7$8$9$0$a$",
-"b$c$d$e$e$f$g$h$i$j$k$l$m$m$n$n$o$p$q$r$s$t$u$v$w$x$y$z$A$B$C$D$",
-"E$F$G$H$I$I$J$K$K$K$K$L$M$N$O$O$O$P$Q$R$S$T$U$V$W$X$Y$Z$`$ %Y$.%",
-"+%@%#%$%%%&%*%=%-%;%;%;%>%,%'%)%!%~%{%]%^%/%(%_%:%<%[%}%}%}%|%1%",
-"2%3%4%5%6%7%7%8%9%0%a%a%0%0%b%c%d%e%f%g%h%i%j%k%<%l%}%m%m%n%o%p%",
-"q%q%r%s%5%6%7%7%t%u%v%0%0%0%0%0%0%w%x%y%v$z%A%B%C%Z$D%E%F%G%H%I%",
-"J%q%K%s%s%L%6%7%7%7%M%N%O%0%0%0%0%w%P%Q%R%S%T%U%V%A$W%X%Y%H%Z%`%",
-" &.&q%+&s%s%5%6%@&7%7%t%t%#&$&N%N%%&&&*&=&-&;&>&C%,&o%'&)&!&!&~&"};
--
A client for connecting to 3D metaverses such as Linden Labs Secondlife(tm) and OpenSim grids
More information about the Pkg-games-commits
mailing list