Image Component Library (ICL)
|
The SceneObject class defines visible objects in scenes or scene graph nodes. More...
#include <SceneObject.h>
Public Member Functions | |
ICLGeom_API | SceneObject () |
create an object | |
ICLGeom_API | SceneObject (const std::string &type, const float *params) |
create by string: | |
ICLGeom_API | 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 | |
ICLGeom_API SceneObject & | operator= (const SceneObject &other) |
assignment operator for deep copy | |
virtual ICLGeom_API | ~SceneObject () |
Empty destructor (but virtual) | |
ICLGeom_API std::vector< Vec > & | getVertices () |
returns object vertices | |
ICLGeom_API const std::vector < Vec > & | getVertices () const |
returns object vertices (const) | |
ICLGeom_API std::vector < GeomColor > & | getVertexColors () |
returns object vertex colors | |
ICLGeom_API const std::vector < GeomColor > & | getVertexColors () const |
returns object vertex colors (const) | |
ICLGeom_API std::vector < Primitive * > & | getPrimitives () |
returns object's primitives (lines, quads, etc...) | |
ICLGeom_API const std::vector < Primitive * > & | getPrimitives () const |
returns object's primitives (lines, quads, etc...) (const) | |
ICLGeom_API void | setVisible (int oredTypes, bool visible, bool recursive=true) |
changes visibility of given primitive type | |
ICLGeom_API bool | isVisible (Primitive::Type t) const |
returns visibility of given primitive type | |
ICLGeom_API void | addVertex (const Vec &p, const GeomColor &color=GeomColor(255, 0, 0, 255)) |
adds a new vertex to this object | |
ICLGeom_API void | addSharedTexture (utils::SmartPtr< qt::GLImg > gli) |
adds a GLImg as shared texture | |
ICLGeom_API void | addSharedTexture (const core::ImgBase *image, core::scalemode sm=core::interpolateLIN) |
adds an core::ImgBase * as shared texutre | |
ICLGeom_API void | addNormal (const Vec &n) |
adds a new normal to this object | |
ICLGeom_API void | addLine (int x, int y, const GeomColor &color=GeomColor(100, 100, 100, 255)) |
adds a new line to this object | |
ICLGeom_API 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 | |
ICLGeom_API 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 | |
ICLGeom_API 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) | |
ICLGeom_API 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 | |
ICLGeom_API 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 | |
ICLGeom_API 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 | |
ICLGeom_API 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 | |
ICLGeom_API 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 | |
ICLGeom_API void | addTwoSidedTGrid (int w, int h, const Vec *vertices, const Vec *normals=0, const GeomColor &frontColor=GeomColor(0, 100, 255, 255), const GeomColor &backColor=GeomColor(255, 0, 100, 255), const GeomColor &lineColor=GeomColor(0, 255, 100, 255), bool drawLines=false, bool drawQuads=true) |
adds a two sided grid (sides may have different colors) | |
ICLGeom_API 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 | |
ICLGeom_API 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 | |
SceneObject * | addCube (float x, float y, float z, float d) |
adds a cube child-object with given parameters | |
ICLGeom_API SceneObject * | addCuboid (float x, float y, float z, float dx, float dy, float dz) |
adds a cuboid child-object with given parameters | |
SceneObject * | addSphere (float x, float y, float z, float r, int rzSteps, int xySlices) |
adds a cuboid child-object with given parameters | |
ICLGeom_API 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 | |
ICLGeom_API SceneObject * | addCylinder (float x, float y, float z, float rx, float ry, float h, int steps) |
adds a cylindical child object with given parameters | |
ICLGeom_API SceneObject * | addCone (float x, float y, float z, float rx, float ry, float h, int steps) |
adds a conical child object with given parameters | |
ICLGeom_API void | setColor (Primitive::Type t, const GeomColor &color, bool recursive=true) |
tints all Primitives with given type in given color | |
ICLGeom_API void | setPointSize (float pointSize, bool recursive=true) |
sets point size | |
ICLGeom_API void | setLineWidth (float lineWidth, bool recursive=true) |
sets point size | |
virtual ICLGeom_API SceneObject * | copy () 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 | |
virtual void | complexCustomRender (icl::geom::ShaderUtil *util) |
this function is called when an object is rendered | |
ICLGeom_API void | setColorsFromVertices (Primitive::Type t, bool on, bool recursive=true) |
sets how 2D-geom colors are set | |
ICLGeom_API bool | getSmoothShading () const |
returns wheather smooth shading is activated | |
ICLGeom_API void | setSmoothShading (bool on, bool recursive=true) |
sets whether to use smoothshading (default is false) | |
ICLGeom_API 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 | |
ICLGeom_API 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) | |
ICLGeom_API std::vector< Hit > | hits (const ViewRay &v, bool recursive=true) |
returns all hits with SceneObjects form the given viewray | |
ICLGeom_API std::vector< Vec > | getTransformedVertices () const |
returns all vertices in their final world coordinates | |
ICLGeom_API Vec | getClosestVertex (const Vec &pWorld, bool relative=false) throw (utils::ICLException) |
returns the vertex, that is closest to the given point in wold coordinates | |
ICLGeom_API 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 () const |
locks the internal mutex if locking enabled is set to true | |
virtual void | unlock () const |
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 | |
ICLGeom_API void | clearAllPrimitives () |
deletes and removes all primitives | |
ICLGeom_API void | createDisplayList () |
creates a displaylist in the next render cycle | |
ICLGeom_API void | freeDisplayList () |
frees the displaylist in the next render cycle | |
ICLGeom_API void | setFragmentShader (qt::GLFragmentShader *shader) |
sets a fragment shader to use for this object | |
qt::GLFragmentShader * | getFragmentShader () |
returns the current fragment shader (or NULL if non was given) | |
const qt::GLFragmentShader * | getFragmentShader () const |
returns the current fragment shader (or NULL if non was given, const version) | |
void | setCastShadowsEnabled (bool castShadows=true) |
bool | getCastShadowsEnabled () |
void | setReceiveShadowsEnabled (bool receiveShadows=true) |
bool | getReceiveShadowsEnabled () |
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 SceneObject * | cube (float x, float y, float z, float r) |
create a cube scene object | |
static SceneObject * | cuboid (float x, float y, float z, float dx, float dy, float dz) |
create a cuboid scene object | |
static SceneObject * | sphere (float x, float y, float z, float r, int rzSteps, int xySlices) |
create a shere scene object | |
static SceneObject * | spheroid (float x, float y, float z, float rx, float ry, float rz, int rzSteps, int xySlices) |
create a shere scene object | |
static 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) |
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< Vec > | m_vertices |
std::vector< Vec > | m_normals |
std::vector< GeomColor > | m_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 |
SceneObject * | m_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::GLFragmentShader * | m_fragmentShader |
internal optionally given fragment shader | |
bool | m_castShadows |
bool | m_receiveShadows |
Friends | |
class | Scene |
provides direct access for the Scene class | |
struct | Primitive |
methods for creation of a scene graph | |
virtual ICLGeom_API void | setTransformation (const Mat &m) |
Sets a transformation matrix. | |
ICLGeom_API void | removeTransformation () |
sets the internal transformation to the identity matrix | |
virtual ICLGeom_API 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 ICLGeom_API void | rotate (float rx, float ry, float rz, icl::math::AXES axes=icl::math::AXES_DEFAULT) |
rotates the scene object (this affects it's transformation matrix) | |
template<class T > | |
void | rotate (const T &t, icl::math::AXES axes=icl::math::AXES_DEFAULT) |
utility wrapper for vector based rotation | |
virtual ICLGeom_API 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 ICLGeom_API 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 | |
ICLGeom_API Mat | getTransformation (bool relative=false) const |
returns the current transformation matrix | |
ICLGeom_API bool | hasTransformation (bool relative=false) const |
returns whether the SceneObject has currently a non-ID-transformation | |
ICLGeom_API SceneObject * | getParent () |
returns the parent scene object | |
ICLGeom_API const SceneObject * | getParent () const |
returns the parent scene object (const version) | |
ICLGeom_API void | addChild (SceneObject *child, bool passOwnerShip=true) |
adds a new child to this scene object | |
void | addChild (utils::SmartPtr< SceneObject > child) |
directly passes a smart pointer as a child | |
ICLGeom_API void | removeChild (SceneObject *child) |
removes given child | |
ICLGeom_API void | removeAllChildren () |
removes all children | |
ICLGeom_API bool | hasChildren () const |
returns whether the SceneObject has children at all | |
ICLGeom_API int | getChildCount () const |
returns the number of children | |
ICLGeom_API SceneObject * | getChild (int index) |
returns child at given index | |
ICLGeom_API const SceneObject * | getChild (int index) const |
returns child at given index (const) | |
utils::SmartPtr< SceneObject > | getChildPtr (int index) |
returns a shared pointer to the child at given index | |
ICLGeom_API bool | hasChild (const SceneObject *o) const |
returns whether the given object is a child of this one |
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.
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 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.
If no normals are provided, the normals are computed automatically at run-time using cross-product:
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(); } ... };
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
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).
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.
create an object
ICLGeom_API icl::geom::SceneObject::SceneObject | ( | const std::string & | type, |
const float * | params | ||
) |
create by string:
currently allowed:
ICLGeom_API 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 ICLGeom_API icl::geom::SceneObject::~SceneObject | ( | ) | [virtual] |
Empty destructor (but virtual)
ICLGeom_API 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.
void icl::geom::SceneObject::addChild | ( | utils::SmartPtr< SceneObject > | child | ) |
directly passes a smart pointer as a child
By passing a smart pointer to an object, pointer-sharing can also be extended to the caller scope. Please note, that adding a child to an object o, will always set the child's parent to o
ICLGeom_API 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
ICLGeom_API 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
void icl::geom::SceneObject::addCustomPrimitive | ( | Primitive * | p | ) | [inline] |
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
ICLGeom_API 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
ICLGeom_API 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
ICLGeom_API void icl::geom::SceneObject::addNormal | ( | const Vec & | n | ) |
adds a new normal to this object
ICLGeom_API 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
ICLGeom_API 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
ICLGeom_API void icl::geom::SceneObject::addSharedTexture | ( | const core::ImgBase * | image, |
core::scalemode | sm = core::interpolateLIN |
||
) |
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
ICLGeom_API 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
ICLGeom_API 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
ICLGeom_API 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
a | |
b | |
c | |
d | |
text | |
color | |
na | |
nb | |
nc | |
nd | |
textSize | the text size |
sm | the 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
ICLGeom_API 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
ICLGeom_API 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
ICLGeom_API 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
ICLGeom_API 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
ICLGeom_API 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
ICLGeom_API 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
ICLGeom_API void icl::geom::SceneObject::addTwoSidedTGrid | ( | int | w, |
int | h, | ||
const Vec * | vertices, | ||
const Vec * | normals = 0 , |
||
const GeomColor & | frontColor = GeomColor(0, 100, 255, 255) , |
||
const GeomColor & | backColor = GeomColor(255, 0, 100, 255) , |
||
const GeomColor & | lineColor = GeomColor(0, 255, 100, 255) , |
||
bool | drawLines = false , |
||
bool | drawQuads = true |
||
) |
adds a two sided grid (sides may have different colors)
ICLGeom_API 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 void icl::geom::SceneObject::complexCustomRender | ( | icl::geom::ShaderUtil * | util | ) | [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 complexCustomRender is called, the OpenGL matrices is already prepared correctly. Custom render is always called before the SceneObject's primitives are rendered. The complexCustomRender function is given a ShaderUtil to enable rendering with the complex shaders from the Scene.
virtual ICLGeom_API SceneObject* icl::geom::SceneObject::copy | ( | ) | const [virtual] |
performs a deep copy of this object
Reimplemented in icl::geom::PointCloudObjectBase, icl::geom::PCLPointCloudObject< PCLPointType >, and icl::geom::PointCloudObject.
ICLGeom_API 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
bool icl::geom::SceneObject::getCastShadowsEnabled | ( | ) | [inline] |
ICLGeom_API SceneObject* icl::geom::SceneObject::getChild | ( | int | index | ) |
returns child at given index
ICLGeom_API const SceneObject* icl::geom::SceneObject::getChild | ( | int | index | ) | const |
returns child at given index (const)
ICLGeom_API int icl::geom::SceneObject::getChildCount | ( | ) | const |
returns the number of children
utils::SmartPtr<SceneObject> icl::geom::SceneObject::getChildPtr | ( | int | index | ) |
returns a shared pointer to the child at given index
ICLGeom_API 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.
bool icl::geom::SceneObject::getDepthTestEnabled | ( | ) | const [inline] |
returns whether depth test is enabled for this object
returns the current fragment shader (or NULL if non was given)
const qt::GLFragmentShader* icl::geom::SceneObject::getFragmentShader | ( | ) | const [inline] |
returns the current fragment shader (or NULL if non was given, const version)
bool icl::geom::SceneObject::getLockingEnabled | ( | ) | const [inline] |
returns whether locking is current enabled for this object
returns the parent scene object
ICLGeom_API const SceneObject* icl::geom::SceneObject::getParent | ( | ) | const |
returns the parent scene object (const version)
ICLGeom_API std::vector<Primitive*>& icl::geom::SceneObject::getPrimitives | ( | ) |
returns object's primitives (lines, quads, etc...)
ICLGeom_API const std::vector<Primitive*>& icl::geom::SceneObject::getPrimitives | ( | ) | const |
returns object's primitives (lines, quads, etc...) (const)
bool icl::geom::SceneObject::getReceiveShadowsEnabled | ( | ) | [inline] |
ICLGeom_API bool icl::geom::SceneObject::getSmoothShading | ( | ) | const |
returns wheather smooth shading is activated
ICLGeom_API 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
ICLGeom_API std::vector<Vec> icl::geom::SceneObject::getTransformedVertices | ( | ) | const |
returns all vertices in their final world coordinates
ICLGeom_API std::vector<GeomColor>& icl::geom::SceneObject::getVertexColors | ( | ) |
returns object vertex colors
If the number of vertex colors is changed, the object needs to be locked
ICLGeom_API const std::vector<GeomColor>& icl::geom::SceneObject::getVertexColors | ( | ) | const |
returns object vertex colors (const)
ICLGeom_API std::vector<Vec>& icl::geom::SceneObject::getVertices | ( | ) |
returns object vertices
If the vertex count is changed, the object needs to be locked
ICLGeom_API const std::vector<Vec>& icl::geom::SceneObject::getVertices | ( | ) | const |
returns object vertices (const)
ICLGeom_API bool icl::geom::SceneObject::hasChild | ( | const SceneObject * | o | ) | const |
returns whether the given object is a child of this one
ICLGeom_API bool icl::geom::SceneObject::hasChildren | ( | ) | const |
returns whether the SceneObject has children at all
ICLGeom_API 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)
ICLGeom_API 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)
ICLGeom_API std::vector<Hit> icl::geom::SceneObject::hits | ( | const ViewRay & | v, |
bool | recursive = true |
||
) |
returns all hits with SceneObjects form the given viewray
ICLGeom_API bool icl::geom::SceneObject::isVisible | ( | Primitive::Type | t | ) | const |
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 | ( | ) | const [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
ICLGeom_API 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
ICLGeom_API void icl::geom::SceneObject::removeChild | ( | SceneObject * | child | ) |
removes given child
no errors if the child was not found
sets the internal transformation to the identity matrix
virtual ICLGeom_API void icl::geom::SceneObject::rotate | ( | float | rx, |
float | ry, | ||
float | rz, | ||
icl::math::AXES | axes = icl::math::AXES_DEFAULT |
||
) | [virtual] |
rotates the scene object (this affects it's transformation matrix)
void icl::geom::SceneObject::rotate | ( | const T & | t, |
icl::math::AXES | axes = icl::math::AXES_DEFAULT |
||
) | [inline] |
utility wrapper for vector based rotation
virtual ICLGeom_API void icl::geom::SceneObject::scale | ( | float | sx, |
float | sy, | ||
float | sz | ||
) | [virtual] |
transformes the current transformation matrix by a scale matrix
void icl::geom::SceneObject::scale | ( | const T & | t | ) | [inline] |
utility wrapper for vector based scaling
void icl::geom::SceneObject::setCastShadowsEnabled | ( | bool | castShadows = true | ) | [inline] |
ICLGeom_API void icl::geom::SceneObject::setColor | ( | Primitive::Type | t, |
const GeomColor & | color, | ||
bool | recursive = true |
||
) |
tints all Primitives with given type in given color
ICLGeom_API 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
ICLGeom_API void icl::geom::SceneObject::setFragmentShader | ( | qt::GLFragmentShader * | shader | ) |
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
ICLGeom_API 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
ICLGeom_API 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::setReceiveShadowsEnabled | ( | bool | receiveShadows = true | ) | [inline] |
void icl::geom::SceneObject::setShininess | ( | icl8u | value | ) | [inline] |
sets the material shininess (default is 128)
ICLGeom_API 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 ICLGeom_API 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
ICLGeom_API void icl::geom::SceneObject::setVisible | ( | int | oredTypes, |
bool | visible, | ||
bool | recursive = true |
||
) |
changes visibility of given primitive type
ICLGeom_API 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 ICLGeom_API void icl::geom::SceneObject::transform | ( | const Mat & | m | ) | [virtual] |
multiplies the current transformation matrix by given matrix
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 ICLGeom_API void icl::geom::SceneObject::translate | ( | float | dx, |
float | dy, | ||
float | dz | ||
) | [virtual] |
translates the scene object (this affects it's translates matrix)
void icl::geom::SceneObject::translate | ( | const T & | t | ) | [inline] |
utility wrapper for vector based translation
virtual void icl::geom::SceneObject::unlock | ( | ) | const [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
friend struct Primitive [friend] |
bool icl::geom::SceneObject::m_castShadows [private] |
std::vector<utils::SmartPtr<SceneObject> > icl::geom::SceneObject::m_children [protected] |
int icl::geom::SceneObject::m_createDisplayListNextTime [private] |
internal flag
bool icl::geom::SceneObject::m_depthTestEnabled [protected] |
default is true
void* icl::geom::SceneObject::m_displayListHandle [private] |
internally used flag
bool icl::geom::SceneObject::m_enableLocking [protected] |
can be enabled
internal optionally given fragment shader
bool icl::geom::SceneObject::m_hasTransformation [protected] |
bool icl::geom::SceneObject::m_isVisible [protected] |
bool icl::geom::SceneObject::m_lineColorsFromVertices [protected] |
bool icl::geom::SceneObject::m_lineSmoothingEnabled [protected] |
float icl::geom::SceneObject::m_lineWidth [protected] |
utils::Mutex icl::geom::SceneObject::m_mutex [mutable, protected] |
for asynchronous updates
std::vector<Vec> icl::geom::SceneObject::m_normals [protected] |
SceneObject* icl::geom::SceneObject::m_parent [protected] |
float icl::geom::SceneObject::m_pointSize [protected] |
bool icl::geom::SceneObject::m_pointSmoothingEnabled [protected] |
bool icl::geom::SceneObject::m_polyColorsFromVertices [protected] |
bool icl::geom::SceneObject::m_polygonSmoothingEnabled [protected] |
std::vector<Primitive*> icl::geom::SceneObject::m_primitives [protected] |
bool icl::geom::SceneObject::m_quadColorsFromVertices [protected] |
bool icl::geom::SceneObject::m_receiveShadows [private] |
std::vector<utils::SmartPtr<qt::GLImg> > icl::geom::SceneObject::m_sharedTextures [protected] |
icl8u icl::geom::SceneObject::m_shininess [protected] |
Mat icl::geom::SceneObject::m_transformation [protected] |
for the scene graph implementation
bool icl::geom::SceneObject::m_triangleColorsFromVertices [protected] |
bool icl::geom::SceneObject::m_useSmoothShading [protected] |
std::vector<GeomColor> icl::geom::SceneObject::m_vertexColors [protected] |
std::vector<Vec> icl::geom::SceneObject::m_vertices [protected] |
int icl::geom::SceneObject::m_visibleMask [protected] |