Initial revision
This commit is contained in:
Hans Lambermont
52
intern/moto/Makefile
Normal file
52
intern/moto/Makefile
Normal file
@@ -0,0 +1,52 @@
|
||||
#
|
||||
# $Id$
|
||||
#
|
||||
# ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version. The Blender
|
||||
# Foundation also sells licenses for use in proprietary software under
|
||||
# the Blender License. See http://www.blender.org/BL/ for information
|
||||
# about this.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software Foundation,
|
||||
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
#
|
||||
# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
# All rights reserved.
|
||||
#
|
||||
# The Original Code is: all of this file.
|
||||
#
|
||||
# Contributor(s): none yet.
|
||||
#
|
||||
# ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
# moto main makefile.
|
||||
#
|
||||
|
||||
include nan_definitions.mk
|
||||
|
||||
LIBNAME = moto
|
||||
SOURCEDIR = intern/$(LIBNAME)
|
||||
DIR = $(OCGDIR)/$(SOURCEDIR)
|
||||
DIRS = intern
|
||||
#not ready yet TESTDIRS = test
|
||||
|
||||
include nan_subdirs.mk
|
||||
|
||||
install: all debug
|
||||
@[ -d $(NAN_MOTO) ] || mkdir $(NAN_MOTO)
|
||||
@[ -d $(NAN_MOTO)/include ] || mkdir $(NAN_MOTO)/include
|
||||
@[ -d $(NAN_MOTO)/lib ] || mkdir $(NAN_MOTO)/lib
|
||||
@[ -d $(NAN_MOTO)/lib/debug ] || mkdir $(NAN_MOTO)/lib/debug
|
||||
cp -f $(DIR)/libmoto.a $(NAN_MOTO)/lib/
|
||||
cp -f $(DIR)/debug/libmoto.a $(NAN_MOTO)/lib/debug/
|
||||
cp -f include/*.h $(NAN_MOTO)/include/
|
||||
|
||||
120
intern/moto/include/GEN_List.h
Normal file
120
intern/moto/include/GEN_List.h
Normal file
@@ -0,0 +1,120 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
|
||||
#ifndef GEN_LIST_H
|
||||
#define GEN_LIST_H
|
||||
|
||||
class GEN_Link {
|
||||
public:
|
||||
GEN_Link() : m_next(0), m_prev(0) {}
|
||||
GEN_Link(GEN_Link *next, GEN_Link *prev) : m_next(next), m_prev(prev) {}
|
||||
|
||||
GEN_Link *getNext() const { return m_next; }
|
||||
GEN_Link *getPrev() const { return m_prev; }
|
||||
|
||||
bool isHead() const { return m_prev == 0; }
|
||||
bool isTail() const { return m_next == 0; }
|
||||
|
||||
void insertBefore(GEN_Link *link) {
|
||||
m_next = link;
|
||||
m_prev = link->m_prev;
|
||||
m_next->m_prev = this;
|
||||
m_prev->m_next = this;
|
||||
}
|
||||
|
||||
void insertAfter(GEN_Link *link) {
|
||||
m_next = link->m_next;
|
||||
m_prev = link;
|
||||
m_next->m_prev = this;
|
||||
m_prev->m_next = this;
|
||||
}
|
||||
|
||||
void remove() {
|
||||
m_next->m_prev = m_prev;
|
||||
m_prev->m_next = m_next;
|
||||
}
|
||||
|
||||
private:
|
||||
GEN_Link *m_next;
|
||||
GEN_Link *m_prev;
|
||||
};
|
||||
|
||||
class GEN_List {
|
||||
public:
|
||||
GEN_List() : m_head(&m_tail, 0), m_tail(0, &m_head) {}
|
||||
|
||||
GEN_Link *getHead() const { return m_head.getNext(); }
|
||||
GEN_Link *getTail() const { return m_tail.getPrev(); }
|
||||
|
||||
void addHead(GEN_Link *link) { link->insertAfter(&m_head); }
|
||||
void addTail(GEN_Link *link) { link->insertBefore(&m_tail); }
|
||||
|
||||
private:
|
||||
GEN_Link m_head;
|
||||
GEN_Link m_tail;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
152
intern/moto/include/GEN_Map.h
Normal file
152
intern/moto/include/GEN_Map.h
Normal file
@@ -0,0 +1,152 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#ifndef GEN_MAP_H
|
||||
|
||||
#define GEN_MAP_H
|
||||
|
||||
template <class Key, class Value>
|
||||
class GEN_Map {
|
||||
private:
|
||||
struct Entry {
|
||||
Entry (Entry *next, Key key, Value value) :
|
||||
m_next(next),
|
||||
m_key(key),
|
||||
m_value(value) {}
|
||||
|
||||
Entry *m_next;
|
||||
Key m_key;
|
||||
Value m_value;
|
||||
};
|
||||
|
||||
public:
|
||||
GEN_Map(int num_buckets = 100) : m_num_buckets(num_buckets) {
|
||||
m_buckets = new Entry *[num_buckets];
|
||||
for (int i = 0; i < num_buckets; ++i) {
|
||||
m_buckets[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
int size() {
|
||||
int count=0;
|
||||
for (int i=0;i<m_num_buckets;i++)
|
||||
{
|
||||
Entry* bucket = m_buckets[i];
|
||||
while(bucket)
|
||||
{
|
||||
bucket = bucket->m_next;
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
Value* at(int index) {
|
||||
int count=0;
|
||||
for (int i=0;i<m_num_buckets;i++)
|
||||
{
|
||||
Entry* bucket = m_buckets[i];
|
||||
while(bucket)
|
||||
{
|
||||
if (count==index)
|
||||
{
|
||||
return &bucket->m_value;
|
||||
}
|
||||
bucket = bucket->m_next;
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void clear() {
|
||||
for (int i = 0; i < m_num_buckets; ++i) {
|
||||
Entry *entry_ptr = m_buckets[i];
|
||||
|
||||
while (entry_ptr != 0) {
|
||||
Entry *tmp_ptr = entry_ptr->m_next;
|
||||
delete entry_ptr;
|
||||
entry_ptr = tmp_ptr;
|
||||
}
|
||||
m_buckets[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
~GEN_Map() {
|
||||
clear();
|
||||
delete [] m_buckets;
|
||||
}
|
||||
|
||||
void insert(const Key& key, const Value& value) {
|
||||
Entry *entry_ptr = m_buckets[key.hash() % m_num_buckets];
|
||||
while ((entry_ptr != 0) && !(key == entry_ptr->m_key)) {
|
||||
entry_ptr = entry_ptr->m_next;
|
||||
}
|
||||
|
||||
if (entry_ptr != 0) {
|
||||
entry_ptr->m_value = value;
|
||||
}
|
||||
else {
|
||||
Entry **bucket = &m_buckets[key.hash() % m_num_buckets];
|
||||
*bucket = new Entry(*bucket, key, value);
|
||||
}
|
||||
}
|
||||
|
||||
void remove(const Key& key) {
|
||||
Entry **entry_ptr = &m_buckets[key.hash() % m_num_buckets];
|
||||
while ((*entry_ptr != 0) && !(key == (*entry_ptr)->m_key)) {
|
||||
entry_ptr = &(*entry_ptr)->m_next;
|
||||
}
|
||||
|
||||
if (*entry_ptr != 0) {
|
||||
Entry *tmp_ptr = (*entry_ptr)->m_next;
|
||||
delete *entry_ptr;
|
||||
*entry_ptr = tmp_ptr;
|
||||
}
|
||||
}
|
||||
|
||||
Value *operator[](Key key) {
|
||||
Entry *bucket = m_buckets[key.hash() % m_num_buckets];
|
||||
while ((bucket != 0) && !(key == bucket->m_key)) {
|
||||
bucket = bucket->m_next;
|
||||
}
|
||||
return bucket != 0 ? &bucket->m_value : 0;
|
||||
}
|
||||
|
||||
private:
|
||||
int m_num_buckets;
|
||||
Entry **m_buckets;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
147
intern/moto/include/MT_CmMatrix4x4.h
Normal file
147
intern/moto/include/MT_CmMatrix4x4.h
Normal file
@@ -0,0 +1,147 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#ifndef INCLUDED_MT_CmMatrix4x4
|
||||
|
||||
#define INCLUDED_MT_CmMatrix4x4
|
||||
|
||||
/**
|
||||
* A 4x4 matrix. This is an OpenGl style matrix (column major) meaning
|
||||
* that the vector {m[0][0],m[0][1],m[0][2],m[0][3]} is the first column of
|
||||
* the matrix , the same as what you get if you transform {1,0,0,0}.
|
||||
* This makes it easy to transform stuff to OpenGl. Please note that the
|
||||
* the other MoTo matrices are row major.
|
||||
*
|
||||
* This class should be deprecated in favour of the more consistent
|
||||
* MT_Matrix4x4. Please do not start using this class.
|
||||
*/
|
||||
|
||||
#include "MT_Scalar.h"
|
||||
|
||||
class MT_Point3;
|
||||
class MT_Vector3;
|
||||
|
||||
class MT_CmMatrix4x4
|
||||
{
|
||||
|
||||
public :
|
||||
|
||||
MT_CmMatrix4x4(
|
||||
const float value[4][4]
|
||||
);
|
||||
|
||||
MT_CmMatrix4x4(
|
||||
);
|
||||
|
||||
|
||||
MT_CmMatrix4x4(
|
||||
const double value[16]
|
||||
);
|
||||
|
||||
MT_CmMatrix4x4(
|
||||
const MT_CmMatrix4x4 & other
|
||||
);
|
||||
|
||||
MT_CmMatrix4x4(
|
||||
const MT_Point3& orig,
|
||||
const MT_Vector3& dir,
|
||||
const MT_Vector3 up
|
||||
);
|
||||
|
||||
void
|
||||
Identity(
|
||||
);
|
||||
|
||||
void
|
||||
SetMatrix(
|
||||
const MT_CmMatrix4x4 & other
|
||||
);
|
||||
|
||||
double*
|
||||
getPointer(
|
||||
);
|
||||
|
||||
const
|
||||
double*
|
||||
getPointer(
|
||||
) const;
|
||||
|
||||
void
|
||||
setElem(
|
||||
int pos,
|
||||
double newvalue
|
||||
);
|
||||
|
||||
MT_Vector3
|
||||
GetRight(
|
||||
) const;
|
||||
|
||||
MT_Vector3
|
||||
GetUp(
|
||||
) const;
|
||||
|
||||
MT_Vector3
|
||||
GetDir(
|
||||
) const;
|
||||
|
||||
MT_Point3
|
||||
GetPos(
|
||||
) const;
|
||||
|
||||
void
|
||||
SetPos(
|
||||
const MT_Vector3 & v
|
||||
);
|
||||
|
||||
double&
|
||||
operator (
|
||||
) (int row,int col) { return m_V[col][row]; }
|
||||
|
||||
static
|
||||
MT_CmMatrix4x4
|
||||
Perspective(
|
||||
MT_Scalar inLeft,
|
||||
MT_Scalar inRight,
|
||||
MT_Scalar inBottom,
|
||||
MT_Scalar inTop,
|
||||
MT_Scalar inNear,
|
||||
MT_Scalar inFar
|
||||
);
|
||||
|
||||
protected:
|
||||
union
|
||||
{
|
||||
double m_V[4][4];
|
||||
double m_Vflat[16];
|
||||
};
|
||||
};
|
||||
|
||||
#endif //MT_CmMatrix4x4
|
||||
214
intern/moto/include/MT_Matrix3x3.h
Executable file
214
intern/moto/include/MT_Matrix3x3.h
Executable file
@@ -0,0 +1,214 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
* Copyright (c) 2000 Gino van den Bergen <gino@acm.org>
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Gino van den Bergen makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MT_MATRIX3X3_H
|
||||
#define MT_MATRIX3X3_H
|
||||
|
||||
#include <MT_assert.h>
|
||||
|
||||
#include "MT_Vector3.h"
|
||||
#include "MT_Quaternion.h"
|
||||
|
||||
class MT_Matrix3x3 {
|
||||
public:
|
||||
MT_Matrix3x3() {}
|
||||
MT_Matrix3x3(const float *m) { setValue(m); }
|
||||
MT_Matrix3x3(const double *m) { setValue(m); }
|
||||
MT_Matrix3x3(const MT_Quaternion& q) { setRotation(q); }
|
||||
|
||||
MT_Matrix3x3(const MT_Quaternion& q, const MT_Vector3& s) {
|
||||
setRotation(q);
|
||||
scale(s[0], s[1], s[2]);
|
||||
}
|
||||
|
||||
MT_Matrix3x3(const MT_Vector3& euler) { setEuler(euler); }
|
||||
MT_Matrix3x3(const MT_Vector3& euler, const MT_Vector3& s) {
|
||||
setEuler(euler);
|
||||
scale(s[0], s[1], s[2]);
|
||||
}
|
||||
|
||||
MT_Matrix3x3(MT_Scalar xx, MT_Scalar xy, MT_Scalar xz,
|
||||
MT_Scalar yx, MT_Scalar yy, MT_Scalar yz,
|
||||
MT_Scalar zx, MT_Scalar zy, MT_Scalar zz) {
|
||||
setValue(xx, xy, xz,
|
||||
yx, yy, yz,
|
||||
zx, zy, zz);
|
||||
}
|
||||
|
||||
MT_Vector3& operator[](int i) { return m_el[i]; }
|
||||
const MT_Vector3& operator[](int i) const { return m_el[i]; }
|
||||
|
||||
void setValue(const float *m) {
|
||||
m_el[0][0] = *m++; m_el[1][0] = *m++; m_el[2][0] = *m++; m++;
|
||||
m_el[0][1] = *m++; m_el[1][1] = *m++; m_el[2][1] = *m++; m++;
|
||||
m_el[0][2] = *m++; m_el[1][2] = *m++; m_el[2][2] = *m;
|
||||
}
|
||||
|
||||
void setValue(const double *m) {
|
||||
m_el[0][0] = *m++; m_el[1][0] = *m++; m_el[2][0] = *m++; m++;
|
||||
m_el[0][1] = *m++; m_el[1][1] = *m++; m_el[2][1] = *m++; m++;
|
||||
m_el[0][2] = *m++; m_el[1][2] = *m++; m_el[2][2] = *m;
|
||||
}
|
||||
|
||||
void setValue(MT_Scalar xx, MT_Scalar xy, MT_Scalar xz,
|
||||
MT_Scalar yx, MT_Scalar yy, MT_Scalar yz,
|
||||
MT_Scalar zx, MT_Scalar zy, MT_Scalar zz) {
|
||||
m_el[0][0] = xx; m_el[0][1] = xy; m_el[0][2] = xz;
|
||||
m_el[1][0] = yx; m_el[1][1] = yy; m_el[1][2] = yz;
|
||||
m_el[2][0] = zx; m_el[2][1] = zy; m_el[2][2] = zz;
|
||||
}
|
||||
|
||||
void setRotation(const MT_Quaternion& q) {
|
||||
MT_Scalar d = q.length2();
|
||||
MT_assert(!MT_fuzzyZero2(d));
|
||||
MT_Scalar s = MT_Scalar(2.0) / d;
|
||||
MT_Scalar xs = q[0] * s, ys = q[1] * s, zs = q[2] * s;
|
||||
MT_Scalar wx = q[3] * xs, wy = q[3] * ys, wz = q[3] * zs;
|
||||
MT_Scalar xx = q[0] * xs, xy = q[0] * ys, xz = q[0] * zs;
|
||||
MT_Scalar yy = q[1] * ys, yz = q[1] * zs, zz = q[2] * zs;
|
||||
setValue(MT_Scalar(1.0) - (yy + zz), xy - wz , xz + wy,
|
||||
xy + wz , MT_Scalar(1.0) - (xx + zz), yz - wx,
|
||||
xz - wy , yz + wx, MT_Scalar(1.0) - (xx + yy));
|
||||
}
|
||||
|
||||
/**
|
||||
* setEuler
|
||||
* @param euler a const reference to a MT_Vector3 of euler angles
|
||||
* These angles are used to produce a rotation matrix. The euler
|
||||
* angles are applied in ZYX order. I.e a vector is first rotated
|
||||
* about X then Y and then Z
|
||||
**/
|
||||
|
||||
void setEuler(const MT_Vector3& euler) {
|
||||
MT_Scalar ci = cos(euler[0]);
|
||||
MT_Scalar cj = cos(euler[1]);
|
||||
MT_Scalar ch = cos(euler[2]);
|
||||
MT_Scalar si = sin(euler[0]);
|
||||
MT_Scalar sj = sin(euler[1]);
|
||||
MT_Scalar sh = sin(euler[2]);
|
||||
MT_Scalar cc = ci * ch;
|
||||
MT_Scalar cs = ci * sh;
|
||||
MT_Scalar sc = si * ch;
|
||||
MT_Scalar ss = si * sh;
|
||||
|
||||
setValue(cj * ch, sj * sc - cs, sj * cc + ss,
|
||||
cj * sh, sj * ss + cc, sj * cs - sc,
|
||||
-sj, cj * si, cj * ci);
|
||||
}
|
||||
|
||||
void scale(MT_Scalar x, MT_Scalar y, MT_Scalar z) {
|
||||
m_el[0][0] *= x; m_el[0][1] *= y; m_el[0][2] *= z;
|
||||
m_el[1][0] *= x; m_el[1][1] *= y; m_el[1][2] *= z;
|
||||
m_el[2][0] *= x; m_el[2][1] *= y; m_el[2][2] *= z;
|
||||
}
|
||||
|
||||
MT_Matrix3x3 scaled(MT_Scalar x, MT_Scalar y, MT_Scalar z) const {
|
||||
return MT_Matrix3x3(m_el[0][0] * x, m_el[0][1] * y, m_el[0][2] * z,
|
||||
m_el[1][0] * x, m_el[1][1] * y, m_el[1][2] * z,
|
||||
m_el[2][0] * x, m_el[2][1] * y, m_el[2][2] * z);
|
||||
}
|
||||
|
||||
void setIdentity() {
|
||||
setValue(MT_Scalar(1.0), MT_Scalar(0.0), MT_Scalar(0.0),
|
||||
MT_Scalar(0.0), MT_Scalar(1.0), MT_Scalar(0.0),
|
||||
MT_Scalar(0.0), MT_Scalar(0.0), MT_Scalar(1.0));
|
||||
}
|
||||
|
||||
void getValue(float *m) const {
|
||||
*m++ = m_el[0][0]; *m++ = m_el[1][0]; *m++ = m_el[2][0]; *m++ = 0.0;
|
||||
*m++ = m_el[0][1]; *m++ = m_el[1][1]; *m++ = m_el[2][1]; *m++ = 0.0;
|
||||
*m++ = m_el[0][2]; *m++ = m_el[1][2]; *m++ = m_el[2][2]; *m = 0.0;
|
||||
}
|
||||
|
||||
void getValue(double *m) const {
|
||||
*m++ = m_el[0][0]; *m++ = m_el[1][0]; *m++ = m_el[2][0]; *m++ = 0.0;
|
||||
*m++ = m_el[0][1]; *m++ = m_el[1][1]; *m++ = m_el[2][1]; *m++ = 0.0;
|
||||
*m++ = m_el[0][2]; *m++ = m_el[1][2]; *m++ = m_el[2][2]; *m = 0.0;
|
||||
}
|
||||
|
||||
MT_Quaternion getRotation() const;
|
||||
|
||||
MT_Matrix3x3& operator*=(const MT_Matrix3x3& m);
|
||||
|
||||
MT_Scalar tdot(int c, const MT_Vector3& v) const {
|
||||
return m_el[0][c] * v[0] + m_el[1][c] * v[1] + m_el[2][c] * v[2];
|
||||
}
|
||||
|
||||
MT_Scalar cofac(int r1, int c1, int r2, int c2) const {
|
||||
return m_el[r1][c1] * m_el[r2][c2] - m_el[r1][c2] * m_el[r2][c1];
|
||||
}
|
||||
|
||||
MT_Scalar determinant() const;
|
||||
MT_Matrix3x3 adjoint() const;
|
||||
|
||||
MT_Matrix3x3 absolute() const;
|
||||
|
||||
MT_Matrix3x3 transposed() const;
|
||||
void transpose();
|
||||
|
||||
MT_Matrix3x3 inverse() const;
|
||||
void invert();
|
||||
|
||||
protected:
|
||||
|
||||
MT_Vector3 m_el[3];
|
||||
};
|
||||
|
||||
MT_Vector3 operator*(const MT_Matrix3x3& m, const MT_Vector3& v);
|
||||
MT_Vector3 operator*(const MT_Vector3& v, const MT_Matrix3x3& m);
|
||||
MT_Matrix3x3 operator*(const MT_Matrix3x3& m1, const MT_Matrix3x3& m2);
|
||||
|
||||
MT_Matrix3x3 MT_multTransposeLeft(const MT_Matrix3x3& m1, const MT_Matrix3x3& m2);
|
||||
MT_Matrix3x3 MT_multTransposeRight(const MT_Matrix3x3& m1, const MT_Matrix3x3& m2);
|
||||
|
||||
inline MT_OStream& operator<<(MT_OStream& os, const MT_Matrix3x3& m) {
|
||||
return os << m[0] << GEN_endl << m[1] << GEN_endl << m[2] << GEN_endl;
|
||||
}
|
||||
|
||||
#ifdef GEN_INLINED
|
||||
#include "MT_Matrix3x3.inl"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
128
intern/moto/include/MT_Matrix3x3.inl
Normal file
128
intern/moto/include/MT_Matrix3x3.inl
Normal file
@@ -0,0 +1,128 @@
|
||||
#include "MT_Optimize.h"
|
||||
|
||||
GEN_INLINE MT_Quaternion MT_Matrix3x3::getRotation() const {
|
||||
static int next[3] = { 1, 2, 0 };
|
||||
|
||||
MT_Quaternion result;
|
||||
|
||||
MT_Scalar trace = m_el[0][0] + m_el[1][1] + m_el[2][2];
|
||||
|
||||
if (trace > 0.0)
|
||||
{
|
||||
MT_Scalar s = sqrt(trace + MT_Scalar(1.0));
|
||||
result[3] = s * MT_Scalar(0.5);
|
||||
s = MT_Scalar(0.5) / s;
|
||||
|
||||
result[0] = (m_el[2][1] - m_el[1][2]) * s;
|
||||
result[1] = (m_el[0][2] - m_el[2][0]) * s;
|
||||
result[2] = (m_el[1][0] - m_el[0][1]) * s;
|
||||
}
|
||||
else
|
||||
{
|
||||
int i = 0;
|
||||
if (m_el[1][1] > m_el[0][0])
|
||||
i = 1;
|
||||
if (m_el[2][2] > m_el[i][i])
|
||||
i = 2;
|
||||
|
||||
int j = next[i];
|
||||
int k = next[j];
|
||||
|
||||
MT_Scalar s = sqrt(m_el[i][i] - m_el[j][j] - m_el[k][k] + MT_Scalar(1.0));
|
||||
|
||||
result[i] = s * MT_Scalar(0.5);
|
||||
|
||||
s = MT_Scalar(0.5) / s;
|
||||
|
||||
result[3] = (m_el[k][j] - m_el[j][k]) * s;
|
||||
result[j] = (m_el[j][i] + m_el[i][j]) * s;
|
||||
result[k] = (m_el[k][i] + m_el[i][k]) * s;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Matrix3x3& MT_Matrix3x3::operator*=(const MT_Matrix3x3& m) {
|
||||
setValue(m.tdot(0, m_el[0]), m.tdot(1, m_el[0]), m.tdot(2, m_el[0]),
|
||||
m.tdot(0, m_el[1]), m.tdot(1, m_el[1]), m.tdot(2, m_el[1]),
|
||||
m.tdot(0, m_el[2]), m.tdot(1, m_el[2]), m.tdot(2, m_el[2]));
|
||||
return *this;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_Matrix3x3::determinant() const {
|
||||
return MT_triple((*this)[0], (*this)[1], (*this)[2]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Matrix3x3 MT_Matrix3x3::absolute() const {
|
||||
return
|
||||
MT_Matrix3x3(MT_abs(m_el[0][0]), MT_abs(m_el[0][1]), MT_abs(m_el[0][2]),
|
||||
MT_abs(m_el[1][0]), MT_abs(m_el[1][1]), MT_abs(m_el[1][2]),
|
||||
MT_abs(m_el[2][0]), MT_abs(m_el[2][1]), MT_abs(m_el[2][2]));
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Matrix3x3 MT_Matrix3x3::transposed() const {
|
||||
return MT_Matrix3x3(m_el[0][0], m_el[1][0], m_el[2][0],
|
||||
m_el[0][1], m_el[1][1], m_el[2][1],
|
||||
m_el[0][2], m_el[1][2], m_el[2][2]);
|
||||
}
|
||||
|
||||
GEN_INLINE void MT_Matrix3x3::transpose() {
|
||||
*this = transposed();
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Matrix3x3 MT_Matrix3x3::adjoint() const {
|
||||
return
|
||||
MT_Matrix3x3(cofac(1, 1, 2, 2), cofac(0, 2, 2, 1), cofac(0, 1, 1, 2),
|
||||
cofac(1, 2, 2, 0), cofac(0, 0, 2, 2), cofac(0, 2, 1, 0),
|
||||
cofac(1, 0, 2, 1), cofac(0, 1, 2, 0), cofac(0, 0, 1, 1));
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Matrix3x3 MT_Matrix3x3::inverse() const {
|
||||
MT_Vector3 co(cofac(1, 1, 2, 2), cofac(1, 2, 2, 0), cofac(1, 0, 2, 1));
|
||||
MT_Scalar det = MT_dot((*this)[0], co);
|
||||
MT_assert(!MT_fuzzyZero2(det));
|
||||
MT_Scalar s = MT_Scalar(1.0) / det;
|
||||
return
|
||||
MT_Matrix3x3(co[0] * s, cofac(0, 2, 2, 1) * s, cofac(0, 1, 1, 2) * s,
|
||||
co[1] * s, cofac(0, 0, 2, 2) * s, cofac(0, 2, 1, 0) * s,
|
||||
co[2] * s, cofac(0, 1, 2, 0) * s, cofac(0, 0, 1, 1) * s);
|
||||
}
|
||||
|
||||
GEN_INLINE void MT_Matrix3x3::invert() {
|
||||
*this = inverse();
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector3 operator*(const MT_Matrix3x3& m, const MT_Vector3& v) {
|
||||
return MT_Vector3(MT_dot(m[0], v), MT_dot(m[1], v), MT_dot(m[2], v));
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector3 operator*(const MT_Vector3& v, const MT_Matrix3x3& m) {
|
||||
return MT_Vector3(m.tdot(0, v), m.tdot(1, v), m.tdot(2, v));
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Matrix3x3 operator*(const MT_Matrix3x3& m1, const MT_Matrix3x3& m2) {
|
||||
return
|
||||
MT_Matrix3x3(m2.tdot(0, m1[0]), m2.tdot(1, m1[0]), m2.tdot(2, m1[0]),
|
||||
m2.tdot(0, m1[1]), m2.tdot(1, m1[1]), m2.tdot(2, m1[1]),
|
||||
m2.tdot(0, m1[2]), m2.tdot(1, m1[2]), m2.tdot(2, m1[2]));
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Matrix3x3 MT_multTransposeLeft(const MT_Matrix3x3& m1, const MT_Matrix3x3& m2) {
|
||||
return MT_Matrix3x3(
|
||||
m1[0][0] * m2[0][0] + m1[1][0] * m2[1][0] + m1[2][0] * m2[2][0],
|
||||
m1[0][0] * m2[0][1] + m1[1][0] * m2[1][1] + m1[2][0] * m2[2][1],
|
||||
m1[0][0] * m2[0][2] + m1[1][0] * m2[1][2] + m1[2][0] * m2[2][2],
|
||||
m1[0][1] * m2[0][0] + m1[1][1] * m2[1][0] + m1[2][1] * m2[2][0],
|
||||
m1[0][1] * m2[0][1] + m1[1][1] * m2[1][1] + m1[2][1] * m2[2][1],
|
||||
m1[0][1] * m2[0][2] + m1[1][1] * m2[1][2] + m1[2][1] * m2[2][2],
|
||||
m1[0][2] * m2[0][0] + m1[1][2] * m2[1][0] + m1[2][2] * m2[2][0],
|
||||
m1[0][2] * m2[0][1] + m1[1][2] * m2[1][1] + m1[2][2] * m2[2][1],
|
||||
m1[0][2] * m2[0][2] + m1[1][2] * m2[1][2] + m1[2][2] * m2[2][2]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Matrix3x3 MT_multTransposeRight(const MT_Matrix3x3& m1, const MT_Matrix3x3& m2) {
|
||||
return
|
||||
MT_Matrix3x3(m1[0].dot(m2[0]), m1[0].dot(m2[1]), m1[0].dot(m2[2]),
|
||||
m1[1].dot(m2[0]), m1[1].dot(m2[1]), m1[1].dot(m2[2]),
|
||||
m1[2].dot(m2[0]), m1[2].dot(m2[1]), m1[2].dot(m2[2]));
|
||||
|
||||
}
|
||||
250
intern/moto/include/MT_Matrix4x4.h
Executable file
250
intern/moto/include/MT_Matrix4x4.h
Executable file
@@ -0,0 +1,250 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/**
|
||||
|
||||
* $Id$
|
||||
* Copyright (C) 2001 NaN Technologies B.V.
|
||||
* A 4x4 matrix compatible with other stuff.
|
||||
*/
|
||||
|
||||
#ifndef MT_MATRIX4X4_H
|
||||
#define MT_MATRIX4X4_H
|
||||
|
||||
#include <MT_assert.h>
|
||||
|
||||
#include "MT_Vector4.h"
|
||||
#include "MT_Transform.h"
|
||||
|
||||
// Row-major 4x4 matrix
|
||||
|
||||
class MT_Matrix4x4 {
|
||||
public:
|
||||
/**
|
||||
* Empty contructor.
|
||||
*/
|
||||
MT_Matrix4x4() {}
|
||||
/**
|
||||
* Initialize all fields with the values pointed at by m. A
|
||||
* contigous block of 16 values is read. */
|
||||
MT_Matrix4x4(const float *m) { setValue(m); }
|
||||
/**
|
||||
* Initialize all fields with the values pointed at by m. A
|
||||
* contigous block of 16 values is read. */
|
||||
MT_Matrix4x4(const double *m) { setValue(m); }
|
||||
|
||||
/**
|
||||
* Initialise with these 16 explicit values.
|
||||
*/
|
||||
MT_Matrix4x4(MT_Scalar xx, MT_Scalar xy, MT_Scalar xz, MT_Scalar xw,
|
||||
MT_Scalar yx, MT_Scalar yy, MT_Scalar yz, MT_Scalar yw,
|
||||
MT_Scalar zx, MT_Scalar zy, MT_Scalar zz, MT_Scalar zw,
|
||||
MT_Scalar wx, MT_Scalar wy, MT_Scalar wz, MT_Scalar ww) {
|
||||
setValue(xx, xy, xz, xw,
|
||||
yx, yy, yz, yw,
|
||||
zx, zy, zz, zw,
|
||||
wx, wy, wz, ww);
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize from an MT_Transform.
|
||||
*/
|
||||
MT_Matrix4x4(const MT_Transform &t) {
|
||||
|
||||
const MT_Matrix3x3 &basis = t.getBasis();
|
||||
const MT_Vector3 &origin = t.getOrigin();
|
||||
|
||||
setValue(
|
||||
basis[0][0],basis[0][1],basis[0][2],origin[0],
|
||||
basis[1][0],basis[1][1],basis[1][2],origin[1],
|
||||
basis[2][0],basis[2][1],basis[2][2],origin[2],
|
||||
MT_Scalar(0),MT_Scalar(0),MT_Scalar(0),MT_Scalar(1)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the i-th row.
|
||||
*/
|
||||
MT_Vector4& operator[](int i) { return m_el[i]; }
|
||||
/**
|
||||
* Get the i-th row.
|
||||
*/
|
||||
const MT_Vector4& operator[](int i) const { return m_el[i]; }
|
||||
|
||||
/**
|
||||
* Set the matrix to the values pointer at by m. A contiguous
|
||||
* block of 16 values is copied. */
|
||||
void setValue(const float *m) {
|
||||
m_el[0][0] = *m++; m_el[1][0] = *m++; m_el[2][0] = *m++; m_el[3][0] = *m++;
|
||||
m_el[0][1] = *m++; m_el[1][1] = *m++; m_el[2][1] = *m++; m_el[3][1] = *m++;
|
||||
m_el[0][2] = *m++; m_el[1][2] = *m++; m_el[2][2] = *m++; m_el[3][2] = *m++;
|
||||
m_el[0][3] = *m++; m_el[1][3] = *m++; m_el[2][3] = *m++; m_el[3][3] = *m;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the matrix to the values pointer at by m. A contiguous
|
||||
* block of 16 values is copied.
|
||||
*/
|
||||
void setValue(const double *m) {
|
||||
m_el[0][0] = *m++; m_el[1][0] = *m++; m_el[2][0] = *m++; m_el[3][0] = *m++;
|
||||
m_el[0][1] = *m++; m_el[1][1] = *m++; m_el[2][1] = *m++; m_el[3][1] = *m++;
|
||||
m_el[0][2] = *m++; m_el[1][2] = *m++; m_el[2][2] = *m++; m_el[3][2] = *m++;
|
||||
m_el[0][3] = *m++; m_el[1][3] = *m++; m_el[2][3] = *m++; m_el[3][3] = *m;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the matrix to these 16 explicit values.
|
||||
*/
|
||||
void setValue(MT_Scalar xx, MT_Scalar xy, MT_Scalar xz, MT_Scalar xw,
|
||||
MT_Scalar yx, MT_Scalar yy, MT_Scalar yz, MT_Scalar yw,
|
||||
MT_Scalar zx, MT_Scalar zy, MT_Scalar zz, MT_Scalar zw,
|
||||
MT_Scalar wx, MT_Scalar wy, MT_Scalar wz, MT_Scalar ww) {
|
||||
m_el[0][0] = xx; m_el[0][1] = xy; m_el[0][2] = xz; m_el[0][3] = xw;
|
||||
m_el[1][0] = yx; m_el[1][1] = yy; m_el[1][2] = yz; m_el[1][3] = yw;
|
||||
m_el[2][0] = zx; m_el[2][1] = zy; m_el[2][2] = zz; m_el[2][3] = zw;
|
||||
m_el[3][0] = wx; m_el[3][1] = wy; m_el[3][2] = wz; m_el[3][3] = ww;
|
||||
}
|
||||
|
||||
/**
|
||||
* Scale the columns of this matrix with x, y, z, w respectively.
|
||||
*/
|
||||
void scale(MT_Scalar x, MT_Scalar y, MT_Scalar z, MT_Scalar w) {
|
||||
m_el[0][0] *= x; m_el[0][1] *= y; m_el[0][2] *= z; m_el[0][3] *= w;
|
||||
m_el[1][0] *= x; m_el[1][1] *= y; m_el[1][2] *= z; m_el[1][3] *= w;
|
||||
m_el[2][0] *= x; m_el[2][1] *= y; m_el[2][2] *= z; m_el[2][3] *= w;
|
||||
m_el[3][0] *= x; m_el[3][1] *= y; m_el[3][2] *= z; m_el[3][3] *= w;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a column-scaled version of this matrix.
|
||||
*/
|
||||
MT_Matrix4x4 scaled(MT_Scalar x, MT_Scalar y, MT_Scalar z, MT_Scalar w) const {
|
||||
return MT_Matrix4x4(m_el[0][0] * x, m_el[0][1] * y, m_el[0][2] * z, m_el[0][3] * w,
|
||||
m_el[1][0] * x, m_el[1][1] * y, m_el[1][2] * z, m_el[1][3] * w,
|
||||
m_el[2][0] * x, m_el[2][1] * y, m_el[2][2] * z, m_el[2][3] * w,
|
||||
m_el[3][0] * x, m_el[3][1] * y, m_el[3][2] * z, m_el[3][3] * w);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set this matrix to I.
|
||||
*/
|
||||
void setIdentity() {
|
||||
setValue(MT_Scalar(1.0), MT_Scalar(0.0), MT_Scalar(0.0), MT_Scalar(0.0),
|
||||
MT_Scalar(0.0), MT_Scalar(1.0), MT_Scalar(0.0), MT_Scalar(0.0),
|
||||
MT_Scalar(0.0), MT_Scalar(0.0), MT_Scalar(1.0), MT_Scalar(0.0),
|
||||
MT_Scalar(0.0), MT_Scalar(0.0), MT_Scalar(0.0), MT_Scalar(1.0));
|
||||
}
|
||||
|
||||
/**
|
||||
* Read the element from row i, column j.
|
||||
*/
|
||||
float getElement(int i, int j) {
|
||||
return m_el[i][j];
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy the contents to a contiguous block of 16 floats.
|
||||
*/
|
||||
void getValue(float *m) const {
|
||||
*m++ = m_el[0][0]; *m++ = m_el[1][0]; *m++ = m_el[2][0]; *m++ = m_el[3][0];
|
||||
*m++ = m_el[0][1]; *m++ = m_el[1][1]; *m++ = m_el[2][1]; *m++ = m_el[3][1];
|
||||
*m++ = m_el[0][2]; *m++ = m_el[1][2]; *m++ = m_el[2][2]; *m++ = m_el[3][2];
|
||||
*m++ = m_el[0][3]; *m++ = m_el[1][3]; *m++ = m_el[2][3]; *m = m_el[3][3];
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy the contents to a contiguous block of 16 doubles.
|
||||
*/
|
||||
void getValue(double *m) const {
|
||||
*m++ = m_el[0][0]; *m++ = m_el[1][0]; *m++ = m_el[2][0]; *m++ = m_el[3][0];
|
||||
*m++ = m_el[0][1]; *m++ = m_el[1][1]; *m++ = m_el[2][1]; *m++ = m_el[3][1];
|
||||
*m++ = m_el[0][2]; *m++ = m_el[1][2]; *m++ = m_el[2][2]; *m++ = m_el[3][2];
|
||||
*m++ = m_el[0][3]; *m++ = m_el[1][3]; *m++ = m_el[2][3]; *m = m_el[3][3];
|
||||
}
|
||||
|
||||
/**
|
||||
* Left-multiply this matrix with the argument.
|
||||
*/
|
||||
MT_Matrix4x4& operator*=(const MT_Matrix4x4& m);
|
||||
|
||||
/**
|
||||
* Left-multiply column c with row vector c.
|
||||
*/
|
||||
MT_Scalar tdot(int c, const MT_Vector4& v) const {
|
||||
return m_el[0][c] * v[0]
|
||||
+ m_el[1][c] * v[1]
|
||||
+ m_el[2][c] * v[2]
|
||||
+ m_el[3][c] * v[3];
|
||||
}
|
||||
|
||||
/* I'll postpone this for now... - nzc*/
|
||||
/* MT_Scalar determinant() const; */
|
||||
/* MT_Matrix4x4 adjoint() const; */
|
||||
/* MT_Matrix4x4 inverse() const; */
|
||||
|
||||
MT_Matrix4x4 absolute() const;
|
||||
|
||||
MT_Matrix4x4 transposed() const;
|
||||
void transpose();
|
||||
|
||||
void invert();
|
||||
|
||||
protected:
|
||||
/**
|
||||
* Access with [row index][column index]
|
||||
*/
|
||||
MT_Vector4 m_el[4];
|
||||
};
|
||||
|
||||
/* These multiplicators do exactly what you ask from them: they
|
||||
* multiply in the indicated order. */
|
||||
MT_Vector4 operator*(const MT_Matrix4x4& m, const MT_Vector4& v);
|
||||
MT_Vector4 operator*(const MT_Vector4& v, const MT_Matrix4x4& m);
|
||||
MT_Matrix4x4 operator*(const MT_Matrix4x4& m1, const MT_Matrix4x4& m2);
|
||||
|
||||
/* MT_Matrix4x4 MT_multTransposeLeft(const MT_Matrix4x4& m1, const MT_Matrix4x4& m2); */
|
||||
/* MT_Matrix4x4 MT_multTransposeRight(const MT_Matrix4x4& m1, const MT_Matrix4x4& m2); */
|
||||
|
||||
inline MT_OStream& operator<<(MT_OStream& os, const MT_Matrix4x4& m) {
|
||||
return os << m[0] << GEN_endl
|
||||
<< m[1] << GEN_endl
|
||||
<< m[2] << GEN_endl
|
||||
<< m[3] << GEN_endl;
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#ifdef GEN_INLINED
|
||||
#include "MT_Matrix4x4.inl"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
108
intern/moto/include/MT_Matrix4x4.inl
Normal file
108
intern/moto/include/MT_Matrix4x4.inl
Normal file
@@ -0,0 +1,108 @@
|
||||
#include "MT_Optimize.h"
|
||||
|
||||
/*
|
||||
* This is a supposedly faster inverter than the cofactor
|
||||
* computation. It uses an LU decomposition sort of thing. */
|
||||
GEN_INLINE void MT_Matrix4x4::invert() {
|
||||
/* normalize row 0 */
|
||||
|
||||
int i,j,k;
|
||||
|
||||
for (i=1; i < 4; i++) m_el[0][i] /= m_el[0][0];
|
||||
for (i=1; i < 4; i++) {
|
||||
for (j=i; j < 4; j++) { // do a column of L
|
||||
MT_Scalar sum = 0.0;
|
||||
for (k = 0; k < i; k++)
|
||||
sum += m_el[j][k] * m_el[k][i];
|
||||
m_el[j][i] -= sum;
|
||||
}
|
||||
if (i == 3) continue;
|
||||
for (j=i+1; j < 4; j++) { // do a row of U
|
||||
MT_Scalar sum = 0.0;
|
||||
for (k = 0; k < i; k++)
|
||||
sum += m_el[i][k]*m_el[k][j];
|
||||
m_el[i][j] =
|
||||
(m_el[i][j]-sum) / m_el[i][i];
|
||||
}
|
||||
}
|
||||
for (i = 0; i < 4; i++ ) // invert L
|
||||
for (j = i; j < 4; j++ ) {
|
||||
MT_Scalar x = 1.0;
|
||||
if ( i != j ) {
|
||||
x = 0.0;
|
||||
for (k = i; k < j; k++ )
|
||||
x -= m_el[j][k]*m_el[k][i];
|
||||
}
|
||||
m_el[j][i] = x / m_el[j][j];
|
||||
}
|
||||
for (i = 0; i < 4; i++ ) // invert U
|
||||
for (j = i; j < 4; j++ ) {
|
||||
if ( i == j ) continue;
|
||||
MT_Scalar sum = 0.0;
|
||||
for (k = i; k < j; k++ )
|
||||
sum += m_el[k][j]*( (i==k) ? 1.0 : m_el[i][k] );
|
||||
m_el[i][j] = -sum;
|
||||
}
|
||||
for (i = 0; i < 4; i++ ) // final inversion
|
||||
for (j = 0; j < 4; j++ ) {
|
||||
MT_Scalar sum = 0.0;
|
||||
for (k = ((i>j)?i:j); k < 4; k++ )
|
||||
sum += ((j==k)?1.0:m_el[j][k])*m_el[k][i];
|
||||
m_el[j][i] = sum;
|
||||
}
|
||||
}
|
||||
|
||||
/* We do things slightly different here, because the invert() modifies
|
||||
* the buffer itself. This makes it impossible to make this op right
|
||||
* away. Like other, still missing facilities, I will repair this
|
||||
* later. */
|
||||
/* GEN_INLINE T_Matrix4x4 MT_Matrix4x4::inverse() const */
|
||||
/* { */
|
||||
/* } */
|
||||
|
||||
|
||||
GEN_INLINE MT_Matrix4x4& MT_Matrix4x4::operator*=(const MT_Matrix4x4& m)
|
||||
{
|
||||
setValue(m.tdot(0, m_el[0]), m.tdot(1, m_el[0]), m.tdot(2, m_el[0]), m.tdot(3, m_el[0]),
|
||||
m.tdot(0, m_el[1]), m.tdot(1, m_el[1]), m.tdot(2, m_el[1]), m.tdot(3, m_el[1]),
|
||||
m.tdot(0, m_el[2]), m.tdot(1, m_el[2]), m.tdot(2, m_el[2]), m.tdot(3, m_el[2]),
|
||||
m.tdot(0, m_el[3]), m.tdot(1, m_el[3]), m.tdot(2, m_el[3]), m.tdot(3, m_el[3]));
|
||||
return *this;
|
||||
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector4 operator*(const MT_Matrix4x4& m, const MT_Vector4& v) {
|
||||
return MT_Vector4(MT_dot(m[0], v), MT_dot(m[1], v), MT_dot(m[2], v), MT_dot(m[3], v));
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector4 operator*(const MT_Vector4& v, const MT_Matrix4x4& m) {
|
||||
return MT_Vector4(m.tdot(0, v), m.tdot(1, v), m.tdot(2, v), m.tdot(3, v));
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Matrix4x4 operator*(const MT_Matrix4x4& m1, const MT_Matrix4x4& m2) {
|
||||
return
|
||||
MT_Matrix4x4(m2.tdot(0, m1[0]), m2.tdot(1, m1[0]), m2.tdot(2, m1[0]), m2.tdot(3, m1[0]),
|
||||
m2.tdot(0, m1[1]), m2.tdot(1, m1[1]), m2.tdot(2, m1[1]), m2.tdot(3, m1[1]),
|
||||
m2.tdot(0, m1[2]), m2.tdot(1, m1[2]), m2.tdot(2, m1[2]), m2.tdot(3, m1[2]),
|
||||
m2.tdot(0, m1[3]), m2.tdot(1, m1[3]), m2.tdot(2, m1[3]), m2.tdot(3, m1[3]));
|
||||
}
|
||||
|
||||
|
||||
GEN_INLINE MT_Matrix4x4 MT_Matrix4x4::transposed() const {
|
||||
return MT_Matrix4x4(m_el[0][0], m_el[1][0], m_el[2][0], m_el[3][0],
|
||||
m_el[0][1], m_el[1][1], m_el[2][1], m_el[3][1],
|
||||
m_el[0][2], m_el[1][2], m_el[2][2], m_el[3][2],
|
||||
m_el[0][3], m_el[1][3], m_el[2][3], m_el[3][3]);
|
||||
}
|
||||
|
||||
GEN_INLINE void MT_Matrix4x4::transpose() {
|
||||
*this = transposed();
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Matrix4x4 MT_Matrix4x4::absolute() const {
|
||||
return
|
||||
MT_Matrix4x4(MT_abs(m_el[0][0]), MT_abs(m_el[0][1]), MT_abs(m_el[0][2]), MT_abs(m_el[0][3]),
|
||||
MT_abs(m_el[1][0]), MT_abs(m_el[1][1]), MT_abs(m_el[1][2]), MT_abs(m_el[1][3]),
|
||||
MT_abs(m_el[2][0]), MT_abs(m_el[2][1]), MT_abs(m_el[2][2]), MT_abs(m_el[2][3]),
|
||||
MT_abs(m_el[3][0]), MT_abs(m_el[3][1]), MT_abs(m_el[3][2]), MT_abs(m_el[3][3]));
|
||||
}
|
||||
69
intern/moto/include/MT_MinMax.h
Executable file
69
intern/moto/include/MT_MinMax.h
Executable file
@@ -0,0 +1,69 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
* Copyright (c) 2000 Gino van den Bergen <gino@acm.org>
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Gino van den Bergen makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MT_MINMAX_H
|
||||
#define MT_MINMAX_H
|
||||
|
||||
template <class T>
|
||||
inline const T& MT_min(const T& a, const T& b) {
|
||||
return b < a ? b : a;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline const T& MT_max(const T& a, const T& b) {
|
||||
return a < b ? b : a;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline void MT_set_min(T& a, const T& b) {
|
||||
if (a > b) a = b;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline void MT_set_max(T& a, const T& b) {
|
||||
if (a < b) a = b;
|
||||
}
|
||||
|
||||
#endif
|
||||
42
intern/moto/include/MT_Optimize.h
Normal file
42
intern/moto/include/MT_Optimize.h
Normal file
@@ -0,0 +1,42 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#ifndef GEN_OPTIMIZE_H
|
||||
|
||||
#define GEN_OPTIMIZE_H
|
||||
|
||||
#ifdef GEN_INLINED
|
||||
#define GEN_INLINE inline
|
||||
#else
|
||||
#define GEN_INLINE
|
||||
#endif
|
||||
|
||||
#endif
|
||||
139
intern/moto/include/MT_Plane3.h
Normal file
139
intern/moto/include/MT_Plane3.h
Normal file
@@ -0,0 +1,139 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#ifndef MT_PLANE3
|
||||
|
||||
#define MT_PLANE3
|
||||
|
||||
#include "MT_Tuple4.h"
|
||||
#include "MT_Point3.h"
|
||||
|
||||
/**
|
||||
* A simple 3d plane class.
|
||||
*
|
||||
* This class represents a plane in 3d. The internal parameterization used
|
||||
* is n.x + d =0 where n is a unit vector and d is a scalar.
|
||||
*
|
||||
* It inherits data from MT_Tuple4 please see this class for low level
|
||||
* access to the internal representation.
|
||||
*
|
||||
*/
|
||||
|
||||
class MT_Plane3 : public MT_Tuple4
|
||||
{
|
||||
public :
|
||||
/**
|
||||
* Constructor from 3 points
|
||||
*/
|
||||
|
||||
MT_Plane3(
|
||||
const MT_Vector3 &a,
|
||||
const MT_Vector3 &b,
|
||||
const MT_Vector3 &c
|
||||
);
|
||||
/**
|
||||
* Construction from vector and a point.
|
||||
*/
|
||||
|
||||
MT_Plane3(
|
||||
const MT_Vector3 &n,
|
||||
const MT_Vector3 &p
|
||||
);
|
||||
|
||||
/**
|
||||
* Default constructor
|
||||
*/
|
||||
MT_Plane3(
|
||||
);
|
||||
|
||||
/**
|
||||
* Default constructor
|
||||
*/
|
||||
|
||||
MT_Plane3(
|
||||
const MT_Plane3 & p
|
||||
):
|
||||
MT_Tuple4(p)
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Return plane normal
|
||||
*/
|
||||
|
||||
MT_Vector3
|
||||
Normal(
|
||||
) const;
|
||||
|
||||
/**
|
||||
* Return plane scalar i.e the d from n.x + d = 0
|
||||
*/
|
||||
|
||||
MT_Scalar
|
||||
Scalar(
|
||||
) const ;
|
||||
|
||||
/**
|
||||
* Invert the plane - just swaps direction of normal.
|
||||
*/
|
||||
void
|
||||
Invert(
|
||||
);
|
||||
|
||||
/**
|
||||
* Assignment operator
|
||||
*/
|
||||
|
||||
MT_Plane3 &
|
||||
operator = (
|
||||
const MT_Plane3 & rhs
|
||||
);
|
||||
|
||||
/**
|
||||
* Return the signed perpendicular distance from a point to the plane
|
||||
*/
|
||||
|
||||
MT_Scalar
|
||||
signedDistance(
|
||||
const MT_Vector3 &
|
||||
) const;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#ifdef GEN_INLINED
|
||||
#include "MT_Plane3.inl"
|
||||
#endif
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
128
intern/moto/include/MT_Plane3.inl
Normal file
128
intern/moto/include/MT_Plane3.inl
Normal file
@@ -0,0 +1,128 @@
|
||||
#include "MT_Optimize.h"
|
||||
|
||||
|
||||
GEN_INLINE
|
||||
MT_Plane3::
|
||||
MT_Plane3(
|
||||
const MT_Vector3 &a,
|
||||
const MT_Vector3 &b,
|
||||
const MT_Vector3 &c
|
||||
){
|
||||
MT_Vector3 l1 = b-a;
|
||||
MT_Vector3 l2 = c-b;
|
||||
|
||||
MT_Vector3 n = l1.cross(l2);
|
||||
n = n.safe_normalized();
|
||||
MT_Scalar d = n.dot(a);
|
||||
|
||||
m_co[0] = n.x();
|
||||
m_co[1] = n.y();
|
||||
m_co[2] = n.z();
|
||||
m_co[3] = -d;
|
||||
}
|
||||
|
||||
/**
|
||||
* Construction from vector and a point.
|
||||
*/
|
||||
GEN_INLINE
|
||||
MT_Plane3::
|
||||
MT_Plane3(
|
||||
const MT_Vector3 &n,
|
||||
const MT_Vector3 &p
|
||||
){
|
||||
|
||||
MT_Vector3 mn = n.safe_normalized();
|
||||
MT_Scalar md = mn.dot(p);
|
||||
|
||||
m_co[0] = mn.x();
|
||||
m_co[1] = mn.y();
|
||||
m_co[2] = mn.z();
|
||||
m_co[3] = -md;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Default constructor
|
||||
*/
|
||||
GEN_INLINE
|
||||
MT_Plane3::
|
||||
MT_Plane3(
|
||||
):
|
||||
MT_Tuple4()
|
||||
{
|
||||
m_co[0] = MT_Scalar(1);
|
||||
m_co[1] = MT_Scalar(0);
|
||||
m_co[2] = MT_Scalar(0);
|
||||
m_co[3] = MT_Scalar(0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return plane normal
|
||||
*/
|
||||
|
||||
GEN_INLINE
|
||||
MT_Vector3
|
||||
MT_Plane3::
|
||||
Normal(
|
||||
) const {
|
||||
return MT_Vector3(m_co[0],m_co[1],m_co[2]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return plane scalar i.e the d from n.x + d = 0
|
||||
*/
|
||||
|
||||
GEN_INLINE
|
||||
MT_Scalar
|
||||
MT_Plane3::
|
||||
Scalar(
|
||||
) const {
|
||||
return m_co[3];
|
||||
}
|
||||
|
||||
GEN_INLINE
|
||||
void
|
||||
MT_Plane3::
|
||||
Invert(
|
||||
) {
|
||||
m_co[0] = -m_co[0];
|
||||
m_co[1] = -m_co[1];
|
||||
m_co[2] = -m_co[2];
|
||||
m_co[3] = -m_co[3];
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Assignment operator
|
||||
*/
|
||||
|
||||
GEN_INLINE
|
||||
MT_Plane3 &
|
||||
MT_Plane3::
|
||||
operator = (
|
||||
const MT_Plane3 & rhs
|
||||
) {
|
||||
m_co[0] = rhs.m_co[0];
|
||||
m_co[1] = rhs.m_co[1];
|
||||
m_co[2] = rhs.m_co[2];
|
||||
m_co[3] = rhs.m_co[3];
|
||||
return *this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the distance from a point to the plane
|
||||
*/
|
||||
|
||||
GEN_INLINE
|
||||
MT_Scalar
|
||||
MT_Plane3::
|
||||
signedDistance(
|
||||
const MT_Vector3 &v
|
||||
) const {
|
||||
return Normal().dot(v) + m_co[3];
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
81
intern/moto/include/MT_Point2.h
Normal file
81
intern/moto/include/MT_Point2.h
Normal file
@@ -0,0 +1,81 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
* Copyright (c) 2000 Gino van den Bergen <gino@acm.org>
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Gino van den Bergen makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MT_POINT2_H
|
||||
#define MT_POINT2_H
|
||||
|
||||
#include "MT_Vector2.h"
|
||||
|
||||
class MT_Point2 : public MT_Vector2 {
|
||||
public:
|
||||
MT_Point2() {}
|
||||
MT_Point2(const float *v) : MT_Vector2(v) {}
|
||||
MT_Point2(const double *v) : MT_Vector2(v) {}
|
||||
MT_Point2(MT_Scalar x, MT_Scalar y) : MT_Vector2(x, y) {}
|
||||
|
||||
MT_Point2& operator+=(const MT_Vector2& v);
|
||||
MT_Point2& operator-=(const MT_Vector2& v);
|
||||
MT_Point2& operator=(const MT_Vector2& v);
|
||||
|
||||
MT_Scalar distance(const MT_Point2& p) const;
|
||||
MT_Scalar distance2(const MT_Point2& p) const;
|
||||
|
||||
MT_Point2 lerp(const MT_Point2& p, MT_Scalar t) const;
|
||||
};
|
||||
|
||||
MT_Point2 operator+(const MT_Point2& p, const MT_Vector2& v);
|
||||
MT_Point2 operator-(const MT_Point2& p, const MT_Vector2& v);
|
||||
MT_Vector2 operator-(const MT_Point2& p1, const MT_Point2& p2);
|
||||
|
||||
MT_Scalar MT_distance(const MT_Point2& p1, const MT_Point2& p2);
|
||||
MT_Scalar MT_distance2(const MT_Point2& p1, const MT_Point2& p2);
|
||||
|
||||
MT_Point2 MT_lerp(const MT_Point2& p1, const MT_Point2& p2, MT_Scalar t);
|
||||
|
||||
#ifdef GEN_INLINED
|
||||
#include "MT_Point2.inl"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
54
intern/moto/include/MT_Point2.inl
Normal file
54
intern/moto/include/MT_Point2.inl
Normal file
@@ -0,0 +1,54 @@
|
||||
#include "MT_Optimize.h"
|
||||
|
||||
GEN_INLINE MT_Point2& MT_Point2::operator+=(const MT_Vector2& v) {
|
||||
m_co[0] += v[0]; m_co[1] += v[1];
|
||||
return *this;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Point2& MT_Point2::operator-=(const MT_Vector2& v) {
|
||||
m_co[0] -= v[0]; m_co[1] -= v[1];
|
||||
return *this;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Point2& MT_Point2::operator=(const MT_Vector2& v) {
|
||||
m_co[0] = v[0]; m_co[1] = v[1];
|
||||
return *this;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_Point2::distance(const MT_Point2& p) const {
|
||||
return (p - *this).length();
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_Point2::distance2(const MT_Point2& p) const {
|
||||
return (p - *this).length2();
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Point2 MT_Point2::lerp(const MT_Point2& p, MT_Scalar t) const {
|
||||
return MT_Point2(m_co[0] + (p[0] - m_co[0]) * t,
|
||||
m_co[1] + (p[1] - m_co[1]) * t);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Point2 operator+(const MT_Point2& p, const MT_Vector2& v) {
|
||||
return MT_Point2(p[0] + v[0], p[1] + v[1]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Point2 operator-(const MT_Point2& p, const MT_Vector2& v) {
|
||||
return MT_Point2(p[0] - v[0], p[1] - v[1]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector2 operator-(const MT_Point2& p1, const MT_Point2& p2) {
|
||||
return MT_Vector2(p1[0] - p2[0], p1[1] - p2[1]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_distance(const MT_Point2& p1, const MT_Point2& p2) {
|
||||
return p1.distance(p2);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_distance2(const MT_Point2& p1, const MT_Point2& p2) {
|
||||
return p1.distance2(p2);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Point2 MT_lerp(const MT_Point2& p1, const MT_Point2& p2, MT_Scalar t) {
|
||||
return p1.lerp(p2, t);
|
||||
}
|
||||
|
||||
81
intern/moto/include/MT_Point3.h
Normal file
81
intern/moto/include/MT_Point3.h
Normal file
@@ -0,0 +1,81 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
* Copyright (c) 2000 Gino van den Bergen <gino@acm.org>
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Gino van den Bergen makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MT_POINT_H
|
||||
#define MT_POINT_H
|
||||
|
||||
#include "MT_Vector3.h"
|
||||
|
||||
class MT_Point3 : public MT_Vector3 {
|
||||
public:
|
||||
MT_Point3() {}
|
||||
MT_Point3(const float *v) : MT_Vector3(v) {}
|
||||
MT_Point3(const double *v) : MT_Vector3(v) {}
|
||||
MT_Point3(MT_Scalar x, MT_Scalar y, MT_Scalar z) : MT_Vector3(x, y, z) {}
|
||||
|
||||
MT_Point3& operator+=(const MT_Vector3& v);
|
||||
MT_Point3& operator-=(const MT_Vector3& v);
|
||||
MT_Point3& operator=(const MT_Vector3& v);
|
||||
|
||||
MT_Scalar distance(const MT_Point3& p) const;
|
||||
MT_Scalar distance2(const MT_Point3& p) const;
|
||||
|
||||
MT_Point3 lerp(const MT_Point3& p, MT_Scalar t) const;
|
||||
};
|
||||
|
||||
MT_Point3 operator+(const MT_Point3& p, const MT_Vector3& v);
|
||||
MT_Point3 operator-(const MT_Point3& p, const MT_Vector3& v);
|
||||
MT_Vector3 operator-(const MT_Point3& p1, const MT_Point3& p2);
|
||||
|
||||
MT_Scalar MT_distance(const MT_Point3& p1, const MT_Point3& p2);
|
||||
MT_Scalar MT_distance2(const MT_Point3& p1, const MT_Point3& p2);
|
||||
|
||||
MT_Point3 MT_lerp(const MT_Point3& p1, const MT_Point3& p2, MT_Scalar t);
|
||||
|
||||
#ifdef GEN_INLINED
|
||||
#include "MT_Point3.inl"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
54
intern/moto/include/MT_Point3.inl
Normal file
54
intern/moto/include/MT_Point3.inl
Normal file
@@ -0,0 +1,54 @@
|
||||
#include "MT_Optimize.h"
|
||||
|
||||
GEN_INLINE MT_Point3& MT_Point3::operator+=(const MT_Vector3& v) {
|
||||
m_co[0] += v[0]; m_co[1] += v[1]; m_co[2] += v[2];
|
||||
return *this;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Point3& MT_Point3::operator-=(const MT_Vector3& v) {
|
||||
m_co[0] -= v[0]; m_co[1] -= v[1]; m_co[2] -= v[2];
|
||||
return *this;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Point3& MT_Point3::operator=(const MT_Vector3& v) {
|
||||
m_co[0] = v[0]; m_co[1] = v[1]; m_co[2] = v[2];
|
||||
return *this;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_Point3::distance(const MT_Point3& p) const {
|
||||
return (p - *this).length();
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_Point3::distance2(const MT_Point3& p) const {
|
||||
return (p - *this).length2();
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Point3 MT_Point3::lerp(const MT_Point3& p, MT_Scalar t) const {
|
||||
return MT_Point3(m_co[0] + (p[0] - m_co[0]) * t,
|
||||
m_co[1] + (p[1] - m_co[1]) * t,
|
||||
m_co[2] + (p[2] - m_co[2]) * t);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Point3 operator+(const MT_Point3& p, const MT_Vector3& v) {
|
||||
return MT_Point3(p[0] + v[0], p[1] + v[1], p[2] + v[2]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Point3 operator-(const MT_Point3& p, const MT_Vector3& v) {
|
||||
return MT_Point3(p[0] - v[0], p[1] - v[1], p[2] - v[2]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector3 operator-(const MT_Point3& p1, const MT_Point3& p2) {
|
||||
return MT_Vector3(p1[0] - p2[0], p1[1] - p2[1], p1[2] - p2[2]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_distance(const MT_Point3& p1, const MT_Point3& p2) {
|
||||
return p1.distance(p2);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_distance2(const MT_Point3& p1, const MT_Point3& p2) {
|
||||
return p1.distance2(p2);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Point3 MT_lerp(const MT_Point3& p1, const MT_Point3& p2, MT_Scalar t) {
|
||||
return p1.lerp(p2, t);
|
||||
}
|
||||
112
intern/moto/include/MT_Quaternion.h
Normal file
112
intern/moto/include/MT_Quaternion.h
Normal file
@@ -0,0 +1,112 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
* Copyright (c) 2000 Gino van den Bergen <gino@acm.org>
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Gino van den Bergen makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MT_QUATERNION_H
|
||||
#define MT_QUATERNION_H
|
||||
|
||||
#include <MT_assert.h>
|
||||
|
||||
#include "MT_Vector3.h"
|
||||
#include "MT_Vector4.h"
|
||||
|
||||
class MT_Quaternion : public MT_Vector4 {
|
||||
public:
|
||||
MT_Quaternion() {}
|
||||
MT_Quaternion(const MT_Vector4& v) : MT_Vector4(v) {}
|
||||
MT_Quaternion(const float v[4]) : MT_Vector4(v) {}
|
||||
MT_Quaternion(const double v[4]) : MT_Vector4(v) {}
|
||||
MT_Quaternion(MT_Scalar x, MT_Scalar y, MT_Scalar z, MT_Scalar w) :
|
||||
MT_Vector4(x, y, z, w) {}
|
||||
MT_Quaternion(const MT_Vector3& axis, MT_Scalar angle) {
|
||||
setRotation(axis, angle);
|
||||
}
|
||||
MT_Quaternion(MT_Scalar yaw, MT_Scalar pitch, MT_Scalar roll) {
|
||||
setEuler(yaw, pitch, roll);
|
||||
}
|
||||
|
||||
void setRotation(const MT_Vector3& axis, MT_Scalar angle) {
|
||||
MT_Scalar d = axis.length();
|
||||
MT_assert(!MT_fuzzyZero(d));
|
||||
MT_Scalar s = sin(angle * MT_Scalar(0.5)) / d;
|
||||
setValue(axis[0] * s, axis[1] * s, axis[2] * s,
|
||||
cos(angle * MT_Scalar(0.5)));
|
||||
}
|
||||
|
||||
void setEuler(MT_Scalar yaw, MT_Scalar pitch, MT_Scalar roll) {
|
||||
MT_Scalar cosYaw = cos(yaw * MT_Scalar(0.5));
|
||||
MT_Scalar sinYaw = sin(yaw * MT_Scalar(0.5));
|
||||
MT_Scalar cosPitch = cos(pitch * MT_Scalar(0.5));
|
||||
MT_Scalar sinPitch = sin(pitch * MT_Scalar(0.5));
|
||||
MT_Scalar cosRoll = cos(roll * MT_Scalar(0.5));
|
||||
MT_Scalar sinRoll = sin(roll * MT_Scalar(0.5));
|
||||
setValue(cosRoll * sinPitch * cosYaw + sinRoll * cosPitch * sinYaw,
|
||||
cosRoll * cosPitch * sinYaw - sinRoll * sinPitch * cosYaw,
|
||||
sinRoll * cosPitch * cosYaw - cosRoll * sinPitch * sinYaw,
|
||||
cosRoll * cosPitch * cosYaw + sinRoll * sinPitch * sinYaw);
|
||||
}
|
||||
|
||||
MT_Quaternion& operator*=(const MT_Quaternion& q);
|
||||
|
||||
void conjugate();
|
||||
MT_Quaternion conjugate() const;
|
||||
|
||||
void invert();
|
||||
MT_Quaternion inverse() const;
|
||||
|
||||
static MT_Quaternion random();
|
||||
};
|
||||
|
||||
MT_Quaternion operator*(const MT_Quaternion& q1, const MT_Quaternion& q2);
|
||||
MT_Quaternion operator*(const MT_Quaternion& q, const MT_Vector3& w);
|
||||
MT_Quaternion operator*(const MT_Vector3& w, const MT_Quaternion& q);
|
||||
|
||||
#ifdef GEN_INLINED
|
||||
#include "MT_Quaternion.inl"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
62
intern/moto/include/MT_Quaternion.inl
Normal file
62
intern/moto/include/MT_Quaternion.inl
Normal file
@@ -0,0 +1,62 @@
|
||||
#include "MT_Optimize.h"
|
||||
|
||||
GEN_INLINE MT_Quaternion& MT_Quaternion::operator*=(const MT_Quaternion& q) {
|
||||
setValue(m_co[3] * q[0] + m_co[0] * q[3] + m_co[1] * q[2] - m_co[2] * q[1],
|
||||
m_co[3] * q[1] + m_co[1] * q[3] + m_co[2] * q[0] - m_co[0] * q[2],
|
||||
m_co[3] * q[2] + m_co[2] * q[3] + m_co[0] * q[1] - m_co[1] * q[0],
|
||||
m_co[3] * q[3] - m_co[0] * q[0] - m_co[1] * q[1] - m_co[2] * q[2]);
|
||||
return *this;
|
||||
}
|
||||
|
||||
GEN_INLINE void MT_Quaternion::conjugate() {
|
||||
m_co[0] = -m_co[0]; m_co[1] = -m_co[1]; m_co[2] = -m_co[2];
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Quaternion MT_Quaternion::conjugate() const {
|
||||
return MT_Quaternion(-m_co[0], -m_co[1], -m_co[2], m_co[3]);
|
||||
}
|
||||
|
||||
GEN_INLINE void MT_Quaternion::invert() {
|
||||
conjugate();
|
||||
*this /= length2();
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Quaternion MT_Quaternion::inverse() const {
|
||||
return conjugate() / length2();
|
||||
}
|
||||
|
||||
// From: "Uniform Random Rotations", Ken Shoemake, Graphics Gems III,
|
||||
// pg. 124-132
|
||||
GEN_INLINE MT_Quaternion MT_Quaternion::random() {
|
||||
MT_Scalar x0 = MT_random();
|
||||
MT_Scalar r1 = sqrt(MT_Scalar(1.0) - x0), r2 = sqrt(x0);
|
||||
MT_Scalar t1 = MT_2_PI * MT_random(), t2 = MT_2_PI * MT_random();
|
||||
MT_Scalar c1 = cos(t1), s1 = sin(t1);
|
||||
MT_Scalar c2 = cos(t2), s2 = sin(t2);
|
||||
return MT_Quaternion(s1 * r1, c1 * r1, s2 * r2, c2 * r2);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Quaternion operator*(const MT_Quaternion& q1,
|
||||
const MT_Quaternion& q2) {
|
||||
return MT_Quaternion(q1[3] * q2[0] + q1[0] * q2[3] + q1[1] * q2[2] - q1[2] * q2[1],
|
||||
q1[3] * q2[1] + q1[1] * q2[3] + q1[2] * q2[0] - q1[0] * q2[2],
|
||||
q1[3] * q2[2] + q1[2] * q2[3] + q1[0] * q2[1] - q1[1] * q2[0],
|
||||
q1[3] * q2[3] - q1[0] * q2[0] - q1[1] * q2[1] - q1[2] * q2[2]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Quaternion operator*(const MT_Quaternion& q, const MT_Vector3& w)
|
||||
{
|
||||
return MT_Quaternion( q[3] * w[0] + q[1] * w[2] - q[2] * w[1],
|
||||
q[3] * w[1] + q[2] * w[0] - q[0] * w[2],
|
||||
q[3] * w[2] + q[0] * w[1] - q[1] * w[0],
|
||||
-q[0] * w[0] - q[1] * w[1] - q[2] * w[2]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Quaternion operator*(const MT_Vector3& w, const MT_Quaternion& q)
|
||||
{
|
||||
return MT_Quaternion( w[0] * q[3] + w[1] * q[2] - w[2] * q[1],
|
||||
w[1] * q[3] + w[2] * q[0] - w[0] * q[2],
|
||||
w[2] * q[3] + w[0] * q[1] - w[1] * q[0],
|
||||
-w[0] * q[0] - w[1] * q[1] - w[2] * q[2]);
|
||||
}
|
||||
|
||||
88
intern/moto/include/MT_Scalar.h
Executable file
88
intern/moto/include/MT_Scalar.h
Executable file
@@ -0,0 +1,88 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
* Copyright (c) 2000 Gino van den Bergen <gino@acm.org>
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Gino van den Bergen makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MT_SCALAR_H
|
||||
#define MT_SCALAR_H
|
||||
|
||||
#include <math.h>
|
||||
#include <float.h>
|
||||
|
||||
#include "MT_random.h"
|
||||
#include "NM_Scalar.h"
|
||||
|
||||
typedef double MT_Scalar;
|
||||
|
||||
const MT_Scalar MT_DEGS_PER_RAD(57.29577951308232286465);
|
||||
const MT_Scalar MT_RADS_PER_DEG(0.01745329251994329547);
|
||||
const MT_Scalar MT_PI(3.14159265358979323846);
|
||||
const MT_Scalar MT_2_PI(6.28318530717958623200);
|
||||
const MT_Scalar MT_EPSILON(1.0e-10);
|
||||
const MT_Scalar MT_EPSILON2(1.0e-20);
|
||||
const MT_Scalar MT_INFINITY(1.0e50);
|
||||
|
||||
inline int MT_sign(MT_Scalar x) {
|
||||
return x < 0.0 ? -1 : x > 0.0 ? 1 : 0;
|
||||
}
|
||||
|
||||
inline MT_Scalar MT_abs(MT_Scalar x) { return fabs(x); }
|
||||
|
||||
inline bool MT_fuzzyZero(MT_Scalar x) { return MT_abs(x) < MT_EPSILON; }
|
||||
inline bool MT_fuzzyZero2(MT_Scalar x) { return MT_abs(x) < MT_EPSILON2; }
|
||||
|
||||
inline MT_Scalar MT_radians(MT_Scalar x) {
|
||||
return x * MT_RADS_PER_DEG;
|
||||
}
|
||||
|
||||
inline MT_Scalar MT_degrees(MT_Scalar x) {
|
||||
return x * MT_DEGS_PER_RAD;
|
||||
}
|
||||
|
||||
inline MT_Scalar MT_random() {
|
||||
return MT_Scalar(MT_rand()) / MT_Scalar(MT_RAND_MAX);
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
58
intern/moto/include/MT_Stream.h
Executable file
58
intern/moto/include/MT_Stream.h
Executable file
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#ifndef GEN_STREAM_H
|
||||
|
||||
#define GEN_STREAM_H
|
||||
|
||||
#ifdef __CUSTOM_STREAM
|
||||
|
||||
class MT_OStream
|
||||
{
|
||||
public:
|
||||
inline MT_OStream& operator<<(double);
|
||||
inline MT_OStream& operator<<(int);
|
||||
inline MT_OStream& operator<<(char*);
|
||||
};
|
||||
|
||||
const char GEN_endl = '\n';
|
||||
|
||||
#else
|
||||
|
||||
#include <iostream>
|
||||
|
||||
typedef std::ostream MT_OStream;
|
||||
|
||||
inline MT_OStream& GEN_endl(MT_OStream& os) { return std::endl(os); }
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
172
intern/moto/include/MT_Transform.h
Normal file
172
intern/moto/include/MT_Transform.h
Normal file
@@ -0,0 +1,172 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
MoTo - 3D Motion Toolkit
|
||||
Copyright (C) 2000 Gino van den Bergen <gino@acm.org>
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Library General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with this library; if not, write to the Free
|
||||
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
|
||||
*/
|
||||
|
||||
#ifndef MT_TRANSFORM_H
|
||||
#define MT_TRANSFORM_H
|
||||
|
||||
#include "MT_Point3.h"
|
||||
#include "MT_Matrix3x3.h"
|
||||
|
||||
class MT_Transform {
|
||||
public:
|
||||
MT_Transform() {}
|
||||
MT_Transform(const float *m) { setValue(m); }
|
||||
MT_Transform(const double *m) { setValue(m); }
|
||||
MT_Transform(const MT_Point3& p, const MT_Quaternion& q) {
|
||||
setOrigin(p);
|
||||
setRotation(q);
|
||||
}
|
||||
|
||||
MT_Transform(const MT_Point3& p, const MT_Matrix3x3& m) {
|
||||
setOrigin(p);
|
||||
setBasis(m);
|
||||
}
|
||||
|
||||
|
||||
|
||||
MT_Point3 operator()(const MT_Point3& p) const {
|
||||
return MT_Point3(MT_dot(m_basis[0], p) + m_origin[0],
|
||||
MT_dot(m_basis[1], p) + m_origin[1],
|
||||
MT_dot(m_basis[2], p) + m_origin[2]);
|
||||
}
|
||||
|
||||
MT_Point3 operator*(const MT_Point3& p) const {
|
||||
return (*this)(p);
|
||||
}
|
||||
|
||||
MT_Matrix3x3& getBasis() { return m_basis; }
|
||||
const MT_Matrix3x3& getBasis() const { return m_basis; }
|
||||
MT_Point3& getOrigin() { return m_origin; }
|
||||
const MT_Point3& getOrigin() const { return m_origin; }
|
||||
MT_Quaternion getRotation() const { return m_basis.getRotation(); }
|
||||
|
||||
void setValue(const float *m);
|
||||
void setValue(const double *m);
|
||||
|
||||
void setOrigin(const MT_Point3& origin) {
|
||||
m_origin = origin;
|
||||
m_type |= TRANSLATION;
|
||||
}
|
||||
|
||||
void setBasis(const MT_Matrix3x3& basis) {
|
||||
m_basis = basis;
|
||||
m_type |= LINEAR;
|
||||
}
|
||||
|
||||
void setRotation(const MT_Quaternion& q) {
|
||||
m_basis.setRotation(q);
|
||||
m_type &= ~SCALING;
|
||||
m_type |= ROTATION;
|
||||
}
|
||||
|
||||
void getValue(float *m) const;
|
||||
void getValue(double *m) const;
|
||||
|
||||
void setIdentity();
|
||||
|
||||
MT_Transform& operator*=(const MT_Transform& t);
|
||||
|
||||
/**
|
||||
* Translate the origin of the transform according to the vector.
|
||||
* @param v The vector to translate over. The vector is specified
|
||||
* in the coordinate system of the transform itself.
|
||||
*/
|
||||
void translate(const MT_Vector3& v);
|
||||
void rotate(const MT_Quaternion& q);
|
||||
void scale(MT_Scalar x, MT_Scalar y, MT_Scalar z);
|
||||
|
||||
void invert(const MT_Transform& t);
|
||||
void mult(const MT_Transform& t1, const MT_Transform& t2);
|
||||
void multInverseLeft(const MT_Transform& t1, const MT_Transform& t2);
|
||||
|
||||
private:
|
||||
enum {
|
||||
IDENTITY = 0x00,
|
||||
TRANSLATION = 0x01,
|
||||
ROTATION = 0x02,
|
||||
RIGID = TRANSLATION | ROTATION,
|
||||
SCALING = 0x04,
|
||||
LINEAR = ROTATION | SCALING,
|
||||
AFFINE = TRANSLATION | LINEAR
|
||||
};
|
||||
|
||||
MT_Transform(const MT_Matrix3x3& basis, const MT_Point3& origin,
|
||||
unsigned int type) {
|
||||
setValue(basis, origin, type);
|
||||
}
|
||||
|
||||
void setValue(const MT_Matrix3x3& basis, const MT_Point3& origin,
|
||||
unsigned int type) {
|
||||
m_basis = basis;
|
||||
m_origin = origin;
|
||||
m_type = type;
|
||||
}
|
||||
|
||||
friend MT_Transform operator*(const MT_Transform& t1, const MT_Transform& t2);
|
||||
|
||||
MT_Matrix3x3 m_basis;
|
||||
MT_Point3 m_origin;
|
||||
unsigned int m_type;
|
||||
};
|
||||
|
||||
inline MT_Transform operator*(const MT_Transform& t1, const MT_Transform& t2) {
|
||||
return MT_Transform(t1.m_basis * t2.m_basis,
|
||||
t1(t2.m_origin),
|
||||
t1.m_type | t2.m_type);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
109
intern/moto/include/MT_Tuple2.h
Executable file
109
intern/moto/include/MT_Tuple2.h
Executable file
@@ -0,0 +1,109 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
* Copyright (c) 2000 Gino van den Bergen <gino@acm.org>
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Gino van den Bergen makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MT_Tuple2_H
|
||||
#define MT_Tuple2_H
|
||||
|
||||
#include "MT_Stream.h"
|
||||
#include "MT_Scalar.h"
|
||||
|
||||
class MT_Tuple2 {
|
||||
public:
|
||||
MT_Tuple2() {}
|
||||
MT_Tuple2(const float *v) { setValue(v); }
|
||||
MT_Tuple2(const double *v) { setValue(v); }
|
||||
MT_Tuple2(MT_Scalar x, MT_Scalar y) { setValue(x, y); }
|
||||
|
||||
MT_Scalar& operator[](int i) { return m_co[i]; }
|
||||
const MT_Scalar& operator[](int i) const { return m_co[i]; }
|
||||
|
||||
MT_Scalar& x() { return m_co[0]; }
|
||||
const MT_Scalar& x() const { return m_co[0]; }
|
||||
|
||||
MT_Scalar& y() { return m_co[1]; }
|
||||
const MT_Scalar& y() const { return m_co[1]; }
|
||||
|
||||
MT_Scalar& u() { return m_co[0]; }
|
||||
const MT_Scalar& u() const { return m_co[0]; }
|
||||
|
||||
MT_Scalar& v() { return m_co[1]; }
|
||||
const MT_Scalar& v() const { return m_co[1]; }
|
||||
|
||||
MT_Scalar *getValue() { return m_co; }
|
||||
const MT_Scalar *getValue() const { return m_co; }
|
||||
|
||||
void getValue(float *v) const {
|
||||
v[0] = m_co[0]; v[1] = m_co[1];
|
||||
}
|
||||
|
||||
void getValue(double *v) const {
|
||||
v[0] = m_co[0]; v[1] = m_co[1];
|
||||
}
|
||||
|
||||
void setValue(const float *v) {
|
||||
m_co[0] = v[0]; m_co[1] = v[1];
|
||||
}
|
||||
|
||||
void setValue(const double *v) {
|
||||
m_co[0] = v[0]; m_co[1] = v[1];
|
||||
}
|
||||
|
||||
void setValue(MT_Scalar x, MT_Scalar y) {
|
||||
m_co[0] = x; m_co[1] = y;
|
||||
}
|
||||
|
||||
protected:
|
||||
MT_Scalar m_co[2];
|
||||
};
|
||||
|
||||
inline bool operator==(const MT_Tuple2& t1, const MT_Tuple2& t2) {
|
||||
return t1[0] == t2[0] && t1[1] == t2[1];
|
||||
}
|
||||
|
||||
inline MT_OStream& operator<<(MT_OStream& os, const MT_Tuple2& t) {
|
||||
return os << t[0] << ' ' << t[1];
|
||||
}
|
||||
|
||||
#endif
|
||||
114
intern/moto/include/MT_Tuple3.h
Executable file
114
intern/moto/include/MT_Tuple3.h
Executable file
@@ -0,0 +1,114 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
* Copyright (c) 2000 Gino van den Bergen <gino@acm.org>
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Gino van den Bergen makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MT_TUPLE3_H
|
||||
#define MT_TUPLE3_H
|
||||
|
||||
#include "MT_Stream.h"
|
||||
#include "MT_Scalar.h"
|
||||
|
||||
class MT_Tuple3 {
|
||||
public:
|
||||
MT_Tuple3() {}
|
||||
MT_Tuple3(const float *v) { setValue(v); }
|
||||
MT_Tuple3(const double *v) { setValue(v); }
|
||||
MT_Tuple3(MT_Scalar x, MT_Scalar y, MT_Scalar z) { setValue(x, y, z); }
|
||||
|
||||
MT_Scalar& operator[](int i) { return m_co[i]; }
|
||||
const MT_Scalar& operator[](int i) const { return m_co[i]; }
|
||||
|
||||
MT_Scalar& x() { return m_co[0]; }
|
||||
const MT_Scalar& x() const { return m_co[0]; }
|
||||
|
||||
MT_Scalar& y() { return m_co[1]; }
|
||||
const MT_Scalar& y() const { return m_co[1]; }
|
||||
|
||||
MT_Scalar& z() { return m_co[2]; }
|
||||
const MT_Scalar& z() const { return m_co[2]; }
|
||||
|
||||
MT_Scalar *getValue() { return m_co; }
|
||||
const MT_Scalar *getValue() const { return m_co; }
|
||||
|
||||
void getValue(float *v) const {
|
||||
v[0] = float(m_co[0]);
|
||||
v[1] = float(m_co[1]);
|
||||
v[2] = float(m_co[2]);
|
||||
}
|
||||
|
||||
void getValue(double *v) const {
|
||||
v[0] = double(m_co[0]);
|
||||
v[1] = double(m_co[1]);
|
||||
v[2] = double(m_co[2]);
|
||||
}
|
||||
|
||||
void setValue(const float *v) {
|
||||
m_co[0] = MT_Scalar(v[0]);
|
||||
m_co[1] = MT_Scalar(v[1]);
|
||||
m_co[2] = MT_Scalar(v[2]);
|
||||
}
|
||||
|
||||
void setValue(const double *v) {
|
||||
m_co[0] = MT_Scalar(v[0]);
|
||||
m_co[1] = MT_Scalar(v[1]);
|
||||
m_co[2] = MT_Scalar(v[2]);
|
||||
}
|
||||
|
||||
void setValue(MT_Scalar x, MT_Scalar y, MT_Scalar z) {
|
||||
m_co[0] = x; m_co[1] = y; m_co[2] = z;
|
||||
}
|
||||
|
||||
protected:
|
||||
MT_Scalar m_co[3];
|
||||
};
|
||||
|
||||
inline bool operator==(const MT_Tuple3& t1, const MT_Tuple3& t2) {
|
||||
return t1[0] == t2[0] && t1[1] == t2[1] && t1[2] == t2[2];
|
||||
}
|
||||
|
||||
inline MT_OStream& operator<<(MT_OStream& os, const MT_Tuple3& t) {
|
||||
return os << t[0] << ' ' << t[1] << ' ' << t[2];
|
||||
}
|
||||
|
||||
#endif
|
||||
124
intern/moto/include/MT_Tuple4.h
Executable file
124
intern/moto/include/MT_Tuple4.h
Executable file
@@ -0,0 +1,124 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
* Copyright (c) 2000 Gino van den Bergen <gino@acm.org>
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Gino van den Bergen makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MT_TUPLE4_H
|
||||
#define MT_TUPLE4_H
|
||||
|
||||
#include "MT_Stream.h"
|
||||
#include "MT_Scalar.h"
|
||||
|
||||
class MT_Tuple4 {
|
||||
public:
|
||||
MT_Tuple4() {}
|
||||
MT_Tuple4(const float *v) { setValue(v); }
|
||||
MT_Tuple4(const double *v) { setValue(v); }
|
||||
MT_Tuple4(MT_Scalar x, MT_Scalar y, MT_Scalar z, MT_Scalar w) {
|
||||
setValue(x, y, z, w);
|
||||
}
|
||||
|
||||
MT_Scalar& operator[](int i) { return m_co[i]; }
|
||||
const MT_Scalar& operator[](int i) const { return m_co[i]; }
|
||||
|
||||
MT_Scalar& x() { return m_co[0]; }
|
||||
const MT_Scalar& x() const { return m_co[0]; }
|
||||
|
||||
MT_Scalar& y() { return m_co[1]; }
|
||||
const MT_Scalar& y() const { return m_co[1]; }
|
||||
|
||||
MT_Scalar& z() { return m_co[2]; }
|
||||
const MT_Scalar& z() const { return m_co[2]; }
|
||||
|
||||
MT_Scalar& w() { return m_co[3]; }
|
||||
const MT_Scalar& w() const { return m_co[3]; }
|
||||
|
||||
MT_Scalar *getValue() { return m_co; }
|
||||
const MT_Scalar *getValue() const { return m_co; }
|
||||
|
||||
|
||||
void getValue(float *v) const {
|
||||
v[0] = float(m_co[0]);
|
||||
v[1] = float(m_co[1]);
|
||||
v[2] = float(m_co[2]);
|
||||
v[3] = float(m_co[3]);
|
||||
}
|
||||
|
||||
void getValue(double *v) const {
|
||||
v[0] = double(m_co[0]);
|
||||
v[1] = double(m_co[1]);
|
||||
v[2] = double(m_co[2]);
|
||||
v[3] = double(m_co[3]);
|
||||
}
|
||||
|
||||
void setValue(const float *v) {
|
||||
m_co[0] = MT_Scalar(v[0]);
|
||||
m_co[1] = MT_Scalar(v[1]);
|
||||
m_co[2] = MT_Scalar(v[2]);
|
||||
m_co[3] = MT_Scalar(v[3]);
|
||||
}
|
||||
|
||||
void setValue(const double *v) {
|
||||
m_co[0] = MT_Scalar(v[0]);
|
||||
m_co[1] = MT_Scalar(v[1]);
|
||||
m_co[2] = MT_Scalar(v[2]);
|
||||
m_co[3] = MT_Scalar(v[3]);
|
||||
}
|
||||
|
||||
void setValue(MT_Scalar x, MT_Scalar y, MT_Scalar z, MT_Scalar w) {
|
||||
m_co[0] = x; m_co[1] = y; m_co[2] = z; m_co[3] = w;
|
||||
}
|
||||
|
||||
protected:
|
||||
MT_Scalar m_co[4];
|
||||
};
|
||||
|
||||
inline bool operator==(const MT_Tuple4& t1, const MT_Tuple4& t2) {
|
||||
return t1[0] == t2[0] && t1[1] == t2[1] && t1[2] == t2[2] && t1[3] == t2[3];
|
||||
}
|
||||
|
||||
inline MT_OStream& operator<<(MT_OStream& os, const MT_Tuple4& t) {
|
||||
return os << t[0] << ' ' << t[1] << ' ' << t[2] << ' ' << t[3];
|
||||
}
|
||||
|
||||
#endif
|
||||
112
intern/moto/include/MT_Vector2.h
Normal file
112
intern/moto/include/MT_Vector2.h
Normal file
@@ -0,0 +1,112 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
* Copyright (c) 2000 Gino van den Bergen <gino@acm.org>
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Gino van den Bergen makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MT_VECTOR2_H
|
||||
#define MT_VECTOR2_H
|
||||
|
||||
#include <MT_assert.h>
|
||||
#include "MT_Tuple2.h"
|
||||
|
||||
class MT_Vector2 : public MT_Tuple2 {
|
||||
public:
|
||||
MT_Vector2() {}
|
||||
MT_Vector2(const float *v) : MT_Tuple2(v) {}
|
||||
MT_Vector2(const double *v) : MT_Tuple2(v) {}
|
||||
MT_Vector2(MT_Scalar x, MT_Scalar y) : MT_Tuple2(x, y) {}
|
||||
|
||||
MT_Vector2& operator+=(const MT_Vector2& v);
|
||||
MT_Vector2& operator-=(const MT_Vector2& v);
|
||||
MT_Vector2& operator*=(MT_Scalar s);
|
||||
MT_Vector2& operator/=(MT_Scalar s);
|
||||
|
||||
MT_Scalar dot(const MT_Vector2& v) const;
|
||||
|
||||
MT_Scalar length2() const;
|
||||
MT_Scalar length() const;
|
||||
|
||||
MT_Vector2 absolute() const;
|
||||
|
||||
void normalize();
|
||||
MT_Vector2 normalized() const;
|
||||
|
||||
void scale(MT_Scalar x, MT_Scalar y);
|
||||
MT_Vector2 scaled(MT_Scalar x, MT_Scalar y) const;
|
||||
|
||||
bool fuzzyZero() const;
|
||||
|
||||
MT_Scalar angle(const MT_Vector2& v) const;
|
||||
MT_Vector2 cross(const MT_Vector2& v) const;
|
||||
MT_Scalar triple(const MT_Vector2& v1, const MT_Vector2& v2) const;
|
||||
|
||||
int closestAxis() const;
|
||||
|
||||
static MT_Vector2 random();
|
||||
};
|
||||
|
||||
MT_Vector2 operator+(const MT_Vector2& v1, const MT_Vector2& v2);
|
||||
MT_Vector2 operator-(const MT_Vector2& v1, const MT_Vector2& v2);
|
||||
MT_Vector2 operator-(const MT_Vector2& v);
|
||||
MT_Vector2 operator*(const MT_Vector2& v, MT_Scalar s);
|
||||
MT_Vector2 operator*(MT_Scalar s, const MT_Vector2& v);
|
||||
MT_Vector2 operator/(const MT_Vector2& v, MT_Scalar s);
|
||||
|
||||
MT_Scalar MT_dot(const MT_Vector2& v1, const MT_Vector2& v2);
|
||||
|
||||
MT_Scalar MT_length2(const MT_Vector2& v);
|
||||
MT_Scalar MT_length(const MT_Vector2& v);
|
||||
|
||||
bool MT_fuzzyZero(const MT_Vector2& v);
|
||||
bool MT_fuzzyEqual(const MT_Vector2& v1, const MT_Vector2& v2);
|
||||
|
||||
MT_Scalar MT_angle(const MT_Vector2& v1, const MT_Vector2& v2);
|
||||
MT_Vector2 MT_cross(const MT_Vector2& v1, const MT_Vector2& v2);
|
||||
MT_Scalar MT_triple(const MT_Vector2& v1, const MT_Vector2& v2,
|
||||
const MT_Vector2& v3);
|
||||
|
||||
#ifdef GEN_INLINED
|
||||
#include "MT_Vector2.inl"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
89
intern/moto/include/MT_Vector2.inl
Normal file
89
intern/moto/include/MT_Vector2.inl
Normal file
@@ -0,0 +1,89 @@
|
||||
#include "MT_Optimize.h"
|
||||
|
||||
GEN_INLINE MT_Vector2& MT_Vector2::operator+=(const MT_Vector2& v) {
|
||||
m_co[0] += v[0]; m_co[1] += v[1];
|
||||
return *this;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector2& MT_Vector2::operator-=(const MT_Vector2& v) {
|
||||
m_co[0] -= v[0]; m_co[1] -= v[1];
|
||||
return *this;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector2& MT_Vector2::operator*=(MT_Scalar s) {
|
||||
m_co[0] *= s; m_co[1] *= s;
|
||||
return *this;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector2& MT_Vector2::operator/=(MT_Scalar s) {
|
||||
MT_assert(!MT_fuzzyZero(s));
|
||||
return *this *= 1.0 / s;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector2 operator+(const MT_Vector2& v1, const MT_Vector2& v2) {
|
||||
return MT_Vector2(v1[0] + v2[0], v1[1] + v2[1]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector2 operator-(const MT_Vector2& v1, const MT_Vector2& v2) {
|
||||
return MT_Vector2(v1[0] - v2[0], v1[1] - v2[1]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector2 operator-(const MT_Vector2& v) {
|
||||
return MT_Vector2(-v[0], -v[1]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector2 operator*(const MT_Vector2& v, MT_Scalar s) {
|
||||
return MT_Vector2(v[0] * s, v[1] * s);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector2 operator*(MT_Scalar s, const MT_Vector2& v) { return v * s; }
|
||||
|
||||
GEN_INLINE MT_Vector2 operator/(const MT_Vector2& v, MT_Scalar s) {
|
||||
MT_assert(!MT_fuzzyZero(s));
|
||||
return v * (1.0 / s);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_Vector2::dot(const MT_Vector2& v) const {
|
||||
return m_co[0] * v[0] + m_co[1] * v[1];
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_Vector2::length2() const { return dot(*this); }
|
||||
GEN_INLINE MT_Scalar MT_Vector2::length() const { return sqrt(length2()); }
|
||||
|
||||
GEN_INLINE MT_Vector2 MT_Vector2::absolute() const {
|
||||
return MT_Vector2(MT_abs(m_co[0]), MT_abs(m_co[1]));
|
||||
}
|
||||
|
||||
GEN_INLINE bool MT_Vector2::fuzzyZero() const { return MT_fuzzyZero2(length2()); }
|
||||
|
||||
GEN_INLINE void MT_Vector2::normalize() { *this /= length(); }
|
||||
GEN_INLINE MT_Vector2 MT_Vector2::normalized() const { return *this / length(); }
|
||||
|
||||
GEN_INLINE void MT_Vector2::scale(MT_Scalar x, MT_Scalar y) {
|
||||
m_co[0] *= x; m_co[1] *= y;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector2 MT_Vector2::scaled(MT_Scalar x, MT_Scalar y) const {
|
||||
return MT_Vector2(m_co[0] * x, m_co[1] * y);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_Vector2::angle(const MT_Vector2& v) const {
|
||||
MT_Scalar s = sqrt(length2() * v.length2());
|
||||
MT_assert(!MT_fuzzyZero(s));
|
||||
return acos(dot(v) / s);
|
||||
}
|
||||
|
||||
|
||||
GEN_INLINE MT_Scalar MT_dot(const MT_Vector2& v1, const MT_Vector2& v2) {
|
||||
return v1.dot(v2);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_length2(const MT_Vector2& v) { return v.length2(); }
|
||||
GEN_INLINE MT_Scalar MT_length(const MT_Vector2& v) { return v.length(); }
|
||||
|
||||
GEN_INLINE bool MT_fuzzyZero(const MT_Vector2& v) { return v.fuzzyZero(); }
|
||||
GEN_INLINE bool MT_fuzzyEqual(const MT_Vector2& v1, const MT_Vector2& v2) {
|
||||
return MT_fuzzyZero(v1 - v2);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_angle(const MT_Vector2& v1, const MT_Vector2& v2) { return v1.angle(v2); }
|
||||
118
intern/moto/include/MT_Vector3.h
Normal file
118
intern/moto/include/MT_Vector3.h
Normal file
@@ -0,0 +1,118 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
* Copyright (c) 2000 Gino van den Bergen <gino@acm.org>
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Gino van den Bergen makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MT_VECTOR3_H
|
||||
#define MT_VECTOR3_H
|
||||
|
||||
#include <MT_assert.h>
|
||||
#include "MT_Tuple3.h"
|
||||
|
||||
class MT_Vector3 : public MT_Tuple3 {
|
||||
public:
|
||||
MT_Vector3() {}
|
||||
MT_Vector3(const float *v) : MT_Tuple3(v) {}
|
||||
MT_Vector3(const double *v) : MT_Tuple3(v) {}
|
||||
MT_Vector3(MT_Scalar x, MT_Scalar y, MT_Scalar z) : MT_Tuple3(x, y, z) {}
|
||||
|
||||
MT_Vector3& operator+=(const MT_Vector3& v);
|
||||
MT_Vector3& operator-=(const MT_Vector3& v);
|
||||
MT_Vector3& operator*=(MT_Scalar s);
|
||||
MT_Vector3& operator/=(MT_Scalar s);
|
||||
|
||||
MT_Scalar dot(const MT_Vector3& v) const;
|
||||
|
||||
MT_Scalar length2() const;
|
||||
MT_Scalar length() const;
|
||||
|
||||
MT_Vector3 absolute() const;
|
||||
|
||||
void noiseGate(MT_Scalar threshold);
|
||||
|
||||
void normalize();
|
||||
MT_Vector3 normalized() const;
|
||||
MT_Vector3 safe_normalized() const;
|
||||
|
||||
|
||||
void scale(MT_Scalar x, MT_Scalar y, MT_Scalar z);
|
||||
MT_Vector3 scaled(MT_Scalar x, MT_Scalar y, MT_Scalar z) const;
|
||||
|
||||
bool fuzzyZero() const;
|
||||
|
||||
MT_Scalar angle(const MT_Vector3& v) const;
|
||||
MT_Vector3 cross(const MT_Vector3& v) const;
|
||||
MT_Scalar triple(const MT_Vector3& v1, const MT_Vector3& v2) const;
|
||||
|
||||
int closestAxis() const;
|
||||
|
||||
static MT_Vector3 random();
|
||||
};
|
||||
|
||||
MT_Vector3 operator+(const MT_Vector3& v1, const MT_Vector3& v2);
|
||||
MT_Vector3 operator-(const MT_Vector3& v1, const MT_Vector3& v2);
|
||||
MT_Vector3 operator-(const MT_Vector3& v);
|
||||
MT_Vector3 operator*(const MT_Vector3& v, MT_Scalar s);
|
||||
MT_Vector3 operator*(MT_Scalar s, const MT_Vector3& v);
|
||||
MT_Vector3 operator/(const MT_Vector3& v, MT_Scalar s);
|
||||
|
||||
MT_Vector3 operator*(const MT_Vector3& v1, const MT_Vector3& v2);
|
||||
|
||||
MT_Scalar MT_dot(const MT_Vector3& v1, const MT_Vector3& v2);
|
||||
|
||||
MT_Scalar MT_length2(const MT_Vector3& v);
|
||||
MT_Scalar MT_length(const MT_Vector3& v);
|
||||
|
||||
bool MT_fuzzyZero(const MT_Vector3& v);
|
||||
bool MT_fuzzyEqual(const MT_Vector3& v1, const MT_Vector3& v2);
|
||||
|
||||
MT_Scalar MT_angle(const MT_Vector3& v1, const MT_Vector3& v2);
|
||||
MT_Vector3 MT_cross(const MT_Vector3& v1, const MT_Vector3& v2);
|
||||
MT_Scalar MT_triple(const MT_Vector3& v1, const MT_Vector3& v2,
|
||||
const MT_Vector3& v3);
|
||||
|
||||
#ifdef GEN_INLINED
|
||||
#include "MT_Vector3.inl"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
134
intern/moto/include/MT_Vector3.inl
Normal file
134
intern/moto/include/MT_Vector3.inl
Normal file
@@ -0,0 +1,134 @@
|
||||
#include "MT_Optimize.h"
|
||||
|
||||
GEN_INLINE MT_Vector3& MT_Vector3::operator+=(const MT_Vector3& v) {
|
||||
m_co[0] += v[0]; m_co[1] += v[1]; m_co[2] += v[2];
|
||||
return *this;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector3& MT_Vector3::operator-=(const MT_Vector3& v) {
|
||||
m_co[0] -= v[0]; m_co[1] -= v[1]; m_co[2] -= v[2];
|
||||
return *this;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector3& MT_Vector3::operator*=(MT_Scalar s) {
|
||||
m_co[0] *= s; m_co[1] *= s; m_co[2] *= s;
|
||||
return *this;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector3& MT_Vector3::operator/=(MT_Scalar s) {
|
||||
MT_assert(!MT_fuzzyZero(s));
|
||||
return *this *= MT_Scalar(1.0) / s;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector3 operator+(const MT_Vector3& v1, const MT_Vector3& v2) {
|
||||
return MT_Vector3(v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector3 operator-(const MT_Vector3& v1, const MT_Vector3& v2) {
|
||||
return MT_Vector3(v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector3 operator-(const MT_Vector3& v) {
|
||||
return MT_Vector3(-v[0], -v[1], -v[2]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector3 operator*(const MT_Vector3& v, MT_Scalar s) {
|
||||
return MT_Vector3(v[0] * s, v[1] * s, v[2] * s);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector3 operator*(MT_Scalar s, const MT_Vector3& v) { return v * s; }
|
||||
|
||||
GEN_INLINE MT_Vector3 operator/(const MT_Vector3& v, MT_Scalar s) {
|
||||
MT_assert(!MT_fuzzyZero(s));
|
||||
return v * (MT_Scalar(1.0) / s);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector3 operator*(const MT_Vector3& v1, const MT_Vector3& v2) {
|
||||
return MT_Vector3(v1[0] * v2[0], v1[1] * v2[1], v1[2] * v2[2]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_Vector3::dot(const MT_Vector3& v) const {
|
||||
return m_co[0] * v[0] + m_co[1] * v[1] + m_co[2] * v[2];
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_Vector3::length2() const { return dot(*this); }
|
||||
GEN_INLINE MT_Scalar MT_Vector3::length() const { return sqrt(length2()); }
|
||||
|
||||
GEN_INLINE MT_Vector3 MT_Vector3::absolute() const {
|
||||
return MT_Vector3(MT_abs(m_co[0]), MT_abs(m_co[1]), MT_abs(m_co[2]));
|
||||
}
|
||||
|
||||
GEN_INLINE bool MT_Vector3::fuzzyZero() const {
|
||||
return MT_fuzzyZero(length2());
|
||||
}
|
||||
|
||||
GEN_INLINE void MT_Vector3::noiseGate(MT_Scalar threshold) {
|
||||
if (length2() < threshold) {
|
||||
setValue(MT_Scalar(0.0), MT_Scalar(0.0), MT_Scalar(0.0));
|
||||
}
|
||||
}
|
||||
|
||||
GEN_INLINE void MT_Vector3::normalize() { *this /= length(); }
|
||||
GEN_INLINE MT_Vector3 MT_Vector3::normalized() const { return *this / length(); }
|
||||
GEN_INLINE MT_Vector3 MT_Vector3::safe_normalized() const {
|
||||
MT_Scalar len = length();
|
||||
return MT_fuzzyZero(len) ?
|
||||
MT_Vector3(MT_Scalar(1.0), MT_Scalar(0.0), MT_Scalar(0.0)) :
|
||||
*this / len;
|
||||
}
|
||||
|
||||
GEN_INLINE void MT_Vector3::scale(MT_Scalar x, MT_Scalar y, MT_Scalar z) {
|
||||
m_co[0] *= x; m_co[1] *= y; m_co[2] *= z;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector3 MT_Vector3::scaled(MT_Scalar x, MT_Scalar y, MT_Scalar z) const {
|
||||
return MT_Vector3(m_co[0] * x, m_co[1] * y, m_co[2] * z);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_Vector3::angle(const MT_Vector3& v) const {
|
||||
MT_Scalar s = sqrt(length2() * v.length2());
|
||||
MT_assert(!MT_fuzzyZero(s));
|
||||
return acos(dot(v) / s);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector3 MT_Vector3::cross(const MT_Vector3& v) const {
|
||||
return MT_Vector3(m_co[1] * v[2] - m_co[2] * v[1],
|
||||
m_co[2] * v[0] - m_co[0] * v[2],
|
||||
m_co[0] * v[1] - m_co[1] * v[0]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_Vector3::triple(const MT_Vector3& v1, const MT_Vector3& v2) const {
|
||||
return m_co[0] * (v1[1] * v2[2] - v1[2] * v2[1]) +
|
||||
m_co[1] * (v1[2] * v2[0] - v1[0] * v2[2]) +
|
||||
m_co[2] * (v1[0] * v2[1] - v1[1] * v2[0]);
|
||||
}
|
||||
|
||||
GEN_INLINE int MT_Vector3::closestAxis() const {
|
||||
MT_Vector3 a = absolute();
|
||||
return a[0] < a[1] ? (a[1] < a[2] ? 2 : 1) : (a[0] < a[2] ? 2 : 0);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector3 MT_Vector3::random() {
|
||||
MT_Scalar z = MT_Scalar(2.0) * MT_random() - MT_Scalar(1.0);
|
||||
MT_Scalar r = sqrt(MT_Scalar(1.0) - z * z);
|
||||
MT_Scalar t = MT_2_PI * MT_random();
|
||||
return MT_Vector3(r * cos(t), r * sin(t), z);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_dot(const MT_Vector3& v1, const MT_Vector3& v2) {
|
||||
return v1.dot(v2);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_length2(const MT_Vector3& v) { return v.length2(); }
|
||||
GEN_INLINE MT_Scalar MT_length(const MT_Vector3& v) { return v.length(); }
|
||||
|
||||
GEN_INLINE bool MT_fuzzyZero(const MT_Vector3& v) { return v.fuzzyZero(); }
|
||||
GEN_INLINE bool MT_fuzzyEqual(const MT_Vector3& v1, const MT_Vector3& v2) {
|
||||
return MT_fuzzyZero(v1 - v2);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_angle(const MT_Vector3& v1, const MT_Vector3& v2) { return v1.angle(v2); }
|
||||
GEN_INLINE MT_Vector3 MT_cross(const MT_Vector3& v1, const MT_Vector3& v2) { return v1.cross(v2); }
|
||||
GEN_INLINE MT_Scalar MT_triple(const MT_Vector3& v1, const MT_Vector3& v2, const MT_Vector3& v3) {
|
||||
return v1.triple(v2, v3);
|
||||
}
|
||||
102
intern/moto/include/MT_Vector4.h
Normal file
102
intern/moto/include/MT_Vector4.h
Normal file
@@ -0,0 +1,102 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
* Copyright (c) 2000 Gino van den Bergen <gino@acm.org>
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Gino van den Bergen makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MT_VECTOR4_H
|
||||
#define MT_VECTOR4_H
|
||||
|
||||
#include <MT_assert.h>
|
||||
|
||||
#include "MT_Tuple4.h"
|
||||
|
||||
class MT_Vector4 : public MT_Tuple4 {
|
||||
public:
|
||||
MT_Vector4() {}
|
||||
MT_Vector4(const float *v) : MT_Tuple4(v) {}
|
||||
MT_Vector4(const double *v) : MT_Tuple4(v) {}
|
||||
MT_Vector4(MT_Scalar x, MT_Scalar y, MT_Scalar z, MT_Scalar w) :
|
||||
MT_Tuple4(x, y, z, w) {}
|
||||
|
||||
MT_Vector4& operator+=(const MT_Vector4& v);
|
||||
MT_Vector4& operator-=(const MT_Vector4& v);
|
||||
MT_Vector4& operator*=(MT_Scalar s);
|
||||
MT_Vector4& operator/=(MT_Scalar s);
|
||||
|
||||
MT_Scalar dot(const MT_Vector4& v) const;
|
||||
|
||||
MT_Scalar length2() const;
|
||||
MT_Scalar length() const;
|
||||
|
||||
MT_Vector4 absolute() const;
|
||||
|
||||
void normalize();
|
||||
MT_Vector4 normalized() const;
|
||||
|
||||
void scale(MT_Scalar x, MT_Scalar y, MT_Scalar z, MT_Scalar w);
|
||||
MT_Vector4 scaled(MT_Scalar x, MT_Scalar y, MT_Scalar z, MT_Scalar w) const;
|
||||
|
||||
bool fuzzyZero() const;
|
||||
};
|
||||
|
||||
MT_Vector4 operator+(const MT_Vector4& v1, const MT_Vector4& v2);
|
||||
MT_Vector4 operator-(const MT_Vector4& v1, const MT_Vector4& v2);
|
||||
MT_Vector4 operator-(const MT_Vector4& v);
|
||||
MT_Vector4 operator*(const MT_Vector4& v, MT_Scalar s);
|
||||
MT_Vector4 operator*(MT_Scalar s, const MT_Vector4& v);
|
||||
MT_Vector4 operator/(const MT_Vector4& v, MT_Scalar s);
|
||||
|
||||
MT_Scalar MT_dot(const MT_Vector4& v1, const MT_Vector4& v2);
|
||||
|
||||
MT_Scalar MT_length2(const MT_Vector4& v);
|
||||
MT_Scalar MT_length(const MT_Vector4& v);
|
||||
|
||||
bool MT_fuzzyZero(const MT_Vector4& v);
|
||||
bool MT_fuzzyEqual(const MT_Vector4& v1, const MT_Vector4& v2);
|
||||
|
||||
#ifdef GEN_INLINED
|
||||
#include "MT_Vector4.inl"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
80
intern/moto/include/MT_Vector4.inl
Normal file
80
intern/moto/include/MT_Vector4.inl
Normal file
@@ -0,0 +1,80 @@
|
||||
#include "MT_Optimize.h"
|
||||
|
||||
GEN_INLINE MT_Vector4& MT_Vector4::operator+=(const MT_Vector4& v) {
|
||||
m_co[0] += v[0]; m_co[1] += v[1]; m_co[2] += v[2]; m_co[3] += v[3];
|
||||
return *this;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector4& MT_Vector4::operator-=(const MT_Vector4& v) {
|
||||
m_co[0] -= v[0]; m_co[1] -= v[1]; m_co[2] -= v[2]; m_co[3] -= v[3];
|
||||
return *this;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector4& MT_Vector4::operator*=(MT_Scalar s) {
|
||||
m_co[0] *= s; m_co[1] *= s; m_co[2] *= s; m_co[3] *= s;
|
||||
return *this;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector4& MT_Vector4::operator/=(MT_Scalar s) {
|
||||
MT_assert(!MT_fuzzyZero(s));
|
||||
return *this *= MT_Scalar(1.0) / s;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector4 operator+(const MT_Vector4& v1, const MT_Vector4& v2) {
|
||||
return MT_Vector4(v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2], v1[3] + v2[3]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector4 operator-(const MT_Vector4& v1, const MT_Vector4& v2) {
|
||||
return MT_Vector4(v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2], v1[3] - v2[3]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector4 operator-(const MT_Vector4& v) {
|
||||
return MT_Vector4(-v[0], -v[1], -v[2], -v[3]);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector4 operator*(const MT_Vector4& v, MT_Scalar s) {
|
||||
return MT_Vector4(v[0] * s, v[1] * s, v[2] * s, v[3] * s);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector4 operator*(MT_Scalar s, const MT_Vector4& v) { return v * s; }
|
||||
|
||||
GEN_INLINE MT_Vector4 operator/(const MT_Vector4& v, MT_Scalar s) {
|
||||
MT_assert(!MT_fuzzyZero(s));
|
||||
return v * (MT_Scalar(1.0) / s);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_Vector4::dot(const MT_Vector4& v) const {
|
||||
return m_co[0] * v[0] + m_co[1] * v[1] + m_co[2] * v[2] + m_co[3] * v[3];
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_Vector4::length2() const { return MT_dot(*this, *this); }
|
||||
GEN_INLINE MT_Scalar MT_Vector4::length() const { return sqrt(length2()); }
|
||||
|
||||
GEN_INLINE MT_Vector4 MT_Vector4::absolute() const {
|
||||
return MT_Vector4(MT_abs(m_co[0]), MT_abs(m_co[1]), MT_abs(m_co[2]), MT_abs(m_co[3]));
|
||||
}
|
||||
|
||||
GEN_INLINE void MT_Vector4::scale(MT_Scalar x, MT_Scalar y, MT_Scalar z, MT_Scalar w) {
|
||||
m_co[0] *= x; m_co[1] *= y; m_co[2] *= z; m_co[3] *= w;
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Vector4 MT_Vector4::scaled(MT_Scalar x, MT_Scalar y, MT_Scalar z, MT_Scalar w) const {
|
||||
return MT_Vector4(m_co[0] * x, m_co[1] * y, m_co[2] * z, m_co[3] * w);
|
||||
}
|
||||
|
||||
GEN_INLINE bool MT_Vector4::fuzzyZero() const { return MT_fuzzyZero2(length2()); }
|
||||
|
||||
GEN_INLINE void MT_Vector4::normalize() { *this /= length(); }
|
||||
GEN_INLINE MT_Vector4 MT_Vector4::normalized() const { return *this / length(); }
|
||||
|
||||
GEN_INLINE MT_Scalar MT_dot(const MT_Vector4& v1, const MT_Vector4& v2) {
|
||||
return v1.dot(v2);
|
||||
}
|
||||
|
||||
GEN_INLINE MT_Scalar MT_length2(const MT_Vector4& v) { return v.length2(); }
|
||||
GEN_INLINE MT_Scalar MT_length(const MT_Vector4& v) { return v.length(); }
|
||||
|
||||
GEN_INLINE bool MT_fuzzyZero(const MT_Vector4& v) { return v.fuzzyZero(); }
|
||||
GEN_INLINE bool MT_fuzzyEqual(const MT_Vector4& v1, const MT_Vector4& v2) {
|
||||
return MT_fuzzyZero(v1 - v2);
|
||||
}
|
||||
51
intern/moto/include/MT_assert.h
Normal file
51
intern/moto/include/MT_assert.h
Normal file
@@ -0,0 +1,51 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#ifndef MT_ASSERT_H
|
||||
|
||||
#define MT_ASSERT_H
|
||||
|
||||
#ifdef MT_NDEBUG
|
||||
|
||||
#define MT_assert(predicate) ((void)0)
|
||||
|
||||
#else
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#define MT_assert(predicate) assert(predicate)
|
||||
|
||||
#endif /* MT_NDEBUG */
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
44
intern/moto/include/MT_random.h
Executable file
44
intern/moto/include/MT_random.h
Executable file
@@ -0,0 +1,44 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#ifndef MT_RANDOM_H
|
||||
|
||||
#define MT_RANDOM_H
|
||||
|
||||
#include <limits.h>
|
||||
|
||||
#define MT_RAND_MAX ULONG_MAX
|
||||
|
||||
extern void MT_srand(unsigned long);
|
||||
extern unsigned long MT_rand();
|
||||
|
||||
#endif
|
||||
|
||||
166
intern/moto/include/NM_Scalar.h
Normal file
166
intern/moto/include/NM_Scalar.h
Normal file
@@ -0,0 +1,166 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include <math.h>
|
||||
|
||||
#include <iostream>
|
||||
|
||||
template <class T>
|
||||
class NM_Scalar {
|
||||
public:
|
||||
NM_Scalar() {}
|
||||
explicit NM_Scalar(T value, T error = 0.0) :
|
||||
m_value(value), m_error(error) {}
|
||||
|
||||
T getValue() const { return m_value; }
|
||||
T getError() const { return m_error; }
|
||||
|
||||
operator T() const { return m_value; }
|
||||
|
||||
NM_Scalar operator-() const {
|
||||
return NM_Scalar<T>(-m_value, m_error);
|
||||
}
|
||||
|
||||
NM_Scalar& operator=(T value) {
|
||||
m_value = value;
|
||||
m_error = 0.0;
|
||||
return *this;
|
||||
}
|
||||
|
||||
NM_Scalar& operator+=(const NM_Scalar& x) {
|
||||
m_value += x.m_value;
|
||||
m_error = (fabs(m_value) * (m_error + 1.0) +
|
||||
fabs(x.m_value) * (x.m_error + 1.0)) /
|
||||
fabs(m_value + x.m_value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
NM_Scalar& operator-=(const NM_Scalar& x) {
|
||||
m_value -= x.m_value;
|
||||
m_error = (fabs(m_value) * (m_error + 1.0) +
|
||||
fabs(x.m_value) * (x.m_error + 1.0)) /
|
||||
fabs(m_value - x.m_value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
NM_Scalar& operator*=(const NM_Scalar& x) {
|
||||
m_value *= x.m_value;
|
||||
m_error += x.m_error + 1.0;
|
||||
return *this;
|
||||
}
|
||||
|
||||
NM_Scalar& operator/=(const NM_Scalar& x) {
|
||||
m_value /= x.m_value;
|
||||
m_error += x.m_error + 1.0;
|
||||
return *this;
|
||||
}
|
||||
|
||||
private:
|
||||
T m_value;
|
||||
T m_error;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
inline NM_Scalar<T> operator+(const NM_Scalar<T>& x, const NM_Scalar<T>& y) {
|
||||
return x.getValue() == 0.0 && y.getValue() == 0.0 ?
|
||||
NM_Scalar<T>(0.0, 0.0) :
|
||||
NM_Scalar<T>(x.getValue() + y.getValue(),
|
||||
(fabs(x.getValue()) * (x.getError() + 1.0) +
|
||||
fabs(y.getValue()) * (y.getError() + 1.0)) /
|
||||
fabs(x.getValue() + y.getValue()));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline NM_Scalar<T> operator-(const NM_Scalar<T>& x, const NM_Scalar<T>& y) {
|
||||
return x.getValue() == 0.0 && y.getValue() == 0.0 ?
|
||||
NM_Scalar<T>(0.0, 0.0) :
|
||||
NM_Scalar<T>(x.getValue() - y.getValue(),
|
||||
(fabs(x.getValue()) * (x.getError() + 1.0) +
|
||||
fabs(y.getValue()) * (y.getError() + 1.0)) /
|
||||
fabs(x.getValue() - y.getValue()));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline NM_Scalar<T> operator*(const NM_Scalar<T>& x, const NM_Scalar<T>& y) {
|
||||
return NM_Scalar<T>(x.getValue() * y.getValue(),
|
||||
x.getError() + y.getError() + 1.0);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline NM_Scalar<T> operator/(const NM_Scalar<T>& x, const NM_Scalar<T>& y) {
|
||||
return NM_Scalar<T>(x.getValue() / y.getValue(),
|
||||
x.getError() + y.getError() + 1.0);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline std::ostream& operator<<(std::ostream& os, const NM_Scalar<T>& x) {
|
||||
return os << x.getValue() << '[' << x.getError() << ']';
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline NM_Scalar<T> sqrt(const NM_Scalar<T>& x) {
|
||||
return NM_Scalar<T>(sqrt(x.getValue()),
|
||||
0.5 * x.getError() + 1.0);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline NM_Scalar<T> acos(const NM_Scalar<T>& x) {
|
||||
return NM_Scalar<T>(acos(x.getValue()), x.getError() + 1.0);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline NM_Scalar<T> cos(const NM_Scalar<T>& x) {
|
||||
return NM_Scalar<T>(cos(x.getValue()), x.getError() + 1.0);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline NM_Scalar<T> sin(const NM_Scalar<T>& x) {
|
||||
return NM_Scalar<T>(sin(x.getValue()), x.getError() + 1.0);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline NM_Scalar<T> fabs(const NM_Scalar<T>& x) {
|
||||
return NM_Scalar<T>(fabs(x.getValue()), x.getError());
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline NM_Scalar<T> pow(const NM_Scalar<T>& x, const NM_Scalar<T>& y) {
|
||||
return NM_Scalar<T>(pow(x.getValue(), y.getValue()),
|
||||
fabs(y.getValue()) * x.getError() + 1.0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
237
intern/moto/intern/MT_CmMatrix4x4.cpp
Executable file
237
intern/moto/intern/MT_CmMatrix4x4.cpp
Executable file
@@ -0,0 +1,237 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
|
||||
#include "MT_CmMatrix4x4.h"
|
||||
#include "MT_Vector3.h"
|
||||
#include "MT_Point3.h"
|
||||
|
||||
|
||||
MT_CmMatrix4x4::MT_CmMatrix4x4()
|
||||
{
|
||||
Identity();
|
||||
}
|
||||
|
||||
|
||||
|
||||
MT_CmMatrix4x4::MT_CmMatrix4x4(const float value[4][4])
|
||||
{
|
||||
for (int i=0;i<4;i++)
|
||||
{
|
||||
for (int j=0;j<4;j++)
|
||||
m_V[i][j] = value[i][j];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
MT_CmMatrix4x4::MT_CmMatrix4x4(const double value[16])
|
||||
{
|
||||
for (int i=0;i<16;i++)
|
||||
m_Vflat[i] = value[i];
|
||||
}
|
||||
|
||||
|
||||
|
||||
MT_CmMatrix4x4::MT_CmMatrix4x4(const MT_CmMatrix4x4& other)
|
||||
{
|
||||
SetMatrix(other);
|
||||
}
|
||||
|
||||
|
||||
|
||||
MT_CmMatrix4x4::MT_CmMatrix4x4(const MT_Point3& orig,
|
||||
const MT_Vector3& dir,
|
||||
const MT_Vector3 up)
|
||||
{
|
||||
MT_Vector3 z = -(dir.normalized());
|
||||
MT_Vector3 x = (up.cross(z)).normalized();
|
||||
MT_Vector3 y = (z.cross(x));
|
||||
|
||||
m_V[0][0] = x.x();
|
||||
m_V[0][1] = y.x();
|
||||
m_V[0][2] = z.x();
|
||||
m_V[0][3] = 0.0f;
|
||||
|
||||
m_V[1][0] = x.y();
|
||||
m_V[1][1] = y.y();
|
||||
m_V[1][2] = z.y();
|
||||
m_V[1][3] = 0.0f;
|
||||
|
||||
m_V[2][0] = x.z();
|
||||
m_V[2][1] = y.z();
|
||||
m_V[2][2] = z.z();
|
||||
m_V[2][3] = 0.0f;
|
||||
|
||||
m_V[3][0] = orig.x();//0.0f;
|
||||
m_V[3][1] = orig.y();//0.0f;
|
||||
m_V[3][2] = orig.z();//0.0f;
|
||||
m_V[3][3] = 1.0f;
|
||||
|
||||
//Translate(-orig);
|
||||
}
|
||||
|
||||
|
||||
|
||||
MT_Vector3 MT_CmMatrix4x4::GetRight() const
|
||||
{
|
||||
return MT_Vector3(m_V[0][0], m_V[0][1], m_V[0][2]);
|
||||
}
|
||||
|
||||
|
||||
|
||||
MT_Vector3 MT_CmMatrix4x4::GetUp() const
|
||||
{
|
||||
return MT_Vector3(m_V[1][0], m_V[1][1], m_V[1][2]);
|
||||
}
|
||||
|
||||
|
||||
|
||||
MT_Vector3 MT_CmMatrix4x4::GetDir() const
|
||||
{
|
||||
return MT_Vector3(m_V[2][0], m_V[2][1], m_V[2][2]);
|
||||
}
|
||||
|
||||
|
||||
|
||||
MT_Point3 MT_CmMatrix4x4::GetPos() const
|
||||
{
|
||||
return MT_Point3(m_V[3][0], m_V[3][1], m_V[3][2]);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void MT_CmMatrix4x4::Identity()
|
||||
{
|
||||
for (int i=0; i<4; i++)
|
||||
{
|
||||
for (int j=0; j<4; j++)
|
||||
m_V[i][j] = (i==j?1.0f:0.0f);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void MT_CmMatrix4x4::SetMatrix(const MT_CmMatrix4x4& other)
|
||||
{
|
||||
for (int i=0; i<16; i++)
|
||||
m_Vflat[i] = other.m_Vflat[i];
|
||||
}
|
||||
|
||||
|
||||
|
||||
double* MT_CmMatrix4x4::getPointer()
|
||||
{
|
||||
return &m_V[0][0];
|
||||
}
|
||||
|
||||
|
||||
|
||||
const double* MT_CmMatrix4x4::getPointer() const
|
||||
{
|
||||
return &m_V[0][0];
|
||||
}
|
||||
|
||||
|
||||
|
||||
void MT_CmMatrix4x4::setElem(int pos,double newvalue)
|
||||
{
|
||||
m_Vflat[pos] = newvalue;
|
||||
}
|
||||
|
||||
MT_CmMatrix4x4 MT_CmMatrix4x4::Perspective(
|
||||
MT_Scalar inLeft,
|
||||
MT_Scalar inRight,
|
||||
MT_Scalar inBottom,
|
||||
MT_Scalar inTop,
|
||||
MT_Scalar inNear,
|
||||
MT_Scalar inFar
|
||||
){
|
||||
|
||||
MT_CmMatrix4x4 mat;
|
||||
|
||||
// Column 0
|
||||
mat(0, 0) = -(2.0*inNear) / (inRight-inLeft);
|
||||
mat(1, 0) = 0;
|
||||
mat(2, 0) = 0;
|
||||
mat(3, 0) = 0;
|
||||
|
||||
// Column 1
|
||||
mat(0, 1) = 0;
|
||||
mat(1, 1) = (2.0*inNear) / (inTop-inBottom);
|
||||
mat(2, 1) = 0;
|
||||
mat(3, 1) = 0;
|
||||
|
||||
// Column 2
|
||||
mat(0, 2) = (inRight+inLeft) / (inRight-inLeft);
|
||||
mat(1, 2) = (inTop+inBottom) / (inTop-inBottom);
|
||||
mat(2, 2) = -(inFar+inNear) / (inFar-inNear);
|
||||
mat(3, 2) = -1;
|
||||
|
||||
// Column 3
|
||||
mat(0, 3) = 0;
|
||||
mat(1, 3) = 0;
|
||||
mat(2, 3) = -(2.0*inFar*inNear) / (inFar-inNear);
|
||||
mat(3, 3) = 0;
|
||||
|
||||
return mat;
|
||||
}
|
||||
37
intern/moto/intern/MT_Matrix3x3.cpp
Normal file
37
intern/moto/intern/MT_Matrix3x3.cpp
Normal file
@@ -0,0 +1,37 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include "MT_Matrix3x3.h"
|
||||
|
||||
|
||||
#ifndef GEN_INLINED
|
||||
#include "MT_Matrix3x3.inl"
|
||||
#endif
|
||||
37
intern/moto/intern/MT_Matrix4x4.cpp
Normal file
37
intern/moto/intern/MT_Matrix4x4.cpp
Normal file
@@ -0,0 +1,37 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include "MT_Matrix4x4.h"
|
||||
|
||||
|
||||
#ifndef GEN_INLINED
|
||||
#include "MT_Matrix4x4.inl"
|
||||
#endif
|
||||
68
intern/moto/intern/MT_Plane3.cpp
Normal file
68
intern/moto/intern/MT_Plane3.cpp
Normal file
@@ -0,0 +1,68 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
|
||||
#ifndef GEN_INLINED
|
||||
#include "MT_Plane3.h"
|
||||
#include "MT_Plane3.inl"
|
||||
#endif
|
||||
|
||||
37
intern/moto/intern/MT_Point3.cpp
Normal file
37
intern/moto/intern/MT_Point3.cpp
Normal file
@@ -0,0 +1,37 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include "MT_Point3.h"
|
||||
|
||||
|
||||
#ifndef GEN_INLINED
|
||||
#include "MT_Point3.inl"
|
||||
#endif
|
||||
37
intern/moto/intern/MT_Quaternion.cpp
Normal file
37
intern/moto/intern/MT_Quaternion.cpp
Normal file
@@ -0,0 +1,37 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include "MT_Quaternion.h"
|
||||
|
||||
|
||||
#ifndef GEN_INLINED
|
||||
#include "MT_Quaternion.inl"
|
||||
#endif
|
||||
138
intern/moto/intern/MT_Transform.cpp
Normal file
138
intern/moto/intern/MT_Transform.cpp
Normal file
@@ -0,0 +1,138 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
MOTTO - 3D Motion Toolkit
|
||||
Copyright (C) 2000 Gino van den Bergen <gino@acm.org>
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Library General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with this library; if not, write to the Free
|
||||
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
|
||||
*/
|
||||
|
||||
#include "MT_Transform.h"
|
||||
|
||||
void MT_Transform::setValue(const float *m) {
|
||||
m_basis.setValue(m);
|
||||
m_origin.setValue(&m[12]);
|
||||
m_type = AFFINE;
|
||||
}
|
||||
|
||||
void MT_Transform::setValue(const double *m) {
|
||||
m_basis.setValue(m);
|
||||
m_origin.setValue(&m[12]);
|
||||
m_type = AFFINE;
|
||||
}
|
||||
|
||||
void MT_Transform::getValue(float *m) const {
|
||||
m_basis.getValue(m);
|
||||
m_origin.getValue(&m[12]);
|
||||
m[15] = 1.0;
|
||||
}
|
||||
|
||||
void MT_Transform::getValue(double *m) const {
|
||||
m_basis.getValue(m);
|
||||
m_origin.getValue(&m[12]);
|
||||
m[15] = 1.0;
|
||||
}
|
||||
|
||||
MT_Transform& MT_Transform::operator*=(const MT_Transform& t) {
|
||||
m_origin += m_basis * t.m_origin;
|
||||
m_basis *= t.m_basis;
|
||||
m_type |= t.m_type;
|
||||
return *this;
|
||||
}
|
||||
|
||||
void MT_Transform::translate(const MT_Vector3& v) {
|
||||
m_origin += m_basis * v;
|
||||
m_type |= TRANSLATION;
|
||||
}
|
||||
|
||||
void MT_Transform::rotate(const MT_Quaternion& q) {
|
||||
m_basis *= MT_Matrix3x3(q);
|
||||
m_type |= ROTATION;
|
||||
}
|
||||
|
||||
void MT_Transform::scale(MT_Scalar x, MT_Scalar y, MT_Scalar z) {
|
||||
m_basis.scale(x, y, z);
|
||||
m_type |= SCALING;
|
||||
}
|
||||
|
||||
void MT_Transform::setIdentity() {
|
||||
m_basis.setIdentity();
|
||||
m_origin.setValue(MT_Scalar(0.0), MT_Scalar(0.0), MT_Scalar(0.0));
|
||||
m_type = IDENTITY;
|
||||
}
|
||||
|
||||
void MT_Transform::invert(const MT_Transform& t) {
|
||||
m_basis = t.m_type & SCALING ?
|
||||
t.m_basis.inverse() :
|
||||
t.m_basis.transposed();
|
||||
m_origin.setValue(-MT_dot(m_basis[0], t.m_origin),
|
||||
-MT_dot(m_basis[1], t.m_origin),
|
||||
-MT_dot(m_basis[2], t.m_origin));
|
||||
m_type = t.m_type;
|
||||
}
|
||||
|
||||
void MT_Transform::mult(const MT_Transform& t1, const MT_Transform& t2) {
|
||||
m_basis = t1.m_basis * t2.m_basis;
|
||||
m_origin = t1(t2.m_origin);
|
||||
m_type = t1.m_type | t2.m_type;
|
||||
}
|
||||
|
||||
void MT_Transform::multInverseLeft(const MT_Transform& t1, const MT_Transform& t2) {
|
||||
MT_Vector3 v = t2.m_origin - t1.m_origin;
|
||||
if (t1.m_type & SCALING) {
|
||||
MT_Matrix3x3 inv = t1.m_basis.inverse();
|
||||
m_basis = inv * t2.m_basis;
|
||||
m_origin = inv * v;
|
||||
}
|
||||
else {
|
||||
m_basis = MT_multTransposeLeft(t1.m_basis, t2.m_basis);
|
||||
m_origin = v * t1.m_basis;
|
||||
}
|
||||
m_type = t1.m_type | t2.m_type;
|
||||
}
|
||||
|
||||
|
||||
|
||||
37
intern/moto/intern/MT_Vector2.cpp
Normal file
37
intern/moto/intern/MT_Vector2.cpp
Normal file
@@ -0,0 +1,37 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include "MT_Vector2.h"
|
||||
|
||||
|
||||
#ifndef GEN_INLINED
|
||||
#include "MT_Vector2.inl"
|
||||
#endif
|
||||
37
intern/moto/intern/MT_Vector3.cpp
Normal file
37
intern/moto/intern/MT_Vector3.cpp
Normal file
@@ -0,0 +1,37 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include "MT_Vector3.h"
|
||||
|
||||
|
||||
#ifndef GEN_INLINED
|
||||
#include "MT_Vector3.inl"
|
||||
#endif
|
||||
37
intern/moto/intern/MT_Vector4.cpp
Normal file
37
intern/moto/intern/MT_Vector4.cpp
Normal file
@@ -0,0 +1,37 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
#include "MT_Vector4.h"
|
||||
|
||||
|
||||
#ifndef GEN_INLINED
|
||||
#include "MT_Vector4.inl"
|
||||
#endif
|
||||
142
intern/moto/intern/MT_random.cpp
Executable file
142
intern/moto/intern/MT_random.cpp
Executable file
@@ -0,0 +1,142 @@
|
||||
/**
|
||||
* $Id$
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/* A C-program for MT19937: Real number version */
|
||||
|
||||
/* genrand() generates one pseudorandom real number (double) */
|
||||
/* which is uniformly distributed on [0,1]-interval, for each */
|
||||
/* call. sgenrand(seed) set initial values to the working area */
|
||||
/* of 624 words. Before genrand(), sgenrand(seed) must be */
|
||||
/* called once. (seed is any 32-bit integer except for 0). */
|
||||
/* Integer generator is obtained by modifying two lines. */
|
||||
/* Coded by Takuji Nishimura, considering the suggestions by */
|
||||
/* Topher Cooper and Marc Rieffel in July-Aug. 1997. */
|
||||
|
||||
/* This library is free software; you can redistribute it and/or */
|
||||
/* modify it under the terms of the GNU Library General Public */
|
||||
/* License as published by the Free Software Foundation; either */
|
||||
/* version 2 of the License, or (at your option) any later */
|
||||
/* version. */
|
||||
/* This library is distributed in the hope that it will be useful, */
|
||||
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
|
||||
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */
|
||||
/* See the GNU Library General Public License for more details. */
|
||||
/* You should have received a copy of the GNU Library General */
|
||||
/* Public License along with this library; if not, write to the */
|
||||
/* Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA */
|
||||
/* 02111-1307 USA */
|
||||
|
||||
/* Copyright (C) 1997 Makoto Matsumoto and Takuji Nishimura. */
|
||||
/* When you use this, send an email to: matumoto@math.keio.ac.jp */
|
||||
/* with an appropriate reference to your work. */
|
||||
|
||||
#include "MT_random.h"
|
||||
|
||||
/* Period parameters */
|
||||
#define N 624
|
||||
#define M 397
|
||||
#define MATRIX_A 0x9908b0df /* constant vector a */
|
||||
#define UPPER_MASK 0x80000000 /* most significant w-r bits */
|
||||
#define LOWER_MASK 0x7fffffff /* least significant r bits */
|
||||
|
||||
/* Tempering parameters */
|
||||
#define TEMPERING_MASK_B 0x9d2c5680
|
||||
#define TEMPERING_MASK_C 0xefc60000
|
||||
#define TEMPERING_SHIFT_U(y) (y >> 11)
|
||||
#define TEMPERING_SHIFT_S(y) (y << 7)
|
||||
#define TEMPERING_SHIFT_T(y) (y << 15)
|
||||
#define TEMPERING_SHIFT_L(y) (y >> 18)
|
||||
|
||||
static unsigned long mt[N]; /* the array for the state vector */
|
||||
static int mti = N+1; /* mti==N+1 means mt[N] is not initialized */
|
||||
|
||||
/* initializing the array with a NONZERO seed */
|
||||
void MT_srand(unsigned long seed)
|
||||
{
|
||||
/* setting initial seeds to mt[N] using */
|
||||
/* the generator Line 25 of Table 1 in */
|
||||
/* [KNUTH 1981, The Art of Computer Programming */
|
||||
/* Vol. 2 (2nd Ed.), pp102] */
|
||||
mt[0] = seed & 0xffffffff;
|
||||
for (mti = 1; mti < N; mti++)
|
||||
mt[mti] = (69069 * mt[mti-1]) & 0xffffffff;
|
||||
}
|
||||
|
||||
unsigned long MT_rand()
|
||||
{
|
||||
static unsigned long mag01[2] = { 0x0, MATRIX_A };
|
||||
/* mag01[x] = x * MATRIX_A for x=0,1 */
|
||||
|
||||
unsigned long y;
|
||||
|
||||
if (mti >= N) { /* generate N words at one time */
|
||||
int kk;
|
||||
|
||||
if (mti == N+1) /* if sgenrand() has not been called, */
|
||||
MT_srand(4357); /* a default initial seed is used */
|
||||
|
||||
for (kk = 0; kk < N - M; kk++) {
|
||||
y = (mt[kk] & UPPER_MASK) | (mt[kk+1] & LOWER_MASK);
|
||||
mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & 0x1];
|
||||
}
|
||||
for (; kk < N-1; kk++) {
|
||||
y = (mt[kk] & UPPER_MASK) | (mt[kk+1] & LOWER_MASK);
|
||||
mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1];
|
||||
}
|
||||
y = (mt[N-1] & UPPER_MASK) | (mt[0] & LOWER_MASK);
|
||||
mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1];
|
||||
|
||||
mti = 0;
|
||||
}
|
||||
|
||||
y = mt[mti++];
|
||||
y ^= TEMPERING_SHIFT_U(y);
|
||||
y ^= TEMPERING_SHIFT_S(y) & TEMPERING_MASK_B;
|
||||
y ^= TEMPERING_SHIFT_T(y) & TEMPERING_MASK_C;
|
||||
y ^= TEMPERING_SHIFT_L(y);
|
||||
|
||||
return y;
|
||||
}
|
||||
|
||||
#undef N
|
||||
#undef M
|
||||
#undef MATRIX_A
|
||||
#undef UPPER_MASK
|
||||
#undef LOWER_MASK
|
||||
|
||||
/* Tempering parameters */
|
||||
#undef TEMPERING_MASK_B
|
||||
#undef TEMPERING_MASK_C
|
||||
#undef TEMPERING_SHIFT_U
|
||||
#undef TEMPERING_SHIFT_S
|
||||
#undef TEMPERING_SHIFT_T
|
||||
#undef TEMPERING_SHIFT_L
|
||||
|
||||
42
intern/moto/intern/Makefile
Normal file
42
intern/moto/intern/Makefile
Normal file
@@ -0,0 +1,42 @@
|
||||
#
|
||||
# $Id$
|
||||
#
|
||||
# ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version. The Blender
|
||||
# Foundation also sells licenses for use in proprietary software under
|
||||
# the Blender License. See http://www.blender.org/BL/ for information
|
||||
# about this.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software Foundation,
|
||||
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
#
|
||||
# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
# All rights reserved.
|
||||
#
|
||||
# The Original Code is: all of this file.
|
||||
#
|
||||
# Contributor(s): none yet.
|
||||
#
|
||||
# ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
# moto intern Makefile
|
||||
#
|
||||
|
||||
LIBNAME = moto
|
||||
DIR = $(OCGDIR)/intern/$(LIBNAME)
|
||||
|
||||
include nan_compile.mk
|
||||
|
||||
CCFLAGS += $(LEVEL_2_CPP_WARNINGS)
|
||||
|
||||
CPPFLAGS += -I../include
|
||||
|
||||
379
intern/moto/make/msvc_6_0/MoTo.dsp
Executable file
379
intern/moto/make/msvc_6_0/MoTo.dsp
Executable file
@@ -0,0 +1,379 @@
|
||||
# Microsoft Developer Studio Project File - Name="MoTo" - Package Owner=<4>
|
||||
# Microsoft Developer Studio Generated Build File, Format Version 6.00
|
||||
# ** DO NOT EDIT **
|
||||
|
||||
# TARGTYPE "Win32 (x86) Static Library" 0x0104
|
||||
|
||||
CFG=MoTo - Win32 Debug
|
||||
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
|
||||
!MESSAGE use the Export Makefile command and run
|
||||
!MESSAGE
|
||||
!MESSAGE NMAKE /f "MoTo.mak".
|
||||
!MESSAGE
|
||||
!MESSAGE You can specify a configuration when running NMAKE
|
||||
!MESSAGE by defining the macro CFG on the command line. For example:
|
||||
!MESSAGE
|
||||
!MESSAGE NMAKE /f "MoTo.mak" CFG="MoTo - Win32 Debug"
|
||||
!MESSAGE
|
||||
!MESSAGE Possible choices for configuration are:
|
||||
!MESSAGE
|
||||
!MESSAGE "MoTo - Win32 Release" (based on "Win32 (x86) Static Library")
|
||||
!MESSAGE "MoTo - Win32 Debug" (based on "Win32 (x86) Static Library")
|
||||
!MESSAGE
|
||||
|
||||
# Begin Project
|
||||
# PROP AllowPerConfigDependencies 0
|
||||
# PROP Scc_ProjName ""
|
||||
# PROP Scc_LocalPath ""
|
||||
CPP=cl.exe
|
||||
RSC=rc.exe
|
||||
|
||||
!IF "$(CFG)" == "MoTo - Win32 Release"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 0
|
||||
# PROP BASE Output_Dir "Release"
|
||||
# PROP BASE Intermediate_Dir "Release"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 0
|
||||
# PROP Output_Dir "Release"
|
||||
# PROP Intermediate_Dir "Release"
|
||||
# PROP Target_Dir ""
|
||||
LINK32=link.exe -lib
|
||||
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
|
||||
# ADD CPP /nologo /MT /W4 /GX /O2 /Ob2 /I "..\..\include\\" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /FD /c
|
||||
# SUBTRACT CPP /YX
|
||||
# ADD BASE RSC /l 0x413 /d "NDEBUG"
|
||||
# ADD RSC /l 0x413 /d "NDEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LIB32=link.exe -lib
|
||||
# ADD BASE LIB32 /nologo
|
||||
# ADD LIB32 /nologo /out:"Release\libmoto.lib"
|
||||
# Begin Special Build Tool
|
||||
SOURCE="$(InputPath)"
|
||||
PostBuild_Cmds=ECHO Copying header files COPY "..\..\include\*.h" "..\..\..\..\lib\windows\moto\include" ECHO Copying lib COPY "Release\libmoto.lib" "..\..\..\..\lib\windows\moto\lib\libmoto.a" ECHO Done
|
||||
# End Special Build Tool
|
||||
|
||||
!ELSEIF "$(CFG)" == "MoTo - Win32 Debug"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 1
|
||||
# PROP BASE Output_Dir "Debug"
|
||||
# PROP BASE Intermediate_Dir "Debug"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 1
|
||||
# PROP Output_Dir "Debug"
|
||||
# PROP Intermediate_Dir "Debug"
|
||||
# PROP Target_Dir ""
|
||||
LINK32=link.exe -lib
|
||||
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
|
||||
# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "..\..\include\\" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /FD /GZ /c
|
||||
# SUBTRACT CPP /YX
|
||||
# ADD BASE RSC /l 0x413 /d "_DEBUG"
|
||||
# ADD RSC /l 0x413 /d "_DEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LIB32=link.exe -lib
|
||||
# ADD BASE LIB32 /nologo
|
||||
# ADD LIB32 /nologo /out:"Debug\libmoto.lib"
|
||||
# Begin Special Build Tool
|
||||
SOURCE="$(InputPath)"
|
||||
PostBuild_Cmds=ECHO Copying header files COPY "..\..\include\*.h" "..\..\..\..\lib\windows\moto\include" ECHO Copying lib COPY "Debug\libmoto.lib" "..\..\..\..\lib\windows\moto\lib\debug\libmoto.a" ECHO Copying Debug info. COPY "Debug\vc60.*" "..\..\..\..\lib\windows\moto\lib\debug\" ECHO Done
|
||||
# End Special Build Tool
|
||||
|
||||
!ENDIF
|
||||
|
||||
# Begin Target
|
||||
|
||||
# Name "MoTo - Win32 Release"
|
||||
# Name "MoTo - Win32 Debug"
|
||||
# Begin Group "Source Files"
|
||||
|
||||
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\intern\MT_CmMatrix4x4.cpp
|
||||
|
||||
!IF "$(CFG)" == "MoTo - Win32 Release"
|
||||
|
||||
# ADD CPP /W3 /I "../../include"
|
||||
|
||||
!ELSEIF "$(CFG)" == "MoTo - Win32 Debug"
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\intern\MT_Matrix3x3.cpp
|
||||
|
||||
!IF "$(CFG)" == "MoTo - Win32 Release"
|
||||
|
||||
# ADD CPP /W3 /I "../../include"
|
||||
|
||||
!ELSEIF "$(CFG)" == "MoTo - Win32 Debug"
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\intern\MT_Matrix4x4.cpp
|
||||
|
||||
!IF "$(CFG)" == "MoTo - Win32 Release"
|
||||
|
||||
# ADD CPP /W3 /I "../../include"
|
||||
|
||||
!ELSEIF "$(CFG)" == "MoTo - Win32 Debug"
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\intern\MT_Plane3.cpp
|
||||
|
||||
!IF "$(CFG)" == "MoTo - Win32 Release"
|
||||
|
||||
# ADD CPP /W3
|
||||
|
||||
!ELSEIF "$(CFG)" == "MoTo - Win32 Debug"
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\intern\MT_Point3.cpp
|
||||
|
||||
!IF "$(CFG)" == "MoTo - Win32 Release"
|
||||
|
||||
# ADD CPP /W3 /I "../../include"
|
||||
|
||||
!ELSEIF "$(CFG)" == "MoTo - Win32 Debug"
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\intern\MT_Quaternion.cpp
|
||||
|
||||
!IF "$(CFG)" == "MoTo - Win32 Release"
|
||||
|
||||
# ADD CPP /W3 /I "../../include"
|
||||
|
||||
!ELSEIF "$(CFG)" == "MoTo - Win32 Debug"
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\intern\MT_random.cpp
|
||||
|
||||
!IF "$(CFG)" == "MoTo - Win32 Release"
|
||||
|
||||
# ADD CPP /W3 /I "../../include"
|
||||
|
||||
!ELSEIF "$(CFG)" == "MoTo - Win32 Debug"
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\intern\MT_Transform.cpp
|
||||
|
||||
!IF "$(CFG)" == "MoTo - Win32 Release"
|
||||
|
||||
# ADD CPP /W3 /I "../../include"
|
||||
|
||||
!ELSEIF "$(CFG)" == "MoTo - Win32 Debug"
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\intern\MT_Vector2.cpp
|
||||
|
||||
!IF "$(CFG)" == "MoTo - Win32 Release"
|
||||
|
||||
# ADD CPP /W3 /I "../../include"
|
||||
|
||||
!ELSEIF "$(CFG)" == "MoTo - Win32 Debug"
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\intern\MT_Vector3.cpp
|
||||
|
||||
!IF "$(CFG)" == "MoTo - Win32 Release"
|
||||
|
||||
# ADD CPP /W3 /I "../../include"
|
||||
|
||||
!ELSEIF "$(CFG)" == "MoTo - Win32 Debug"
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\intern\MT_Vector4.cpp
|
||||
|
||||
!IF "$(CFG)" == "MoTo - Win32 Release"
|
||||
|
||||
# ADD CPP /W3 /I "../../include"
|
||||
|
||||
!ELSEIF "$(CFG)" == "MoTo - Win32 Debug"
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "Header Files"
|
||||
|
||||
# PROP Default_Filter "h;hpp;hxx;hm;inl"
|
||||
# Begin Group "inlines"
|
||||
|
||||
# PROP Default_Filter ""
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Matrix3x3.inl
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Matrix4x4.inl
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Plane3.inl
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Point2.inl
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Point3.inl
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Quaternion.inl
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Vector2.inl
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Vector3.inl
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Vector4.inl
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\GEN_List.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\GEN_Map.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_assert.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_CmMatrix4x4.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Matrix3x3.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Matrix4x4.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_MinMax.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Optimize.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Plane3.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Point2.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Point3.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Quaternion.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_random.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Scalar.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Stream.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Transform.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Tuple2.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Tuple3.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Tuple4.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Vector2.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Vector3.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\MT_Vector4.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\include\NM_Scalar.h
|
||||
# End Source File
|
||||
# End Group
|
||||
# End Target
|
||||
# End Project
|
||||
58
intern/moto/make/msvc_6_0/MoTo.dsw
Executable file
58
intern/moto/make/msvc_6_0/MoTo.dsw
Executable file
@@ -0,0 +1,58 @@
|
||||
Microsoft Developer Studio Workspace File, Format Version 6.00
|
||||
|
||||
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
|
||||
|
||||
|
||||
|
||||
###############################################################################
|
||||
|
||||
|
||||
|
||||
Project: "MoTo"=.\MoTo.dsp - Package Owner=<4>
|
||||
|
||||
|
||||
|
||||
Package=<5>
|
||||
|
||||
{{{
|
||||
|
||||
}}}
|
||||
|
||||
|
||||
|
||||
Package=<4>
|
||||
|
||||
{{{
|
||||
|
||||
}}}
|
||||
|
||||
|
||||
|
||||
###############################################################################
|
||||
|
||||
|
||||
|
||||
Global:
|
||||
|
||||
|
||||
|
||||
Package=<5>
|
||||
|
||||
{{{
|
||||
|
||||
}}}
|
||||
|
||||
|
||||
|
||||
Package=<3>
|
||||
|
||||
{{{
|
||||
|
||||
}}}
|
||||
|
||||
|
||||
|
||||
###############################################################################
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user