Spinning Topp Logo BlackTopp Studios
inc
conecollisionshape.cpp
1 // © Copyright 2010 - 2016 BlackTopp Studios Inc.
2 /* This file is part of The Mezzanine Engine.
3 
4  The Mezzanine Engine is free software: you can redistribute it and/or modify
5  it under the terms of the GNU General Public License as published by
6  the Free Software Foundation, either version 3 of the License, or
7  (at your option) any later version.
8 
9  The Mezzanine Engine is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  GNU General Public License for more details.
13 
14  You should have received a copy of the GNU General Public License
15  along with The Mezzanine Engine. If not, see <http://www.gnu.org/licenses/>.
16 */
17 /* The original authors have included a copy of the license specified above in the
18  'Docs' folder. See 'gpl.txt'
19 */
20 /* We welcome the use of the Mezzanine engine to anyone, including companies who wish to
21  Build professional software and charge for their product.
22 
23  However there are some practical restrictions, so if your project involves
24  any of the following you should contact us and we will try to work something
25  out:
26  - DRM or Copy Protection of any kind(except Copyrights)
27  - Software Patents You Do Not Wish to Freely License
28  - Any Kind of Linking to Non-GPL licensed Works
29  - Are Currently In Violation of Another Copyright Holder's GPL License
30  - If You want to change our code and not add a few hundred MB of stuff to
31  your distribution
32 
33  These and other limitations could cause serious legal problems if you ignore
34  them, so it is best to simply contact us or the Free Software Foundation, if
35  you have any questions.
36 
37  Joseph Toppi - toppij@gmail.com
38  John Blackwood - makoenergy02@gmail.com
39 */
40 #ifndef _physicsconecollisionshape_cpp
41 #define _physicsconecollisionshape_cpp
42 
43 #include "Physics/conecollisionshape.h"
44 #include "collisionshapemanager.h"
45 #include "stringtool.h"
46 
47 #include "btBulletDynamicsCommon.h"
48 
49 namespace Mezzanine
50 {
51  namespace Physics
52  {
53  /////////////////////////////////////////
54  // ConeCollisionShape Functions
55 
56  void ConeCollisionShape::Construct(const String& Name, const Real& Radius, const Real& Height, StandardAxis UpAxis)
57  {
58  this->Name = Name;
59  btConeShape* ConeShape;
60  if(Axis_Y == UpAxis) ConeShape = new btConeShape(Radius,Height);
61  else if(Axis_X == UpAxis) ConeShape = new btConeShapeX(Radius,Height);
62  else if(Axis_Z == UpAxis) ConeShape = new btConeShapeZ(Radius,Height);
63  else { MEZZ_EXCEPTION(ExceptionBase::PARAMETERS_EXCEPTION,"Non-supported up StandardAxis passed into ConeCollisionShape constructor."); }
64  SetPointers(ConeShape);
65  this->GetBulletConeShape()->setImplicitShapeDimensions(Vector3(0,0,0).GetBulletVector3());
66  }
67 
69  {
70  Vector3 Results;
71  switch (GetUpStandardAxis())
72  {
73  case 0:
74  Results[0] = 1;
75  Results[1] = 0;
76  Results[2] = 2;
77  break;
78  case 1:
79  Results[0] = 0;
80  Results[1] = 1;
81  Results[2] = 2;
82  break;
83  case 2:
84  Results[0] = 0;
85  Results[1] = 2;
86  Results[2] = 1;
87  break;
88  default:
89  { MEZZ_EXCEPTION(ExceptionBase::PARAMETERS_EXCEPTION,"Non-supported up StandardAxis passed into ConeCollisionShape::GetAxisMathBS()."); }
90  }
91 
92  return Results;
93  }
94 
95  ConeCollisionShape::ConeCollisionShape(const String& Name, const Real& Radius, const Real& Height, const Vector3& UpAxis)
96  { Construct(Name, Radius, Height, UpAxis.IsStandardUnitAxis()); }
97 
98  ConeCollisionShape::ConeCollisionShape(const String& Name, const Real& Radius, const Real& Height, StandardAxis UpAxis)
99  { Construct(Name, Radius, Height, UpAxis); }
100 
102  {
103  if(OneNode.GetAttribute("Version").AsInt() == 1)
104  {
105  XML::Attribute OneName = OneNode.GetChild("PrimitiveCollisionShape").GetChild("CollisionShape").GetAttribute("Name"); // get name
106  if(!OneName) { MEZZ_EXCEPTION(ExceptionBase::PARAMETERS_EXCEPTION,"Could not find Name Attribute on CollsionShape Node during preparation for deserialization"); }
107  String Name_(OneName.AsString());
108 
109  XML::Attribute Radius = OneNode.GetAttribute("Radius"); // Find Attributes
110  if (!Radius) { DeSerializeError("find Radius Attribute",ConeCollisionShape::GetSerializableName()); }
111  XML::Attribute Axis = OneNode.GetAttribute("Axis");
112  if (!Axis) { DeSerializeError("find Axis Attribute",ConeCollisionShape::GetSerializableName()); }
113  XML::Attribute Height = OneNode.GetAttribute("Height");
114  if (!Height) { DeSerializeError("find Height Attribute",ConeCollisionShape::GetSerializableName()); }
115 
116  this->Construct(Name_,Radius.AsReal(),Height.AsReal(), (StandardAxis)Axis.AsInteger()); // make and deserialize the shape
117  this->ProtoDeSerialize(OneNode);
118  }else{
119  DeSerializeError("find usable serialization version",ConeCollisionShape::GetSerializableName());
120  }
121  }
122 
123  ConeCollisionShape::ConeCollisionShape(const String& Name, btConeShape* BulletShape)
124  {
125  this->Name = Name;
126  SetPointers(BulletShape);
127  this->GetBulletConeShape()->setImplicitShapeDimensions(Vector3(0,0,0).GetBulletVector3());
128  }
129 
131  {
132  delete GetBulletConeShape();
133  }
134 
136  {
137  return GetBulletConeShape()->getRadius();
138  }
139 
141  {
142  return GetBulletConeShape()->getHeight();
143  }
144 
146  {
147  return (GetRadius()) / GetRadiusScaling();
148  }
149 
151  {
152  return GetHeight() / GetHeightScaling();
153  }
154 
156  { return (GetScaling()[GetAxisMathBS()[0]]+GetScaling()[GetAxisMathBS()[2]])/2.0; }
157 
159  { return GetScaling()[GetUpStandardAxis()]; }
160 
162  { return Vector3::UnitOnAxis( (StandardAxis)GetBulletConeShape()->getConeUpIndex() ); }
163 
165  { return (StandardAxis)GetBulletConeShape()->getConeUpIndex(); }
166 
167 
169  {
171  }
172 
174  { return static_cast<btConeShape*>(ShapeBase); }
175 
177  {
178  XML::Node CollisionNode = CurrentRoot.AppendChild(this->ConeCollisionShape::GetSerializableName());
179  if (!CollisionNode) { SerializeError("create CollisionNode",this->ConeCollisionShape::GetSerializableName());}
180 
181  XML::Attribute Version = CollisionNode.AppendAttribute("Version");
182  if (Version)
183  { Version.SetValue(1); }
184  else
185  { SerializeError("Create Version Attribute", GetSerializableName()); }
186 
187  XML::Attribute RadiusAttr = CollisionNode.AppendAttribute("Radius");
188  if (RadiusAttr)
189  { RadiusAttr.SetValue(this->GetCleanRadius()); }
190  else
191  { SerializeError("Create RadiusAttr Attribute", GetSerializableName()); }
192 
193  /*XML::Attribute DirtyRadius = CollisionNode.AppendAttribute("DirtyRadius");
194  if (DirtyRadius)
195  { DirtyRadius.SetValue(this->GetRadius()); }
196  else
197  { SerializeError("Create DirtyRadius Attribute", GetSerializableName()); }*/
198 
199  XML::Attribute HeightAttr = CollisionNode.AppendAttribute("Height");
200  if (HeightAttr)
201  { HeightAttr.SetValue(this->GetCleanHeight()); }
202  else
203  { SerializeError("Create HeightAttr Attribute", GetSerializableName()); }
204 
205  XML::Attribute AxisAttr = CollisionNode.AppendAttribute("Axis");
206  if (AxisAttr)
207  { AxisAttr.SetValue(this->GetUpStandardAxis()); }
208  else
209  { SerializeError("Create AxisAttr Attribute", GetSerializableName()); }
210 
211  this->PrimitiveCollisionShape::ProtoSerialize(CollisionNode);
212  }
213 
215  {
217  {
218  if(OneNode.GetAttribute("Version").AsInt() == 1)
219  {
220  XML::Node CollisionNode = OneNode.GetChild(this->PrimitiveCollisionShape::GetSerializableName());
221  if(!CollisionNode)
222  { DeSerializeError("locate PrimitiveCollisionShape node",GetSerializableName()); }
223  this->PrimitiveCollisionShape::ProtoDeSerialize(CollisionNode);
224  }else{
225  DeSerializeError("find usable serialization version",GetSerializableName());
226  }
227  }else{
228  DeSerializeError(String("find correct class to deserialize, found a ")+OneNode.Name(),GetSerializableName());
229  }
230  }
231 
233  { return String("ConeCollisionShape"); }
234  }//Physics
235 }//Mezzanine
236 
237  std::ostream& operator << (std::ostream& stream, const Mezzanine::Physics::ConeCollisionShape& ShapeToSerialize)
238  { Mezzanine::Serialize(stream, ShapeToSerialize); return stream; }
239 
240  std::istream& operator >> (std::istream& stream, Mezzanine::Physics::ConeCollisionShape& x)
241  { return Mezzanine::DeSerialize(stream, x); }
242 
244  { x.ProtoDeSerialize(OneNode); }
245 
246 #endif
std::ostream & operator<<(std::ostream &stream, const Mezzanine::LinearInterpolator< T > &Lint)
Used to Serialize an Mezzanine::LinearInterpolator to a human readable stream.
Definition: interpolator.h:433
Attribute AppendAttribute(const Char8 *Name)
Creates an Attribute and puts it at the end of this Nodes attributes.
virtual void ProtoDeSerialize(const XML::Node &OneNode)
Take the data stored in an XML and overwrite this instance of this object with it.
A light-weight handle for manipulating attributes in DOM tree.
Definition: attribute.h:74
Indicates the class is a ConeCollisionShape.
StandardAxis
Used to identify different Axis in a 3d coordinate system.
Definition: enumerations.h:119
virtual void ProtoDeSerialize(const XML::Node &OneNode)
#define MEZZ_EXCEPTION(num, desc)
An easy way to throw exceptions with rich information.
Definition: exception.h:3048
std::ostream & Serialize(std::ostream &Stream, const T &Converted, const String &Indent=String(""))
Convert any class that supports serialization or has a serializer to a string of chars in a stream...
Real GetHeightScaling() const
Which axis is up defines which axis is used to scale height.
virtual Vector3 GetScaling() const
Gets the current scaling being applied to the collision shape.
static String GetSerializableName()
Get the name of the the XML tag this class will leave behind as its instances are serialized...
const Char8 * AsString(const Char8 *def="") const
Attempts to convert the value of the attribute to a String and returns the results.
virtual Real GetRadius() const
Gets the radius of the cone, as used for collision checking.
static String GetSerializableName()
Get the name of the the XML tag this class will leave behind as its instances are serialized...
virtual void ProtoSerialize(XML::Node &CurrentRoot) const
float Real
A Datatype used to represent a real floating point number.
Definition: datatypes.h:141
virtual Real GetCleanRadius() const
Gets the radius of the cone, as originally passed in.
bool SetValue(const Char8 *rhs)
Set the value of this.
virtual CollisionShape::ShapeType GetType() const
Gets the type of Collision shape this is.
virtual Vector3 GetUpAxis() const
Gets which axis this cone is oriented along.
A light-weight handle for manipulating nodes in DOM tree.
Definition: node.h:89
int AsInt(int def=0) const
Attempts to convert the value of the attribute to an int and returns the results. ...
void Construct(const String &Name, const Real &Radius, const Real &Height, StandardAxis UpAxis)
Performe shared contructor work.
ShapeType
This enum describes what kind of shape you are currently working with.
Integer AsInteger(Integer def=0) const
Attempts to convert the value of the attribute to a Integer and returns the results.
Real AsReal(Real def=0) const
Attempts to convert the value of the attribute to a Real and returns the results. ...
virtual ~ConeCollisionShape()
Class Destructor.
Real GetRadiusScaling() const
Which axis is up defines which 2 axis are used to scale the radius.
virtual Real GetCleanHeight() const
Gets the height of the cone, as originally passed in.
std::istream & DeSerialize(std::istream &Stream, T &Converted)
Deserialize the next xml tag in the stream into a specific in memory class instance.
void DeSerializeError(const String &FailedTo, const String &ClassName, Boole SOrD)
Simply does some string concatenation, then throws an Exception.
Thrown when parameters are checked at runtime and found invalid.
Definition: exception.h:108
virtual StandardAxis GetUpStandardAxis() const
Gets which axis this cone is oriented along.
ConeCollisionShape(const String &Name, const Real &Radius, const Real &Height, const Vector3 &UpAxis)
Class Constructor.
virtual void ProtoSerialize(XML::Node &CurrentRoot) const
Convert this class to an XML::Node ready for serialization.
This is used to represent a point in space, or a vector through space.
Definition: vector3.h:77
void SetPointers(btConvexInternalShape *Shape)
Sets the internal pointers on the base classes.
virtual btConeShape * GetBulletConeShape() const
Gets a pointer to the upcasted internal shape.
String Name
Storage for the name of this class instance.
The bulk of the engine components go in this namspace.
Definition: actor.cpp:56
std::istream & operator>>(std::istream &stream, Mezzanine::LinearInterpolator< T > &Lint)
Used to de-serialize an Mezzanine::LinearInterpolator from a stream.
Definition: interpolator.h:448
static Vector3 UnitOnAxis(StandardAxis Axis)
Get a Unit Vector along the given Axis.
Definition: vector3.cpp:149
virtual Real GetHeight() const
Gets the height of the cone, as used for collision checking.
btCollisionShape * ShapeBase
A pointer to the bullet collision this uses.
Vector3 GetAxisMathBS() const
Simulate some messed up the physics library does.
const Char8 * Name() const
ptrdiff_tGet the name of this Node.
void SerializeError(const String &FailedTo, const String &ClassName, Boole SOrD)
Simply does some string concatenation, then throws an Exception.
Node AppendChild(NodeType Type=NodeElement)
Creates a Node and makes it a child of this one.
std::string String
A datatype used to a series of characters.
Definition: datatypes.h:159
Attribute GetAttribute(const Char8 *Name) const
Attempt to get an Attribute on this Node with a given name.
Node GetChild(const Char8 *Name) const
Attempt to get a child Node with a given name.
StandardAxis IsStandardUnitAxis() const
Get a Unit Vector along the given Axis.
Definition: vector3.cpp:160