OpenSceneGraph/src/osg/CMakeLists.txt

455 lines
12 KiB
CMake
Raw Normal View History

2007-03-08 23:31:36 +08:00
# FIXME: For OS X, need flag for Framework or dylib
IF(DYNAMIC_OPENSCENEGRAPH)
ADD_DEFINITIONS(-DOSG_LIBRARY)
ELSE()
ADD_DEFINITIONS(-DOSG_LIBRARY_STATIC)
ENDIF()
2007-03-08 23:31:36 +08:00
SET(LIB_NAME osg)
#
# Enable workaround for OpenGL driver crash with occlusion query
#
OPTION(OSG_FORCE_QUERY_RESULT_AVAILABLE_BEFORE_RETRIEVAL "Set to ON to build OcclussionQueryNode with a workaround for multi-threaded OpenGL driver occlussion query crash. " OFF)
IF(OSG_FORCE_QUERY_RESULT_AVAILABLE_BEFORE_RETRIEVAL)
ADD_DEFINITIONS(-DFORCE_QUERY_RESULT_AVAILABLE_BEFORE_RETRIEVAL)
ENDIF()
2007-03-08 23:31:36 +08:00
SET(HEADER_PATH ${OpenSceneGraph_SOURCE_DIR}/include/${LIB_NAME})
SET(TARGET_H
${HEADER_PATH}/AlphaFunc
${HEADER_PATH}/AnimationPath
${HEADER_PATH}/ApplicationUsage
${HEADER_PATH}/ArgumentParser
${HEADER_PATH}/Array
${HEADER_PATH}/ArrayDispatchers
${HEADER_PATH}/AudioStream
${HEADER_PATH}/AutoTransform
${HEADER_PATH}/Billboard
${HEADER_PATH}/BlendColor
${HEADER_PATH}/BlendEquation
${HEADER_PATH}/BlendEquationi
${HEADER_PATH}/BlendFunc
${HEADER_PATH}/BlendFunci
${HEADER_PATH}/BoundingBox
${HEADER_PATH}/BoundingSphere
${HEADER_PATH}/BoundsChecking
${HEADER_PATH}/buffered_value
${HEADER_PATH}/BufferIndexBinding
${HEADER_PATH}/BufferObject
From PawelKsiezopolski, "This submission contains a new example for OSG : a geometry instancing rendering algorithm consisting of two consequent phases : - first phase is a GLSL shader performing object culling and LOD picking ( a culling shader ). Every culled object is represented as GL_POINT in the input osg::Geometry. The output of the culling shader is a set of object LODs that need to be rendered. The output is stored in texture buffer objects. No pixel is drawn to the screen because GL_RASTERIZER_DISCARD mode is used. - second phase draws osg::Geometry containing merged LODs using glDrawArraysIndirect() function. Information about quantity of instances to render, its positions and other parameters is sourced from texture buffer objects filled in the first phase. The example uses various OpenGL 4.2 features such as texture buffer objects, atomic counters, image units and functions defined in GL_ARB_shader_image_load_store extension to achieve its goal and thus will not work on graphic cards with older OpenGL versions. The example was tested on Linux and Windows with NVidia 570 and 580 cards. The tests on AMD cards were not conducted ( due to lack of it ). The tests were performed using OSG revision 14088. The main advantages of this rendering method : - instanced rendering capable of drawing thousands of different objects with almost no CPU intervention ( cull and draw times are close to 0 ms ). - input objects may be sourced from any OSG graph ( for example - information about object points may be stored in a PagedLOD graph. This way we may cover the whole countries with trees, buildings and other objects ). Furthermore if we create osgDB plugins that generate data on the fly, we may generate information for every grass blade for that country. - every object may have its own parameters and thus may be distinct from other objects of the same type. - relatively low memory footprint ( single object information is stored in a few vertex attributes ). - no GPU->CPU roundtrip typical for such methods ( method uses atomic counters and glDrawArraysIndirect() function instead of OpenGL queries. This way information about quantity of rendered objects never goes back to CPU. The typical GPU->CPU roundtrip cost is about 2 ms ). - this example also shows how to render dynamic objects ( objects that may change its position ) with moving parts ( like car wheels or airplane propellers ) . The obvious extension to that dynamic method would be the animated crowd rendering. - rendered objects may be easily replaced ( there is no need to process the whole OSG graphs, because these graphs store only positional information ). The main disadvantages of a method : - the maximum quantity of objects to render must be known beforehand ( because texture buffer objects holding data between phases have constant size ). - OSG statistics are flawed ( they don't know anymore how many objects are drawn ). - osgUtil::Intersection does not work Example application may be used to make some performance tests, so below you will find some extended parameter description : --skip-dynamic - skip rendering of dynamic objects if you only want to observe static object statistics --skip-static - the same for static objects --dynamic-area-size - size of the area for dynamic rendering. Default = 1000 meters ( square 1000m x 1000m ). Along with density defines how many dynamic objects is there in the example. --static-area-size - the same for static objects. Default = 2000 meters ( square 2000m x 2000m ). Example application defines some parameters (density, LOD ranges, object's triangle count). You may manipulate its values using below described modifiers: --density-modifier - density modifier in percent. Default = 100%. Density ( along with LOD ranges ) defines maximum quantity of rendered objects. registerType() function accepts maximum density ( in objects per square kilometer ) as its parameter. --lod-modifier - defines the LOD ranges. Default = 100%. --triangle-modifier - defines the number of triangles in finally rendered objects. Default = 100 %. --instances-per-cell - for static rendering the application builds OSG graph using InstanceCell class ( this class is a modified version of Cell class from osgforest example - it builds simple quadtree from a list of static instances ). This parameter defines maximum number of instances in a single osg::Group in quadtree. If, for example, you modify it to value=100, you will see really big cull time in OSG statistics ( because resulting tree generated by InstanceCell will be very deep ). Default value = 4096 . --export-objects - write object geometries and quadtree of instances to osgt files for later analysis. --use-multi-draw - use glMultiDrawArraysIndirect() instead of glDrawArraysIndirect() in a draw shader. Thanks to this we may render all ( different ) objects using only one draw call. Requires OpenGL version 4.3 and some more work from me, because now it does not work ( probably I implemented it wrong, or Windows NVidia driver has errors, because it hangs the apllication at the moment ). This application is inspired by Daniel Rákos work : "GPU based dynamic geometry LOD" that may be found under this address : http://rastergrid.com/blog/2010/10/gpu-based-dynamic-geometry-lod/ There are however some differences : - Daniel Rákos uses GL queries to count objects to render, while this example uses atomic counters ( no GPU->CPU roundtrip ) - this example does not use transform feedback buffers to store intermediate data ( it uses texture buffer objects instead ). - I use only the vertex shader to cull objects, whereas Daniel Rákos uses vertex shader and geometry shader ( because only geometry shader can send more than one primitive to transform feedback buffers ). - objects in the example are drawn using glDrawArraysIndirect() function, instead of glDrawElementsInstanced(). Finally there are some things to consider/discuss : - the whole algorithm exploits nice OpenGL feature that any GL buffer may be bound as any type of buffer ( in our example a buffer is once bound as a texture buffer object, and later is bound as GL_DRAW_INDIRECT_BUFFER ). osg::TextureBuffer class has one handy method to do that trick ( bindBufferAs() ), and new primitive sets use osg::TextureBuffer as input. For now I added new primitive sets to example ( DrawArraysIndirect and MultiDrawArraysIndirect defined in examples/osggpucull/DrawIndirectPrimitiveSet.h ), but if Robert will accept its current implementations ( I mean - primitive sets that have osg::TextureBuffer in constructor ), I may add it to osg/include/PrimitiveSet header. - I used BufferTemplate class writen and published by Aurelien in submission forum some time ago. For some reason this class never got into osg/include, but is really needed during creation of UBOs, TBOs, and possibly SSBOs in the future. I added std::vector specialization to that template class. - I needed to create similar osg::Geometries with variable number of vertices ( to create different LODs in my example ). For this reason I've written some code allowing me to create osg::Geometries from osg::Shape descendants. This code may be found in ShapeToGeometry.* files. Examples of use are in osggpucull.cpp . The question is : should this code stay in example, or should it be moved to osgUtil ? - this remark is important for NVidia cards on Linux and Windows : if you have "Sync to VBlank" turned ON in nvidia-settings and you want to see real GPU times in OSG statistics window, you must set the power management settings to "Prefer maximum performance", because when "Adaptive mode" is used, the graphic card's clock may be slowed down by the driver during program execution ( On Linux when OpenGL application starts in adaptive mode, clock should work as fast as possible, but after one minute of program execution, the clock slows down ). This happens when GPU time in OSG statistics window is shorter than 3 ms. " git-svn-id: http://svn.openscenegraph.org/osg/OpenSceneGraph/trunk@14531 16af8721-9629-0410-8352-f15c8da7e697
2014-11-25 18:58:23 +08:00
${HEADER_PATH}/BufferTemplate
${HEADER_PATH}/Callback
${HEADER_PATH}/Camera
${HEADER_PATH}/CameraView
${HEADER_PATH}/Capability
${HEADER_PATH}/ClampColor
${HEADER_PATH}/ClearNode
${HEADER_PATH}/ClipControl
${HEADER_PATH}/ClipNode
${HEADER_PATH}/ClipPlane
${HEADER_PATH}/ClusterCullingCallback
${HEADER_PATH}/CollectOccludersVisitor
${HEADER_PATH}/ColorMask
${HEADER_PATH}/ColorMaski
${HEADER_PATH}/ColorMatrix
${HEADER_PATH}/ComputeBoundsVisitor
${HEADER_PATH}/ContextData
${HEADER_PATH}/ConvexPlanarOccluder
${HEADER_PATH}/ConvexPlanarPolygon
${HEADER_PATH}/CoordinateSystemNode
${HEADER_PATH}/CopyOp
${HEADER_PATH}/CullFace
${HEADER_PATH}/CullingSet
${HEADER_PATH}/CullSettings
${HEADER_PATH}/CullStack
${HEADER_PATH}/DeleteHandler
${HEADER_PATH}/Depth
${HEADER_PATH}/DisplaySettings
${HEADER_PATH}/Drawable
${HEADER_PATH}/DrawPixels
${HEADER_PATH}/Endian
${HEADER_PATH}/Export
${HEADER_PATH}/fast_back_stack
${HEADER_PATH}/Fog
${HEADER_PATH}/FragmentProgram
${HEADER_PATH}/FrameBufferObject
${HEADER_PATH}/FrameStamp
${HEADER_PATH}/FrontFace
${HEADER_PATH}/Geode
${HEADER_PATH}/Geometry
${HEADER_PATH}/GL2Extensions
${HEADER_PATH}/GLDefines
${HEADER_PATH}/GLExtensions
${HEADER_PATH}/GLBeginEndAdapter
${HEADER_PATH}/GLObjects
${HEADER_PATH}/GLU
${HEADER_PATH}/GraphicsCostEstimator
${HEADER_PATH}/GraphicsContext
${HEADER_PATH}/GraphicsThread
${HEADER_PATH}/Group
${HEADER_PATH}/Hint
${HEADER_PATH}/Identifier
${HEADER_PATH}/Image
2008-07-21 17:46:53 +08:00
${HEADER_PATH}/ImageSequence
${HEADER_PATH}/ImageStream
${HEADER_PATH}/ImageUtils
${HEADER_PATH}/io_utils
${HEADER_PATH}/KdTree
${HEADER_PATH}/Light
${HEADER_PATH}/LightModel
${HEADER_PATH}/LightSource
${HEADER_PATH}/LineSegment
${HEADER_PATH}/LineStipple
${HEADER_PATH}/LineWidth
${HEADER_PATH}/LOD
${HEADER_PATH}/LogicOp
${HEADER_PATH}/Material
${HEADER_PATH}/Math
${HEADER_PATH}/Matrix
${HEADER_PATH}/Matrixd
${HEADER_PATH}/Matrixf
${HEADER_PATH}/MatrixTransform
${HEADER_PATH}/MixinVector
${HEADER_PATH}/Multisample
${HEADER_PATH}/Node
${HEADER_PATH}/NodeCallback
${HEADER_PATH}/NodeTrackerCallback
${HEADER_PATH}/NodeVisitor
${HEADER_PATH}/Notify
${HEADER_PATH}/Object
${HEADER_PATH}/observer_ptr
${HEADER_PATH}/Observer
${HEADER_PATH}/ObserverNodePath
${HEADER_PATH}/OccluderNode
${HEADER_PATH}/OcclusionQueryNode
${HEADER_PATH}/OperationThread
${HEADER_PATH}/PatchParameter
${HEADER_PATH}/PagedLOD
${HEADER_PATH}/Plane
${HEADER_PATH}/Point
${HEADER_PATH}/PointSprite
${HEADER_PATH}/PolygonMode
${HEADER_PATH}/PolygonOffset
${HEADER_PATH}/PolygonStipple
${HEADER_PATH}/Polytope
${HEADER_PATH}/PositionAttitudeTransform
${HEADER_PATH}/PrimitiveSet
From Aurelien Albert, Added support for glPrimitiveRestartIndex. "The idea of this new OpenGL feature is : - set RestartIndex = "n" - draw elements strip -> when the index is "n", the strip is "stopped" and restarted It's very usefull for drawing tiles with a single strip and a "restart" at the end of each row. The idea a an OSG StateAttribute is : Usually we use to build geometry from code, because software modelers rarely support it (and 3d file formats doesn't support it) : -RootNode <= "PrimitiveRestartIndex=0" // So now, we know that our restart index is 0 for all drawables under this node | - Drawable 1 : triangles => as usual | - Drawable 2 : triangles strip => as usual | - Drawable 3 : triangles strip + "GL_PRIMITIVE_RESTART" mode = ON => use the restart index | - Drawable 4 : triangles strip + "GL_PRIMITIVE_RESTART" mode = ON => use the restart index | - Drawable 5 : triangles strip => as usual With a StateAttribute, it's easy for the developper to say "0 will be my restart index for all this object" and then activate the mode only on some nodes. The main problem is if you set and restart index value which is not included in the vertex array (for exemple set restart index = 100 but you have only 50 vertex). There is no problem with OpenGL, but some OSG algorithms will try to access the vertex[100] and will segfault. To solve this, I think there is two ways : 1/ add restart index in osg::PrimitiveSet and use this value in all algorithms. It's a lot of work, maybe dangerous, and it concern only a few situations : developpers who use this extension should be aware of advanced OpenGL (and OSG) data management 2/ use a StateAttribute, and choose a "correct" restart index. In my applications, I always use "0" as a restart index and duplicate the first vertex (vertex[0] = vertex[1]). So there is no difference for OpenGL and all OSG algorithms works properly. "
2013-06-28 21:43:46 +08:00
${HEADER_PATH}/PrimitiveRestartIndex
${HEADER_PATH}/Program
${HEADER_PATH}/Projection
${HEADER_PATH}/ProxyNode
${HEADER_PATH}/Quat
${HEADER_PATH}/Referenced
${HEADER_PATH}/ref_ptr
${HEADER_PATH}/RenderInfo
${HEADER_PATH}/SampleMaski
${HEADER_PATH}/Scissor
${HEADER_PATH}/ScriptEngine
${HEADER_PATH}/Sequence
${HEADER_PATH}/ShadeModel
${HEADER_PATH}/Shader
${HEADER_PATH}/ShaderAttribute
${HEADER_PATH}/ShaderComposer
${HEADER_PATH}/ShadowVolumeOccluder
${HEADER_PATH}/Shape
${HEADER_PATH}/ShapeDrawable
${HEADER_PATH}/State
${HEADER_PATH}/StateAttribute
${HEADER_PATH}/StateAttributeCallback
${HEADER_PATH}/StateSet
${HEADER_PATH}/Stats
${HEADER_PATH}/Stencil
${HEADER_PATH}/StencilTwoSided
${HEADER_PATH}/Switch
${HEADER_PATH}/TemplatePrimitiveFunctor
${HEADER_PATH}/TexEnv
${HEADER_PATH}/TexEnvCombine
${HEADER_PATH}/TexEnvFilter
${HEADER_PATH}/TexGen
${HEADER_PATH}/TexGenNode
${HEADER_PATH}/TexMat
${HEADER_PATH}/Texture
${HEADER_PATH}/Texture1D
${HEADER_PATH}/Texture2D
${HEADER_PATH}/Texture2DMultisample
${HEADER_PATH}/Texture2DArray
${HEADER_PATH}/Texture3D
${HEADER_PATH}/TextureBuffer
${HEADER_PATH}/TextureCubeMap
${HEADER_PATH}/TextureRectangle
${HEADER_PATH}/Timer
${HEADER_PATH}/TransferFunction
${HEADER_PATH}/Transform
${HEADER_PATH}/TriangleFunctor
${HEADER_PATH}/TriangleIndexFunctor
${HEADER_PATH}/TriangleLinePointIndexFunctor
${HEADER_PATH}/Types
${HEADER_PATH}/Uniform
${HEADER_PATH}/UserDataContainer
${HEADER_PATH}/ValueObject
${HEADER_PATH}/ValueMap
${HEADER_PATH}/ValueStack
${HEADER_PATH}/Vec2
${HEADER_PATH}/Vec2b
${HEADER_PATH}/Vec2d
${HEADER_PATH}/Vec2f
${HEADER_PATH}/Vec2i
${HEADER_PATH}/Vec2s
${HEADER_PATH}/Vec2ub
${HEADER_PATH}/Vec2ui
${HEADER_PATH}/Vec2us
${HEADER_PATH}/Vec3
${HEADER_PATH}/Vec3b
${HEADER_PATH}/Vec3d
${HEADER_PATH}/Vec3f
${HEADER_PATH}/Vec3i
${HEADER_PATH}/Vec3s
${HEADER_PATH}/Vec3ub
${HEADER_PATH}/Vec3ui
${HEADER_PATH}/Vec3us
${HEADER_PATH}/Vec4
${HEADER_PATH}/Vec4b
${HEADER_PATH}/Vec4d
${HEADER_PATH}/Vec4f
${HEADER_PATH}/Vec4i
${HEADER_PATH}/Vec4s
${HEADER_PATH}/Vec4ub
${HEADER_PATH}/Vec4ui
${HEADER_PATH}/Vec4us
${HEADER_PATH}/VertexAttribDivisor
${HEADER_PATH}/VertexProgram
${HEADER_PATH}/View
${HEADER_PATH}/Viewport
${HEADER_PATH}/ViewportIndexed
${OPENSCENEGRAPH_VERSION_HEADER}
${OPENSCENEGRAPH_CONFIG_HEADER}
${OPENSCENEGRAPH_OPENGL_HEADER}
2007-03-08 23:31:36 +08:00
)
#ADD_LIBRARY(${LIB_NAME}
# ${OPENSCENEGRAPH_USER_DEFINED_DYNAMIC_OR_STATIC}
# ${LIB_PUBLIC_HEADERS}
SET(TARGET_SRC
AlphaFunc.cpp
AnimationPath.cpp
ApplicationUsage.cpp
ArgumentParser.cpp
Array.cpp
ArrayDispatchers.cpp
AudioStream.cpp
AutoTransform.cpp
Billboard.cpp
BlendColor.cpp
BlendEquation.cpp
BlendEquationi.cpp
BlendFunc.cpp
BlendFunci.cpp
BufferIndexBinding.cpp
BufferObject.cpp
Callback.cpp
Capability.cpp
Camera.cpp
CameraView.cpp
ClampColor.cpp
ClearNode.cpp
ClipControl.cpp
ClipNode.cpp
ClipPlane.cpp
ClusterCullingCallback.cpp
CollectOccludersVisitor.cpp
ColorMask.cpp
ColorMaski.cpp
ColorMatrix.cpp
ComputeBoundsVisitor.cpp
ContextData.cpp
ConvexPlanarOccluder.cpp
ConvexPlanarPolygon.cpp
CoordinateSystemNode.cpp
CopyOp.cpp
CullFace.cpp
CullingSet.cpp
CullSettings.cpp
CullStack.cpp
DeleteHandler.cpp
Depth.cpp
DisplaySettings.cpp
Drawable.cpp
DrawPixels.cpp
dxtctool.cpp
dxtctool.h
Fog.cpp
FragmentProgram.cpp
FrameBufferObject.cpp
FrameStamp.cpp
FrontFace.cpp
Geode.cpp
Geometry.cpp
GLExtensions.cpp
GLBeginEndAdapter.cpp
GLObjects.cpp
GLStaticLibrary.h
GLStaticLibrary.cpp
GraphicsCostEstimator.cpp
GraphicsContext.cpp
GraphicsThread.cpp
Group.cpp
Hint.cpp
Identifier.cpp
Image.cpp
2008-07-21 17:46:53 +08:00
ImageSequence.cpp
ImageStream.cpp
ImageUtils.cpp
KdTree.cpp
Light.cpp
LightModel.cpp
LightSource.cpp
LineSegment.cpp
LineStipple.cpp
LineWidth.cpp
LOD.cpp
LogicOp.cpp
Material.cpp
Math.cpp
Matrixd.cpp
MatrixDecomposition.cpp
Matrixf.cpp
# We don't build this one
# Matrix_implementation.cpp
MatrixTransform.cpp
Multisample.cpp
Node.cpp
NodeTrackerCallback.cpp
NodeVisitor.cpp
Notify.cpp
Object.cpp
Observer.cpp
ObserverNodePath.cpp
OccluderNode.cpp
OcclusionQueryNode.cpp
OperationThread.cpp
PatchParameter.cpp
PagedLOD.cpp
Point.cpp
PointSprite.cpp
PolygonMode.cpp
PolygonOffset.cpp
PolygonStipple.cpp
PositionAttitudeTransform.cpp
PrimitiveSet.cpp
From Aurelien Albert, Added support for glPrimitiveRestartIndex. "The idea of this new OpenGL feature is : - set RestartIndex = "n" - draw elements strip -> when the index is "n", the strip is "stopped" and restarted It's very usefull for drawing tiles with a single strip and a "restart" at the end of each row. The idea a an OSG StateAttribute is : Usually we use to build geometry from code, because software modelers rarely support it (and 3d file formats doesn't support it) : -RootNode <= "PrimitiveRestartIndex=0" // So now, we know that our restart index is 0 for all drawables under this node | - Drawable 1 : triangles => as usual | - Drawable 2 : triangles strip => as usual | - Drawable 3 : triangles strip + "GL_PRIMITIVE_RESTART" mode = ON => use the restart index | - Drawable 4 : triangles strip + "GL_PRIMITIVE_RESTART" mode = ON => use the restart index | - Drawable 5 : triangles strip => as usual With a StateAttribute, it's easy for the developper to say "0 will be my restart index for all this object" and then activate the mode only on some nodes. The main problem is if you set and restart index value which is not included in the vertex array (for exemple set restart index = 100 but you have only 50 vertex). There is no problem with OpenGL, but some OSG algorithms will try to access the vertex[100] and will segfault. To solve this, I think there is two ways : 1/ add restart index in osg::PrimitiveSet and use this value in all algorithms. It's a lot of work, maybe dangerous, and it concern only a few situations : developpers who use this extension should be aware of advanced OpenGL (and OSG) data management 2/ use a StateAttribute, and choose a "correct" restart index. In my applications, I always use "0" as a restart index and duplicate the first vertex (vertex[0] = vertex[1]). So there is no difference for OpenGL and all OSG algorithms works properly. "
2013-06-28 21:43:46 +08:00
PrimitiveRestartIndex.cpp
Program.cpp
Projection.cpp
ProxyNode.cpp
Quat.cpp
Referenced.cpp
SampleMaski.cpp
Scissor.cpp
ScriptEngine.cpp
Sequence.cpp
ShadeModel.cpp
Shader.cpp
ShaderAttribute.cpp
ShaderComposer.cpp
ShadowVolumeOccluder.cpp
Shape.cpp
ShapeDrawable.cpp
StateAttribute.cpp
State.cpp
StateSet.cpp
Stats.cpp
Stencil.cpp
StencilTwoSided.cpp
Switch.cpp
TexEnvCombine.cpp
TexEnv.cpp
TexEnvFilter.cpp
TexGen.cpp
TexGenNode.cpp
TexMat.cpp
Texture1D.cpp
Texture2DArray.cpp
Texture2D.cpp
Texture2DMultisample.cpp
Texture3D.cpp
Texture.cpp
TextureBuffer.cpp
TextureCubeMap.cpp
TextureRectangle.cpp
Timer.cpp
TransferFunction.cpp
Transform.cpp
Uniform.cpp
UserDataContainer.cpp
ValueMap.cpp
ValueStack.cpp
Version.cpp
VertexAttribDivisor.cpp
VertexProgram.cpp
View.cpp
Viewport.cpp
ViewportIndexed.cpp
glu/libutil/error.cpp
glu/libutil/mipmap.cpp
glu/libtess/normal.cpp
glu/libtess/memalloc.cpp
glu/libtess/dict-list.h
glu/libtess/alg-outline
glu/libtess/priorityq.cpp
glu/libtess/normal.h
glu/libtess/dict.h
glu/libtess/render.cpp
glu/libtess/tessmono.h
glu/libtess/mesh.cpp
glu/libtess/render.h
glu/libtess/tessmono.cpp
glu/libtess/priorityq.h
glu/libtess/sweep.h
glu/libtess/priorityq-sort.h
glu/libtess/sweep.cpp
glu/libtess/tess.h
glu/libtess/geom.h
glu/libtess/memalloc.h
glu/libtess/dict.cpp
glu/libtess/priorityq-heap.h
glu/libtess/geom.cpp
glu/libtess/tess.cpp
glu/libtess/mesh.h
${OPENSCENEGRAPH_VERSIONINFO_RC}
2007-03-08 23:31:36 +08:00
)
2016-06-08 16:20:16 +08:00
################################################################################
## Quieten warnings that a due to optional code paths
IF(CMAKE_COMPILER_IS_GNUCXX)
# Remove -Wextra flag as it barfs on ffmoeg headers
STRING(REGEX REPLACE "-Wextra" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
ENDIF()
SET(TARGET_LIBRARIES OpenThreads)
2007-03-08 23:31:36 +08:00
SET(TARGET_EXTERNAL_LIBRARIES
2013-08-09 19:00:55 +08:00
${CMAKE_THREAD_LIBS_INIT}
${MATH_LIBRARY}
${RT_LIBRARY}
${DL_LIBRARY}
)
2007-03-08 23:31:36 +08:00
2013-08-09 19:00:55 +08:00
#LINK_INTERNAL(${LIB_NAME}
# OpenThreads
#)
#LINK_EXTERNAL(${LIB_NAME} ${CMAKE_THREAD_LIBS_INIT} ${MATH_LIBRARY} ${RT_LIBRARY} ${DL_LIBRARY})
#LINK_CORELIB_DEFAULT(${LIB_NAME} ${CMAKE_THREAD_LIBS_INIT} ${MATH_LIBRARY} ${RT_LIBRARY} )
#INCLUDE(ModuleInstall OPTIONAL)
SETUP_LIBRARY(${LIB_NAME})