Image Component Library (ICL)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Public Member Functions | Static Public Member Functions | Static Protected Member Functions | Protected Attributes | Private Attributes | Friends
icl::geom::SceneObject Class Reference

The SceneObject class defines visible objects in scenes or scene graph nodes. More...

#include <SceneObject.h>

Inheritance diagram for icl::geom::SceneObject:
icl::geom::ComplexCoordinateFrameSceneObject icl::geom::CoordinateFrameSceneObject icl::geom::GridSceneObject icl::geom::OctreeObject< Scalar, CAPACITY, SF, Pt, ALLOC_CHUNK_SIZE > icl::geom::PointCloudObjectBase icl::geom::SceneLightObject icl::geom::OctreeObject< float, 16, 1, Vec, 1024 > icl::geom::PCLPointCloudObject< PCLPointType > icl::geom::PointCloudObject icl::geom::RayCastOctreeObject

List of all members.

Public Member Functions

 SceneObject ()
 create an object
 SceneObject (const std::string &type, const float *params)
 create by string:
 SceneObject (const std::string &objFileName) throw (utils::ICLException)
 creates a scene object from given .obj file
 SceneObject (const SceneObject &other)
 deep copy of SceneObject instance
SceneObjectoperator= (const SceneObject &other)
 assignment operator for deep copy
virtual ~SceneObject ()
 Empty destructor (but virtual)
std::vector< Vec > & getVertices ()
 returns object vertices
const std::vector< Vec > & getVertices () const
 returns object vertices (const)
std::vector< GeomColor > & getVertexColors ()
 returns object vertex colors
const std::vector< GeomColor > & getVertexColors () const
 returns object vertex colors (const)
std::vector< Primitive * > & getPrimitives ()
 returns object's primitives (lines, quads, etc...)
const std::vector< Primitive * > & getPrimitives () const
 returns object's primitives (lines, quads, etc...) (const)
void setVisible (int oredTypes, bool visible, bool recursive=true)
 changes visibility of given primitive type
bool isVisible (Primitive::Type t) const
 returns visibility of given primitive type
void addVertex (const Vec &p, const GeomColor &color=GeomColor(255, 0, 0, 255))
 adds a new vertex to this object
void addSharedTexture (utils::SmartPtr< qt::GLImg > gli)
 adds a GLImg as shared texture
void addSharedTexture (const core::ImgBase *image, core::scalemode sm=core::interpolateLIN)
 adds an core::ImgBase * as shared texutre
void addNormal (const Vec &n)
 adds a new normal to this object
void addLine (int x, int y, const GeomColor &color=GeomColor(100, 100, 100, 255))
 adds a new line to this object
void addTriangle (int a, int b, int c, int na, int nb, int nc, const GeomColor &color=GeomColor(0, 100, 250, 255))
 adds a new triangle to this onject
void addTriangle (int a, int b, int c, const GeomColor &color=GeomColor(0, 100, 250, 255))
 convenience method for creation of a triangle with auto-normals
void addQuad (int a, int b, int c, int d, int na, int nb, int nc, int nd, const GeomColor &color=GeomColor(0, 100, 250, 255))
 adds a new triangle to this onject
void addQuad (int a, int b, int c, int d, const GeomColor &color=GeomColor(0, 100, 250, 255))
 convenience method for creation of a quad with auto-normals
void addPolygon (int nPoints, const int *vertexIndices, const GeomColor &color=GeomColor(0, 100, 250, 255), const int *normalIndices=0)
 add a polygon to this object (note triangles and quads are slower here)
void addTexture (int a, int b, int c, int d, const core::ImgBase *texture, int na, int nb, int nc, int nd, bool createTextureOnce=true, core::scalemode sm=core::interpolateLIN)
void addTexture (int a, int b, int c, int d, const core::ImgBase *texture, bool createTextureOnce=true, core::scalemode sm=core::interpolateLIN)
 convenience method for creation of a texture with auto-normals
void addTexture (int a, int b, int c, int d, int sharedTextureIndex, int na=-1, int nb=-1, int nc=-1, int nd=-1)
 adds are shared texture primitive
void addTexture (const core::ImgBase *image, int numPoints, const int *vertexIndices, const utils::Point32f *texCoords, const int *normalIndices=0, bool createTextureOnce=true)
 adds a GenericTexturePrimitive for custom texCoords
void addTextureGrid (int w, int h, const core::ImgBase *image, const icl32f *px, const icl32f *py, const icl32f *pz, const icl32f *pnx=0, const icl32f *pny=0, const icl32f *pnz=0, int stride=1, bool createTextureOnce=true, core::scalemode sm=core::interpolateLIN)
 adds a texture that is drawn on a 2D grid of vertices in 3D space
void addTwoSidedTextureGrid (int w, int h, const core::ImgBase *front, const core::ImgBase *back, const icl32f *px, const icl32f *py, const icl32f *pz, const icl32f *pnx=0, const icl32f *pny=0, const icl32f *pnz=0, int stride=1, bool createFrontOnce=true, bool createBackOnce=true, core::scalemode sm=core::interpolateLIN)
 adds a texture grid that has two different texture for the two faces
void addTextTexture (int a, int b, int c, int d, const std::string &text, const GeomColor &color, int na, int nb, int nc, int nd, int textSize, core::scalemode sm=core::interpolateLIN)
 adds text-texture quad -primitive to this object
void addTextTexture (int a, int b, int c, int d, const std::string &text, const GeomColor &color=GeomColor(255, 255, 255, 255), int textSize=30, core::scalemode sm=core::interpolateLIN)
 convenience method for creation of a text-texture with auto-normals
void addText (int a, const std::string &text, float billboardHeight=10, const GeomColor &color=GeomColor(255, 255, 255, 255), int textRenderSize=30, core::scalemode sm=core::interpolateLIN)
 adds a billboard text-texture attached to given node index a
void addCustomPrimitive (Primitive *p)
 adds a custom primitive
SceneObjectaddCube (float x, float y, float z, float d)
 adds a cube child-object with given parameters
SceneObjectaddCuboid (float x, float y, float z, float dx, float dy, float dz)
 adds a cuboid child-object with given parameters
SceneObjectaddSphere (float x, float y, float z, float r, int rzSteps, int xySlices)
 adds a cuboid child-object with given parameters
SceneObjectaddSpheroid (float x, float y, float z, float rx, float ry, float rz, int rzSteps, int xySlices)
 adds a cuboid child-object with given parameters
SceneObjectaddCylinder (float x, float y, float z, float rx, float ry, float h, int steps)
 adds a cylindical child object with given parameters
SceneObjectaddCone (float x, float y, float z, float rx, float ry, float h, int steps)
 adds a conical child object with given parameters
void setColor (Primitive::Type t, const GeomColor &color, bool recursive=true)
 tints all Primitives with given type in given color
void setPointSize (float pointSize, bool recursive=true)
 sets point size
void setLineWidth (float lineWidth, bool recursive=true)
 sets point size
virtual SceneObjectcopy () const
 performs a deep copy of this object
virtual void prepareForRendering ()
 called by the renderer before the object is rendered
virtual void customRender ()
 this function is called when an object is rendered
void setColorsFromVertices (Primitive::Type t, bool on, bool recursive=true)
 sets how 2D-geom colors are set
bool getSmoothShading () const
 returns wheather smooth shading is activated
void setSmoothShading (bool on, bool recursive=true)
 sets whether to use smoothshading (default is false)
void createAutoNormals (bool smooth=true)
 automatically creates precomputed normals
virtual GeomColor getDefaultVertexColor () const
 can be reimplemented by subclass to provide and interface for setting default vertex color
Hit hit (const ViewRay &v, bool recursive=true)
 returns whether this object is hit by the given viewray
const Hit hit (const ViewRay &v, bool recursive=true) const
 returns whether this object is hit by the given viewray (const)
std::vector< Hithits (const ViewRay &v, bool recursive=true)
 returns all hits with SceneObjects form the given viewray
std::vector< VecgetTransformedVertices () const
 returns all vertices in their final world coordinates
Vec getClosestVertex (const Vec &pWorld, bool relative=false) throw (utils::ICLException)
 returns the vertex, that is closest to the given point in wold coordinates
void setVisible (bool visible, bool recursive=true)
 sets the visibility of this object
bool isVisible () const
 returns whether this object is currently visible
void hide (bool recursive=true)
 calls setVisible(false)
void show (bool recursive=true)
 calls setVisible(true)
void setLockingEnabled (bool enabled)
 sets locking enabled or disabled
bool getLockingEnabled () const
 returns whether locking is current enabled for this object
virtual void lock ()
 locks the internal mutex if locking enabled is set to true
virtual void unlock ()
 unlocks the internal mutex if locking enabled is set to true
void setPointSmoothingEnabled (bool enabled=true)
 sets whether points are visualized in a smoothed manner
void setLineSmoothingEnabled (bool enabled=true)
 sets whether lines are visualized in a smoothed manner
void setPolygonSmoothingEnabled (bool enabled=true)
 sets whether faces are visualized in a smoothed manner
void clearAllPrimitives ()
 deletes and removes all primitives
void createDisplayList ()
 creates a displaylist in the next render cycle
void freeDisplayList ()
 frees the displaylist in the next render cycle
void setFragmentShader (qt::GLFragmentShader *shader)
 sets a fragment shader to use for this object
qt::GLFragmentShadergetFragmentShader ()
 returns the current fragment shader (or NULL if non was given)
const qt::GLFragmentShadergetFragmentShader () const
 returns the current fragment shader (or NULL if non was given, const version)
void setShininess (icl8u value)
 sets the material shininess (default is 128)
void setSpecularReflectance (const GeomColor &values)
 sets the materials specular reflectance
bool getDepthTestEnabled () const
 returns whether depth test is enabled for this object
void setDepthTestEnabled (bool enabled)
 sets whether depth test is enabled for this object

Static Public Member Functions

static SceneObjectcube (float x, float y, float z, float r)
 create a cube scene object
static SceneObjectcuboid (float x, float y, float z, float dx, float dy, float dz)
 create a cuboid scene object
static SceneObjectsphere (float x, float y, float z, float r, int rzSteps, int xySlices)
 create a shere scene object
static SceneObjectspheroid (float x, float y, float z, float rx, float ry, float rz, int rzSteps, int xySlices)
 create a shere scene object
static SceneObjectsuperquadric (float x, float y, float z, float rx, float ry, float rz, float dx, float dy, float dz, float e1, float e2, int rzSteps, int xySlices)
 create a superquadric scene object

Static Protected Member Functions

static void collect_hits_recursive (SceneObject *obj, const ViewRay &v, std::vector< Hit > &hits, bool recursive)
 recursive picking method

Protected Attributes

std::vector< Vecm_vertices
std::vector< Vecm_normals
std::vector< GeomColorm_vertexColors
std::vector< Primitive * > m_primitives
std::vector< utils::SmartPtr
< qt::GLImg > > 
m_sharedTextures
int m_visibleMask
bool m_lineColorsFromVertices
bool m_triangleColorsFromVertices
bool m_quadColorsFromVertices
bool m_polyColorsFromVertices
float m_pointSize
float m_lineWidth
bool m_useSmoothShading
bool m_isVisible
Mat m_transformation
 for the scene graph implementation
bool m_hasTransformation
SceneObjectm_parent
std::vector< utils::SmartPtr
< SceneObject > > 
m_children
utils::Mutex m_mutex
 for asynchronous updates
bool m_enableLocking
 can be enabled
bool m_pointSmoothingEnabled
bool m_lineSmoothingEnabled
bool m_polygonSmoothingEnabled
bool m_depthTestEnabled
 default is true
icl8u m_shininess
GeomColor m_specularReflectance

Private Attributes

void * m_displayListHandle
 internally used flag
int m_createDisplayListNextTime
 internal flag
qt::GLFragmentShaderm_fragmentShader
 internal optionally given fragment shader

Friends

class Scene
 provides direct access for the Scene class
struct Primitive

methods for creation of a scene graph

virtual void setTransformation (const Mat &m)
 Sets a transformation matrix.
void removeTransformation ()
 sets the internal transformation to the identity matrix
virtual void transform (const Mat &m)
 multiplies the current transformation matrix by given matrix
template<class T >
void transform (const T &m)
 utility method for passing arbitrary matrix classes
virtual void rotate (float rx, float ry, float rz)
 rotates the scene object (this affects it's transformation matrix)
template<class T >
void rotate (const T &t)
 utility wrapper for vector based rotation
virtual void translate (float dx, float dy, float dz)
 translates the scene object (this affects it's translates matrix)
template<class T >
void translate (const T &t)
 utility wrapper for vector based translation
virtual void scale (float sx, float sy, float sz)
 transformes the current transformation matrix by a scale matrix
template<class T >
void scale (const T &t)
 utility wrapper for vector based scaling
Mat getTransformation (bool relative=false) const
 returns the current transformation matrix
bool hasTransformation (bool relative=false) const
 returns whether the SceneObject has currently a non-ID-transformation
SceneObjectgetParent ()
 returns the parent scene object
const SceneObjectgetParent () const
 returns the parent scene object (const version)
void addChild (SceneObject *child, bool passOwnerShip=true)
 adds a new child to this scene object
void removeChild (SceneObject *child)
 removes given child
void removeAllChildren ()
 removes all children
bool hasChildren () const
 returns whether the SceneObject has children at all
int getChildCount () const
 returns the number of children
SceneObjectgetChild (int index)
 returns child at given index
const SceneObjectgetChild (int index) const
 returns child at given index (const)
bool hasChild (const SceneObject *o) const
 returns whether the given object is a child of this one

Detailed Description

The SceneObject class defines visible objects in scenes or scene graph nodes.

SceneObject instances are used in combination with the icl::Scene class. You can add SceneObjects into a Scene and then render these as an image overlay.

A scene object is defined by

SceneGraph objects can also have no vertices. In this case they are invisible nodes within a scene graph.

Creation of SceneObjects

Usually special SceneObject instances are created by subclassing the SceneObject class. Subclasses can either simply add other SceneObjects e.g. using the utility methods SceneObject::addCube or SceneObject::addSphere or they can also define a custom geometry by adding vertices and primitives using SceneObject::addVertex and e.g. SceneObject::addLine or SceneObject::addQuad

Normals

Normals are used for realistic lighting. Therefore, it is recommended to use normals when objects are defined. Normals are also stored in a list. Each face-vertex references one of the normals of this list.

AutoNormals

If no normals are provided, the normals are computed automatically at run-time using cross-product:

Dynamic SceneObjects and Locking

Custome extensions of the SceneObject-interface can implement the SceneObject's virtual method SceneObject::prepareForRendering which is calle every time before the object is acutally rendered. Here, the custom SceneObject can be adapted dynamically.
Please note: When then you want to change the vertex-, primitive- or you'll have to enable the SceneObjects locking mechanism using SceneObject::setLockingEnabled(true).

For compatibility with former version of the SceneObject class, you can also re-implement the virtual methods SceneObject::lock() and SceneObject::unlock() appropriately. Usually this will look like this:

        class MySceneObject : public SceneObject{
          utils::Mutex mutex;
          public:
          void lock() { mutex.lock(); }
          void unlock() { mutex.unlock(); }
          ...
        };

Colors

In the object specification (when you add vertices and other primitives, colors are always expected to be in ICL's commong [0,255]^3 range. However, the colors are scaled by 1/255 to range [0,1]^3 internally, since this is how OpenGL can access the colors more easily. Please keep in mind, that the colors you can find in m_vertexColors and also in primitive-instances is alaws in [0,1]^3 range

Colors From Vertices

Sometimes, you might want to draw primtives that use different colors for different corners and interpolate between these. This can be achieved by using SceneObject::setColorsFromVertices(true).

Display Lists

For static objects (or objects that are not so frequently changed), display lists can be created using SceneObject::createDisplayList(). This will speed up the object rendering significantly. Please note, that a display list is always created in the next render cycle, which is why SceneObject::createDisplayList can also be called from the working thread.


Constructor & Destructor Documentation

create an object

icl::geom::SceneObject::SceneObject ( const std::string &  type,
const float *  params 
)

create by string:

currently allowed:

  • "cube" params: [x,y,z,radius];
  • "cuboid" params: [x,y,z,dx,dy,dz]
  • "sphere" params: [x,y,z,radius,rzSteps,xySlices]
  • "spheroid" params: [x,y,z,rx,ry,rz,rzSteps,xySlices]
  • "superquadric" params: [x,y,z,rx,ry,rz,dx,dy,dz,e1,e2,rzSteps,xySlices] where
    • (x,y,z)^T is the center position
    • (rx,ry,rz)^T are the rotation euler angles
    • (dx,dy,dz)^T are the diameters into x-, y- and z-direction
    • (e1,and e2) are the roundness parameters
    • (rzSlices,rxSlices) is used for the number of steps the create nodes
icl::geom::SceneObject::SceneObject ( const std::string &  objFileName) throw (utils::ICLException)

creates a scene object from given .obj file

icl::geom::SceneObject::SceneObject ( const SceneObject other) [inline]

deep copy of SceneObject instance

The new instance's parent is set to null, i.e. it must be added to other's parent explicitly if this is necessary.

virtual icl::geom::SceneObject::~SceneObject ( ) [virtual]

Empty destructor (but virtual)


Member Function Documentation

void icl::geom::SceneObject::addChild ( SceneObject child,
bool  passOwnerShip = true 
)

adds a new child to this scene object

If the child's owner ship is passed, it is deleted automatically when it is removed or if the parent is deleted. Otherwise, the caller has to manage the passed child's memory. Note: there is no cycle detection in the SceneObject class. Adding A to B and B to A leads to unknown results and most likely to programm errors.

SceneObject* icl::geom::SceneObject::addCone ( float  x,
float  y,
float  z,
float  rx,
float  ry,
float  h,
int  steps 
)

adds a conical child object with given parameters

returns a pointer to the cone added. This can be used to adapt further properties of that object

SceneObject* icl::geom::SceneObject::addCube ( float  x,
float  y,
float  z,
float  d 
) [inline]

adds a cube child-object with given parameters

returns a pointer to the cube added. This can be used to adapt further properties of that object

SceneObject* icl::geom::SceneObject::addCuboid ( float  x,
float  y,
float  z,
float  dx,
float  dy,
float  dz 
)

adds a cuboid child-object with given parameters

returns a pointer to the cube added. This can be used to adapt further properties of that object

adds a custom primitive

This should only be used for non-directly supported primitives Note: right now, there is no 'hit' checking for non standard primitives

SceneObject* icl::geom::SceneObject::addCylinder ( float  x,
float  y,
float  z,
float  rx,
float  ry,
float  h,
int  steps 
)

adds a cylindical child object with given parameters

returns a pointer to the cylinder added. This can be used to adapt further properties of that object

void icl::geom::SceneObject::addLine ( int  x,
int  y,
const GeomColor color = GeomColor(100, 100, 100, 255) 
)

adds a new line to this object

If the given normal indices (na and nb) are -1, no normals are used for this primitives

adds a new normal to this object

void icl::geom::SceneObject::addPolygon ( int  nPoints,
const int *  vertexIndices,
const GeomColor color = GeomColor(0, 100, 250, 255),
const int *  normalIndices = 0 
)

add a polygon to this object (note triangles and quads are slower here)

If the given normal indices's size is 0, auto-normal are computed using cross-product

void icl::geom::SceneObject::addQuad ( int  a,
int  b,
int  c,
int  d,
int  na,
int  nb,
int  nc,
int  nd,
const GeomColor color = GeomColor(0, 100, 250, 255) 
)

adds a new triangle to this onject

If the given normal indices (na,nb,nc and nd) are -1, auto-normal are computed using cross-product

void icl::geom::SceneObject::addQuad ( int  a,
int  b,
int  c,
int  d,
const GeomColor color = GeomColor(0,100,250,255) 
) [inline]

convenience method for creation of a quad with auto-normals

adds a GLImg as shared texture

adds an core::ImgBase * as shared texutre

SceneObject* icl::geom::SceneObject::addSphere ( float  x,
float  y,
float  z,
float  r,
int  rzSteps,
int  xySlices 
) [inline]

adds a cuboid child-object with given parameters

returns a pointer to the cube added. This can be used to adapt further properties of that object

SceneObject* icl::geom::SceneObject::addSpheroid ( float  x,
float  y,
float  z,
float  rx,
float  ry,
float  rz,
int  rzSteps,
int  xySlices 
)

adds a cuboid child-object with given parameters

returns a pointer to the cube added. This can be used to adapt further properties of that object

void icl::geom::SceneObject::addText ( int  a,
const std::string &  text,
float  billboardHeight = 10,
const GeomColor color = GeomColor(255, 255, 255, 255),
int  textRenderSize = 30,
core::scalemode  sm = core::interpolateLIN 
)

adds a billboard text-texture attached to given node index a

the billboardHeight parameters defines the actual height in world units. The text is always centered at m_vertices[a] and it will always be oriented towards the camera. The textRenderSize parameter defines the pixel resolution of the text

void icl::geom::SceneObject::addTextTexture ( int  a,
int  b,
int  c,
int  d,
const std::string &  text,
const GeomColor color,
int  na,
int  nb,
int  nc,
int  nd,
int  textSize,
core::scalemode  sm = core::interpolateLIN 
)

adds text-texture quad -primitive to this object

If the given normal indices (na,nb,nc and nd) are -1, auto-normal are computed using cross-product. Please note, that the text aspect ratio might not be preserved

Parameters:
a
b
c
d
text
color
na
nb
nc
nd
textSizethe text size
smthe scale mode
void icl::geom::SceneObject::addTextTexture ( int  a,
int  b,
int  c,
int  d,
const std::string &  text,
const GeomColor color = GeomColor(255,255,255,255),
int  textSize = 30,
core::scalemode  sm = core::interpolateLIN 
) [inline]

convenience method for creation of a text-texture with auto-normals

void icl::geom::SceneObject::addTexture ( int  a,
int  b,
int  c,
int  d,
const core::ImgBase texture,
int  na,
int  nb,
int  nc,
int  nd,
bool  createTextureOnce = true,
core::scalemode  sm = core::interpolateLIN 
)

If the given normal indices (na,nb,nc and nd) are -1, auto-normal are computed using cross-product

void icl::geom::SceneObject::addTexture ( int  a,
int  b,
int  c,
int  d,
const core::ImgBase texture,
bool  createTextureOnce = true,
core::scalemode  sm = core::interpolateLIN 
) [inline]

convenience method for creation of a texture with auto-normals

void icl::geom::SceneObject::addTexture ( int  a,
int  b,
int  c,
int  d,
int  sharedTextureIndex,
int  na = -1,
int  nb = -1,
int  nc = -1,
int  nd = -1 
)

adds are shared texture primitive

The sharedTextureIndex references a shared texture that has been added by using SceneObject::addSharedTexture

void icl::geom::SceneObject::addTexture ( const core::ImgBase image,
int  numPoints,
const int *  vertexIndices,
const utils::Point32f texCoords,
const int *  normalIndices = 0,
bool  createTextureOnce = true 
)

adds a GenericTexturePrimitive for custom texCoords

void icl::geom::SceneObject::addTextureGrid ( int  w,
int  h,
const core::ImgBase image,
const icl32f px,
const icl32f py,
const icl32f pz,
const icl32f pnx = 0,
const icl32f pny = 0,
const icl32f pnz = 0,
int  stride = 1,
bool  createTextureOnce = true,
core::scalemode  sm = core::interpolateLIN 
)

adds a texture that is drawn on a 2D grid of vertices in 3D space

void icl::geom::SceneObject::addTriangle ( int  a,
int  b,
int  c,
int  na,
int  nb,
int  nc,
const GeomColor color = GeomColor(0, 100, 250, 255) 
)

adds a new triangle to this onject

If the given normal indices (na,nb and nc) are -1, auto-normal are computed using cross-product

void icl::geom::SceneObject::addTriangle ( int  a,
int  b,
int  c,
const GeomColor color = GeomColor(0,100,250,255) 
) [inline]

convenience method for creation of a triangle with auto-normals

void icl::geom::SceneObject::addTwoSidedTextureGrid ( int  w,
int  h,
const core::ImgBase front,
const core::ImgBase back,
const icl32f px,
const icl32f py,
const icl32f pz,
const icl32f pnx = 0,
const icl32f pny = 0,
const icl32f pnz = 0,
int  stride = 1,
bool  createFrontOnce = true,
bool  createBackOnce = true,
core::scalemode  sm = core::interpolateLIN 
)

adds a texture grid that has two different texture for the two faces

Internally, the TwoSidedTextureGridPrimitive is used

void icl::geom::SceneObject::addVertex ( const Vec p,
const GeomColor color = GeomColor(255, 0, 0, 255) 
)

adds a new vertex to this object

Please note, that colors are defined in ICL's commong [0,255] range, but they are stored internally in [0,1] range, since this is how OpenGL expects colors

deletes and removes all primitives

static void icl::geom::SceneObject::collect_hits_recursive ( SceneObject obj,
const ViewRay v,
std::vector< Hit > &  hits,
bool  recursive 
) [static, protected]

recursive picking method

virtual SceneObject* icl::geom::SceneObject::copy ( ) const [virtual]
void icl::geom::SceneObject::createAutoNormals ( bool  smooth = true)

automatically creates precomputed normals

in smooth mode, for each vertex a surface normal is created. The normals are defined by the mean normal of all adjacent faces (triangles and quads). This does only work for sphere-like object, where a "mean normal" makes sense. This does not make sense for a cube.

The non-smooth mode pre-computes normals for each face, but here, each face-vertex uses the same normal leading to a flat-shaded result. The non-smooth-mode looks identical to the Primitives automatically created online normals, but reduces processor load.

creates a displaylist in the next render cycle

if the displaylist was already created, it is updated

static SceneObject* icl::geom::SceneObject::cube ( float  x,
float  y,
float  z,
float  r 
) [inline, static]

create a cube scene object

static SceneObject* icl::geom::SceneObject::cuboid ( float  x,
float  y,
float  z,
float  dx,
float  dy,
float  dz 
) [inline, static]

create a cuboid scene object

virtual void icl::geom::SceneObject::customRender ( ) [inline, virtual]

this function is called when an object is rendered

The function can be used to draw something in Object coordinates using OpenGL commands directly. When customRender is called, the OpenGL matrices is already prepared correctly. Custom render is always called before the SceneObject's primitives are rendered

Reimplemented in icl::geom::PointCloudObjectBase, icl::geom::OctreeObject< Scalar, CAPACITY, SF, Pt, ALLOC_CHUNK_SIZE >, icl::geom::OctreeObject< float, 16, 1, Vec, 1024 >, and icl::geom::PointCloudObject.

frees the displaylist in the next render cycle

returns child at given index

const SceneObject* icl::geom::SceneObject::getChild ( int  index) const

returns child at given index (const)

returns the number of children

Vec icl::geom::SceneObject::getClosestVertex ( const Vec pWorld,
bool  relative = false 
) throw (utils::ICLException)

returns the vertex, that is closest to the given point in wold coordinates

If relative is true, the vertex is returned in object-coordinates, otherwise it is returned in world coordinates

virtual GeomColor icl::geom::SceneObject::getDefaultVertexColor ( ) const [inline, virtual]

can be reimplemented by subclass to provide and interface for setting default vertex color

The default vertex color is used if no color information is available (m_vertexColors.size() is 0

Reimplemented in icl::geom::PointCloudObjectBase.

returns whether depth test is enabled for this object

returns the current fragment shader (or NULL if non was given)

returns the current fragment shader (or NULL if non was given, const version)

returns whether locking is current enabled for this object

returns the parent scene object

returns the parent scene object (const version)

returns object's primitives (lines, quads, etc...)

const std::vector<Primitive*>& icl::geom::SceneObject::getPrimitives ( ) const

returns object's primitives (lines, quads, etc...) (const)

returns wheather smooth shading is activated

Mat icl::geom::SceneObject::getTransformation ( bool  relative = false) const

returns the current transformation matrix

If the relative flag is true, only this objects transformation matrix is returned. If it is set to false (which is default), also the parent SceneObjects absolute transformation matrix is queried and premultiplied

returns all vertices in their final world coordinates

returns object vertex colors

If the number of vertex colors is changed, the object needs to be locked

const std::vector<GeomColor>& icl::geom::SceneObject::getVertexColors ( ) const

returns object vertex colors (const)

returns object vertices

If the vertex count is changed, the object needs to be locked

const std::vector<Vec>& icl::geom::SceneObject::getVertices ( ) const

returns object vertices (const)

bool icl::geom::SceneObject::hasChild ( const SceneObject o) const

returns whether the given object is a child of this one

returns whether the SceneObject has children at all

bool icl::geom::SceneObject::hasTransformation ( bool  relative = false) const

returns whether the SceneObject has currently a non-ID-transformation

Here also the parent transformation is regarded if relative is false

void icl::geom::SceneObject::hide ( bool  recursive = true) [inline]

calls setVisible(false)

Hit icl::geom::SceneObject::hit ( const ViewRay v,
bool  recursive = true 
)

returns whether this object is hit by the given viewray

Please note: only faces (i.e. quads, triangles and polygons are checked) The method returns the hit scene object that was closest to the given view-rays origin or null, if it was not hit. If recursive is true, the scene-graph is traversed from this object on and the actually hit child (or child of child etc.) might also be returned.

const Hit icl::geom::SceneObject::hit ( const ViewRay v,
bool  recursive = true 
) const [inline]

returns whether this object is hit by the given viewray (const)

std::vector<Hit> icl::geom::SceneObject::hits ( const ViewRay v,
bool  recursive = true 
)

returns all hits with SceneObjects form the given viewray

returns visibility of given primitive type

bool icl::geom::SceneObject::isVisible ( ) const [inline]

returns whether this object is currently visible

virtual void icl::geom::SceneObject::lock ( ) [inline, virtual]

locks the internal mutex if locking enabled is set to true

This function can be re implemented by subclasses that need an eplicit locking. Note, that explicit locking can be enabled/disabled using setLockingEnabled
E.g. if an objects data is updated from another thread, you can sub-class this class and implement a locking mechanism for it

Reimplemented in icl::geom::ComplexCoordinateFrameSceneObject.

SceneObject& icl::geom::SceneObject::operator= ( const SceneObject other)

assignment operator for deep copy

This instances parent is not changed. I.e. it must be added to other's parent explicitly if this is necessary.

virtual void icl::geom::SceneObject::prepareForRendering ( ) [inline, virtual]

called by the renderer before the object is rendered

here, dynamic object types can adapt e.g. their vertices or colors

Reimplemented in icl::geom::SceneLightObject.

removes all children

removes given child

no errors if the child was not found

sets the internal transformation to the identity matrix

virtual void icl::geom::SceneObject::rotate ( float  rx,
float  ry,
float  rz 
) [virtual]

rotates the scene object (this affects it's transformation matrix)

template<class T >
void icl::geom::SceneObject::rotate ( const T &  t) [inline]

utility wrapper for vector based rotation

virtual void icl::geom::SceneObject::scale ( float  sx,
float  sy,
float  sz 
) [virtual]

transformes the current transformation matrix by a scale matrix

template<class T >
void icl::geom::SceneObject::scale ( const T &  t) [inline]

utility wrapper for vector based scaling

void icl::geom::SceneObject::setColor ( Primitive::Type  t,
const GeomColor color,
bool  recursive = true 
)

tints all Primitives with given type in given color

void icl::geom::SceneObject::setColorsFromVertices ( Primitive::Type  t,
bool  on,
bool  recursive = true 
)

sets how 2D-geom colors are set

void icl::geom::SceneObject::setDepthTestEnabled ( bool  enabled) [inline]

sets whether depth test is enabled for this object

sets a fragment shader to use for this object

use set fragment shader (0) in order to delete the fragment shader

void icl::geom::SceneObject::setLineSmoothingEnabled ( bool  enabled = true) [inline]

sets whether lines are visualized in a smoothed manner

This might not be supported by the graphics hardware or driver Default value is true

void icl::geom::SceneObject::setLineWidth ( float  lineWidth,
bool  recursive = true 
)

sets point size

void icl::geom::SceneObject::setLockingEnabled ( bool  enabled) [inline]

sets locking enabled or disabled

Note, that the method itself locks the internal mutex to prevent, that m_enableLocking is disabled while the mutex is locked somewhere else

void icl::geom::SceneObject::setPointSize ( float  pointSize,
bool  recursive = true 
)

sets point size

void icl::geom::SceneObject::setPointSmoothingEnabled ( bool  enabled = true) [inline]

sets whether points are visualized in a smoothed manner

This might not be supported by the graphics hardware or driver. Default value is true

void icl::geom::SceneObject::setPolygonSmoothingEnabled ( bool  enabled = true) [inline]

sets whether faces are visualized in a smoothed manner

This might not be supported by the graphics hardware or driver Default value is true

void icl::geom::SceneObject::setShininess ( icl8u  value) [inline]

sets the material shininess (default is 128)

void icl::geom::SceneObject::setSmoothShading ( bool  on,
bool  recursive = true 
)

sets whether to use smoothshading (default is false)

void icl::geom::SceneObject::setSpecularReflectance ( const GeomColor values) [inline]

sets the materials specular reflectance

given color ranges are expected in range [0,255]

virtual void icl::geom::SceneObject::setTransformation ( const Mat m) [virtual]

Sets a transformation matrix.

All vertices are transformed with this matrix before rendering. If the SceneObject instance has a parent-Scene object, then the parent's SceneObject's transformation pre-multiplied

void icl::geom::SceneObject::setVisible ( int  oredTypes,
bool  visible,
bool  recursive = true 
)

changes visibility of given primitive type

void icl::geom::SceneObject::setVisible ( bool  visible,
bool  recursive = true 
)

sets the visibility of this object

void icl::geom::SceneObject::show ( bool  recursive = true) [inline]

calls setVisible(true)

static SceneObject* icl::geom::SceneObject::sphere ( float  x,
float  y,
float  z,
float  r,
int  rzSteps,
int  xySlices 
) [inline, static]

create a shere scene object

static SceneObject* icl::geom::SceneObject::spheroid ( float  x,
float  y,
float  z,
float  rx,
float  ry,
float  rz,
int  rzSteps,
int  xySlices 
) [inline, static]

create a shere scene object

static SceneObject* icl::geom::SceneObject::superquadric ( float  x,
float  y,
float  z,
float  rx,
float  ry,
float  rz,
float  dx,
float  dy,
float  dz,
float  e1,
float  e2,
int  rzSteps,
int  xySlices 
) [inline, static]

create a superquadric scene object

virtual void icl::geom::SceneObject::transform ( const Mat m) [virtual]

multiplies the current transformation matrix by given matrix

template<class T >
void icl::geom::SceneObject::transform ( const T &  m) [inline]

utility method for passing arbitrary matrix classes

Note: the given T instance m, needs to have a function-operator(x,y)

virtual void icl::geom::SceneObject::translate ( float  dx,
float  dy,
float  dz 
) [virtual]

translates the scene object (this affects it's translates matrix)

template<class T >
void icl::geom::SceneObject::translate ( const T &  t) [inline]

utility wrapper for vector based translation

virtual void icl::geom::SceneObject::unlock ( ) [inline, virtual]

unlocks the internal mutex if locking enabled is set to true

This function can be re implemented by subclasses that need an eplicit locking. Note, that explicit locking can be enabled/disabled using setLockingEnabled
E.g. if an objects data is updated from another thread, you can sub-class this class and implement a locking mechanism for it

Reimplemented in icl::geom::ComplexCoordinateFrameSceneObject.


Friends And Related Function Documentation

friend struct Primitive [friend]
friend class Scene [friend]

provides direct access for the Scene class


Member Data Documentation

internal flag

  • 0: no change.
    • 1: create/update display list in next render cycle
    • 2: free display-list (if there is any) in the next render cycle

default is true

internally used flag

can be enabled

internal optionally given fragment shader

for asynchronous updates

std::vector<Vec> icl::geom::SceneObject::m_normals [protected]

for the scene graph implementation

std::vector<Vec> icl::geom::SceneObject::m_vertices [protected]

The documentation for this class was generated from the following file:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines