GL Studio C++ Runtime API
gls_eyepoint.h
Go to the documentation of this file.
1/// \file gls_eyepoint.h
2/// \brief The disti::GlsEyePoint class. Implements eyepoints.
3///
4/// \par Copyright Information
5///
6/// Copyright (c) 2017 by The DiSTI Corporation.<br>
7/// 12249 Science Drive; Suite 300<br>
8/// Orlando, Florida 32826<br>
9/// USA<br>
10/// <br>
11/// All rights reserved.<br>
12///
13/// This Software contains proprietary trade secrets of DiSTI and may not be
14/// reproduced, in whole or part, in any form, or by any means of electronic,
15/// mechanical, or otherwise, without the written permission of DiSTI. Said
16/// permission may be derived through the purchase of applicable DiSTI product
17/// licenses which detail the distribution rights of this content and any
18/// Derivative Works based on this or other copyrighted DiSTI Software.
19///
20/// NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
21/// AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
22/// PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
23/// AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
24/// IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
25/// PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.
26///
27/// LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
28/// IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
29/// INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
30/// DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
31/// INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
32/// INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
33/// OF SUCH DAMAGES. DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
34/// EXCEED FIVE DOLLARS (US$5.00).
35///
36/// The aforementioned terms and restrictions are governed by the laws of the
37/// State of Florida and the United States of America.
38
39#ifndef DISTI_INCLUDED_GLS_EYEPOINT_H
40#define DISTI_INCLUDED_GLS_EYEPOINT_H
41
42#include "display.h"
43#include "disti_metadata.h"
44#include "gls_color.h"
46#include "gls_include.h"
48
49namespace disti
50{
51/**
52 Eye Point Initializers
53*/
54typedef enum
55{
56 GLS_EYEPOINT_FOV = GLS_LAST_INITIALIZER + 1,
57 GLS_EYEPOINT_ORTHOGRAPHIC,
58 GLS_EYEPOINT_ORTHO_SIZE,
59 GLS_EYEPOINT_FOV_IS_HORIZONTAL,
60 GLS_EYEPOINT_ASPECT,
61 GLS_EYEPOINT_NEAR_CLIP,
62 GLS_EYEPOINT_FAR_CLIP,
63 GLS_EYEPOINT_MAINTAIN_ASPECT,
64 GLS_EYEPOINT_VIEW_VECTORS
66
67class GlsEyePoint;
68
69/// The EyePointCalcViewCallbackBase class.
71{
72public:
74
75 /// The callback method interface, used for custom user callbacks to configure the eyepoint's view.
76 /// \param viewWidth The view width in pixels.
77 /// \param viewHeight The view height in pixels.
78 /// \param thisEye The GlsEyePoint associated with this callback.
79 /// \param rval1 Returned user defined value.
80 /// \param rval2 Another returned user defined value.
81 virtual void Call( int viewWidth, int viewHeight, GlsEyePoint* thisEye, double& rval1, double& rval2 ) = 0;
82};
83
84/// The EyePointCalcViewCallback class.
85template<class T>
87{
88public:
89 typedef void ( T::*MethodType )( int viewWidth, int viewHeight, GlsEyePoint* thisEye, double& rval1, double& rval2 ); ///< Typedef for the callback function pointer.
90
91 T* _container; ///< The object which contains the method to call.
92 MethodType _method; ///< The callback method function pointer.
93
94 /// Construct a new EyePointCalcViewCallback object.
95 /// \param container The object containing the callback method.
96 /// \param method The callback function pointer to call.
97 EyePointCalcViewCallback( T* container, MethodType method )
98 : _container( container )
99 , _method( method )
100 {
101 }
102
103 void Call( int viewWidth, int viewHeight, GlsEyePoint* thisEye, double& rval1, double& rval2 ) DISTI_METHOD_OVERRIDE
104 {
105 if( _container )
106 {
107 ( _container->*( _method ) )( viewWidth, viewHeight, thisEye, rval1, rval2 );
108 }
109 }
110};
111
112/**
113 The GlsEyePoint class. Implements Eyepoints
114*/
116{
117public:
118 DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
119 typedef DisplayObject _BaseClass; ///< Deprecated typedef for the base class.
120 typedef DisplayObject BaseClass; ///< Typedef for the base class.
121 friend class GlsEyePointEditor;
122
123 /// The FovConstraintType enum. Defines view constraint behavior.
124 typedef enum
125 {
126 FOV_CONSTRAINT_NONE,
127 FOV_CONSTRAINT_GREATER,
128 FOV_CONSTRAINT_LESS,
129 FOV_CONSTRAINT_EXACTLY
131
132private:
133 static bool _drawDebugGeometry; /** Causes eyepoints to draw debugging geometry. Defaults to false. */
134
135protected:
136 double _fov; /** Field of view of eyepoint in Degrees, if _fovIsHorizontal is true, this is horizontal */
137 double _otherFov; /** Field of view for the other direction, based on _fovIsHorizontal */
138 bool _orthographic; /** True if orthographic projection, else perspective projection */
139 double _orthoSize; /** Size of ortho projection in logical units, if _fovIsHorizontal is true, this is horizontal */
140 double _otherOrthoSize; /** Size of ortho projection for the other direction, based on _fovIsHorizontal */
141 bool _fovIsHorizontal; /** True if field of view measurement is along horizonal axis, else along vertical axis */
142 FovConstraintType _horizontalConstraint; /** The type of constraint in the horizontal direction */
143 FovConstraintType _verticalConstraint; /** The type of constraint in the vertical direction */
144 double _nearClip; /** Distance from eyepoint to near clipping plane */
145 double _farClip; /** Distance from eyepoint to far clipping plane */
146 Vector _viewVectors[ 3 ]; /** 3 vectors used to set the orientation of the eyepoint */
147
148 EyePointCalcViewCallbackBase* _alternateCalcOrthographicView; /** Alternate callback for calculating the orthographic view */
149 EyePointCalcViewCallbackBase* _alternateCalcPerspectiveView; /** Alternate callback for calculating the perspective view */
150
151#ifdef GLES
152 /** Set a single attribute from the GLO file.
153 * \param data The attribute to set and its associated data.
154 */
155 GLS_EXPORT void SetFromGloData( GlsGloFileAttribute& data ) DISTI_METHOD_OVERRIDE;
156#endif
157
158public:
159 /// Set DrawDebugGeometry to true to cause eyepoints to draw at runtime.
160 /// \note This affects all eyepoint instances.
161 /// \param draw The new debug state to set.
162 static void DrawDebugGeometry( bool draw ) { _drawDebugGeometry = draw; }
163
165
166 /** Allocate a (blank) EyePoint object */
168
169 /** The copy constructor for GlsEyePoint
170 *
171 * \param that The GlsEyePoint object that is being copied
172 * \param generateNames Whether or not to generate a new instance name
173 */
174 GLS_EXPORT GlsEyePoint( const GlsEyePoint& that, const bool generateNames );
175
176 /** Destroy an Eyepoint object */
178
180
181 /** Draws does nothing because this object is not a visible object,
182 * unless DrawDebugGeometry() is true, then it draws the view frustum. */
184
185#ifndef GLES
186 /// Draws a representation of the frustum. This is done primarily for the editor.
187 /// but is available at runtime. The specific values can be specified to avoid
188 /// making the editor set them and set them back.
189 /// \param selected If true, this object is currently selected.
190 /// \param orthographic If true, this eyepoint is orthographic, otherwise it is perspective.
191 /// \param fovIsHorizontal If true the field of view is horizontal, otherwise it is vertical.
192 /// \param orthoSize The width of the orthographic view in pixels.
193 /// \param otherOrthoSize The height of the orthographic view in pixels.
194 /// \param fov The width of the view in degrees, height if fovIsHorizontal is true.
195 /// \param otherFov The height of the view in degrees, width if fovIsHorizontal is true.
196 /// \param horizontalConstraint The horizontal constraint behavior.
197 /// \param verticalConstraint The vertical constraint behavior.
198 /// \param farClip The far clip distance.
199 /// \param nearClip The near clip distance.
201 bool selected,
202 bool orthographic,
203 bool fovIsHorizontal,
204 double orthoSize,
205 double otherOrthoSize,
206 double fov,
207 double otherFov,
208 FovConstraintType horizontalConstraint,
209 FovConstraintType verticalConstraint,
210 double farClip,
211 double nearClip );
212#endif
213
216
217#ifndef GLES
220#endif
221
222 /* Unhides base class implementation. */
223 using BaseClass::Rotate;
224 GLS_EXPORT void Rotate( const Vector& orig, float angle, const Vector& axis ) DISTI_METHOD_OVERRIDE;
225
226 GLS_EXPORT void SetValue( int spec, va_list& args ) DISTI_METHOD_OVERRIDE;
227
228 /** Sets the Field Of View for this eyepoint.
229 * If FovIsHorizontal, this is the horizontal fov.
230 * \param fovDeg The new field of view, in degrees
231 */
232 GLS_EXPORT void FOV( double fovDeg );
233
234 /** Sets the Field Of View for this eyepoint.
235 * If FovIsHorizontal, this is the vertical fov.
236 * \param fovDeg The new field of view, in degrees
237 */
238 GLS_EXPORT void OtherFOV( double fovDeg );
239
240 /** Sets whether or not the field of view measurement is along horizontal or vertical axis
241 * \param val True if FOV measurement is along horizonal axis of eyepoint
242 */
243 GLS_EXPORT void FovIsHorizontal( bool val );
244
245 /** Sets whether the eyepoint uses an orthographic projection or a perspective projection
246 * \param val True if the eypoint uses an orthographic projection. False if it uses a perspective projection.
247 */
248 GLS_EXPORT void Orthographic( bool val );
249
250 /** Sets the size of the orthographic projection, in logical units.
251 * The direction this controls is set by FovIsHorizontal. If true, it is horizontal.
252 * \param val The size of the orthographic projection, in logical units
253 */
254 GLS_EXPORT void OrthoSize( double val );
255
256 /** Sets the size of the orthographic projection, in logical units.
257 * The direction this controls is set by FovIsHorizontal. If true, it is vertical.
258 * \param val The size of the orthographic projection, in logical units
259 */
260 GLS_EXPORT void OtherOrthoSize( double val );
261
262 /** Sets the distance to the near clipping plane from the eyepoint
263 * \param val Distance to the near clipping plane from the eyepoint in logical units
264 */
265 GLS_EXPORT void NearClip( double val );
266
267 /** Sets the distance to the far clipping plane from the eyepoint
268 * \param val Distance to the far clipping plane from the eyepoint in logical units
269 */
270 GLS_EXPORT void FarClip( double val );
271
272 /// Sets the constraint for the horizontal direction.
273 /// \param val The new horizontal constraint behavior to set.
275
276 /// Sets the constraint for the vertical direction.
277 /// \param val The new vertical constraint behavior to set.
279
280 /// Allows the view vectors to be set directly.
281 /// \note These are normally controlled by the Orientation call.
282 /// \param x The new X view vector to set.
283 /// \param y The new Y view vector to set.
284 /// \param z The new Z view vector to set.
285 GLS_EXPORT void SetViewVectors( const Vector& x, const Vector& y, const Vector& z );
286
287 /** Gets the Field Of View for this eyepoint.
288 * If FovIsHorizontal is true, this is the horizontal fov.
289 * \return The field of view, in degrees
290 */
291 GLS_EXPORT double FOV();
292
293 /** Gets the Field Of View for this eyepoint.
294 * If FovIsHorizontal is true, this is the vertical fov.
295 * \return The field of view, in degrees
296 */
298
299 /** Gets whether or not the field of view measurement is along horizontal or vertical axis
300 * \return True if FOV measurement is along horizonal axis of eyepoint
301 */
303
304 /** Gets whether the eyepoint uses an orthographic projection or a perspective projection
305 * \return True if the eypoint uses an orthographic projection. False if it uses a perspective projection.
306 */
308
309 /// The direction this returns is set by FovIsHorizontal. If true, it is horizontal.
310 /// \return The size of the orthographic projection, in logical units.
312
313 /// The direction this returns is set by FovIsHorizontal. If true, it is vertical.
314 /// \return The size of the orthographic projection, in logical units.
316
317 /** Gets the distance to the near clipping plane from the eyepoint
318 * \return Distance to the near clipping plane from the eyepoint in logical units
319 */
321
322 /** Gets the distance to the far clipping plane from the eyepoint
323 * \return Distance to the far clipping plane from the eyepoint in logical units
324 */
326
327 /// \return the constraint for the horizontal direction
329
330 /// \return the constraint for the vertical direction
332
333 /// Returns the current view vectors.
334 /// \param x The returned X view vector.
335 /// \param y The returned Y view vector.
336 /// \param z The returned Z view vector.
338
339 /** Sets the orientation of the eyepoint
340 * \param direction A direction vector
341 * \param roll A roll value about the direction vector, in degrees
342 * \param upVector defines the "up" direction for the purposes of calculating roll.
343 */
344 GLS_EXPORT void Orientation( const Vector& direction, float roll, const Vector& upVector = Vector( 0, 1, 0 ) /* Y Axis */ );
345
346 /** Gets the current direction vector of the eyepoint
347 * \return The direction vector
348 */
350
351 /** Gets the current roll angle of the eyepoint
352 * \return The current roll
353 * \param upVector The "up" direction used for determining roll.
354 */
355 GLS_EXPORT float Roll( const Vector upVector = Vector( 0, 1, 0 ) /* Y Axis */ );
356
357 /// Called by ApplyViewMatrices() to do the sizing logic.
358 /// \param viewWidth The width of the view in pixels.
359 /// \param viewHeight The height of the view in pixels.
360 /// \param thisEye The associated eyepoint (this).
361 /// \param fovY The vertical field of view in degrees.
362 /// \param aspect The aspect ratio width / height.
363 virtual GLS_EXPORT void CalcOrthographicView( int viewWidth, int viewHeight, GlsEyePoint* thisEye, double& fovY, double& aspect );
364
365 /// Called by ApplyViewMatrices() to do the sizing logic.
366 /// \param viewWidth The width of the view in pixels.
367 /// \param viewHeight The height of the view in pixels.
368 /// \param thisEye The associated eyepoint (this).
369 /// \param fovY The vertical field of view in degrees.
370 /// \param aspect The aspect ratio width / height.
371 virtual GLS_EXPORT void CalcPerspectiveView( int viewWidth, int viewHeight, GlsEyePoint* thisEye, double& fovY, double& aspect );
372
373#ifdef GLES
374 /** Calculates and applies the projection and modelview matrices for this eyepoint
375 * \param proj The projection matrix (returned)
376 * \param modelView The modelview matrix (returned)
377 * \param width The current view width
378 * \param height The current view height
379 */
380 virtual GLS_EXPORT void ApplyViewMatrices( GlsMatrixType& proj, GlsMatrixType& modelView, int width, int height );
381#else
382 /** Calculates and applies the projection and modelview matrices for this eyepoint */
384#endif
385
386 /** Returns the modelview matrix for this eyepoint.
387 * \param modelview Output
388 * \param includeEyeToWorld If true, will include all transforms up to the top of the hierarcy.
389 */
390 virtual GLS_EXPORT void GetModelViewMatrix( GlsMatrixType& modelview, bool includeEyeToWorld = true );
391 /** Returns the projection matrix for this eyepoint
392 * \param proj The requested projection matrix
393 * \param viewW The width of the view in pixels
394 * \param viewH The height of the view in pixels
395 */
396 virtual GLS_EXPORT void GetProjectionMatrix( GlsMatrixType& proj, int viewW, int viewH );
397
398 /// Assigns a custom user defined callback to be called to configure the orthographic view instead of GlsEyePoint's default behavior.
399 /// \param eye The associated eyepoint.
400 /// \param container The object containing the callback method.
401 /// \param method The callback function pointer to call.
402 template<class T>
404 {
405 if( !eye )
406 return;
409 eye->_alternateCalcOrthographicView = new EyePointCalcViewCallback<T>( container, method );
410 }
411
412 /// Assigns a custom user defined callback to be called to configure the perspective view instead of GlsEyePoint's default behavior.
413 /// \param eye The associated eyepoint.
414 /// \param container The object containing the callback method.
415 /// \param method The callback function pointer to call.
416 template<class T>
418 {
419 if( !eye )
420 return;
423 eye->_alternateCalcPerspectiveView = new EyePointCalcViewCallback<T>( container, method );
424 }
425
426private:
427 // Returns the 16 doubles representing the ModelView matrix
428 // Must set with bool_includeEyeToWorld before reading
429 GLS_EXPORT GlsPropString GetModelViewMatrix();
430 GLS_EXPORT void GetModelViewMatrix( const GlsPropString& bool_includeEyeToWorld );
431 bool _getModelViewMatrixIncludeEyeToWorld;
432
433 // Returns the 16 doubles representing the Projection matrix
434 // Must set with int_width_height before reading
435 GLS_EXPORT GlsPropString GetProjectionMatrix();
436 GLS_EXPORT void GetProjectionMatrix( const GlsPropString& int_width_height );
437 int _getProjectionMatrixWidth;
438 int _getProjectionMatrixHeight;
439
440 /** Assignment operator not implemented. Use CloneObject() or the copy constructor instead. */
441 GlsEyePoint& operator=( const GlsEyePoint& that ) DISTI_SPECIAL_MEM_FUN_DELETE;
443};
444
445///////////////////////////////////////////////////////////
446// DistiAttributeFovConstraintTypeEnum
447///////////////////////////////////////////////////////////
448/// The DistiAttributeFovConstraintTypeEnum class.
449class DistiAttributeFovConstraintTypeEnum : public DistiAttributeEnum<GlsEyePoint, GlsEyePoint::FovConstraintType, GlsEyePoint::FovConstraintType>
450{
451public:
452 /// Create a new DistiAttributeFovConstraintTypeEnum object.
453 /// \param frame The GlsEyePoint object holding the Fov constraint property.
454 /// \param setMethod The set method function pointer.
455 /// \param getMethod The get method function pointer.
456 /// \param name The name of the associated property.
458
460
461 std::string Type() const DISTI_METHOD_OVERRIDE;
462};
463
464} // namespace disti
465
466#endif
Definition: disti_metadata.h:87
Definition: display.h:95
virtual void Rotate(float angle, int axis=Z_AXIS)
Definition: disti_metadata.h:1021
void(containerClass::* SetMethodType)(GlsEyePoint::FovConstraintType)
Typedef for the set method function pointer.
Definition: disti_metadata.h:1023
GlsEyePoint::FovConstraintType(containerClass::* GetMethodType)()
Typedef for the get method function pointer.
Definition: disti_metadata.h:1024
The DistiAttributeFovConstraintTypeEnum class.
Definition: gls_eyepoint.h:450
std::string Type() const override
DistiAttributeFovConstraintTypeEnum(GlsEyePoint *frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName &name)
Definition: dynamic_array.h:79
The EyePointCalcViewCallbackBase class.
Definition: gls_eyepoint.h:71
virtual void Call(int viewWidth, int viewHeight, GlsEyePoint *thisEye, double &rval1, double &rval2)=0
The EyePointCalcViewCallback class.
Definition: gls_eyepoint.h:87
void Call(int viewWidth, int viewHeight, GlsEyePoint *thisEye, double &rval1, double &rval2) override
Definition: gls_eyepoint.h:103
void(T::* MethodType)(int viewWidth, int viewHeight, GlsEyePoint *thisEye, double &rval1, double &rval2)
Typedef for the callback function pointer.
Definition: gls_eyepoint.h:89
EyePointCalcViewCallback(T *container, MethodType method)
Definition: gls_eyepoint.h:97
T * _container
The object which contains the method to call.
Definition: gls_eyepoint.h:91
MethodType _method
The callback method function pointer.
Definition: gls_eyepoint.h:92
Definition: gls_eyepoint.h:116
static void DrawDebugGeometry(bool draw)
Definition: gls_eyepoint.h:162
void FOV(double fovDeg)
virtual void CalcPerspectiveView(int viewWidth, int viewHeight, GlsEyePoint *thisEye, double &fovY, double &aspect)
void VerticalConstraint(FovConstraintType val)
void SetAvailableAttributes(unsigned int value) override
InterfaceListType * GetCppInterfaceDescription(InterfaceListType *addToThisList) override
FovConstraintType _verticalConstraint
Definition: gls_eyepoint.h:143
EyePointCalcViewCallbackBase * _alternateCalcPerspectiveView
Definition: gls_eyepoint.h:149
void CopyProperties(DisplayObject *src) override
double _orthoSize
Definition: gls_eyepoint.h:139
float Roll(const Vector upVector=Vector(0, 1, 0))
double _otherFov
Definition: gls_eyepoint.h:137
bool _orthographic
Definition: gls_eyepoint.h:138
EyePointCalcViewCallbackBase * _alternateCalcOrthographicView
Definition: gls_eyepoint.h:148
void Orthographic(bool val)
bool _fovIsHorizontal
Definition: gls_eyepoint.h:141
void CopyGeometry(DisplayObject *src) override
void SetValue(int spec, va_list &args) override
void NearClip(double val)
Vector _viewVectors[3]
Definition: gls_eyepoint.h:146
void OrthoSize(double val)
FovConstraintType _horizontalConstraint
Definition: gls_eyepoint.h:142
static void SetAlternateCalcPerspectiveView(GlsEyePoint *eye, T *container, typename EyePointCalcViewCallback< T >::MethodType method)
Definition: gls_eyepoint.h:417
void GetCppInterfaceDescriptionFree(InterfaceListType *list) override
DisplayObject * CloneObject(bool generateNames=false) override
virtual void GetModelViewMatrix(GlsMatrixType &modelview, bool includeEyeToWorld=true)
double _fov
Definition: gls_eyepoint.h:136
static void SetAlternateCalcOrthographicView(GlsEyePoint *eye, T *container, typename EyePointCalcViewCallback< T >::MethodType method)
Definition: gls_eyepoint.h:403
virtual void DrawFrustum(bool selected, bool orthographic, bool fovIsHorizontal, double orthoSize, double otherOrthoSize, double fov, double otherFov, FovConstraintType horizontalConstraint, FovConstraintType verticalConstraint, double farClip, double nearClip)
double OtherOrthoSize()
virtual void CalcOrthographicView(int viewWidth, int viewHeight, GlsEyePoint *thisEye, double &fovY, double &aspect)
void Orientation(const Vector &direction, float roll, const Vector &upVector=Vector(0, 1, 0))
FovConstraintType VerticalConstraint()
FovConstraintType HorizontalConstraint()
void Rotate(const Vector &orig, float angle, const Vector &axis) override
void OtherOrthoSize(double val)
void FovIsHorizontal(bool val)
virtual void GetProjectionMatrix(GlsMatrixType &proj, int viewW, int viewH)
double _otherOrthoSize
Definition: gls_eyepoint.h:140
void GetViewVectors(Vector &x, Vector &y, Vector &z)
void SetViewVectors(const Vector &x, const Vector &y, const Vector &z)
void HorizontalConstraint(FovConstraintType val)
FovConstraintType
The FovConstraintType enum. Defines view constraint behavior.
Definition: gls_eyepoint.h:125
void OtherFOV(double fovDeg)
virtual void ApplyViewMatrices()
void FarClip(double val)
double _farClip
Definition: gls_eyepoint.h:145
void Draw() override
double _nearClip
Definition: gls_eyepoint.h:144
Definition: gls_glo_file.h:1241
Definition: util.h:1603
Definition: vertex.h:84
The disti::DisplayObject class and global enumerations.
The disti metadata.
The Color class: Implements a 4 component RGBA color.
Macros and helper code to determine what subset of C++11/14/17 is available.
#define DISTI_SPECIAL_MEM_FUN_DELETE
Macro to wrap function deletion, removed on compilers that don't support it.
Definition: gls_cpp_lang_support.h:245
#define DISTI_DEPRECATED(msg)
Defines whether this compiler supports the C++14 deprecated attribute.
Definition: gls_cpp_lang_support.h:487
#define DISTI_METHOD_OVERRIDE
Macro to wrap the override keyword, removed on compilers that don't support it.
Definition: gls_cpp_lang_support.h:221
A file for all GL Studio files to include.
#define GLS_EXPORT
Macro denoting which functions should be visible from the runtime library.
Definition: gls_include.h:50
Defines templated metadata classes for DisplayObjects and other uses.
Definition: bmpimage.h:46
VertexNoColor Vector
Definition: gls_font_base.h:68
GLS_EyePoint_Initializers
Definition: gls_eyepoint.h:55