Spinning Topp Logo BlackTopp Studios
inc
conegenerator.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 /*
41  -----------------------------------------------------------------------------
42  This source file is part of ogre-procedural
43 
44  For the latest info, see http://code.google.com/p/ogre-procedural/
45 
46  Copyright (c) 2010-2013 Michael Broutin
47 
48  Permission is hereby granted, free of charge, to any person obtaining a copy
49  of this software and associated documentation files (the "Software"), to deal
50  in the Software without restriction, including without limitation the rights
51  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
52  copies of the Software, and to permit persons to whom the Software is
53  furnished to do so, subject to the following conditions:
54 
55  The above copyright notice and this permission notice shall be included in
56  all copies or substantial portions of the Software.
57 
58  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
59  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
60  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
61  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
62  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
63  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
64  THE SOFTWARE.
65  -----------------------------------------------------------------------------
66  */
67 #ifndef _graphicsproceduralconegenerator_cpp
68 #define _graphicsproceduralconegenerator_cpp
69 
70 #include "Graphics/Procedural/Mesh/conegenerator.h"
71 
72 #include "MathTools/mathtools.h"
73 #include "exception.h"
74 
75 namespace Mezzanine
76 {
77  namespace Graphics
78  {
79  namespace Procedural
80  {
81  ConeGenerator::ConeGenerator(const Real Radius, const Real Height, const Whole SegCircle, const Whole SegHeight) :
82  ConeRadius(Radius),
83  ConeHeight(Height),
84  NumSegCircle(SegCircle),
85  NumSegHeight(SegHeight)
86  { }
87 
89  { }
90 
91  ///////////////////////////////////////////////////////////////////////////////
92  // Utility
93 
95  {
96  Buffer.RebaseOffset();
97  Buffer.EstimateVertexCount( ( this->NumSegHeight + 1 ) * ( this->NumSegCircle + 1 ) + this->NumSegCircle + 2 );
98  Buffer.EstimateIndexCount( this->NumSegHeight * this->NumSegCircle * 6 + 3 * this->NumSegCircle );
99 
100  Real deltaAngle = ( MathTools::GetTwoPi() / this->NumSegCircle );
101  Real deltaHeight = this->ConeHeight / (Real)this->NumSegHeight;
102  Integer Offset = 0;
103 
104  Vector3 refNormal = Vector3( this->ConeRadius, this->ConeHeight, 0.f ).GetNormal();
105  Quaternion q;
106 
107  for( Whole i = 0 ; i <= this->NumSegHeight ; i++ )
108  {
109  Real r0 = this->ConeRadius * ( 1 - i / (Real)this->NumSegHeight );
110  for( Whole j = 0; j <= this->NumSegCircle ; j++ )
111  {
112  Real x0 = r0 * cosf( j * deltaAngle );
113  Real z0 = r0 * sinf( j * deltaAngle );
114 
115  q.SetFromAxisAngle( -deltaAngle * j, Vector3::Unit_Y() );
116 
117  this->AddPoint(Buffer, Vector3( x0, i * deltaHeight, z0 ),
118  q * refNormal,
119  Vector2( j / (Real)this->NumSegCircle, i / (Real)this->NumSegHeight ) );
120 
121  if( i != this->NumSegHeight && j != this->NumSegCircle ) {
122  Buffer.AddIndex( Offset + this->NumSegCircle + 2 );
123  Buffer.AddIndex( Offset );
124  Buffer.AddIndex( Offset + this->NumSegCircle + 1 );
125  Buffer.AddIndex( Offset + this->NumSegCircle + 2 );
126  Buffer.AddIndex( Offset + 1 );
127  Buffer.AddIndex( Offset );
128  }
129 
130  Offset++;
131  }
132  }
133 
134  //low cap
135  Integer CenterIndex = Offset;
136  this->AddPoint(Buffer, Vector3(0.0,0.0,0.0),
138  Vector2(0.0,1.0) );
139  Offset++;
140  for( Whole j = 0 ; j <= this->NumSegCircle ; j++ )
141  {
142  Real x0 = this->ConeRadius * cosf( j * deltaAngle );
143  Real z0 = this->ConeRadius * sinf( j * deltaAngle );
144 
145  this->AddPoint(Buffer, Vector3(x0, 0.0f, z0),
147  Vector2( j / (Real)this->NumSegCircle, 0.0 ) );
148 
149  if( j != this->NumSegCircle ) {
150  Buffer.AddIndex( CenterIndex );
151  Buffer.AddIndex( Offset );
152  Buffer.AddIndex( Offset + 1 );
153  }
154  Offset++;
155  }
156  }
157 
158  ///////////////////////////////////////////////////////////////////////////////
159  // Configuration
160 
162  {
163  if( Radius <= 0.0 )
164  MEZZ_EXCEPTION(ExceptionBase::PARAMETERS_EXCEPTION,"Radius for a generated cone mesh must be greater than zero.");
165 
166  this->ConeRadius = Radius;
167  return *this;
168  }
169 
171  {
172  if( Height <= 0.0 )
173  MEZZ_EXCEPTION(ExceptionBase::PARAMETERS_EXCEPTION,"Height for a generated cone mesh must be greater than zero.");
174 
175  this->ConeHeight = Height;
176  return *this;
177  }
178 
180  {
181  if( SegCircle < 3 )
182  MEZZ_EXCEPTION(ExceptionBase::PARAMETERS_EXCEPTION,"Number of segments for circular component of generated cone mesh must be greater than two.");
183 
184  this->NumSegCircle = SegCircle;
185  return *this;
186  }
187 
189  {
190  if( SegHeight == 0 )
191  MEZZ_EXCEPTION(ExceptionBase::PARAMETERS_EXCEPTION,"Number of segments for length component of generated cone mesh must be greater than zero.");
192 
193  this->NumSegHeight = SegHeight;
194  return *this;
195  }
196  }//Procedural
197  }//Graphics
198 }//Mezzanine
199 
200 #endif
Real ConeRadius
The radius of the cone.
Definition: conegenerator.h:87
ConeGenerator & SetHeight(const Real Height)
Sets the height of the cone. the height is set to 0 or less, a PARAMETERS_EXCEPTION will be thrown...
Vector3 GetNormal() const
This returns the normal for this relative to the origin.
Definition: vector3.cpp:363
virtual void AddToTriangleBuffer(TriangleBuffer &Buffer) const
Adds the vertices and indices as configured in this generator to a triangle buffer.
A convenience buffer that stores vertices and indices of a mesh to be generated.
ConeGenerator & SetNumSegHeight(const Whole SegHeight)
Sets the number of segments on the height. the number of segments is set to 0, a PARAMETERS_EXCEPTION...
void SetFromAxisAngle(const Real &Angle, const Vector3 &Axis)
Generates and sets the values of this quaternion to describe a rotation from an axis and angle on tha...
Definition: quaternion.cpp:115
#define MEZZ_EXCEPTION(num, desc)
An easy way to throw exceptions with rich information.
Definition: exception.h:3048
void EstimateIndexCount(const Whole IndexCount)
Gives an estimation of the number of indices needed for this triangle buffer.
int Integer
A datatype used to represent any integer close to.
Definition: datatypes.h:154
This implements the exception hiearchy for Mezzanine.
A generator class for a cone mesh.
Definition: conegenerator.h:82
float Real
A Datatype used to represent a real floating point number.
Definition: datatypes.h:141
ConeGenerator & SetRadius(const Real Radius)
Sets the base radius. the radius is set to 0 or less, a PARAMETERS_EXCEPTION will be thrown...
void EstimateVertexCount(const Whole VertexCount)
Gives an estimation of the number of vertices need for this triangle buffer.
This is used to represent a point on a 2 dimentional area, such as a screen.
Definition: vector2.h:63
static Vector3 Unit_Y()
Gets a vector representing the Y unit of a Vector3.
Definition: vector3.cpp:134
Whole NumSegCircle
The resolution of the circular component of the cone.
Definition: conegenerator.h:93
void AddPoint(TriangleBuffer &Buffer, const Vector3 &Loc, const Vector3 &Norm, const Vector2 &UV) const
Adds a new point to a triangle buffer, using the format defined for that MeshGenerator.
Whole NumSegHeight
The number of segments in the cones length.
Definition: conegenerator.h:96
Thrown when parameters are checked at runtime and found invalid.
Definition: exception.h:108
Real ConeHeight
The height of the cone.
Definition: conegenerator.h:90
TriangleBuffer & AddIndex(const Integer Index)
Adds an index to the index buffer.
This is used to represent a point in space, or a vector through space.
Definition: vector3.h:77
The bulk of the engine components go in this namspace.
Definition: actor.cpp:56
unsigned long Whole
Whole is an unsigned integer, it will be at least 32bits in size.
Definition: datatypes.h:151
ConeGenerator & SetNumSegCircle(const Whole SegCircle)
Sets the number of segments on the side of the base. the number of segments is less than three...
This is used to store information about rotation in 3d space.
Definition: quaternion.h:68
ConeGenerator(const Real Radius, const Real Height, const Whole SegCircle=16, const Whole SegHeight=1)
Class constructor.
static Vector3 Neg_Unit_Y()
Gets a vector representing the negative Y unit of a Vector3.
Definition: vector3.cpp:143