Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/core3/src/util/Math.cc @ 1778

Last change on this file since 1778 was 1778, checked in by rgrieder, 16 years ago

Convert.h done. Has yet to be tested with gcc. And the comments have to be adapted.

  • Property svn:eol-style set to native
File size: 8.4 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29#include "Math.h"
30
31#include <OgrePlane.h>
32#include "MathConvert.h"
33
34/**
35    @brief Function for writing to a stream.
36*/
37std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian)
38{
39    out << radian.valueRadians();
40    return out;
41}
42
43/**
44    @brief Function for reading from a stream.
45*/
46std::istream& operator>>(std::istream& in, orxonox::Radian& radian)
47{
48    float temp;
49    in >> temp;
50    radian = temp;
51    return in;
52}
53
54/**
55    @brief Function for writing to a stream.
56*/
57std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree)
58{
59    out << degree.valueDegrees();
60    return out;
61}
62
63/**
64    @brief Function for reading from a stream.
65*/
66std::istream& operator>>(std::istream& in, orxonox::Degree& degree)
67{
68    float temp;
69    in >> temp;
70    degree = temp;
71    return in;
72}
73
74
75float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition)
76{
77    orxonox::Vector3 distance = otherposition - myposition;
78    return acos(mydirection.dotProduct(distance) / distance.length());
79}
80
81orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
82{
83    orxonox::Vector3 distance = otherposition - myposition;
84
85    // project difference vector on our plane
86    orxonox::Vector3 projection = Ogre::Plane(mydirection, myposition).projectVector(distance);
87    float angle = acos(myorthonormal.dotProduct(projection) / projection.length());
88
89    if ((mydirection.crossProduct(myorthonormal)).dotProduct(distance) > 0)
90        return orxonox::Vector2(sin(angle), cos(angle));
91    else
92        return orxonox::Vector2(-sin(angle), cos(angle));
93}
94
95orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
96{
97    orxonox::Vector3 distance = otherposition - myposition;
98
99    // project difference vector on our plane
100    orxonox::Vector3 projection = Ogre::Plane(mydirection, myposition).projectVector(distance);
101    float angle = acos(myorthonormal.dotProduct(projection) / projection.length());
102    float radius = acos(mydirection.dotProduct(distance) / distance.length()) / Ogre::Math::PI;
103
104    if ((mydirection.crossProduct(myorthonormal)).dotProduct(distance) > 0)
105        return orxonox::Vector2(sin(angle) * radius, cos(angle) * radius);
106    else
107        return orxonox::Vector2(-sin(angle) * radius, cos(angle) * radius);
108}
109
110orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity)
111{
112    float squaredProjectilespeed = projectilespeed * projectilespeed;
113    orxonox::Vector3 distance = targetposition - myposition;
114    float a = distance.squaredLength();
115    float b = 2 * (distance.x + distance.y + distance.z) * (targetvelocity.x + targetvelocity.y + targetvelocity.z);
116    float c = targetvelocity.squaredLength();
117
118    float temp = 4*squaredProjectilespeed*c + a*a - 4*b*c;
119    if (temp < 0)
120        return orxonox::Vector3::ZERO;
121
122    temp = sqrt(temp);
123    float time = (temp + a) / (2 * (squaredProjectilespeed - b));
124    return (targetposition + targetvelocity * time);
125}
126
127//////////////////////////
128// Conversion functions //
129//////////////////////////
130
131// std::string to Vector2
132bool fallbackConversion(orxonox::Vector2* output, const std::string& input)
133{
134    unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
135    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
136
137    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
138    if (tokens.size() >= 2)
139    {
140        if (!ConvertValue(&(output->x), tokens[0]))
141            return false;
142        if (!ConvertValue(&(output->y), tokens[1]))
143            return false;
144
145        return true;
146    }
147    return false;
148}
149
150// std::string to Vector3
151bool fallbackConversion(orxonox::Vector3* output, const std::string& input)
152{
153    unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
154    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
155
156    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
157    if (tokens.size() >= 3)
158    {
159        if (!ConvertValue(&(output->x), tokens[0]))
160            return false;
161        if (!ConvertValue(&(output->y), tokens[1]))
162            return false;
163        if (!ConvertValue(&(output->z), tokens[2]))
164            return false;
165
166        return true;
167    }
168    return false;
169}
170
171// std::string to Vector4
172bool fallbackConversion(orxonox::Vector4* output, const std::string& input)
173{
174    unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
175    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
176
177    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
178    if (tokens.size() >= 4)
179    {
180        if (!ConvertValue(&(output->x), tokens[0]))
181            return false;
182        if (!ConvertValue(&(output->y), tokens[1]))
183            return false;
184        if (!ConvertValue(&(output->z), tokens[2]))
185            return false;
186        if (!ConvertValue(&(output->w), tokens[3]))
187            return false;
188
189        return true;
190    }
191    return false;
192}
193
194// std::string to Quaternion
195bool fallbackConversion(orxonox::Quaternion* output, const std::string& input)
196{
197    unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
198    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
199
200    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
201    if (tokens.size() >= 4)
202    {
203        if (!ConvertValue(&(output->w), tokens[0]))
204            return false;
205        if (!ConvertValue(&(output->x), tokens[1]))
206            return false;
207        if (!ConvertValue(&(output->y), tokens[2]))
208            return false;
209        if (!ConvertValue(&(output->z), tokens[3]))
210            return false;
211
212        return true;
213    }
214    return false;
215}
216
217// std::string to ColourValue
218bool fallbackConversion(orxonox::ColourValue* output, const std::string& input)
219{
220    unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
221    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
222
223    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
224    if (tokens.size() >= 4)
225    {
226        if (!ConvertValue(&(output->r), tokens[0]))
227            return false;
228        if (!ConvertValue(&(output->g), tokens[1]))
229            return false;
230        if (!ConvertValue(&(output->b), tokens[2]))
231            return false;
232        if (!ConvertValue(&(output->a), tokens[3]))
233            return false;
234
235        return true;
236    }
237    return false;
238}
239
Note: See TracBrowser for help on using the repository browser.