//==============================================================================
void LineSegmentShapeDrawable::refresh(bool firstTime)
{
if(mLineSegmentShape->getDataVariance() == dart::dynamics::Shape::STATIC)
setDataVariance(osg::Object::STATIC);
else
setDataVariance(osg::Object::DYNAMIC);
const std::vector<Eigen::Vector3d>& vertices =
mLineSegmentShape->getVertices();
const Eigen::aligned_vector<Eigen::Vector2i>& connections =
mLineSegmentShape->getConnections();
if( mLineSegmentShape->checkDataVariance(dart::dynamics::Shape::DYNAMIC_ELEMENTS)
|| firstTime)
{
osg::ref_ptr<osg::DrawElementsUInt> elements =
new osg::DrawElementsUInt(GL_LINES);
elements->reserve(2*connections.size());
for(size_t i=0; i < connections.size(); ++i)
{
const Eigen::Vector2i& c = connections[i];
elements->push_back(c[0]);
elements->push_back(c[1]);
}
addPrimitiveSet(elements);
}
if( mLineSegmentShape->checkDataVariance(dart::dynamics::Shape::DYNAMIC_VERTICES)
|| mLineSegmentShape->checkDataVariance(dart::dynamics::Shape::DYNAMIC_ELEMENTS)
|| firstTime)
{
if(mVertices->size() != vertices.size())
mVertices->resize(vertices.size());
for(size_t i=0; i<vertices.size(); ++i)
(*mVertices)[i] = eigToOsgVec3(vertices[i]);
setVertexArray(mVertices);
}
if( mLineSegmentShape->checkDataVariance(dart::dynamics::Shape::DYNAMIC_COLOR)
|| firstTime)
{
if(mColors->size() != 1)
mColors->resize(1);
(*mColors)[0] = eigToOsgVec4(mLineSegmentShape->getRGBA());
setColorArray(mColors, osg::Array::BIND_OVERALL);
}
}
void Scene::createVertexNode()
{
_vgeode = new osg::Geode;
_vgeode->setDataVariance(osg::Object::DYNAMIC);
osg::Vec3f lightDir(1.0f, 1.0f, 1.0f);
lightDir.normalize();
auto offsets = new osg::Uniform(osg::Uniform::FLOAT_VEC3, "offsets", Scene::VertexInstances);
offsets->setDataVariance(osg::Object::DYNAMIC);
auto stateSet = _vgeode->getOrCreateStateSet();
stateSet->setAttributeAndModes(_instancedProgram, osg::StateAttribute::ON);
stateSet->addUniform(new osg::Uniform("ecLightDirection", lightDir));
stateSet->addUniform(new osg::Uniform("lightColor", osg::Vec3(1.0f, 1.0f, 1.0f)));
stateSet->addUniform(offsets);
osg::Vec3 scale(1.0f, 1.0f, 1.0f);
osg::Vec4 color(0.25f, 0.25f, 0.25f, 1.0f);
auto vertexMatrix = osg::Matrixf::scale(scale * 0.125f * 0.25f);
auto normalMatrix = inverseTranspose(vertexMatrix);
_vgeometry = new osgKaleido::PolyhedronGeometry("#27");
_vgeometry->setUseDisplayList(false);
_vgeometry->setUseVertexBufferObjects(true);
_vgeometry->update(nullptr); // Force geometry generation
auto vertices = dynamic_cast<osg::Vec3Array*>(_vgeometry->getVertexArray());
if (vertices != nullptr) {
transform(*vertices, vertexMatrix);
}
auto normals = dynamic_cast<osg::Vec3Array*>(_vgeometry->getNormalArray());
if (normals != nullptr) {
transform(*normals, normalMatrix);
}
auto colors = dynamic_cast<osg::Vec4Array*>(_vgeometry->getColorArray());
if (colors != nullptr) {
fill(*colors, color);
}
makeInstanced(_vgeometry, Scene::VertexInstances);
auto size = 1.0f;
osg::BoundingBox bb(-size, -size, -size, +size, +size, +size);
_vgeometry->setInitialBound(bb);
_vgeode->addDrawable(_vgeometry);
addChild(_vgeode);
}
LaserScanLine::LaserScanLine(URGCPPWrapper &urg)
: urg(urg), vertices(new osg::Vec3Array(urg.getNumberOfPoints())), color(new osg::Vec4Array(1))
{
setDataVariance(osg::Object::DYNAMIC);
getOrCreateStateSet()->setAttribute(new osg::Point(3), osg::StateAttribute::ON);
addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::POINTS, 0, urg.getNumberOfPoints()));
setColorBinding(osg::Geometry::BIND_OVERALL);
(*color)[0] = osg::Vec4(1.0f, 0.0f, 0.0f, 1.0f);
setColorArray(color);
}
void HeightmapShapeDrawable<S>::refresh(bool /*firstTime*/)
{
if (mHeightmapShape->getDataVariance() == dynamics::Shape::STATIC)
setDataVariance(::osg::Object::STATIC);
else
setDataVariance(::osg::Object::DYNAMIC);
// Row major matrix where top left corner is the height at (0, 0), and bottom
// right corner is the height at (rows, -cols) in (x, y) coordinates.
const auto& heightmap = mHeightmapShape->getHeightField();
// This function is called whenever the heightmap version is increased, and
// the heightmap could be updated in the version up. So we always update the
// heightmap.
{
assert(mElements);
assert(mNormals);
setVertices<S>(
heightmap,
*mVertices,
*mElements,
*mNormals,
mHeightmapShape->getScale());
addPrimitiveSet(mElements);
setVertexArray(mVertices);
setNormalArray(mNormals, ::osg::Array::BIND_PER_VERTEX);
}
// This function is called whenever the heightmap version is increased, and
// the color could be updated in the version up. So we always update the
// color.
{
if (mColors->size() != 1)
mColors->resize(1);
(*mColors)[0] = eigToOsgVec4d(mVisualAspect->getRGBA());
setColorArray(mColors, ::osg::Array::BIND_OVERALL);
}
}
Renderable::Renderable(void)
:read_write_lock_(QReadWriteLock::NonRecursive),
content_root_(new osg::MatrixTransform),
expired_(true),
hidden_(false)
{
addChild(content_root_);
setUpdateCallback(new UpdateCallback);
setDataVariance(Object::DYNAMIC);
return;
}
OcclusionQueryNode::OcclusionQueryNode()
: _enabled( true ),
_visThreshold( 500 ),
_queryFrameCount( 5 ),
_debugBB( false )
{
setDataVariance( osg::Object::DYNAMIC );
// OQN has two Geode member variables, one for doing the
// query and one for rendering the debug geometry.
// Create and initialize them.
createSupportNodes();
}
// create fake layer geometry
void CloudsLayer::_createGeometry()
{
// dummy bounding box callback
osg::Drawable::ComputeBoundingBoxCallback * pDummyBBCompute = new osg::Drawable::ComputeBoundingBoxCallback();
// create OSG geode with 1 drawable node
setCullingActive(false);
setDataVariance(osg::Object::STATIC);
// create tetrahedron around viewer (just to fill the whole volume)
osg::Geometry * box_geometry = new osg::Geometry;
box_geometry->setUseDisplayList(true);
box_geometry->setDataVariance(osg::Object::STATIC);
box_geometry->setComputeBoundingBoxCallback(pDummyBBCompute);
const float fSqrt3 = sqrtf(3.0f);
// create its' vertex
osg::Vec3Array * paBoxPointsPos = new osg::Vec3Array;
paBoxPointsPos->resize(4);
paBoxPointsPos->at(0).set(0.f, 0.f, +2.f);
paBoxPointsPos->at(1).set(-2.0f * fSqrt3, 0.f, -1.0f);
paBoxPointsPos->at(2).set(fSqrt3, -3.0f, -1.0f);
paBoxPointsPos->at(3).set(fSqrt3, +3.0f, -1.0f);
// set vertex array
paBoxPointsPos->setDataVariance(osg::Object::STATIC);
box_geometry->setVertexArray(paBoxPointsPos);
// draw elements command, that would be executed
// volume is made looking inside
osg::DrawElementsUShort * paBoxDrawElem = new osg::DrawElementsUShort(GL_TRIANGLES, 12);
paBoxDrawElem->at(0) = 0;
paBoxDrawElem->at(1) = 2;
paBoxDrawElem->at(2) = 1;
paBoxDrawElem->at(3) = 0;
paBoxDrawElem->at(4) = 3;
paBoxDrawElem->at(5) = 2;
paBoxDrawElem->at(6) = 0;
paBoxDrawElem->at(7) = 1;
paBoxDrawElem->at(8) = 3;
paBoxDrawElem->at(9) = 1;
paBoxDrawElem->at(10) = 2;
paBoxDrawElem->at(11) = 3;
// add DIP
paBoxDrawElem->setDataVariance(osg::Object::STATIC);
box_geometry->addPrimitiveSet(paBoxDrawElem);
// all is done, so add box to this geode
addDrawable(box_geometry);
}
//==============================================================================
void BoxShapeDrawable::refresh(bool firstTime)
{
if(mBoxShape->getDataVariance() == dart::dynamics::Shape::STATIC)
setDataVariance(osg::Object::STATIC);
else
setDataVariance(osg::Object::DYNAMIC);
if(mBoxShape->checkDataVariance(dart::dynamics::Shape::DYNAMIC_PRIMITIVE)
|| firstTime)
{
const Eigen::Vector3d& d = mBoxShape->getSize();
osg::ref_ptr<osg::Box> osg_shape = new osg::Box(osg::Vec3(0,0,0),
d[0], d[1], d[2]);
setShape(osg_shape);
dirtyDisplayList();
}
if(mBoxShape->checkDataVariance(dart::dynamics::Shape::DYNAMIC_COLOR)
|| firstTime)
{
setColor(eigToOsgVec4(mBoxShape->getRGBA()));
}
}
//==============================================================================
void CylinderShapeDrawable::refresh(bool firstTime)
{
if(mCylinderShape->getDataVariance() == dart::dynamics::Shape::STATIC)
setDataVariance(osg::Object::STATIC);
else
setDataVariance(osg::Object::DYNAMIC);
if(mCylinderShape->checkDataVariance(dart::dynamics::Shape::DYNAMIC_PRIMITIVE)
|| firstTime)
{
double R = mCylinderShape->getRadius();
double h = mCylinderShape->getHeight();
osg::ref_ptr<osg::Cylinder> osg_shape =
new osg::Cylinder(osg::Vec3(0,0,0), R, h);
setShape(osg_shape);
dirtyDisplayList();
}
if(mCylinderShape->checkDataVariance(dart::dynamics::Shape::DYNAMIC_COLOR)
|| firstTime)
{
setColor(eigToOsgVec4(mCylinderShape->getRGBA()));
}
}
//==============================================================================
void EllipsoidShapeDrawable::refresh(bool firstTime)
{
if(mEllipsoidShape->getDataVariance() == dart::dynamics::Shape::STATIC)
setDataVariance(::osg::Object::STATIC);
else
setDataVariance(::osg::Object::DYNAMIC);
if(mEllipsoidShape->checkDataVariance(dart::dynamics::Shape::DYNAMIC_PRIMITIVE)
|| firstTime)
{
::osg::ref_ptr<::osg::Sphere> osg_shape = nullptr;
osg_shape = new ::osg::Sphere(::osg::Vec3(0,0,0),
0.5*smallestComponent(mEllipsoidShape->getSize()));
setShape(osg_shape);
dirtyDisplayList();
}
if(mEllipsoidShape->checkDataVariance(dart::dynamics::Shape::DYNAMIC_COLOR)
|| firstTime)
{
setColor(eigToOsgVec4(mVisualAspect->getRGBA()));
}
}
Widget::Widget(const std::string& name, point_type w, point_type h):
_parent (0),
_index (0),
_layer (LAYER_LOW),
_padLeft (0.0f),
_padRight (0.0f),
_padTop (0.0f),
_padBottom (0.0f),
_valign (VA_CENTER),
_halign (HA_CENTER),
_coordMode (CM_ABSOLUTE),
_canFill (false),
_canClone (true),
_isManaged (false),
_isStyled (false),
_minWidth (0.0f),
_minHeight (0.0f) {
_name = name.size() ? name : generateRandomName("Widget");
if(!_norms.valid()) {
_norms = new PointArray(1);
(*_norms)[0].set(0.0f, 0.0f, 1.0f);
(*_norms)[0].normalize();
}
TexCoordArray* texs = new TexCoordArray(4);
// Fill our texture coordinates with null stuff for now, since we aren't using them
// until an Image is set at some later point.
std::fill(texs->begin(), texs->end(), osg::Vec2(0.0f, 0.0f));
setUseDisplayList(false);
setDataVariance(osg::Object::DYNAMIC);
setVertexArray(new PointArray(4));
setColorArray(new ColorArray(4));
setNormalArray(_norms.get());
setTexCoordArray(0, texs);
setNormalBinding(osg::Geometry::BIND_OVERALL);
setColorBinding(osg::Geometry::BIND_PER_VERTEX);
addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS, 0, 4));
setDimensions(0.0f, 0.0f, w, h);
setColor(1.0f, 1.0f, 1.0f, 1.0f);
}
dustDrawable::dustDrawable()
: osg::Drawable()
, coMenuListener()
, coTUIListener()
, state(NULL)
, animate(false)
, anim(0)
, threshold(0)
{
//box = osg::BoundingBox(b[0], b[1], b[2], b[3], b[4], b[5]);
renderer = NULL;
setDataVariance(Object::DYNAMIC);
threshold = FLT_MAX;
changed = true;
doReset = false;
}
Window::Window(const std::string& name):
_parent (0),
_wm (0),
_index (0),
_x (0.0f),
_y (0.0f),
_z (0.0f),
_zRange (0.0f),
_strata (STRATA_NONE),
_vis (VM_FULL),
_r (0.0f),
_s (1.0f),
_scaleDenom (100.0f),
_vAnchor (VA_NONE),
_hAnchor (HA_NONE)
{
_name = name.size() ? name : generateRandomName("Window");
// TODO: Fix the "bg" name.
osg::Geode* geode = new osg::Geode();
Widget* bg = new Widget(name + "bg", 0.0f, 0.0f);
bg->setLayer(Widget::LAYER_BG);
bg->setColor(1.0f, 1.0f, 1.0f, 1.0f);
_setParented(bg);
geode->addDrawable(bg);
addChild(geode);
setDataVariance(osg::Object::DYNAMIC);
setEventMask(EVENT_ALL);
getOrCreateStateSet()->setAttributeAndModes(
new osg::Scissor(0, 0, 0, 0),
osg::StateAttribute::ON
);
}
LightManager::LightManager()
{
setDataVariance(DYNAMIC);
setUpdateCallback(Utils::makeNodeCallback(this, &LightManager::update));
}
