i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

* Fix many style issues. Quaternion and Vector3 still show some of their foreign

Browse Source 
origin. Yes.. shame on me, i had even imported their non unix line endings :)
  Will make them BCitizens soon.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33890 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Alexandre Deckner
2009-11-05 09:37:45 +00:00
parent ae762f316d
commit 3904801c31
10 changed files with 877 additions and 833 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/apps/haiku3d/MathUtils.cpp
+24 -20
View File
@@ -15,43 +15,47 @@
float float
MathUtils::EaseInOutCubic(float t /*time*/, float b /*begin*/, float c /*distance*/, float d /*duration*/) MathUtils::EaseInOutCubic(float time, float start, float distance,
float duration)
{ {
t /= d / 2.0; time /= duration / 2.0;
if (t < 1.0) if (time < 1.0)
return c / 2.0 * t * t * t + b; return distance / 2.0 * time * time * time + start;
t -= 2.0; time -= 2.0;
return c / 2.0 * (t * t * t + 2.0) + b; return distance / 2.0 * (time * time * time + 2.0) + start;
} }
float float
MathUtils::EaseInOutQuart(float t /*time*/, float b /*begin*/, float c /*distance*/, float d /*duration*/) MathUtils::EaseInOutQuart(float time, float start, float distance,
float duration)
{ {
t /= d / 2; time /= duration / 2;
if (t < 1) if (time < 1)
return c / 2 * t * t * t * t + b; return distance / 2 * time * time * time * time + start;
t -= 2; time -= 2;
return -c / 2 * (t * t * t * t - 2) + b; return -distance / 2 * (time * time * time * time - 2) + start;
} }
float float
MathUtils::EaseInOutQuint(float t /*time*/, float b /*begin*/, float c /*distance*/, float d /*duration*/) MathUtils::EaseInOutQuint(float time, float start, float distance,
float duration)
{ {
t /= d / 2; time /= duration / 2;
if (t < 1) if (time < 1)
return c / 2 * t * t * t * t * t + b; return distance / 2 * time * time * time * time * time + start;
t -= 2; time -= 2;
return c / 2 *(t * t * t * t * t + 2) + b; return distance / 2 *(time * time * time * time * time + 2) + start;
} }
float float
MathUtils::EaseInOutSine(float t /*time*/, float b /*begin*/, float c /*distance*/, float d /*duration*/) MathUtils::EaseInOutSine(float time, float start, float distance,
float duration)
{ {
return -c / 2 * (cos(3.14159 * t / d) - 1) + b; return -distance / 2 * (cos(3.14159 * time / distance) - 1) + start;
} }
src/apps/haiku3d/MathUtils.h
+10 -6
View File
@@ -1,4 +1,4 @@
/* /*
* Copyright 2009, Haiku Inc. All rights reserved. * Copyright 2009, Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License. * Distributed under the terms of the MIT License.
* *
@@ -11,11 +11,15 @@
class MathUtils class MathUtils
{ {
public: public:
static float EaseInOutCubic(float time, float begin, float distance, float duration); static float EaseInOutCubic(float time, float begin, float distance,
static float EaseInOutQuart(float time, float begin, float distance, float duration); float duration);
static float EaseInOutQuint(float time, float begin, float distance, float duration); static float EaseInOutQuart(float time, float begin, float distance,
static float EaseInOutSine(float time, float begin, float distance, float duration); float duration);
static float EaseInOutQuint(float time, float begin, float distance,
float duration);
static float EaseInOutSine(float time, float begin, float distance,
float duration);
}; };
#endif /* _MATH_UTILS_H */ #endif /* _MATH_UTILS_H */
src/apps/haiku3d/MeshInstance.cpp
+3 -7
View File
@@ -76,9 +76,8 @@ MeshInstance::Render()
glBindTexture(GL_TEXTURE_2D, fTextureReference->Id()); glBindTexture(GL_TEXTURE_2D, fTextureReference->Id());
int lastVertexCount = 0; int lastVertexCount = 0;
//int batchCount = 0;
for(uint32 i = 0; i < fMeshReference->FaceCount(); i++) { for (uint32 i = 0; i < fMeshReference->FaceCount(); i++) {
const Face& face = fMeshReference->GetFace(i); const Face& face = fMeshReference->GetFace(i);
@@ -91,8 +90,6 @@ MeshInstance::Render()
glBegin(GL_TRIANGLES); glBegin(GL_TRIANGLES);
else else
glBegin(GL_QUADS); glBegin(GL_QUADS);
//batchCount++;
} }
// calculate normal // calculate normal
@@ -144,11 +141,10 @@ MeshInstance::Render()
lastVertexCount = face.vertexCount; lastVertexCount = face.vertexCount;
} }
glEnd(); glEnd();
//printf("batchCount %d\n", batchCount);
if (fDrawNormals) { if (fDrawNormals) {
glBegin(GL_LINES); glBegin(GL_LINES);
for(uint32 i = 0; i < fMeshReference->FaceCount(); i++) { for (uint32 i = 0; i < fMeshReference->FaceCount(); i++) {
const Face& face = fMeshReference->GetFace(i); const Face& face = fMeshReference->GetFace(i);
@@ -174,7 +170,7 @@ MeshInstance::Render()
glVertex3f(g.x(), g.y(), g.z()); glVertex3f(g.x(), g.y(), g.z());
glVertex3f(h.x(), h.y(), h.z()); glVertex3f(h.x(), h.y(), h.z());
} }
} }
glEnd(); glEnd();
} }
src/apps/haiku3d/Quaternion.h
+416 -407
View File
@@ -1,407 +1,416 @@
/* /*
* Copyright 2008 Haiku Inc. All rights reserved. * Copyright 2008 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License. * Distributed under the terms of the MIT License.
* *
* Authors: * Authors:
* Alexandre Deckner * Alexandre Deckner
* *
*/ */
/* /*
* *
* This is a refactored and stripped down version of bullet-2.66 src\LinearMath\btQuaternion.h * This is a refactored and stripped down version of
* The dependancies on base class btQuadWord have been removed for simplification. * bullet-2.66 src\LinearMath\btQuaternion.h
* Added gl matrix conversion method. * The dependancies on base class btQuadWord have been removed for
* * simplification.
*/ * Added gl matrix conversion method.
*
/* */
Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans http://continuousphysics.com/Bullet/
/*
This software is provided 'as-is', without any express or implied warranty. Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans
In no event will the authors be held liable for any damages arising from the use of this software. http://continuousphysics.com/Bullet/
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely, This software is provided 'as-is', without any express or implied warranty.
subject to the following restrictions: In no event will the authors be held liable for any damages arising from the
use of this software.
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. Permission is granted to anyone to use this software for any purpose,
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. including commercial applications, and to alter it and redistribute it freely,
3. This notice may not be removed or altered from any source distribution. subject to the following restrictions:
*/
#ifndef __QUATERNION_H__ 1. The origin of this software must not be misrepresented; you must not claim
#define __QUATERNION_H__ that you wrote the original software. If you use this software in a product,
an acknowledgment in the product documentation would be appreciated but is
#include "Vector3.h" not required.
#include <SupportDefs.h> //pout FLT_EPSILON 2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
class Quaternion { 3. This notice may not be removed or altered from any source distribution.
protected: */
float m_x; #ifndef __QUATERNION_H__
float m_y; #define __QUATERNION_H__
float m_z;
float m_w; #include "Vector3.h"
public: #include <SupportDefs.h>
Quaternion() {}
class Quaternion {
Quaternion(const Quaternion& q) protected:
{ float m_x;
*((Quaternion*)this) = q; float m_y;
} float m_z;
float m_w;
Quaternion(const float& x, const float& y, const float& z,const float& w) public:
{ Quaternion() {}
m_x = x, m_y = y, m_z = z, m_w = w;
} Quaternion(const Quaternion& q)
{
Quaternion(const Vector3& axis, const float& angle) *((Quaternion*)this) = q;
{ }
setRotation(axis, angle);
} Quaternion(const float& x, const float& y, const float& z, const float& w)
{
Quaternion(const float& yaw, const float& pitch, const float& roll) m_x = x, m_y = y, m_z = z, m_w = w;
{ }
setEuler(yaw, pitch, roll);
} Quaternion(const Vector3& axis, const float& angle)
{
inline const float& x() const { return m_x; } setRotation(axis, angle);
}
inline const float& y() const { return m_y; } Quaternion(const float& yaw, const float& pitch, const float& roll)
{
setEuler(yaw, pitch, roll);
inline const float& z() const { return m_z; } }
inline const float& x() const { return m_x; }
inline const float& w() const { return m_w; }
inline const float& y() const { return m_y; }
void setValue(const float& x, const float& y, const float& z)
{
m_x=x; inline const float& z() const { return m_z; }
m_y=y;
m_z=z;
m_w = 0.f; inline const float& w() const { return m_w; }
}
void setValue(const float& x, const float& y, const float& z)
void setValue(const float& x, const float& y, const float& z,const float& w) {
{ m_x = x;
m_x=x; m_y = y;
m_y=y; m_z = z;
m_z=z; m_w = 0.f;
m_w=w; }
}
void setValue(const float& x, const float& y, const float& z, const float& w)
void setRotation(const Vector3& axis, const float& angle) {
{ m_x = x;
float d = axis.length(); m_y = y;
assert(d != 0.0f); m_z = z;
float s = sin(angle * 0.5f) / d; m_w = w;
setValue(axis.x() * s, axis.y() * s, axis.z() * s, }
cos(angle * 0.5f));
}
void setRotation(const Vector3& axis, const float& angle)
{
void setEuler(const float& yaw, const float& pitch, const float& roll) float d = axis.length();
{ assert(d != 0.0f);
float halfYaw = yaw * 0.5f; float s = sin(angle * 0.5f) / d;
float halfPitch = pitch * 0.5f; setValue(axis.x() * s, axis.y() * s, axis.z() * s,
float halfRoll = roll * 0.5f; cos(angle * 0.5f));
float cosYaw = cos(halfYaw); }
float sinYaw = sin(halfYaw);
float cosPitch = cos(halfPitch);
float sinPitch = sin(halfPitch); void setEuler(const float& yaw, const float& pitch, const float& roll)
float cosRoll = cos(halfRoll); {
float sinRoll = sin(halfRoll); float halfYaw = yaw * 0.5f;
setValue(cosRoll * sinPitch * cosYaw + sinRoll * cosPitch * sinYaw, float halfPitch = pitch * 0.5f;
cosRoll * cosPitch * sinYaw - sinRoll * sinPitch * cosYaw, float halfRoll = roll * 0.5f;
sinRoll * cosPitch * cosYaw - cosRoll * sinPitch * sinYaw, float cosYaw = cos(halfYaw);
cosRoll * cosPitch * cosYaw + sinRoll * sinPitch * sinYaw); float sinYaw = sin(halfYaw);
} float cosPitch = cos(halfPitch);
float sinPitch = sin(halfPitch);
float cosRoll = cos(halfRoll);
Quaternion& operator+=(const Quaternion& q) float sinRoll = sin(halfRoll);
{ setValue(cosRoll * sinPitch * cosYaw + sinRoll * cosPitch * sinYaw,
m_x += q.x(); m_y += q.y(); m_z += q.z(); m_w += q.m_w; cosRoll * cosPitch * sinYaw - sinRoll * sinPitch * cosYaw,
return *this; sinRoll * cosPitch * cosYaw - cosRoll * sinPitch * sinYaw,
} cosRoll * cosPitch * cosYaw + sinRoll * sinPitch * sinYaw);
}
Quaternion& operator-=(const Quaternion& q)
{ Quaternion& operator+=(const Quaternion& q)
m_x -= q.x(); m_y -= q.y(); m_z -= q.z(); m_w -= q.m_w; {
return *this; m_x += q.x(); m_y += q.y(); m_z += q.z(); m_w += q.m_w;
} return *this;
}
Quaternion& operator*=(const float& s)
{ Quaternion& operator-=(const Quaternion& q)
m_x *= s; m_y *= s; m_z *= s; m_w *= s; {
return *this; m_x -= q.x(); m_y -= q.y(); m_z -= q.z(); m_w -= q.m_w;
} return *this;
}
Quaternion& operator*=(const Quaternion& q)
{ Quaternion& operator*=(const float& s)
setValue(m_w * q.x() + m_x * q.m_w + m_y * q.z() - m_z * q.y(), {
m_w * q.y() + m_y * q.m_w + m_z * q.x() - m_x * q.z(), m_x *= s; m_y *= s; m_z *= s; m_w *= s;
m_w * q.z() + m_z * q.m_w + m_x * q.y() - m_y * q.x(), return *this;
m_w * q.m_w - m_x * q.x() - m_y * q.y() - m_z * q.z()); }
return *this;
}
Quaternion& operator*=(const Quaternion& q)
{
float dot(const Quaternion& q) const setValue(m_w * q.x() + m_x * q.m_w + m_y * q.z() - m_z * q.y(),
{ m_w * q.y() + m_y * q.m_w + m_z * q.x() - m_x * q.z(),
return m_x * q.x() + m_y * q.y() + m_z * q.z() + m_w * q.m_w; m_w * q.z() + m_z * q.m_w + m_x * q.y() - m_y * q.x(),
} m_w * q.m_w - m_x * q.x() - m_y * q.y() - m_z * q.z());
return *this;
}
float length2() const
{
return dot(*this); float dot(const Quaternion& q) const
} {
return m_x * q.x() + m_y * q.y() + m_z * q.z() + m_w * q.m_w;
}
float length() const
{
return sqrt(length2()); float length2() const
} {
return dot(*this);
}
Quaternion& normalize()
{
return *this /= length(); float length() const
} {
return sqrt(length2());
}
inline Quaternion
operator*(const float& s) const
{ Quaternion& normalize()
return Quaternion(x() * s, y() * s, z() * s, m_w * s); {
} return *this /= length();
}
Quaternion operator/(const float& s) const
{ inline Quaternion
assert(s != 0.0f); operator*(const float& s) const
return *this * (1.0f / s); {
} return Quaternion(x() * s, y() * s, z() * s, m_w * s);
}
Quaternion& operator/=(const float& s)
{ Quaternion operator/(const float& s) const
assert(s != 0.0f); {
return *this *= 1.0f / s; assert(s != 0.0f);
} return *this * (1.0f / s);
}
Quaternion normalized() const
{ Quaternion& operator/=(const float& s)
return *this / length(); {
} assert(s != 0.0f);
return *this *= 1.0f / s;
}
float angle(const Quaternion& q) const
{
float s = sqrt(length2() * q.length2()); Quaternion normalized() const
assert(s != 0.0f); {
return acos(dot(q) / s); return *this / length();
} }
float getAngle() const float angle(const Quaternion& q) const
{ {
float s = 2.0f * acos(m_w); float s = sqrt(length2() * q.length2());
return s; assert(s != 0.0f);
} return acos(dot(q) / s);
}
Quaternion inverse() const
{ float getAngle() const
return Quaternion(m_x, m_y, m_z, -m_w); {
} float s = 2.0f * acos(m_w);
return s;
}
inline Quaternion
operator+(const Quaternion& q2) const
{ Quaternion inverse() const
const Quaternion& q1 = *this; {
return Quaternion(q1.x() + q2.x(), q1.y() + q2.y(), q1.z() + q2.z(), q1.m_w + q2.m_w); return Quaternion(m_x, m_y, m_z, -m_w);
} }
inline Quaternion inline Quaternion
operator-(const Quaternion& q2) const operator+(const Quaternion& q2) const
{ {
const Quaternion& q1 = *this; const Quaternion& q1 = *this;
return Quaternion(q1.x() - q2.x(), q1.y() - q2.y(), q1.z() - q2.z(), q1.m_w - q2.m_w); return Quaternion(q1.x() + q2.x(), q1.y() + q2.y(), q1.z() + q2.z(),
} q1.m_w + q2.m_w);
}
inline Quaternion operator-() const
{ inline Quaternion
const Quaternion& q2 = *this; operator-(const Quaternion& q2) const
return Quaternion( - q2.x(), - q2.y(), - q2.z(), - q2.m_w); {
} const Quaternion& q1 = *this;
return Quaternion(q1.x() - q2.x(), q1.y() - q2.y(), q1.z() - q2.z(),
q1.m_w - q2.m_w);
inline Quaternion farthest( const Quaternion& qd) const }
{
Quaternion diff,sum;
diff = *this - qd; inline Quaternion operator-() const
sum = *this + qd; {
if( diff.dot(diff) > sum.dot(sum) ) const Quaternion& q2 = *this;
return qd; return Quaternion( - q2.x(), - q2.y(), - q2.z(), - q2.m_w);
return (-qd); }
}
inline Quaternion farthest( const Quaternion& qd) const
Quaternion slerp(const Quaternion& q, const float& t) const {
{ Quaternion diff, sum;
float theta = angle(q); diff = *this - qd;
if (theta != 0.0f) sum = *this + qd;
{ if (diff.dot(diff) > sum.dot(sum))
float d = 1.0f / sin(theta); return qd;
float s0 = sin((1.0f - t) * theta); return (-qd);
float s1 = sin(t * theta); }
return Quaternion((m_x * s0 + q.x() * s1) * d,
(m_y * s0 + q.y() * s1) * d,
(m_z * s0 + q.z() * s1) * d, Quaternion slerp(const Quaternion& q, const float& t) const
(m_w * s0 + q.m_w * s1) * d); {
} float theta = angle(q);
else if (theta != 0.0f) {
{ float d = 1.0f / sin(theta);
return *this; float s0 = sin((1.0f - t) * theta);
} float s1 = sin(t * theta);
} return Quaternion((m_x * s0 + q.x() * s1) * d,
(m_y * s0 + q.y() * s1) * d,
(m_z * s0 + q.z() * s1) * d,
void toOpenGLMatrix(float m[4][4]){ (m_w * s0 + q.m_w * s1) * d);
} else {
float wx, wy, wz, xx, yy, yz, xy, xz, zz, x2, y2, z2; return *this;
}
// calculate coefficients }
x2 = m_x + m_x; y2 = m_y + m_y;
z2 = m_z + m_z;
xx = m_x * x2; xy = m_x * y2; xz = m_x * z2; void toOpenGLMatrix(float m[4][4])
yy = m_y * y2; yz = m_y * z2; zz = m_z * z2; {
wx = m_w * x2; wy = m_w * y2; wz = m_w * z2; float wx, wy, wz, xx, yy, yz, xy, xz, zz, x2, y2, z2;
// calculate coefficients
m[0][0] = 1.0 - (yy + zz); m[1][0] = xy - wz; x2 = m_x + m_x; y2 = m_y + m_y;
m[2][0] = xz + wy; m[3][0] = 0.0; z2 = m_z + m_z;
xx = m_x * x2; xy = m_x * y2; xz = m_x * z2;
m[0][1] = xy + wz; m[1][1] = 1.0 - (xx + zz); yy = m_y * y2; yz = m_y * z2; zz = m_z * z2;
m[2][1] = yz - wx; m[3][1] = 0.0; wx = m_w * x2; wy = m_w * y2; wz = m_w * z2;
m[0][2] = xz - wy; m[1][2] = yz + wx; m[0][0] = 1.0 - (yy + zz); m[1][0] = xy - wz;
m[2][2] = 1.0 - (xx + yy); m[3][2] = 0.0; m[2][0] = xz + wy; m[3][0] = 0.0;
m[0][1] = xy + wz; m[1][1] = 1.0 - (xx + zz);
m[0][3] = 0; m[1][3] = 0; m[2][1] = yz - wx; m[3][1] = 0.0;
m[2][3] = 0; m[3][3] = 1;
}
}; m[0][2] = xz - wy; m[1][2] = yz + wx;
m[2][2] = 1.0 - (xx + yy); m[3][2] = 0.0;
inline Quaternion
operator-(const Quaternion& q) m[0][3] = 0; m[1][3] = 0;
{ m[2][3] = 0; m[3][3] = 1;
return Quaternion(-q.x(), -q.y(), -q.z(), -q.w()); }
} };
inline Quaternion inline Quaternion
operator*(const Quaternion& q1, const Quaternion& q2) { operator-(const Quaternion& q)
return Quaternion(q1.w() * q2.x() + q1.x() * q2.w() + q1.y() * q2.z() - q1.z() * q2.y(), {
q1.w() * q2.y() + q1.y() * q2.w() + q1.z() * q2.x() - q1.x() * q2.z(), return Quaternion(-q.x(), -q.y(), -q.z(), -q.w());
q1.w() * q2.z() + q1.z() * q2.w() + q1.x() * q2.y() - q1.y() * q2.x(), }
q1.w() * q2.w() - q1.x() * q2.x() - q1.y() * q2.y() - q1.z() * q2.z());
}
inline Quaternion
operator*(const Quaternion& q1, const Quaternion& q2) {
inline Quaternion return Quaternion(
operator*(const Quaternion& q, const Vector3& w) q1.w() * q2.x() + q1.x() * q2.w() + q1.y() * q2.z() - q1.z() * q2.y(),
{ q1.w() * q2.y() + q1.y() * q2.w() + q1.z() * q2.x() - q1.x() * q2.z(),
return Quaternion( q.w() * w.x() + q.y() * w.z() - q.z() * w.y(), q1.w() * q2.z() + q1.z() * q2.w() + q1.x() * q2.y() - q1.y() * q2.x(),
q.w() * w.y() + q.z() * w.x() - q.x() * w.z(), q1.w() * q2.w() - q1.x() * q2.x() - q1.y() * q2.y() - q1.z() * q2.z());
q.w() * w.z() + q.x() * w.y() - q.y() * w.x(), }
-q.x() * w.x() - q.y() * w.y() - q.z() * w.z());
}
inline Quaternion
operator*(const Quaternion& q, const Vector3& w)
inline Quaternion {
operator*(const Vector3& w, const Quaternion& q) return Quaternion( q.w() * w.x() + q.y() * w.z() - q.z() * w.y(),
{ q.w() * w.y() + q.z() * w.x() - q.x() * w.z(),
return Quaternion( w.x() * q.w() + w.y() * q.z() - w.z() * q.y(), q.w() * w.z() + q.x() * w.y() - q.y() * w.x(),
w.y() * q.w() + w.z() * q.x() - w.x() * q.z(), -q.x() * w.x() - q.y() * w.y() - q.z() * w.z());
w.z() * q.w() + w.x() * q.y() - w.y() * q.x(), }
-w.x() * q.x() - w.y() * q.y() - w.z() * q.z());
}
inline Quaternion
operator*(const Vector3& w, const Quaternion& q)
inline float {
dot(const Quaternion& q1, const Quaternion& q2) return Quaternion( w.x() * q.w() + w.y() * q.z() - w.z() * q.y(),
{ w.y() * q.w() + w.z() * q.x() - w.x() * q.z(),
return q1.dot(q2); w.z() * q.w() + w.x() * q.y() - w.y() * q.x(),
} -w.x() * q.x() - w.y() * q.y() - w.z() * q.z());
}
inline float
length(const Quaternion& q) inline float
{ dot(const Quaternion& q1, const Quaternion& q2)
return q.length(); {
} return q1.dot(q2);
}
inline float
angle(const Quaternion& q1, const Quaternion& q2) inline float
{ length(const Quaternion& q)
return q1.angle(q2); {
} return q.length();
}
inline Quaternion
inverse(const Quaternion& q) inline float
{ angle(const Quaternion& q1, const Quaternion& q2)
return q.inverse(); {
} return q1.angle(q2);
}
inline Quaternion
slerp(const Quaternion& q1, const Quaternion& q2, const float& t) inline Quaternion
{ inverse(const Quaternion& q)
return q1.slerp(q2, t); {
} return q.inverse();
}
inline Quaternion
shortestArcQuat(const Vector3& v0, const Vector3& v1) // Game Programming Gems 2.10. make sure v0,v1 are normalized inline Quaternion
{ slerp(const Quaternion& q1, const Quaternion& q2, const float& t)
Vector3 c = v0.cross(v1); {
float d = v0.dot(v1); return q1.slerp(q2, t);
}
if (d < -1.0 + FLT_EPSILON)
return Quaternion(0.0f, 1.0f, 0.0f, 0.0f); // just pick any vector
// Game Programming Gems 2.10. make sure v0,v1 are normalized
float s = sqrt((1.0f + d) * 2.0f); inline Quaternion
float rs = 1.0f / s; shortestArcQuat(const Vector3& v0, const Vector3& v1)
{
return Quaternion(c.x() * rs, c.y() * rs, c.z() * rs, s * 0.5f); Vector3 c = v0.cross(v1);
} float d = v0.dot(v1);
if (d < -1.0 + FLT_EPSILON)
inline Quaternion return Quaternion(0.0f, 1.0f, 0.0f, 0.0f); // just pick any vector
shortestArcQuatNormalize2(Vector3& v0, Vector3& v1)
{ float s = sqrt((1.0f + d) * 2.0f);
v0.normalize(); float rs = 1.0f / s;
v1.normalize();
return shortestArcQuat(v0, v1); return Quaternion(c.x() * rs, c.y() * rs, c.z() * rs, s * 0.5f);
} }
#endif
inline Quaternion
shortestArcQuatNormalize2(Vector3& v0, Vector3& v1)
{
v0.normalize();
v1.normalize();
return shortestArcQuat(v0, v1);
}
#endif
src/apps/haiku3d/RenderView.cpp
+2 -2
View File
@@ -186,7 +186,7 @@ void
RenderView::_DeleteScene() RenderView::_DeleteScene()
{ {
MeshInstanceList::iterator it = fMeshInstances.begin(); MeshInstanceList::iterator it = fMeshInstances.begin();
for(; it != fMeshInstances.end(); it++) { for (; it != fMeshInstances.end(); it++) {
delete (*it); delete (*it);
} }
fMeshInstances.clear(); fMeshInstances.clear();
@@ -231,7 +231,7 @@ RenderView::_Render()
fLastFrameTime = time; fLastFrameTime = time;
MeshInstanceList::iterator it = fMeshInstances.begin(); MeshInstanceList::iterator it = fMeshInstances.begin();
for(; it != fMeshInstances.end(); it++) { for (; it != fMeshInstances.end(); it++) {
(*it)->Update(deltaTime); (*it)->Update(deltaTime);
(*it)->Render(); (*it)->Render();
} }
src/apps/haiku3d/Texture.h
+1 -1
View File
@@ -18,7 +18,7 @@ public:
Texture(); Texture();
virtual ~Texture(); virtual ~Texture();
GLuint Id(); GLuint Id();
virtual void Update(float dt); virtual void Update(float dt);
src/apps/haiku3d/Vector3.h
+384 -353
View File
@@ -1,353 +1,384 @@
/* /*
* Copyright 2008 Haiku Inc. All rights reserved. * Copyright 2008 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License. * Distributed under the terms of the MIT License.
* *
* Authors: * Authors:
* Alexandre Deckner * Alexandre Deckner
* *
*/ */
/* /*
* *
* This is a refactored and stripped down version of bullet-2.66 src\LinearMath\btVector3.h * This is a refactored and stripped down version of bullet-2.66
* The dependancies on base class btQuadWord have been removed for simplification. * src\LinearMath\btVector3.h
* * The dependancies on base class btQuadWord have been removed for
*/ * simplification.
*
/* */
Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans http://continuousphysics.com/Bullet/
/*
This software is provided 'as-is', without any express or implied warranty. Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans
In no event will the authors be held liable for any damages arising from the use of this software. http://continuousphysics.com/Bullet/
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely, This software is provided 'as-is', without any express or implied warranty.
subject to the following restrictions: In no event will the authors be held liable for any damages arising from the
use of this software.
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. Permission is granted to anyone to use this software for any purpose,
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. including commercial applications, and to alter it and redistribute it freely,
3. This notice may not be removed or altered from any source distribution. subject to the following restrictions:
*/
1. The origin of this software must not be misrepresented; you must not claim
that you wrote the original software. If you use this software in a product,
#ifndef __VECTOR3_H__ an acknowledgment in the product documentation would be appreciated but is
#define __VECTOR3_H__ not required.
2. Altered source versions must be plainly marked as such, and must not be
#include "assert.h" misrepresented as being the original software.
#include "math.h" 3. This notice may not be removed or altered from any source distribution.
*/
///Vector3 can be used to represent 3D points and vectors.
class Vector3 { #ifndef __VECTOR3_H__
protected: #define __VECTOR3_H__
float m_x;
float m_y; #include "assert.h"
float m_z; #include "math.h"
public: ///Vector3 can be used to represent 3D points and vectors.
inline Vector3() {}
class Vector3 {
protected:
inline Vector3(const Vector3& v) float m_x;
{ float m_y;
*((Vector3*)this) = v; float m_z;
}
public:
inline Vector3() {}
inline Vector3(const float& x, const float& y, const float& z)
{
m_x = x, m_y = y, m_z = z; inline Vector3(const Vector3& v)
} {
*((Vector3*)this) = v;
}
inline const float& x() const { return m_x; }
inline Vector3(const float& x, const float& y, const float& z)
inline const float& y() const { return m_y; } {
m_x = x, m_y = y, m_z = z;
}
inline const float& z() const { return m_z; }
inline const float& x() const { return m_x; }
inline void setValue(const float& x, const float& y, const float& z)
{
m_x=x; inline const float& y() const { return m_y; }
m_y=y;
m_z=z;
} inline const float& z() const { return m_z; }
inline Vector3& operator+=(const Vector3& v)
{ inline void setValue(const float& x, const float& y, const float& z)
m_x += v.x(); m_y += v.y(); m_z += v.z(); {
return *this; m_x = x;
} m_y = y;
m_z = z;
}
inline Vector3& operator-=(const Vector3& v)
{ inline Vector3& operator+=(const Vector3& v)
m_x -= v.x(); m_y -= v.y(); m_z -= v.z(); {
return *this; m_x += v.x(); m_y += v.y(); m_z += v.z();
} return *this;
}
inline Vector3& operator*=(const float& s)
{ inline Vector3& operator-=(const Vector3& v)
m_x *= s; m_y *= s; m_z *= s; {
return *this; m_x -= v.x(); m_y -= v.y(); m_z -= v.z();
} return *this;
}
inline Vector3& operator/=(const float& s)
{ inline Vector3& operator*=(const float& s)
assert(s != 0.0f); {
return *this *= 1.0f / s; m_x *= s; m_y *= s; m_z *= s;
} return *this;
}
inline float dot(const Vector3& v) const
{ inline Vector3& operator/=(const float& s)
return m_x * v.x() + m_y * v.y() + m_z * v.z(); {
} assert(s != 0.0f);
return *this *= 1.0f / s;
}
inline float length2() const
{
return dot(*this); inline float dot(const Vector3& v) const
} {
return m_x * v.x() + m_y * v.y() + m_z * v.z();
}
inline float length() const
{
return sqrt(length2()); inline float length2() const
} {
return dot(*this);
}
inline float distance2(const Vector3& v) const;
inline float length() const
inline float distance(const Vector3& v) const; {
return sqrt(length2());
}
inline Vector3& normalize()
{
return *this /= length(); inline float distance2(const Vector3& v) const;
}
inline float distance(const Vector3& v) const;
inline Vector3 normalized() const;
inline Vector3& normalize()
inline Vector3 rotate( const Vector3& wAxis, const float angle ); {
return *this /= length();
}
inline float angle(const Vector3& v) const
{
float s = sqrt(length2() * v.length2()); inline Vector3 normalized() const;
assert(s != 0.0f);
return acos(dot(v) / s);
} inline Vector3 rotate( const Vector3& wAxis, const float angle );
inline Vector3 absolute() const inline float angle(const Vector3& v) const
{ {
return Vector3( float s = sqrt(length2() * v.length2());
fabs(m_x), assert(s != 0.0f);
fabs(m_y), return acos(dot(v) / s);
fabs(m_z)); }
}
inline Vector3 absolute() const
inline Vector3 cross(const Vector3& v) const {
{ return Vector3(
return Vector3( fabs(m_x),
m_y * v.z() - m_z * v.y(), fabs(m_y),
m_z * v.x() - m_x * v.z(), fabs(m_z));
m_x * v.y() - m_y * v.x()); }
}
inline Vector3 cross(const Vector3& v) const
inline float triple(const Vector3& v1, const Vector3& v2) const {
{ return Vector3(
return m_x * (v1.y() * v2.z() - v1.z() * v2.y()) + m_y * v.z() - m_z * v.y(),
m_y * (v1.z() * v2.x() - v1.x() * v2.z()) + m_z * v.x() - m_x * v.z(),
m_z * (v1.x() * v2.y() - v1.y() * v2.x()); m_x * v.y() - m_y * v.x());
} }
inline int minAxis() const inline float triple(const Vector3& v1, const Vector3& v2) const
{ {
return m_x < m_y ? (m_x < m_z ? 0 : 2) : (m_y < m_z ? 1 : 2); return m_x * (v1.y() * v2.z() - v1.z() * v2.y())
} + m_y * (v1.z() * v2.x() - v1.x() * v2.z())
+ m_z * (v1.x() * v2.y() - v1.y() * v2.x());
}
inline int maxAxis() const
{
return m_x < m_y ? (m_y < m_z ? 2 : 1) : (m_x < m_z ? 2 : 0); inline int minAxis() const
} {
return m_x < m_y ? (m_x < m_z ? 0 : 2) : (m_y < m_z ? 1 : 2);
}
inline int furthestAxis() const
{
return absolute().minAxis(); inline int maxAxis() const
} {
return m_x < m_y ? (m_y < m_z ? 2 : 1) : (m_x < m_z ? 2 : 0);
}
inline int closestAxis() const
{
return absolute().maxAxis(); inline int furthestAxis() const
} {
return absolute().minAxis();
}
inline void setInterpolate3(const Vector3& v0, const Vector3& v1, float rt)
{
float s = 1.0f - rt; inline int closestAxis() const
m_x = s * v0.x() + rt * v1.x(); {
m_y = s * v0.y() + rt * v1.y(); return absolute().maxAxis();
m_z = s * v0.z() + rt * v1.z(); }
//don't do the unused w component
// m_co[3] = s * v0[3] + rt * v1[3];
} inline void setInterpolate3(const Vector3& v0, const Vector3& v1, float rt)
{
float s = 1.0f - rt;
inline Vector3 lerp(const Vector3& v, const float& t) const m_x = s * v0.x() + rt * v1.x();
{ m_y = s * v0.y() + rt * v1.y();
return Vector3(m_x + (v.x() - m_x) * t, m_z = s * v0.z() + rt * v1.z();
m_y + (v.y() - m_y) * t, // don't do the unused w component
m_z + (v.z() - m_z) * t); // m_co[3] = s * v0[3] + rt * v1[3];
} }
inline Vector3& operator*=(const Vector3& v) inline Vector3 lerp(const Vector3& v, const float& t) const
{ {
m_x *= v.x(); m_y *= v.y(); m_z *= v.z(); return Vector3(m_x + (v.x() - m_x) * t,
return *this; m_y + (v.y() - m_y) * t,
} m_z + (v.z() - m_z) * t);
}
};
inline Vector3 inline Vector3& operator*=(const Vector3& v)
operator+(const Vector3& v1, const Vector3& v2) {
{ m_x *= v.x(); m_y *= v.y(); m_z *= v.z();
return Vector3(v1.x() + v2.x(), v1.y() + v2.y(), v1.z() + v2.z()); return *this;
} }
inline Vector3 };
operator*(const Vector3& v1, const Vector3& v2)
{
return Vector3(v1.x() * v2.x(), v1.y() * v2.y(), v1.z() * v2.z()); inline Vector3
} operator+(const Vector3& v1, const Vector3& v2)
{
inline Vector3 return Vector3(v1.x() + v2.x(), v1.y() + v2.y(), v1.z() + v2.z());
operator-(const Vector3& v1, const Vector3& v2) }
{
return Vector3(v1.x() - v2.x(), v1.y() - v2.y(), v1.z() - v2.z());
} inline Vector3
operator*(const Vector3& v1, const Vector3& v2)
inline Vector3 {
operator-(const Vector3& v) return Vector3(v1.x() * v2.x(), v1.y() * v2.y(), v1.z() * v2.z());
{ }
return Vector3(-v.x(), -v.y(), -v.z());
}
inline Vector3
inline Vector3 operator-(const Vector3& v1, const Vector3& v2)
operator*(const Vector3& v, const float& s) {
{ return Vector3(v1.x() - v2.x(), v1.y() - v2.y(), v1.z() - v2.z());
return Vector3(v.x() * s, v.y() * s, v.z() * s); }
}
inline Vector3 inline Vector3
operator*(const float& s, const Vector3& v) operator-(const Vector3& v)
{ {
return v * s; return Vector3(-v.x(), -v.y(), -v.z());
} }
inline Vector3
operator/(const Vector3& v, const float& s) inline Vector3
{ operator*(const Vector3& v, const float& s)
assert(s != 0.0f); {
return v * (1.0f / s); return Vector3(v.x() * s, v.y() * s, v.z() * s);
} }
inline Vector3
operator/(const Vector3& v1, const Vector3& v2) inline Vector3
{ operator*(const float& s, const Vector3& v)
return Vector3(v1.x() / v2.x(),v1.y() / v2.y(),v1.z() / v2.z()); {
} return v * s;
}
inline float
dot(const Vector3& v1, const Vector3& v2)
{ inline Vector3
return v1.dot(v2); operator/(const Vector3& v, const float& s)
} {
assert(s != 0.0f);
inline float return v * (1.0f / s);
distance2(const Vector3& v1, const Vector3& v2) }
{
return v1.distance2(v2);
} inline Vector3
operator/(const Vector3& v1, const Vector3& v2)
{
inline float return Vector3(v1.x() / v2.x(),v1.y() / v2.y(),v1.z() / v2.z());
distance(const Vector3& v1, const Vector3& v2) }
{
return v1.distance(v2);
} inline float
dot(const Vector3& v1, const Vector3& v2)
inline float {
angle(const Vector3& v1, const Vector3& v2) return v1.dot(v2);
{ }
return v1.angle(v2);
}
inline float
inline Vector3 distance2(const Vector3& v1, const Vector3& v2)
cross(const Vector3& v1, const Vector3& v2) {
{ return v1.distance2(v2);
return v1.cross(v2); }
}
inline float inline float
triple(const Vector3& v1, const Vector3& v2, const Vector3& v3) distance(const Vector3& v1, const Vector3& v2)
{ {
return v1.triple(v2, v3); return v1.distance(v2);
} }
inline Vector3
lerp(const Vector3& v1, const Vector3& v2, const float& t) inline float
{ angle(const Vector3& v1, const Vector3& v2)
return v1.lerp(v2, t); {
} return v1.angle(v2);
}
inline bool operator==(const Vector3& p1, const Vector3& p2)
{ inline Vector3
return p1.x() == p2.x() && p1.y() == p2.y() && p1.z() == p2.z(); cross(const Vector3& v1, const Vector3& v2)
} {
return v1.cross(v2);
inline float Vector3::distance2(const Vector3& v) const }
{
return (v - *this).length2();
} inline float
triple(const Vector3& v1, const Vector3& v2, const Vector3& v3)
inline float Vector3::distance(const Vector3& v) const {
{ return v1.triple(v2, v3);
return (v - *this).length(); }
}
inline Vector3 Vector3::normalized() const inline Vector3
{ lerp(const Vector3& v1, const Vector3& v2, const float& t)
return *this / length(); {
} return v1.lerp(v2, t);
}
inline Vector3 Vector3::rotate( const Vector3& wAxis, const float angle )
{
// wAxis must be a unit lenght vector inline bool
operator==(const Vector3& p1, const Vector3& p2)
Vector3 o = wAxis * wAxis.dot( *this ); {
Vector3 x = *this - o; return p1.x() == p2.x() && p1.y() == p2.y() && p1.z() == p2.z();
Vector3 y; }
y = wAxis.cross( *this );
inline float
return ( o + x * cos( angle ) + y * sin( angle ) ); Vector3::distance2(const Vector3& v) const
} {
return (v - *this).length2();
#endif //__VECTOR3_H__ }
inline float
Vector3::distance(const Vector3& v) const
{
return (v - *this).length();
}
inline Vector3
Vector3::normalized() const
{
return *this / length();
}
inline Vector3
Vector3::rotate( const Vector3& wAxis, const float angle )
{
// wAxis must be a unit lenght vector
Vector3 o = wAxis * wAxis.dot( *this );
Vector3 x = *this - o;
Vector3 y;
y = wAxis.cross( *this );
return ( o + x * cos( angle ) + y * sin( angle ) );
}
#endif //__VECTOR3_H__
src/apps/haiku3d/mesh/StaticMesh.cpp
+10 -10
View File
@@ -43,11 +43,11 @@ StaticMesh::~StaticMesh()
void void
StaticMesh::_ReadText(const char* fileName) StaticMesh::_ReadText(const char* fileName)
{ {
FILE* f = fopen(fileName, "r"); FILE* f = fopen(fileName, "r");
if (f == NULL) { if (f == NULL) {
printf("Mesh::_ReadText, error accessing %s\n", fileName); printf("Mesh::_ReadText, error accessing %s\n", fileName);
return; return;
} }
fscanf(f, "%lu", &fFaceCount); fscanf(f, "%lu", &fFaceCount);
fFaces = new Face[fFaceCount]; fFaces = new Face[fFaceCount];
@@ -98,10 +98,10 @@ StaticMesh::_ReadBinary(const char* fileName)
{ {
BFile file(fileName, B_READ_ONLY); BFile file(fileName, B_READ_ONLY);
if (file.InitCheck() != B_OK) { if (file.InitCheck() != B_OK) {
printf("Mesh::_ReadBinary, error accessing %s\n", fileName); printf("Mesh::_ReadBinary, error accessing %s\n", fileName);
return; return;
} }
file.Read(&fFaceCount, sizeof(uint32)); file.Read(&fFaceCount, sizeof(uint32));
fFaces = new Face[fFaceCount]; fFaces = new Face[fFaceCount];
@@ -119,7 +119,7 @@ void
StaticMesh::_ReadResource(const char* resourceName) StaticMesh::_ReadResource(const char* resourceName)
{ {
// TODO: factorize with _ReadBinary // TODO: factorize with _ReadBinary
app_info info; app_info info;
be_app->GetAppInfo(&info); be_app->GetAppInfo(&info);
BFile file(&info.ref, B_READ_ONLY); BFile file(&info.ref, B_READ_ONLY);
src/apps/haiku3d/texture/BitmapTexture.cpp
+15 -15
View File
@@ -30,23 +30,23 @@ BitmapTexture::~BitmapTexture()
void void
BitmapTexture::_Load(BBitmap* bitmap) { BitmapTexture::_Load(BBitmap* bitmap) {
if (bitmap == NULL) if (bitmap == NULL)
return; return;
glGenTextures(1, &fId); glGenTextures(1, &fId);
glBindTexture(GL_TEXTURE_2D, fId); glBindTexture(GL_TEXTURE_2D, fId);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, 4, glTexImage2D(GL_TEXTURE_2D, 0, 4,
(int) bitmap->Bounds().Width() + 1, (int) bitmap->Bounds().Width() + 1,
(int) bitmap->Bounds().Height() + 1, (int) bitmap->Bounds().Height() + 1,
0, GL_BGRA, GL_UNSIGNED_BYTE, 0, GL_BGRA, GL_UNSIGNED_BYTE,
bitmap->Bits()); bitmap->Bits());
printf("BitmapTexture::_Load, loaded texture %u (%li, %li, %libits)\n", printf("BitmapTexture::_Load, loaded texture %u (%li, %li, %libits)\n",
fId, (int32) bitmap->Bounds().Width(), fId, (int32) bitmap->Bounds().Width(),
(int32) bitmap->Bounds().Height(), (int32) bitmap->Bounds().Height(),
8 * bitmap->BytesPerRow() / (int)bitmap->Bounds().Width()); 8 * bitmap->BytesPerRow() / (int)bitmap->Bounds().Width());
delete bitmap; delete bitmap;
} }
src/apps/haiku3d/texture/VideoFileTexture.cpp
+12 -12
View File
@@ -91,8 +91,8 @@ VideoFileTexture::_Load(const char* fileName)
format.u.raw_video.display.format = fVideoBitmap->ColorSpace(); format.u.raw_video.display.format = fVideoBitmap->ColorSpace();
format.u.raw_video.display.line_width = (int32) bounds.Width(); format.u.raw_video.display.line_width = (int32) bounds.Width();
format.u.raw_video.display.line_count = (int32) bounds.Height(); format.u.raw_video.display.line_count = (int32) bounds.Height();
format.u.raw_video.display.bytes_per_row = format.u.raw_video.display.bytes_per_row
fVideoBitmap->BytesPerRow(); = fVideoBitmap->BytesPerRow();
err = fVideoTrack->DecodedFormat(&format); err = fVideoTrack->DecodedFormat(&format);
if (err != B_OK) { if (err != B_OK) {
@@ -102,14 +102,14 @@ VideoFileTexture::_Load(const char* fileName)
} }
// Create Texture // Create Texture
glGenTextures(1, &fId); glGenTextures(1, &fId);
glBindTexture(GL_TEXTURE_2D, fId); glBindTexture(GL_TEXTURE_2D, fId);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, 4, glTexImage2D(GL_TEXTURE_2D, 0, 4,
(int) fVideoBitmap->Bounds().Width() + 1, (int) fVideoBitmap->Bounds().Width() + 1,
(int) fVideoBitmap->Bounds().Height() + 1, (int) fVideoBitmap->Bounds().Height() + 1,
0, GL_BGRA, GL_UNSIGNED_BYTE, fVideoBitmap->Bits()); 0, GL_BGRA, GL_UNSIGNED_BYTE, fVideoBitmap->Bits());
} }
} }
} }
@@ -120,8 +120,8 @@ VideoFileTexture::Update(float /*dt*/) {
// TODO loop // TODO loop
int64 frameCount = 0; int64 frameCount = 0;
media_header mh; media_header mh;
status_t err = status_t err
fVideoTrack->ReadFrames(fVideoBitmap->Bits(), &frameCount, &mh); = fVideoTrack->ReadFrames(fVideoBitmap->Bits(), &frameCount, &mh);
if (err) { if (err) {
printf("BMediaTrack::ReadFrames error -- %s\n", strerror(err)); printf("BMediaTrack::ReadFrames error -- %s\n", strerror(err));
return; return;