Visualization Library 2.1.0

A lightweight C++ OpenGL middleware for 2D/3D graphics

VL     Star     Watch     Fork     Issue

[Download] [Tutorials] [All Classes] [Grouped Classes]
init_graphics.cpp
Go to the documentation of this file.
1 /**************************************************************************************/
2 /* */
3 /* Visualization Library */
4 /* http://visualizationlibrary.org */
5 /* */
6 /* Copyright (c) 2005-2020, Michele Bosi */
7 /* All rights reserved. */
8 /* */
9 /* Redistribution and use in source and binary forms, with or without modification, */
10 /* are permitted provided that the following conditions are met: */
11 /* */
12 /* - Redistributions of source code must retain the above copyright notice, this */
13 /* list of conditions and the following disclaimer. */
14 /* */
15 /* - Redistributions in binary form must reproduce the above copyright notice, this */
16 /* list of conditions and the following disclaimer in the documentation and/or */
17 /* other materials provided with the distribution. */
18 /* */
19 /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND */
20 /* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED */
21 /* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE */
22 /* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR */
23 /* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES */
24 /* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; */
25 /* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON */
26 /* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */
27 /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */
28 /* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
29 /* */
30 /**************************************************************************************/
31 
32 #include <vlCore/VisualizationLibrary.hpp>
33 #include <vlCore/LoadWriterManager.hpp>
34 #include <vlGraphics/Rendering.hpp>
35 #include <vlGraphics/BezierSurface.hpp>
36 #include <vlGraphics/FontManager.hpp>
37 
38 #include <vlX/WrappersGraphics.hpp>
39 
40 #if defined(VL_IO_3D_3DS)
41  #include <vlGraphics/plugins/io3DS.hpp>
42 #endif
43 #if defined(VL_IO_3D_OBJ)
44  #include <vlGraphics/plugins/ioOBJ.hpp>
45 #endif
46 #if defined(VL_IO_3D_AC3D)
47  #include <vlGraphics/plugins/ioAC3D.hpp>
48 #endif
49 #if defined(VL_IO_3D_PLY)
50  #include <vlGraphics/plugins/ioPLY.hpp>
51 #endif
52 #if defined(VL_IO_3D_STL)
53  #include <vlGraphics/plugins/ioSTL.hpp>
54 #endif
55 #if defined(VL_IO_3D_MD2)
56  #include <vlGraphics/plugins/ioMD2.hpp>
57 #endif
58 #if defined(VL_IO_3D_COLLADA)
59  #include <vlGraphics/plugins/COLLADA/ioDae.hpp>
60 #endif
61 
62 static void registerVLXGraphicsWrappers();
63 
64 using namespace vl;
65 
66 //------------------------------------------------------------------------------
67 namespace
68 {
69  bool gInitializedGraphics = false;
70 };
71 //------------------------------------------------------------------------------
72 void VisualizationLibrary::initGraphics()
73 {
74  VL_CHECK( ! gInitializedGraphics );
75  if (gInitializedGraphics) {
76  Log::bug("VisualizationLibrary::initGraphics(): Visualization Library Graphics is already initialized!\n");
77  return;
78  }
79 
80  // Install default FontManager
81  setDefFontManager( new FontManager );
82 
83  // Register VLGraphics classes to VLX
84  registerVLXGraphicsWrappers();
85 
86  // Register VLGraphics modules
87 
88  #if defined(VL_IO_3D_OBJ)
89  registerLoadWriter(new LoadWriterOBJ);
90  #endif
91  #if defined(VL_IO_3D_3DS)
92  registerLoadWriter(new LoadWriter3DS);
93  #endif
94  #if defined(VL_IO_3D_AC3D)
95  registerLoadWriter(new LoadWriterAC3D);
96  #endif
97  #if defined(VL_IO_3D_PLY)
98  registerLoadWriter(new LoadWriterPLY);
99  #endif
100  #if defined(VL_IO_3D_STL)
101  registerLoadWriter(new LoadWriterSTL);
102  #endif
103  #if defined(VL_IO_3D_MD2)
104  registerLoadWriter(new LoadWriterMD2);
105  #endif
106  #if defined(VL_IO_3D_COLLADA)
107  registerLoadWriter(new LoadWriterDae);
108  #endif
109 
110  gInitializedGraphics = true;
111 }
112 //------------------------------------------------------------------------------
113 void VisualizationLibrary::shutdownGraphics()
114 {
115  if ( ! gInitializedGraphics ) {
116  Log::debug("VisualizationLibrary::shutdownGraphics(): VL Graphics not initialized.\n");
117  return;
118  }
119 
120  gInitializedGraphics = false;
121 
122  // Dispose default FontManager
123  if ( defFontManager() ) {
124  defFontManager()->releaseAllFonts();
125  setDefFontManager( NULL );
126  }
127 
128  Log::debug("VisualizationLibrary::shutdownGraphics()\n");
129 }
130 //------------------------------------------------------------------------------
131 void VisualizationLibrary::init(bool log_info)
132 {
133  initCore(log_info);
134  initGraphics();
135 }
136 //------------------------------------------------------------------------------
137 void VisualizationLibrary::shutdown()
138 {
139  shutdownGraphics();
140  shutdownCore();
141 }
142 //------------------------------------------------------------------------------
143 bool VisualizationLibrary::isGraphicsInitialized() { return gInitializedGraphics; }
144 //------------------------------------------------------------------------------
145 void registerVLXGraphicsWrappers()
146 {
147  // Geometry serializer
148  vlX::defVLXRegistry()->registerClassWrapper( Geometry::Type(), new vlX::VLXClassWrapper_Geometry );
149 
150  // BezierSurface
151  vlX::defVLXRegistry()->registerClassWrapper( BezierSurface::Type(), new vlX::VLXClassWrapper_Geometry );
152 
153  // PatchParameter
154  vlX::defVLXRegistry()->registerClassWrapper( PatchParameter::Type(), new vlX::VLXClassWrapper_PatchParameter );
155 
156  // DrawCall
157  ref<vlX::VLXClassWrapper_DrawCall> drawcall_serializer = new vlX::VLXClassWrapper_DrawCall;
158  vlX::defVLXRegistry()->registerClassWrapper( DrawArrays::Type(), drawcall_serializer.get() );
159  vlX::defVLXRegistry()->registerClassWrapper( DrawElementsUInt::Type(), drawcall_serializer.get() );
160  vlX::defVLXRegistry()->registerClassWrapper( DrawElementsUShort::Type(), drawcall_serializer.get() );
161  vlX::defVLXRegistry()->registerClassWrapper( DrawElementsUByte::Type(), drawcall_serializer.get() );
162  vlX::defVLXRegistry()->registerClassWrapper( MultiDrawElementsUInt::Type(), drawcall_serializer.get() );
163  vlX::defVLXRegistry()->registerClassWrapper( MultiDrawElementsUShort::Type(), drawcall_serializer.get() );
164  vlX::defVLXRegistry()->registerClassWrapper( MultiDrawElementsUByte::Type(), drawcall_serializer.get() );
165 
166  // ResourceDatabase
167  vlX::defVLXRegistry()->registerClassWrapper( ResourceDatabase::Type(), new vlX::VLXClassWrapper_ResourceDatabase );
168 
169  // Uniform
170  vlX::defVLXRegistry()->registerClassWrapper( Uniform::Type(), new vlX::VLXClassWrapper_Uniform );
171 
172  // LODEvaluator
173  vlX::defVLXRegistry()->registerClassWrapper( LODEvaluator::Type(), new vlX::VLXClassWrapper_LODEvaluator );
174 
175  // Transform
176  vlX::defVLXRegistry()->registerClassWrapper( Transform::Type(), new vlX::VLXClassWrapper_Transform );
177 
178  // Material
179  vlX::defVLXRegistry()->registerClassWrapper( Material::Type(), new vlX::VLXClassWrapper_Material );
180 
181  // Texture
182  vlX::defVLXRegistry()->registerClassWrapper( Texture::Type(), new vlX::VLXClassWrapper_Texture );
183 
184  // TextureImageUnit
185  vlX::defVLXRegistry()->registerClassWrapper( TextureImageUnit::Type(), new vlX::VLXClassWrapper_TextureImageUnit );
186 
187  // TexParameter
188  vlX::defVLXRegistry()->registerClassWrapper( TexParameter::Type(), new vlX::VLXClassWrapper_TexParameter );
189 
190  // ActorEventCallback
191  vlX::defVLXRegistry()->registerClassWrapper( DepthSortCallback::Type(), new vlX::VLXClassWrapper_ActorEventCallback );
192 
193  // LODEvaluator
194  ref<vlX::VLXClassWrapper_LODEvaluator> lod_evaluator = new vlX::VLXClassWrapper_LODEvaluator;
195  vlX::defVLXRegistry()->registerClassWrapper( PixelLODEvaluator::Type(), lod_evaluator.get() );
196  vlX::defVLXRegistry()->registerClassWrapper( DistanceLODEvaluator::Type(), lod_evaluator.get() );
197 
198  // Actor
199  vlX::defVLXRegistry()->registerClassWrapper( Actor::Type(), new vlX::VLXClassWrapper_Actor );
200 
201  // Effect
202  vlX::defVLXRegistry()->registerClassWrapper( Effect::Type(), new vlX::VLXClassWrapper_Effect );
203 
204  // Shader
205  vlX::defVLXRegistry()->registerClassWrapper( Shader::Type(), new vlX::VLXClassWrapper_Shader );
206 
207  // Camera
208  vlX::defVLXRegistry()->registerClassWrapper( Camera::Type(), new vlX::VLXClassWrapper_Camera );
209 
210  // Light
211  vlX::defVLXRegistry()->registerClassWrapper( Light::Type(), new vlX::VLXClassWrapper_Light );
212 
213  // ClipPlane
214  vlX::defVLXRegistry()->registerClassWrapper( ClipPlane::Type(), new vlX::VLXClassWrapper_ClipPlane );
215 
216  // Color
217  vlX::defVLXRegistry()->registerClassWrapper( Color::Type(), new vlX::VLXClassWrapper_Color );
218 
219  // SecondaryColor
220  vlX::defVLXRegistry()->registerClassWrapper( SecondaryColor::Type(), new vlX::VLXClassWrapper_SecondaryColor );
221 
222  // Normal
223  vlX::defVLXRegistry()->registerClassWrapper( Normal::Type(), new vlX::VLXClassWrapper_Normal );
224 
225  // VertexAttrib
226  vlX::defVLXRegistry()->registerClassWrapper( VertexAttrib::Type(), new vlX::VLXClassWrapper_VertexAttrib );
227 
228  // Viewport
229  vlX::defVLXRegistry()->registerClassWrapper( Viewport::Type(), new vlX::VLXClassWrapper_Viewport );
230 
231  // GLSL
232  vlX::defVLXRegistry()->registerClassWrapper( GLSLProgram::Type(), new vlX::VLXClassWrapper_GLSLProgram );
233  ref<vlX::VLXClassWrapper_GLSLShader> sh_serializer = new vlX::VLXClassWrapper_GLSLShader;
234  vlX::defVLXRegistry()->registerClassWrapper( GLSLVertexShader::Type(), sh_serializer.get() );
235  vlX::defVLXRegistry()->registerClassWrapper( GLSLFragmentShader::Type(), sh_serializer.get() );
236  vlX::defVLXRegistry()->registerClassWrapper( GLSLGeometryShader::Type(), sh_serializer.get() );
237  vlX::defVLXRegistry()->registerClassWrapper( GLSLTessControlShader::Type(), sh_serializer.get() );
238  vlX::defVLXRegistry()->registerClassWrapper( GLSLTessEvaluationShader::Type(), sh_serializer.get() );
239 
240  // GLSLShader
241  vlX::defVLXRegistry()->registerClassWrapper( GLSLShader::Type(), new vlX::VLXClassWrapper_GLSLShader );
242 
243  // Array serializer
244  ref<vlX::VLXClassWrapper_Array> array_serializer = new vlX::VLXClassWrapper_Array;
245 
246  vlX::defVLXRegistry()->registerClassWrapper( ArrayFloat1::Type(), array_serializer.get() );
247  vlX::defVLXRegistry()->registerClassWrapper( ArrayFloat2::Type(), array_serializer.get() );
248  vlX::defVLXRegistry()->registerClassWrapper( ArrayFloat3::Type(), array_serializer.get() );
249  vlX::defVLXRegistry()->registerClassWrapper( ArrayFloat4::Type(), array_serializer.get() );
250 
251  vlX::defVLXRegistry()->registerClassWrapper( ArrayDouble1::Type(), array_serializer.get() );
252  vlX::defVLXRegistry()->registerClassWrapper( ArrayDouble2::Type(), array_serializer.get() );
253  vlX::defVLXRegistry()->registerClassWrapper( ArrayDouble3::Type(), array_serializer.get() );
254  vlX::defVLXRegistry()->registerClassWrapper( ArrayDouble4::Type(), array_serializer.get() );
255 
256  vlX::defVLXRegistry()->registerClassWrapper( ArrayInt1::Type(), array_serializer.get() );
257  vlX::defVLXRegistry()->registerClassWrapper( ArrayInt2::Type(), array_serializer.get() );
258  vlX::defVLXRegistry()->registerClassWrapper( ArrayInt3::Type(), array_serializer.get() );
259  vlX::defVLXRegistry()->registerClassWrapper( ArrayInt4::Type(), array_serializer.get() );
260 
261  vlX::defVLXRegistry()->registerClassWrapper( ArrayUInt1::Type(), array_serializer.get() );
262  vlX::defVLXRegistry()->registerClassWrapper( ArrayUInt2::Type(), array_serializer.get() );
263  vlX::defVLXRegistry()->registerClassWrapper( ArrayUInt3::Type(), array_serializer.get() );
264  vlX::defVLXRegistry()->registerClassWrapper( ArrayUInt4::Type(), array_serializer.get() );
265 
266  vlX::defVLXRegistry()->registerClassWrapper( ArrayShort1::Type(), array_serializer.get() );
267  vlX::defVLXRegistry()->registerClassWrapper( ArrayShort2::Type(), array_serializer.get() );
268  vlX::defVLXRegistry()->registerClassWrapper( ArrayShort3::Type(), array_serializer.get() );
269  vlX::defVLXRegistry()->registerClassWrapper( ArrayShort4::Type(), array_serializer.get() );
270 
271  vlX::defVLXRegistry()->registerClassWrapper( ArrayUShort1::Type(), array_serializer.get() );
272  vlX::defVLXRegistry()->registerClassWrapper( ArrayUShort2::Type(), array_serializer.get() );
273  vlX::defVLXRegistry()->registerClassWrapper( ArrayUShort3::Type(), array_serializer.get() );
274  vlX::defVLXRegistry()->registerClassWrapper( ArrayUShort4::Type(), array_serializer.get() );
275 
276  vlX::defVLXRegistry()->registerClassWrapper( ArrayByte1::Type(), array_serializer.get() );
277  vlX::defVLXRegistry()->registerClassWrapper( ArrayByte2::Type(), array_serializer.get() );
278  vlX::defVLXRegistry()->registerClassWrapper( ArrayByte3::Type(), array_serializer.get() );
279  vlX::defVLXRegistry()->registerClassWrapper( ArrayByte4::Type(), array_serializer.get() );
280 
281  vlX::defVLXRegistry()->registerClassWrapper( ArrayUByte1::Type(), array_serializer.get() );
282  vlX::defVLXRegistry()->registerClassWrapper( ArrayUByte2::Type(), array_serializer.get() );
283  vlX::defVLXRegistry()->registerClassWrapper( ArrayUByte3::Type(), array_serializer.get() );
284  vlX::defVLXRegistry()->registerClassWrapper( ArrayUByte4::Type(), array_serializer.get() );
285 }
286 //------------------------------------------------------------------------------
vl::Log::debug
static void debug(const String &message)
Use this function to provide extra information useful to investigate and solve problems.
Definition: Log.cpp:145
VisualizationLibrary.hpp
vlX::VLXClassWrapper_Array
VLX wrapper of vl::Array.
Definition: WrappersGraphics.hpp:58
vl::FontManager
The FontManager class keeps a map associating a font path, size and smoothing flag to a Font object...
Definition: FontManager.hpp:45
vlX::VLXClassWrapper_Uniform
VLX wrapper of vl::Uniform.
Definition: WrappersGraphics.hpp:1255
vlX::Registry::registerClassWrapper
void registerClassWrapper(const vl::TypeInfo &type, ClassWrapper *wrapper)
Definition: Registry.hpp:48
Rendering.hpp
LoadWriterManager.hpp
vl::ref::get
const T * get() const
Definition: Object.hpp:128
vlX::VLXClassWrapper_Texture
VLX wrapper of vl::Texture.
Definition: WrappersGraphics.hpp:3219
vlX::VLXClassWrapper_LODEvaluator
VLX wrapper of vl::DistanceLODEvaluator and vl::PixelLODEvaluator.
Definition: WrappersGraphics.hpp:1724
vl::LoadWriterMD2
The LoadWriterMD2 class is a ResourceLoadWriter capable of reading MD2 files.
Definition: ioMD2.hpp:52
vlX::VLXClassWrapper_Material
VLX wrapper of vl::Material.
Definition: WrappersGraphics.hpp:3003
vl::VisualizationLibrary::shutdown
static void shutdown()
Releases all the resources acquired by VLCore and VLGraphics.
Definition: init_graphics.cpp:137
vlX::VLXClassWrapper_Viewport
VLX wrapper of vl::Viewport.
Definition: WrappersGraphics.hpp:2256
vl::setDefFontManager
VLGRAPHICS_EXPORT void setDefFontManager(FontManager *)
Sets the default FontManager used by Visualization Library.
Definition: pimpl.cpp:47
vlX::VLXClassWrapper_GLSLProgram
VLX wrapper of vl::GLSLProgram.
Definition: WrappersGraphics.hpp:2646
vlX::defVLXRegistry
VLX_EXPORT Registry * defVLXRegistry()
Definition: pimpl.cpp:43
vl::LoadWriterPLY
The LoadWriterPLY class is a ResourceLoadWriter capable of reading PLY files.
Definition: ioPLY.hpp:56
vl::LoadWriterAC3D
The LoadWriterAC3D class is a ResourceLoadWriter capable of reading AC3D files.
Definition: ioAC3D.hpp:73
vl
Visualization Library main namespace.
vl::LoadWriterDae
The LoadWriterDae class is a ResourceLoadWriter capable of reading COLLADA files. ...
Definition: ioDae.hpp:48
vlX::VLXClassWrapper_SecondaryColor
VLX wrapper of vl::SecondaryColor.
Definition: WrappersGraphics.hpp:2929
vl::VisualizationLibrary::init
static void init(bool log_info=true)
Initializes VLCore and VLGraphics libraries.
Definition: init_graphics.cpp:131
vl::Log::bug
static void bug(const String &message)
Use this function to provide information about programming errors: wrong parameter initialization...
Definition: Log.cpp:175
vlX::VLXClassWrapper_Light
VLX wrapper of vl::Light.
Definition: WrappersGraphics.hpp:2461
vlX::VLXClassWrapper_Color
VLX wrapper of vl::Color.
Definition: WrappersGraphics.hpp:2892
FontManager.hpp
vl::VisualizationLibrary::isGraphicsInitialized
static bool isGraphicsInitialized()
Returns true if VLGraphics library is initialized and shutdown has not been called.
Definition: init_graphics.cpp:143
vl::LoadWriterOBJ
The LoadWriterOBJ class is a ResourceLoadWriter capable of reading OBJ files.
Definition: ioOBJ.hpp:57
vlX::VLXClassWrapper_Geometry
VLX wrapper of vl::Geometry.
Definition: WrappersGraphics.hpp:597
vl::FontManager::releaseAllFonts
void releaseAllFonts()
Releases all Fonts and associated resources and memory.
Definition: FontManager.cpp:94
BezierSurface.hpp
vlX::VLXClassWrapper_Actor
VLX wrapper of vl::Actor.
Definition: WrappersGraphics.hpp:1933
vlX::VLXClassWrapper_ClipPlane
VLX wrapper of vl::ClipPlane.
Definition: WrappersGraphics.hpp:2585
vlX::VLXClassWrapper_Transform
VLX wrapper of vl::Transform.
Definition: WrappersGraphics.hpp:2376
NULL
#define NULL
Definition: OpenGLDefs.hpp:81
vlX::VLXClassWrapper_ActorEventCallback
VLX wrapper of vl::DepthSortCallback.
Definition: WrappersGraphics.hpp:3147
vlX::VLXClassWrapper_Camera
VLX wrapper of vl::Camera.
Definition: WrappersGraphics.hpp:2119
WrappersGraphics.hpp
vlX::VLXClassWrapper_GLSLShader
VLX wrapper of vl::GLSLVertexShader, vl::GLSLFragmentShader, vl::GLSLGeometryShader, vl::GLSLTessControlShader, vl::GLSLTessEvaluationShader.
Definition: WrappersGraphics.hpp:2766
vlX::VLXClassWrapper_VertexAttrib
VLX wrapper of vl::VertexAttrib.
Definition: WrappersGraphics.hpp:2849
vlX::VLXClassWrapper_ResourceDatabase
VLX wrapper of vl::ResourceDatabase.
Definition: WrappersGraphics.hpp:1180
vlX::VLXClassWrapper_Normal
VLX wrapper of vl::Normal.
Definition: WrappersGraphics.hpp:2966
vlX::VLXClassWrapper_TexParameter
VLX wrapper of vl::TexParameter.
Definition: WrappersGraphics.hpp:3388
vl::ref
The ref<> class is used to reference-count an Object.
Definition: Object.hpp:55
vlX::VLXClassWrapper_TextureImageUnit
VLX wrapper of vl::TextureImageUnit.
Definition: WrappersGraphics.hpp:3503
vlX::VLXClassWrapper_Shader
VLX wrapper of vl::Shader.
Definition: WrappersGraphics.hpp:1589
vlX::VLXClassWrapper_DrawCall
VLX wrapper of vl::DrawCall and subclasses.
Definition: WrappersGraphics.hpp:791
vl::LoadWriterSTL
The LoadWriterSTL class is a ResourceLoadWriter capable of reading STL files.
Definition: ioSTL.hpp:56
VL_CHECK
#define VL_CHECK(expr)
Definition: checks.hpp:73
vl::defFontManager
VLGRAPHICS_EXPORT FontManager * defFontManager()
Returns the default FontManager used by Visualization Library.
Definition: pimpl.cpp:43
vlX::VLXClassWrapper_Effect
VLX wrapper of vl::Effect.
Definition: WrappersGraphics.hpp:1823
vl::registerLoadWriter
void registerLoadWriter(ResourceLoadWriter *rlw)
Utility function, equivalent to defLoadWriterManager()->registerLoadWriter(rlw).
Definition: LoadWriterManager.hpp:148
vlX::VLXClassWrapper_PatchParameter
VLX wrapper of vl::PatchParameter.
Definition: WrappersGraphics.hpp:1125
vl::LoadWriter3DS
The LoadWriter3DS class is a ResourceLoadWriter capable of reading 3DS files.
Definition: io3DS.hpp:57

Visualization Library 2.1.0 Reference Documentation

Updated on Wed Mar 10 2021 16:02:41.

© Copyright Michele Bosi. All rights reserved.