mirror/openlara
1
0
Fork 0
mirror of https://github.com/XProger/OpenLara.git synced 2025-04-21 03:21:51 +02:00
Code Issues Releases Wiki Activity

minor fixes, tab to spaces

Browse Source
This commit is contained in:
XProger 2016-09-12 11:27:41 +03:00
parent 071081b612
commit e47f8c5fd7
5 changed files with 463 additions and 451 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
bin/OpenLara.exe
View File

Binary file not shown.

14
src/controller.h
View File

@ -225,7 +225,19 @@ struct Controller {
do {
trigCmd = (*fd++).triggerCmd; // trigger action
switch (trigCmd.func) {
case 0 : break; // activate item
case 0 :
/*
if (getEntity().id == 0 && cmd.sub == 2) {
TR::Entity &e = level->entities[trigCmd.args];
for (int i = 0; i < level->modelsCount; i++)
if (e.id == level->models[i].id) {
TR::Animation *anim = &level->anims[level->models[i].animation];
for (int j = 0; j < anim->scCount; j++)
LOG("state: %d\n", anim->state);
break;
}
}*/
break; // activate item
case 1 : break; // switch to camera
case 2 : break; // camera delay
case 3 : break; // flip map

124
src/shader.glsl
View File

@ -1,85 +1,85 @@
R"====(
#ifndef SPRITE
varying vec4 vNormal;
varying vec3 vLightVec;
varying vec3 vViewVec;
varying vec4 vNormal;
varying vec3 vLightVec;
varying vec3 vViewVec;
#endif
varying vec2 vTexCoord;
varying vec4 vColor;
#ifdef VERTEX
uniform mat4 uViewProj;
uniform mat4 uModel;
uniform vec4 uColor;
uniform mat4 uViewProj;
uniform mat4 uModel;
uniform vec4 uColor;
#ifndef SPRITE
uniform vec3 uViewPos;
uniform vec3 uLightPos;
uniform vec2 uAnimTexRanges[MAX_RANGES];
uniform vec2 uAnimTexOffsets[MAX_OFFSETS];
#ifndef SPRITE
uniform vec3 uViewPos;
uniform vec3 uLightPos;
uniform vec2 uAnimTexRanges[MAX_RANGES];
uniform vec2 uAnimTexOffsets[MAX_OFFSETS];
#else
uniform mat4 uViewInv;
#endif
uniform mat4 uViewInv;
#endif
uniform vec4 uParam; // x - time
attribute vec4 aCoord;
attribute vec4 aTexCoord;
attribute vec4 aNormal;
attribute vec4 aColor;
uniform vec4 uParam; // x - time
attribute vec4 aCoord;
attribute vec4 aTexCoord;
attribute vec4 aNormal;
attribute vec4 aColor;
#define TEXCOORD_SCALE (1.0 / 32767.0)
void main() {
vec4 coord = uModel * vec4(aCoord.xyz, 1.0);
vColor = aColor * uColor;
void main() {
vec4 coord = uModel * vec4(aCoord.xyz, 1.0);
vColor = aColor * uColor;
#ifdef CAUSTICS
float sum = coord.x + coord.y + coord.z;
vColor.xyz *= abs(sin(sum / 512.0 + uParam.x)) * 0.75 + 0.25;
#endif
#ifdef CAUSTICS
float sum = coord.x + coord.y + coord.z;
vColor.xyz *= abs(sin(sum / 512.0 + uParam.x)) * 0.75 + 0.25;
#endif
#ifndef SPRITE
// animated texture coordinates
vec2 range = uAnimTexRanges[int(aTexCoord.z)]; // x - start index, y - count
#ifndef SPRITE
// animated texture coordinates
vec2 range = uAnimTexRanges[int(aTexCoord.z)]; // x - start index, y - count
float f = fract((aTexCoord.w + uParam.x * 4.0 - range.x) / range.y) * range.y;
vec2 offset = uAnimTexOffsets[int(range.x + f)]; // texCoord offset from first frame
vec2 offset = uAnimTexOffsets[int(range.x + f)]; // texCoord offset from first frame
vTexCoord = (aTexCoord.xy + offset) * TEXCOORD_SCALE; // first frame + offset * isAnimated
vTexCoord = (aTexCoord.xy + offset) * TEXCOORD_SCALE; // first frame + offset * isAnimated
vViewVec = uViewPos - coord.xyz;
vLightVec = uLightPos - coord.xyz;
vNormal = uModel * aNormal;
#else
vTexCoord = aTexCoord.xy * TEXCOORD_SCALE;
coord.xyz -= uViewInv[0].xyz * aTexCoord.z + uViewInv[1].xyz * aTexCoord.w;
#endif
gl_Position = uViewProj * coord;
}
vViewVec = uViewPos - coord.xyz;
vLightVec = uLightPos - coord.xyz;
vNormal = uModel * aNormal;
#else
vTexCoord = aTexCoord.xy * TEXCOORD_SCALE;
coord.xyz -= uViewInv[0].xyz * aTexCoord.z + uViewInv[1].xyz * aTexCoord.w;
#endif
gl_Position = uViewProj * coord;
}
#else
uniform sampler2D sDiffuse;
uniform sampler2D sDiffuse;
#ifndef SPRITE
uniform vec3 uAmbient;
uniform vec4 uLightColor;
#endif
#ifndef SPRITE
uniform vec3 uAmbient;
uniform vec4 uLightColor;
#endif
void main() {
vec4 color = texture2D(sDiffuse, vTexCoord);
if (color.w < 0.6)
discard;
void main() {
vec4 color = texture2D(sDiffuse, vTexCoord);
if (color.w < 0.6)
discard;
color *= vColor;
#ifndef SPRITE
color.xyz = pow(abs(color.xyz), vec3(2.2));
float lum = dot(normalize(vNormal.xyz), normalize(vLightVec));
float att = max(0.0, 1.0 - dot(vLightVec, vLightVec) / uLightColor.w);
vec3 light = uLightColor.xyz * max(vNormal.w, lum * att) + uAmbient;
color.xyz *= light;
color.xyz = pow(abs(color.xyz), vec3(1.0/2.2));
#endif
gl_FragColor = color;
}
color *= vColor;
#ifndef SPRITE
color.xyz = pow(abs(color.xyz), vec3(2.2));
float lum = dot(normalize(vNormal.xyz), normalize(vLightVec));
float att = max(0.0, 1.0 - dot(vLightVec, vLightVec) / uLightColor.w);
vec3 light = uLightColor.xyz * max(vNormal.w, lum * att) + uAmbient;
color.xyz *= light;
color.xyz = pow(abs(color.xyz), vec3(1.0/2.2));
#endif
gl_FragColor = color;
}
#endif
)===="

2
src/shader.h
View File

@ -19,7 +19,7 @@ struct Shader {
#ifdef MOBILE
#define GLSL_DEFINE "precision highp float;\n" "#define MOBILE\n"
#else
#define GLSL_DEFINE "#version 120\n"
#define GLSL_DEFINE "#version 120\n"
#endif
const int type[2] = { GL_VERTEX_SHADER, GL_FRAGMENT_SHADER };

774
src/utils.h
View File

@ -7,514 +7,514 @@
#include <float.h>
#ifdef _DEBUG
#define debugBreak() _asm { int 3 }
#define ASSERT(expr) if (expr) {} else { LOG("ASSERT %s in %s:%d\n", #expr, __FILE__, __LINE__); debugBreak(); }
#define debugBreak() _asm { int 3 }
#define ASSERT(expr) if (expr) {} else { LOG("ASSERT %s in %s:%d\n", #expr, __FILE__, __LINE__); debugBreak(); }
#ifndef ANDROID
#define LOG(...) printf(__VA_ARGS__)
#define LOG(...) printf(__VA_ARGS__)
#else
#include <android/log.h>
#define LOG(...) __android_log_print(ANDROID_LOG_INFO,"X5",__VA_ARGS__)
#include <android/log.h>
#define LOG(...) __android_log_print(ANDROID_LOG_INFO,"X5",__VA_ARGS__)
#endif
#else
#define ASSERT(expr)
#define ASSERT(expr)
// #define LOG(...) ((void)0)
#define LOG(...) printf(__VA_ARGS__)
#endif
#define PI 3.14159265358979323846f
#define DEG2RAD (PI / 180.0f)
#define RAD2DEG (180.0f / PI)
#define EPS FLT_EPSILON
#define PI 3.14159265358979323846f
#define DEG2RAD (PI / 180.0f)
#define RAD2DEG (180.0f / PI)
#define EPS FLT_EPSILON
typedef char int8;
typedef short int16;
typedef int int32;
typedef unsigned char uint8;
typedef unsigned short uint16;
typedef unsigned int uint32;
typedef char int8;
typedef short int16;
typedef int int32;
typedef unsigned char uint8;
typedef unsigned short uint16;
typedef unsigned int uint32;
struct ubyte4 {
uint8 x, y, z, w;
uint8 x, y, z, w;
};
struct short2 {
int16 x, y;
int16 x, y;
};
struct short3 {
int16 x, y, z;
int16 x, y, z;
};
struct short4 {
int16 x, y, z, w;
int16 x, y, z, w;
};
template <typename T>
inline const T& min(const T &a, const T &b) {
return a < b ? a : b;
return a < b ? a : b;
}
template <class T>
inline const T& max(const T &a, const T &b) {
return a > b ? a : b;
return a > b ? a : b;
}
template <class T>
inline const T& clamp(const T &x, const T &a, const T &b) {
return x < a ? a : (x > b ? b : x);
return x < a ? a : (x > b ? b : x);
}
template <class T>
inline const int sign(const T &x) {
return x > 0 ? 1 : (x < 0 ? -1 : 0);
return x > 0 ? 1 : (x < 0 ? -1 : 0);
}
struct vec2 {
float x, y;
vec2() {}
vec2(float s) : x(s), y(s) {}
vec2(float x, float y) : x(x), y(y) {}
float x, y;
vec2() {}
vec2(float s) : x(s), y(s) {}
vec2(float x, float y) : x(x), y(y) {}
vec2 operator + (const vec2 &v) const { return vec2(x+v.x, y+v.y); }
vec2 operator - (const vec2 &v) const { return vec2(x-v.x, y-v.y); }
vec2 operator * (float s) const { return vec2(x*s, y*s); }
float dot(const vec2 &v) const { return x*v.x + y*v.y; }
float cross(const vec2 &v) const { return x*v.y - y*v.x; }
float length2() const { return dot(*this); }
float length() const { return sqrtf(length2()); }
vec2 normal() const { float s = length(); return s == 0.0 ? (*this) : (*this)*(1.0f/s); }
vec2 operator + (const vec2 &v) const { return vec2(x+v.x, y+v.y); }
vec2 operator - (const vec2 &v) const { return vec2(x-v.x, y-v.y); }
vec2 operator * (float s) const { return vec2(x*s, y*s); }
float dot(const vec2 &v) const { return x*v.x + y*v.y; }
float cross(const vec2 &v) const { return x*v.y - y*v.x; }
float length2() const { return dot(*this); }
float length() const { return sqrtf(length2()); }
vec2 normal() const { float s = length(); return s == 0.0 ? (*this) : (*this)*(1.0f/s); }
};
struct vec3 {
float x, y, z;
vec3() {}
vec3(float s) : x(s), y(s), z(s) {}
vec3(float x, float y, float z) : x(x), y(y), z(z) {}
vec3(const vec2 &xy, float z = 0.0f) : x(xy.x), y(xy.y), z(z) {}
float x, y, z;
vec3() {}
vec3(float s) : x(s), y(s), z(s) {}
vec3(float x, float y, float z) : x(x), y(y), z(z) {}
vec3(const vec2 &xy, float z = 0.0f) : x(xy.x), y(xy.y), z(z) {}
vec3(float lng, float lat) : x(sinf(lat) * cosf(lng)), y(-sinf(lng)), z(cosf(lat) * cosf(lng)) {}
float& operator [] (int index) const { return ((float*)this)[index]; }
float& operator [] (int index) const { return ((float*)this)[index]; }
vec3 operator + (const vec3 &v) const { return vec3(x+v.x, y+v.y, z+v.z); }
vec3 operator - (const vec3 &v) const { return vec3(x-v.x, y-v.y, z-v.z); }
vec3 operator * (const vec3 &v) const { return vec3(x*v.x, y*v.y, z*v.z); }
vec3 operator / (const vec3 &v) const { return vec3(x/v.x, y/v.y, z/v.z); }
vec3 operator * (float s) const { return vec3(x*s, y*s, z*s); }
vec3 operator + (const vec3 &v) const { return vec3(x+v.x, y+v.y, z+v.z); }
vec3 operator - (const vec3 &v) const { return vec3(x-v.x, y-v.y, z-v.z); }
vec3 operator * (const vec3 &v) const { return vec3(x*v.x, y*v.y, z*v.z); }
vec3 operator / (const vec3 &v) const { return vec3(x/v.x, y/v.y, z/v.z); }
vec3 operator * (float s) const { return vec3(x*s, y*s, z*s); }
float dot(const vec3 &v) const { return x*v.x + y*v.y + z*v.z; }
vec3 cross(const vec3 &v) const { return vec3(y*v.z - z*v.y, z*v.x - x*v.z, x*v.y - y*v.x); }
float length2() const { return dot(*this); }
float length() const { return sqrtf(length2()); }
vec3 normal() const { float s = length(); return s == 0.0 ? (*this) : (*this)*(1.0f/s); }
float dot(const vec3 &v) const { return x*v.x + y*v.y + z*v.z; }
vec3 cross(const vec3 &v) const { return vec3(y*v.z - z*v.y, z*v.x - x*v.z, x*v.y - y*v.x); }
float length2() const { return dot(*this); }
float length() const { return sqrtf(length2()); }
vec3 normal() const { float s = length(); return s == 0.0 ? (*this) : (*this)*(1.0f/s); }
vec3 lerp(const vec3 &v, const float t) const {
return *this + (v - *this) * t;
}
vec3 lerp(const vec3 &v, const float t) const {
return *this + (v - *this) * t;
}
vec3 rotateY(float angle) const {
float s = sinf(angle), c = cosf(angle);
return vec3(x*c - z*s, y, x*s + z*c);
float s = sinf(angle), c = cosf(angle);
return vec3(x*c - z*s, y, x*s + z*c);
}
};
struct vec4 {
union {
struct { vec3 xyz; };
struct { float x, y, z, w; };
};
union {
struct { vec3 xyz; };
struct { float x, y, z, w; };
};
vec4() {}
vec4(float s) : x(s), y(s), z(s), w(s) {}
vec4(float x, float y, float z, float w) : x(x), y(y), z(z), w(w) {}
vec4(const vec3 &xyz, float w) : x(xyz.x), y(xyz.y), z(xyz.z), w(w) {}
vec4() {}
vec4(float s) : x(s), y(s), z(s), w(s) {}
vec4(float x, float y, float z, float w) : x(x), y(y), z(z), w(w) {}
vec4(const vec3 &xyz, float w) : x(xyz.x), y(xyz.y), z(xyz.z), w(w) {}
vec4& operator *= (const vec4 &v) { x*=v.x; y*=v.y; z*=v.z; w*=v.w; return *this; }
};
struct quat {
float x, y, z, w;
float x, y, z, w;
quat() {}
quat(float x, float y, float z, float w) : x(x), y(y), z(z), w(w) {}
quat() {}
quat(float x, float y, float z, float w) : x(x), y(y), z(z), w(w) {}
quat(const vec3 &axis, float angle) {
angle *= 0.5f;
float s = sinf(angle);
x = axis.x * s;
y = axis.y * s;
z = axis.z * s;
w = cosf(angle);
}
quat(const vec3 &axis, float angle) {
angle *= 0.5f;
float s = sinf(angle);
x = axis.x * s;
y = axis.y * s;
z = axis.z * s;
w = cosf(angle);
}
quat operator - () const {
return quat(-x, -y, -z, -w);
}
quat operator - () const {
return quat(-x, -y, -z, -w);
}
quat operator + (const quat &q) const {
return quat(x + q.x, y + q.y, z + q.z, w + q.w);
}
quat operator + (const quat &q) const {
return quat(x + q.x, y + q.y, z + q.z, w + q.w);
}
quat operator - (const quat &q) const {
return quat(x - q.x, y - q.y, z - q.z, w - q.w);
}
quat operator - (const quat &q) const {
return quat(x - q.x, y - q.y, z - q.z, w - q.w);
}
quat operator * (const float s) const {
return quat(x * s, y * s, z * s, w * s);
}
quat operator * (const float s) const {
return quat(x * s, y * s, z * s, w * s);
}
quat operator * (const quat &q) const {
return quat(w * q.x + x * q.w + y * q.z - z * q.y,
w * q.y + y * q.w + z * q.x - x * q.z,
w * q.z + z * q.w + x * q.y - y * q.x,
w * q.w - x * q.x - y * q.y - z * q.z);
}
quat operator * (const quat &q) const {
return quat(w * q.x + x * q.w + y * q.z - z * q.y,
w * q.y + y * q.w + z * q.x - x * q.z,
w * q.z + z * q.w + x * q.y - y * q.x,
w * q.w - x * q.x - y * q.y - z * q.z);
}
float dot(const quat &q) const {
return x * q.x + y * q.y + z * q.z + w * q.w;
}
float dot(const quat &q) const {
return x * q.x + y * q.y + z * q.z + w * q.w;
}
float length2() const {
return dot(*this);
}
float length2() const {
return dot(*this);
}
float length() const {
return sqrtf(length2());
}
float length() const {
return sqrtf(length2());
}
void normalize() {
*this = normal();
}
void normalize() {
*this = normal();
}
quat normal() const {
return *this * (1.0f / length());
}
quat normal() const {
return *this * (1.0f / length());
}
quat conjugate() const {
return quat(-x, -y, -z, w);
}
quat conjugate() const {
return quat(-x, -y, -z, w);
}
quat inverse() const {
return conjugate() * (1.0f / length2());
}
quat inverse() const {
return conjugate() * (1.0f / length2());
}
quat lerp(const quat &q, float t) const {
if (t <= 0.0f) return *this;
if (t >= 1.0f) return q;
quat lerp(const quat &q, float t) const {
if (t <= 0.0f) return *this;
if (t >= 1.0f) return q;
return dot(q) < 0 ? (*this - (q + *this) * t) :
(*this + (q - *this) * t);
}
return dot(q) < 0 ? (*this - (q + *this) * t) :
(*this + (q - *this) * t);
}
quat slerp(const quat &q, float t) const {
if (t <= 0.0f) return *this;
if (t >= 1.0f) return q;
quat slerp(const quat &q, float t) const {
if (t <= 0.0f) return *this;
if (t >= 1.0f) return q;
quat temp;
float omega, cosom, sinom, scale0, scale1;
quat temp;
float omega, cosom, sinom, scale0, scale1;
cosom = dot(q);
if (cosom < 0.0f) {
temp = -q;
cosom = -cosom;
} else
temp = q;
cosom = dot(q);
if (cosom < 0.0f) {
temp = -q;
cosom = -cosom;
} else
temp = q;
if (1.0f - cosom > EPS) {
omega = acos(cosom);
sinom = 1.0f / sin(omega);
scale0 = sin((1.0f - t) * omega) * sinom;
scale1 = sin(t * omega) * sinom;
} else {
scale0 = 1.0f - t;
scale1 = t;
}
if (1.0f - cosom > EPS) {
omega = acos(cosom);
sinom = 1.0f / sin(omega);
scale0 = sin((1.0f - t) * omega) * sinom;
scale1 = sin(t * omega) * sinom;
} else {
scale0 = 1.0f - t;
scale1 = t;
}
return *this * scale0 + temp * scale1;
}
return *this * scale0 + temp * scale1;
}
};
struct mat4 {
union {
struct {
float e00, e10, e20, e30,
e01, e11, e21, e31,
e02, e12, e22, e32,
e03, e13, e23, e33;
};
struct { vec4 right, up, dir, offset; };
};
union {
struct {
float e00, e10, e20, e30,
e01, e11, e21, e31,
e02, e12, e22, e32,
e03, e13, e23, e33;
};
struct { vec4 right, up, dir, offset; };
};
mat4() {}
mat4() {}
mat4(const quat &rot, const vec3 &pos) {
setRot(rot);
setPos(pos);
e30 = e31 = e32 = 0.0f;
e33 = 1.0f;
}
mat4(float l, float r, float b, float t, float znear, float zfar) {
identity();
e00 = 2.0f / (r - l);
e11 = 2.0f / (t - b);
e22 = 2.0f / (znear - zfar);
e03 = (l + r) / (l - r);
e13 = (b + t) / (b - t);
e23 = (zfar + znear) / (znear - zfar);
}
mat4(float fov, float aspect, float znear, float zfar) {
float k = 1.0f / tanf(fov * 0.5f * DEG2RAD);
identity();
e00 = k / aspect;
e11 = k;
e22 = (znear + zfar) / (znear - zfar);
e33 = 0.0f;
e32 = -1.0f;
e23 = 2.0f * zfar * znear / (znear - zfar);
}
mat4(const vec3 &from, const vec3 &at, const vec3 &up) {
vec3 r, u, d;
d = (from - at).normal();
r = up.cross(d).normal();
u = d.cross(r);
this->right = vec4(r, 0.0f);
this->up = vec4(u, 0.0f);
this->dir = vec4(d, 0.0f);
this->offset = vec4(from, 1.0f);
mat4(const quat &rot, const vec3 &pos) {
setRot(rot);
setPos(pos);
e30 = e31 = e32 = 0.0f;
e33 = 1.0f;
}
void identity() {
e10 = e20 = e30 = e01 = e21 = e31 = e02 = e12 = e32 = e03 = e13 = e23 = 0.0f;
e00 = e11 = e22 = e33 = 1.0f;
}
mat4(float l, float r, float b, float t, float znear, float zfar) {
identity();
e00 = 2.0f / (r - l);
e11 = 2.0f / (t - b);
e22 = 2.0f / (znear - zfar);
e03 = (l + r) / (l - r);
e13 = (b + t) / (b - t);
e23 = (zfar + znear) / (znear - zfar);
}
mat4 operator * (const mat4 &m) const {
mat4 r;
r.e00 = e00 * m.e00 + e01 * m.e10 + e02 * m.e20 + e03 * m.e30;
r.e10 = e10 * m.e00 + e11 * m.e10 + e12 * m.e20 + e13 * m.e30;
r.e20 = e20 * m.e00 + e21 * m.e10 + e22 * m.e20 + e23 * m.e30;
r.e30 = e30 * m.e00 + e31 * m.e10 + e32 * m.e20 + e33 * m.e30;
r.e01 = e00 * m.e01 + e01 * m.e11 + e02 * m.e21 + e03 * m.e31;
r.e11 = e10 * m.e01 + e11 * m.e11 + e12 * m.e21 + e13 * m.e31;
r.e21 = e20 * m.e01 + e21 * m.e11 + e22 * m.e21 + e23 * m.e31;
r.e31 = e30 * m.e01 + e31 * m.e11 + e32 * m.e21 + e33 * m.e31;
r.e02 = e00 * m.e02 + e01 * m.e12 + e02 * m.e22 + e03 * m.e32;
r.e12 = e10 * m.e02 + e11 * m.e12 + e12 * m.e22 + e13 * m.e32;
r.e22 = e20 * m.e02 + e21 * m.e12 + e22 * m.e22 + e23 * m.e32;
r.e32 = e30 * m.e02 + e31 * m.e12 + e32 * m.e22 + e33 * m.e32;
r.e03 = e00 * m.e03 + e01 * m.e13 + e02 * m.e23 + e03 * m.e33;
r.e13 = e10 * m.e03 + e11 * m.e13 + e12 * m.e23 + e13 * m.e33;
r.e23 = e20 * m.e03 + e21 * m.e13 + e22 * m.e23 + e23 * m.e33;
r.e33 = e30 * m.e03 + e31 * m.e13 + e32 * m.e23 + e33 * m.e33;
return r;
}
mat4(float fov, float aspect, float znear, float zfar) {
float k = 1.0f / tanf(fov * 0.5f * DEG2RAD);
identity();
e00 = k / aspect;
e11 = k;
e22 = (znear + zfar) / (znear - zfar);
e33 = 0.0f;
e32 = -1.0f;
e23 = 2.0f * zfar * znear / (znear - zfar);
}
vec3 operator * (const vec3 &v) const {
return vec3(
e00 * v.x + e01 * v.y + e02 * v.z + e03,
e10 * v.x + e11 * v.y + e12 * v.z + e13,
e20 * v.x + e21 * v.y + e22 * v.z + e23);
}
vec4 operator * (const vec4 &v) const {
return vec4(
e00 * v.x + e01 * v.y + e02 * v.z + e03 * v.w,
e10 * v.x + e11 * v.y + e12 * v.z + e13 * v.w,
e20 * v.x + e21 * v.y + e22 * v.z + e23 * v.w,
e30 * v.x + e31 * v.y + e32 * v.z + e33 * v.w);
}
mat4(const vec3 &from, const vec3 &at, const vec3 &up) {
vec3 r, u, d;
d = (from - at).normal();
r = up.cross(d).normal();
u = d.cross(r);
void translate(const vec3 &offset) {
mat4 m;
m.identity();
m.setPos(offset);
*this = *this * m;
};
this->right = vec4(r, 0.0f);
this->up = vec4(u, 0.0f);
this->dir = vec4(d, 0.0f);
this->offset = vec4(from, 1.0f);
}
void scale(const vec3 &factor) {
mat4 m;
m.identity();
m.e00 = factor.x;
m.e11 = factor.y;
m.e22 = factor.z;
*this = *this * m;
}
void identity() {
e10 = e20 = e30 = e01 = e21 = e31 = e02 = e12 = e32 = e03 = e13 = e23 = 0.0f;
e00 = e11 = e22 = e33 = 1.0f;
}
void rotateX(float angle) {
mat4 m;
m.identity();
float s = sinf(angle), c = cosf(angle);
m.e11 = c; m.e21 = s;
m.e12 = -s; m.e22 = c;
*this = *this * m;
}
mat4 operator * (const mat4 &m) const {
mat4 r;
r.e00 = e00 * m.e00 + e01 * m.e10 + e02 * m.e20 + e03 * m.e30;
r.e10 = e10 * m.e00 + e11 * m.e10 + e12 * m.e20 + e13 * m.e30;
r.e20 = e20 * m.e00 + e21 * m.e10 + e22 * m.e20 + e23 * m.e30;
r.e30 = e30 * m.e00 + e31 * m.e10 + e32 * m.e20 + e33 * m.e30;
r.e01 = e00 * m.e01 + e01 * m.e11 + e02 * m.e21 + e03 * m.e31;
r.e11 = e10 * m.e01 + e11 * m.e11 + e12 * m.e21 + e13 * m.e31;
r.e21 = e20 * m.e01 + e21 * m.e11 + e22 * m.e21 + e23 * m.e31;
r.e31 = e30 * m.e01 + e31 * m.e11 + e32 * m.e21 + e33 * m.e31;
r.e02 = e00 * m.e02 + e01 * m.e12 + e02 * m.e22 + e03 * m.e32;
r.e12 = e10 * m.e02 + e11 * m.e12 + e12 * m.e22 + e13 * m.e32;
r.e22 = e20 * m.e02 + e21 * m.e12 + e22 * m.e22 + e23 * m.e32;
r.e32 = e30 * m.e02 + e31 * m.e12 + e32 * m.e22 + e33 * m.e32;
r.e03 = e00 * m.e03 + e01 * m.e13 + e02 * m.e23 + e03 * m.e33;
r.e13 = e10 * m.e03 + e11 * m.e13 + e12 * m.e23 + e13 * m.e33;
r.e23 = e20 * m.e03 + e21 * m.e13 + e22 * m.e23 + e23 * m.e33;
r.e33 = e30 * m.e03 + e31 * m.e13 + e32 * m.e23 + e33 * m.e33;
return r;
}
void rotateY(float angle) {
mat4 m;
m.identity();
float s = sinf(angle), c = cosf(angle);
m.e00 = c; m.e20 = -s;
m.e02 = s; m.e22 = c;
*this = *this * m;
}
vec3 operator * (const vec3 &v) const {
return vec3(
e00 * v.x + e01 * v.y + e02 * v.z + e03,
e10 * v.x + e11 * v.y + e12 * v.z + e13,
e20 * v.x + e21 * v.y + e22 * v.z + e23);
}
vec4 operator * (const vec4 &v) const {
return vec4(
e00 * v.x + e01 * v.y + e02 * v.z + e03 * v.w,
e10 * v.x + e11 * v.y + e12 * v.z + e13 * v.w,
e20 * v.x + e21 * v.y + e22 * v.z + e23 * v.w,
e30 * v.x + e31 * v.y + e32 * v.z + e33 * v.w);
}
void rotateZ(float angle) {
mat4 m;
m.identity();
float s = sinf(angle), c = cosf(angle);
m.e00 = c; m.e01 = -s;
m.e10 = s; m.e11 = c;
*this = *this * m;
}
void translate(const vec3 &offset) {
mat4 m;
m.identity();
m.setPos(offset);
*this = *this * m;
};
float det() const {
return e00 * (e11 * (e22 * e33 - e32 * e23) - e21 * (e12 * e33 - e32 * e13) + e31 * (e12 * e23 - e22 * e13)) -
e10 * (e01 * (e22 * e33 - e32 * e23) - e21 * (e02 * e33 - e32 * e03) + e31 * (e02 * e23 - e22 * e03)) +
e20 * (e01 * (e12 * e33 - e32 * e13) - e11 * (e02 * e33 - e32 * e03) + e31 * (e02 * e13 - e12 * e03)) -
e30 * (e01 * (e12 * e23 - e22 * e13) - e11 * (e02 * e23 - e22 * e03) + e21 * (e02 * e13 - e12 * e03));
}
void scale(const vec3 &factor) {
mat4 m;
m.identity();
m.e00 = factor.x;
m.e11 = factor.y;
m.e22 = factor.z;
*this = *this * m;
}
mat4 inverse() const {
float idet = 1.0f / det();
mat4 r;
r.e00 = (e11 * (e22 * e33 - e32 * e23) - e21 * (e12 * e33 - e32 * e13) + e31 * (e12 * e23 - e22 * e13)) * idet;
r.e01 = -(e01 * (e22 * e33 - e32 * e23) - e21 * (e02 * e33 - e32 * e03) + e31 * (e02 * e23 - e22 * e03)) * idet;
r.e02 = (e01 * (e12 * e33 - e32 * e13) - e11 * (e02 * e33 - e32 * e03) + e31 * (e02 * e13 - e12 * e03)) * idet;
r.e03 = -(e01 * (e12 * e23 - e22 * e13) - e11 * (e02 * e23 - e22 * e03) + e21 * (e02 * e13 - e12 * e03)) * idet;
r.e10 = -(e10 * (e22 * e33 - e32 * e23) - e20 * (e12 * e33 - e32 * e13) + e30 * (e12 * e23 - e22 * e13)) * idet;
r.e11 = (e00 * (e22 * e33 - e32 * e23) - e20 * (e02 * e33 - e32 * e03) + e30 * (e02 * e23 - e22 * e03)) * idet;
r.e12 = -(e00 * (e12 * e33 - e32 * e13) - e10 * (e02 * e33 - e32 * e03) + e30 * (e02 * e13 - e12 * e03)) * idet;
r.e13 = (e00 * (e12 * e23 - e22 * e13) - e10 * (e02 * e23 - e22 * e03) + e20 * (e02 * e13 - e12 * e03)) * idet;
r.e20 = (e10 * (e21 * e33 - e31 * e23) - e20 * (e11 * e33 - e31 * e13) + e30 * (e11 * e23 - e21 * e13)) * idet;
r.e21 = -(e00 * (e21 * e33 - e31 * e23) - e20 * (e01 * e33 - e31 * e03) + e30 * (e01 * e23 - e21 * e03)) * idet;
r.e22 = (e00 * (e11 * e33 - e31 * e13) - e10 * (e01 * e33 - e31 * e03) + e30 * (e01 * e13 - e11 * e03)) * idet;
r.e23 = -(e00 * (e11 * e23 - e21 * e13) - e10 * (e01 * e23 - e21 * e03) + e20 * (e01 * e13 - e11 * e03)) * idet;
r.e30 = -(e10 * (e21 * e32 - e31 * e22) - e20 * (e11 * e32 - e31 * e12) + e30 * (e11 * e22 - e21 * e12)) * idet;
r.e31 = (e00 * (e21 * e32 - e31 * e22) - e20 * (e01 * e32 - e31 * e02) + e30 * (e01 * e22 - e21 * e02)) * idet;
r.e32 = -(e00 * (e11 * e32 - e31 * e12) - e10 * (e01 * e32 - e31 * e02) + e30 * (e01 * e12 - e11 * e02)) * idet;
r.e33 = (e00 * (e11 * e22 - e21 * e12) - e10 * (e01 * e22 - e21 * e02) + e20 * (e01 * e12 - e11 * e02)) * idet;
return r;
}
void rotateX(float angle) {
mat4 m;
m.identity();
float s = sinf(angle), c = cosf(angle);
m.e11 = c; m.e21 = s;
m.e12 = -s; m.e22 = c;
*this = *this * m;
}
mat4 transpose() const {
mat4 r;
r.e00 = e00; r.e10 = e01; r.e20 = e02; r.e30 = e03;
r.e01 = e10; r.e11 = e11; r.e21 = e12; r.e31 = e13;
r.e02 = e20; r.e12 = e21; r.e22 = e22; r.e32 = e23;
r.e03 = e30; r.e13 = e31; r.e23 = e32; r.e33 = e33;
return r;
}
void rotateY(float angle) {
mat4 m;
m.identity();
float s = sinf(angle), c = cosf(angle);
m.e00 = c; m.e20 = -s;
m.e02 = s; m.e22 = c;
*this = *this * m;
}
quat getRot() const {
float t, s;
t = 1.0f + e00 + e11 + e22;
if (t > EPS) {
s = 0.5f / sqrtf(t);
return quat((e21 - e12) * s, (e02 - e20) * s, (e10 - e01) * s, 0.25f / s);
} else
if (e00 > e11 && e00 > e22) {
s = 0.5f / sqrtf(1.0f + e00 - e11 - e22);
return quat(0.25f / s, (e01 + e10) * s, (e02 + e20) * s, (e21 - e12) * s);
} else
if (e11 > e22) {
s = 0.5f / sqrtf(1.0f - e00 + e11 - e22);
return quat((e01 + e10) * s, 0.25f / s, (e12 + e21) * s, (e02 - e20) * s);
} else {
s = 0.5f / sqrtf(1.0f - e00 - e11 + e22);
return quat((e02 + e20) * s, (e12 + e21) * s, 0.25f / s, (e10 - e01) * s);
}
}
void rotateZ(float angle) {
mat4 m;
m.identity();
float s = sinf(angle), c = cosf(angle);
m.e00 = c; m.e01 = -s;
m.e10 = s; m.e11 = c;
*this = *this * m;
}
void setRot(const quat &rot) {
float sx = rot.x * rot.x,
sy = rot.y * rot.y,
sz = rot.z * rot.z,
sw = rot.w * rot.w,
inv = 1.0f / (sx + sy + sz + sw);
float det() const {
return e00 * (e11 * (e22 * e33 - e32 * e23) - e21 * (e12 * e33 - e32 * e13) + e31 * (e12 * e23 - e22 * e13)) -
e10 * (e01 * (e22 * e33 - e32 * e23) - e21 * (e02 * e33 - e32 * e03) + e31 * (e02 * e23 - e22 * e03)) +
e20 * (e01 * (e12 * e33 - e32 * e13) - e11 * (e02 * e33 - e32 * e03) + e31 * (e02 * e13 - e12 * e03)) -
e30 * (e01 * (e12 * e23 - e22 * e13) - e11 * (e02 * e23 - e22 * e03) + e21 * (e02 * e13 - e12 * e03));
}
e00 = ( sx - sy - sz + sw) * inv;
e11 = (-sx + sy - sz + sw) * inv;
e22 = (-sx - sy + sz + sw) * inv;
inv *= 2.0f;
mat4 inverse() const {
float idet = 1.0f / det();
mat4 r;
r.e00 = (e11 * (e22 * e33 - e32 * e23) - e21 * (e12 * e33 - e32 * e13) + e31 * (e12 * e23 - e22 * e13)) * idet;
r.e01 = -(e01 * (e22 * e33 - e32 * e23) - e21 * (e02 * e33 - e32 * e03) + e31 * (e02 * e23 - e22 * e03)) * idet;
r.e02 = (e01 * (e12 * e33 - e32 * e13) - e11 * (e02 * e33 - e32 * e03) + e31 * (e02 * e13 - e12 * e03)) * idet;
r.e03 = -(e01 * (e12 * e23 - e22 * e13) - e11 * (e02 * e23 - e22 * e03) + e21 * (e02 * e13 - e12 * e03)) * idet;
r.e10 = -(e10 * (e22 * e33 - e32 * e23) - e20 * (e12 * e33 - e32 * e13) + e30 * (e12 * e23 - e22 * e13)) * idet;
r.e11 = (e00 * (e22 * e33 - e32 * e23) - e20 * (e02 * e33 - e32 * e03) + e30 * (e02 * e23 - e22 * e03)) * idet;
r.e12 = -(e00 * (e12 * e33 - e32 * e13) - e10 * (e02 * e33 - e32 * e03) + e30 * (e02 * e13 - e12 * e03)) * idet;
r.e13 = (e00 * (e12 * e23 - e22 * e13) - e10 * (e02 * e23 - e22 * e03) + e20 * (e02 * e13 - e12 * e03)) * idet;
r.e20 = (e10 * (e21 * e33 - e31 * e23) - e20 * (e11 * e33 - e31 * e13) + e30 * (e11 * e23 - e21 * e13)) * idet;
r.e21 = -(e00 * (e21 * e33 - e31 * e23) - e20 * (e01 * e33 - e31 * e03) + e30 * (e01 * e23 - e21 * e03)) * idet;
r.e22 = (e00 * (e11 * e33 - e31 * e13) - e10 * (e01 * e33 - e31 * e03) + e30 * (e01 * e13 - e11 * e03)) * idet;
r.e23 = -(e00 * (e11 * e23 - e21 * e13) - e10 * (e01 * e23 - e21 * e03) + e20 * (e01 * e13 - e11 * e03)) * idet;
r.e30 = -(e10 * (e21 * e32 - e31 * e22) - e20 * (e11 * e32 - e31 * e12) + e30 * (e11 * e22 - e21 * e12)) * idet;
r.e31 = (e00 * (e21 * e32 - e31 * e22) - e20 * (e01 * e32 - e31 * e02) + e30 * (e01 * e22 - e21 * e02)) * idet;
r.e32 = -(e00 * (e11 * e32 - e31 * e12) - e10 * (e01 * e32 - e31 * e02) + e30 * (e01 * e12 - e11 * e02)) * idet;
r.e33 = (e00 * (e11 * e22 - e21 * e12) - e10 * (e01 * e22 - e21 * e02) + e20 * (e01 * e12 - e11 * e02)) * idet;
return r;
}
float t1 = rot.x * rot.y;
float t2 = rot.z * rot.w;
e10 = (t1 + t2) * inv;
e01 = (t1 - t2) * inv;
mat4 transpose() const {
mat4 r;
r.e00 = e00; r.e10 = e01; r.e20 = e02; r.e30 = e03;
r.e01 = e10; r.e11 = e11; r.e21 = e12; r.e31 = e13;
r.e02 = e20; r.e12 = e21; r.e22 = e22; r.e32 = e23;
r.e03 = e30; r.e13 = e31; r.e23 = e32; r.e33 = e33;
return r;
}
t1 = rot.x * rot.z;
t2 = rot.y * rot.w;
e20 = (t1 - t2) * inv;
e02 = (t1 + t2) * inv;
quat getRot() const {
float t, s;
t = 1.0f + e00 + e11 + e22;
if (t > EPS) {
s = 0.5f / sqrtf(t);
return quat((e21 - e12) * s, (e02 - e20) * s, (e10 - e01) * s, 0.25f / s);
} else
if (e00 > e11 && e00 > e22) {
s = 0.5f / sqrtf(1.0f + e00 - e11 - e22);
return quat(0.25f / s, (e01 + e10) * s, (e02 + e20) * s, (e21 - e12) * s);
} else
if (e11 > e22) {
s = 0.5f / sqrtf(1.0f - e00 + e11 - e22);
return quat((e01 + e10) * s, 0.25f / s, (e12 + e21) * s, (e02 - e20) * s);
} else {
s = 0.5f / sqrtf(1.0f - e00 - e11 + e22);
return quat((e02 + e20) * s, (e12 + e21) * s, 0.25f / s, (e10 - e01) * s);
}
}
t1 = rot.y * rot.z;
t2 = rot.x * rot.w;
e21 = (t1 + t2) * inv;
e12 = (t1 - t2) * inv;
}
void setRot(const quat &rot) {
float sx = rot.x * rot.x,
sy = rot.y * rot.y,
sz = rot.z * rot.z,
sw = rot.w * rot.w,
inv = 1.0f / (sx + sy + sz + sw);
vec3 getPos() const {
return offset.xyz;
}
e00 = ( sx - sy - sz + sw) * inv;
e11 = (-sx + sy - sz + sw) * inv;
e22 = (-sx - sy + sz + sw) * inv;
inv *= 2.0f;
void setPos(const vec3 &pos) {
offset.xyz = pos;
}
float t1 = rot.x * rot.y;
float t2 = rot.z * rot.w;
e10 = (t1 + t2) * inv;
e01 = (t1 - t2) * inv;
t1 = rot.x * rot.z;
t2 = rot.y * rot.w;
e20 = (t1 - t2) * inv;
e02 = (t1 + t2) * inv;
t1 = rot.y * rot.z;
t2 = rot.x * rot.w;
e21 = (t1 + t2) * inv;
e12 = (t1 - t2) * inv;
}
vec3 getPos() const {
return offset.xyz;
}
void setPos(const vec3 &pos) {
offset.xyz = pos;
}
};
struct Stream {
FILE *f;
int size, pos;
FILE *f;
int size, pos;
Stream(const char *name) : pos(0) {
f = fopen(name, "rb");
Stream(const char *name) : pos(0) {
f = fopen(name, "rb");
if (!f) LOG("error loading file\n");
fseek(f, 0, SEEK_END);
size = ftell(f);
fseek(f, 0, SEEK_SET);
}
fseek(f, 0, SEEK_END);
size = ftell(f);
fseek(f, 0, SEEK_SET);
}
~Stream() {
fclose(f);
}
~Stream() {
fclose(f);
}
void setPos(int pos) {
this->pos = pos;
fseek(f, pos, SEEK_SET);
}
void setPos(int pos) {
this->pos = pos;
fseek(f, pos, SEEK_SET);
}
void seek(int offset) {
fseek(f, offset, SEEK_CUR);
pos += offset;
}
void seek(int offset) {
fseek(f, offset, SEEK_CUR);
pos += offset;
}
int raw(void *data, int size) {
pos += size;
return fread(data, 1, size, f);
}
int raw(void *data, int size) {
pos += size;
return fread(data, 1, size, f);
}
template <typename T>
T& read(T &x) {
raw(&x, sizeof(x));
return x;
}
template <typename T>
T& read(T &x) {
raw(&x, sizeof(x));
return x;
}
template <typename T>
T* read(T *&a, int count) {
if (count) {
a = new T[count];
raw(a, count * sizeof(T));
} else
a = NULL;
return a;
}
template <typename T>
T* read(T *&a, int count) {
if (count) {
a = new T[count];
raw(a, count * sizeof(T));
} else
a = NULL;
return a;
}
};
#endif