void MetaShapeRenderer::prepRenderImage( SceneRenderState *state )
{
// Do a little prep work if needed
if ( mVertexBuffer.isNull() )
createGeometry();
if(mUpdatePolyList)
this->createGeometry();
// Allocate an ObjectRenderInst so that we can submit it to the RenderPassManager
ObjectRenderInst *ri = state->getRenderPass()->allocInst<ObjectRenderInst>();
// Now bind our rendering function so that it will get called
ri->renderDelegate.bind( this, &MetaShapeRenderer::render );
// Set our RenderInst as a standard object render
ri->type = RenderPassManager::RIT_Object;
// Set our sorting keys to a default value
ri->defaultKey = 0;
ri->defaultKey2 = 0;
// Submit our RenderInst to the RenderPassManager
state->getRenderPass()->addInst( ri );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::ensureStaticGeometryPartsCreated(RivCellSetEnum geometryType)
{
if (geometryType < PROPERTY_FILTERED && m_geometriesNeedsRegen[geometryType])
{
createGeometry( geometryType);
}
}
void QtRenderer::initialize()
{
QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
vshader->compileSourceCode(
"attribute highp vec4 vertex;"
"attribute mediump vec3 normal;"
"uniform mediump mat4 matrix;"
"uniform lowp vec4 sourceColor;"
"varying mediump vec4 color;"
"void main(void)"
"{"
" vec3 toLight = normalize(vec3(0.0, 0.3, 1.0));"
" float angle = max(dot(normal, toLight), 0.0);"
" vec3 col = sourceColor.rgb;"
" color = vec4(col * 0.2 + col * 0.8 * angle, 1.0);"
" color = clamp(color, 0.0, 1.0);"
" gl_Position = matrix * vertex;"
"}");
QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
fshader->compileSourceCode(
"varying mediump vec4 color;"
"void main(void)"
"{"
" gl_FragColor = color;"
"}");
m_program = new QOpenGLShaderProgram(this);
m_program->addShader(vshader);
m_program->addShader(fshader);
m_program->link();
m_program->bind();
vertexAttr = m_program->attributeLocation("vertex");
normalAttr = m_program->attributeLocation("normal");
matrixUniform = m_program->uniformLocation("matrix");
colorUniform = m_program->uniformLocation("sourceColor");
m_fAngle = 0;
createGeometry();
m_vbo.create();
m_vbo.bind();
const int verticesSize = vertices.count() * 3 * sizeof(GLfloat);
m_vbo.allocate(verticesSize * 2);
m_vbo.write(0, vertices.constData(), verticesSize);
m_vbo.write(verticesSize, normals.constData(), verticesSize);
QOpenGLFunctions *f = m_context->functions();
f->glClearColor(0.1f, 0.1f, 0.2f, 1.0f);
f->glFrontFace(GL_CW);
f->glCullFace(GL_FRONT);
f->glEnable(GL_CULL_FACE);
f->glEnable(GL_DEPTH_TEST);
m_program->enableAttributeArray(vertexAttr);
m_program->enableAttributeArray(normalAttr);
m_program->setAttributeBuffer(vertexAttr, GL_FLOAT, 0, 3);
m_program->setAttributeBuffer(normalAttr, GL_FLOAT, verticesSize, 3);
}
void initializeGL()
{
QOpenGLFunctions::initializeOpenGLFunctions();
createShaderProgram(); m_pgm.bind();
// Set lighting information
m_pgm.setUniformValue("lightSource.ambient", QVector3D( 0.0f, 0.0f, 0.0f )); // opengl fixed-function default
m_pgm.setUniformValue("lightSource.diffuse", QVector3D( 1.0f, 1.0f, 1.0f )); // opengl fixed-function default
m_pgm.setUniformValue("lightSource.specular", QVector3D( 1.0f, 1.0f, 1.0f )); // opengl fixed-function default
m_pgm.setUniformValue("lightSource.position", QVector3D( 1.0f, 1.0f, 1.0f )); // NOT DEFAULT VALUE
m_pgm.setUniformValue("lightModel.ambient", QVector3D( 0.2f, 0.2f, 0.2f )); // opengl fixed-function default
m_pgm.setUniformValue("material.emission", QVector3D( 0.0f, 0.0f, 0.0f )); // opengl fixed-function default
m_pgm.setUniformValue("material.specular", QVector3D( 1.0f, 1.0f, 1.0f )); // NOT DEFAULT VALUE
m_pgm.setUniformValue("material.shininess", 10.0f); // NOT DEFAULT VALUE
createGeometry();
m_view.setToIdentity();
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0);
m_pgm.setUniformValue("texUnit", 0);
createTexture();
glClearColor(.5f,.5f,.5f,1.f);
}
void Cloth::init(int width, int height, int numW, int numH) {
this->width = width;
this->height = height;
this->numW = numW;
this->numH = numH;
rotX = 0; rotY = 0;
//glEnable(GL_DEPTH_TEST);
//glDepthFunc(GL_LEQUAL);
ofDisableArbTex();
shader.setup("shaders/shader1.vert", "shaders/shader1.frag");
checkGLErrors("init()");
shader.begin();
posAttribLoc = glGetAttribLocationARB((GLhandleARB)shader.getProgram(), "aVertexPosition");
normalAttribLoc = glGetAttribLocationARB((GLhandleARB)shader.getProgram(), "aVertexNormal");
glEnableVertexAttribArray(posAttribLoc);
glEnableVertexAttribArray(normalAttribLoc);
pMatrixUniformLoc = glGetUniformLocationARB((GLhandleARB)shader.getProgram(), "uPMatrix");
mvMatrixUniformLoc = glGetUniformLocationARB((GLhandleARB)shader.getProgram(), "uMVMatrix");
nMatrixUniformLoc = glGetUniformLocationARB((GLhandleARB)shader.getProgram(), "uNMatrix");
shader.end();
glGenBuffersARB(1, &verticesBuffer);
glGenBuffersARB(1, &facesBuffer);
createGeometry();
}
bool Primitive::create(Physics* pPhysics, PxMaterial* pMaterial, PxVec3 position, PxReal density,
PxVec3 velocity) {
if(!Object::isCreated()) {
Object::construct(pPhysics, pMaterial, position, density, velocity, createGeometry());
return true;
}
}
void Cylinder::createPhysics()
{
//create physic engine stuff
setPointerToPhysicalWorld(simulation->getPhysicalWorld());
setPointerToCollisionSpace(simulation->getCurrentSpace());
if(movableID)
{
createGeometry(*simulation->getMovableSpace());
createBody();
dGeomSetBody(geometry, body);
}
else
{
createGeometry(*simulation->getStaticSpace());
}
}
void createShape(int type)
{
cleanup();
createGeometry(type, &geometry, uTessellation, uTessellation);
createIndices(&geometry, uTessellation, uTessellation);
createNormals(type, &geometry, uTessellation, uTessellation);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::appendFaultLabelsStaticGeometryPartsToModel(cvf::ModelBasicList* model, ReservoirGeometryCacheType geometryType)
{
if (m_geometriesNeedsRegen[geometryType])
{
createGeometry(geometryType);
}
m_geometries[geometryType].appendFaultLabelPartsToModel(model);
}
Camera(const glm::vec3 &position, const glm::vec3 ¢er, const glm::vec3 &up){
//set camera
set(position, center,up);
//update geometrie si update
createGeometry();
updateGeometry();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::setFaultForceVisibilityForGeometryType(ReservoirGeometryCacheType geometryType, bool forceVisibility)
{
if (m_geometriesNeedsRegen[geometryType])
{
createGeometry(geometryType);
}
m_geometries[geometryType].setFaultForceVisibility(forceVisibility);
}
DebugDrawer::DebugDrawer(osg::ref_ptr<osg::Group> parentNode, btCollisionWorld *world)
: mParentNode(parentNode),
mWorld(world),
mDebugOn(true)
{
createGeometry();
}
void DebugDrawer::setDebugMode(int isOn)
{
mDebugOn = (isOn == 0) ? false : true;
if (!mDebugOn)
destroyGeometry();
else
createGeometry();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::appendStaticGeometryPartsToModel(cvf::ModelBasicList* model, ReservoirGeometryCacheType geometryType,
const std::vector<size_t>& gridIndices)
{
if (m_geometriesNeedsRegen[geometryType])
{
createGeometry( geometryType);
}
m_geometries[geometryType].appendPartsToModel(model, gridIndices);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::createPropertyFilteredWellGeometry(size_t frameIndex)
{
RigReservoir* res = m_reservoirView->eclipseCase()->reservoirData();
if ( frameIndex >= m_propFilteredWellGeometryFrames.size())
{
m_propFilteredWellGeometryFrames.resize(frameIndex + 1);
m_propFilteredWellGeometryFramesNeedsRegen.resize(frameIndex + 1, true);
}
if ( m_propFilteredWellGeometryFrames[frameIndex].isNull()) m_propFilteredWellGeometryFrames[frameIndex] = new RivReservoirPartMgr;
m_propFilteredWellGeometryFrames[frameIndex]->clearAndSetReservoir(res);
m_propFilteredWellGeometryFrames[frameIndex]->setTransform(m_scaleTransform.p());
std::vector<RigGridBase*> grids;
res->allGrids(&grids);
bool hasActiveRangeFilters = m_reservoirView->rangeFilterCollection()->hasActiveFilters() || m_reservoirView->wellCollection()->hasVisibleWellCells();
for (size_t i = 0; i < grids.size(); ++i)
{
cvf::ref<cvf::UByteArray> cellVisibility = m_propFilteredWellGeometryFrames[frameIndex]->cellVisibility(i);
cvf::ref<cvf::UByteArray> rangeVisibility;
cvf::ref<cvf::UByteArray> wellCellsOutsideVisibility;
if (m_geometriesNeedsRegen[RANGE_FILTERED_WELL_CELLS]) createGeometry(RANGE_FILTERED_WELL_CELLS);
rangeVisibility = m_geometries[RANGE_FILTERED_WELL_CELLS].cellVisibility(i);
if (m_geometriesNeedsRegen[VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER]) createGeometry(VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER);
wellCellsOutsideVisibility = m_geometries[VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER].cellVisibility(i);
cellVisibility->resize(rangeVisibility->size());
#pragma omp parallel for
for (int cellIdx = 0; cellIdx < static_cast<int>(cellVisibility->size()); ++cellIdx)
{
(*cellVisibility)[cellIdx] = (!hasActiveRangeFilters && grids[i]->cell(cellIdx).isWellCell()) || (*rangeVisibility)[cellIdx] || (*wellCellsOutsideVisibility)[cellIdx];
}
computePropertyVisibility(cellVisibility.p(), grids[i], frameIndex, cellVisibility.p(), m_reservoirView->propertyFilterCollection());
m_propFilteredWellGeometryFrames[frameIndex]->setCellVisibility(i, cellVisibility.p());
}
m_propFilteredWellGeometryFramesNeedsRegen[frameIndex] = false;
}
Overlay::Overlay()
: positioning( PositionMode::Relative )
, anchor( AnchorMode::TopLeft )
, opacity(1.0f)
, borderWidth(0)
, borderColor(Color::Black)
, backgroundColor(Color::White)
{
createGeometry();
}
void CapsuleMesh::setLevelOfDetail(int lod)
{
lod = qBound(1, lod, 10);
if (d->lod != lod) {
d->lod = lod;
createGeometry(true);
emit levelOfDetailChanged();
emit dataChanged();
}
}
void SphereMesh::setAxis(Qt::Axis axis)
{
if (d->axis != axis)
{
d->axis = axis;
createGeometry();
emit axisChanged();
emit dataChanged();
}
}
/*
* Constructor
*/
CButCamCast::CButCamCast(const std::string & name,rviz::VisualizationManager * manager)
: Display( name, manager )
, m_bPublish(true)
{
// Create and connect pane
rviz::WindowManagerInterface * wi( manager->getWindowManager() );
if( wi != 0 )
{
// Arm manipulation controls
m_pane = new CControllPane( wi->getParentWindow(), wxT("Screencasts manager"), wi);
if( m_pane != 0 )
{
wi->addPane( "Screencasts manager", m_pane );
wi->showPane( m_pane );
// Connect signal
m_pane->getSigChckBox().connect( boost::bind( &CButCamCast::onPublishStateChanged, this, _1) );
m_pane->getSigSave().connect( boost::bind( &CButCamCast::onSave, this, _1 ) );
}
}else{
std::cerr << "No window manager, no panes :( " << std::endl;
}
// Get node handle
ros::NodeHandle private_nh("/");
// Set parameters
// Get camera screencasting topic name
private_nh.param("rviz_screencast_topic_name", m_camCastPublisherName, CAMERA_SCREENCAST_TOPIC_NAME);
// Get timer period
private_nh.param("publishig_period", m_timerPeriod, DEFAULT_PUBLISHING_PERIOD );
// Get scene node
m_sceneNode = scene_manager_->getRootSceneNode()->createChildSceneNode();
// Create publisher
this->m_camCastPublisher = private_nh.advertise< sensor_msgs::Image >(m_camCastPublisherName, 100, false);
// Create geometry
createGeometry(private_nh);
// Create publishing timer
m_timer = private_nh.createTimer( ros::Duration(m_timerPeriod), boost::bind( &CButCamCast::onTimerPublish, this, _1) );
// Set publishing parameters
m_textureWithRtt->setFrame("/map");
}
void CapsuleMesh::setRadius(float radius)
{
if (qFuzzyCompare(radius, 1))
radius = 1.0f;
if (d->radius != radius) {
d->radius = radius;
createGeometry(true);
emit radiusChanged();
emit dataChanged();
}
}
void CapsuleMesh::setLength(float length)
{
if (qFuzzyCompare(length, 1))
length = 1.0f;
if (d->length != length) {
d->length = length;
createGeometry(true);
emit lengthChanged();
emit dataChanged();
}
}
int main(int , char **)
{
// construct the viewer.
osgViewer::Viewer viewer;
// add model to viewer.
viewer.setSceneData( createGeometry() );
// create the windows and run the threads.
return viewer.run();
}
Camera(){
//initializeaza camera
position = glm::vec3(0,0,50);
forward = glm::vec3(0,0,-1);
up = glm::vec3(0,1,0);
right = glm::vec3(1,0,0);
//creaza geometry si update
createGeometry();
updateGeometry();
}
TextSprite::TextSprite(MaterialPtr material, const std::string &text, FontPtr font, PropertiesPtr properties)
: Sprite(), _text(text), _font(font)
{
// Create geometry
createGeometry();
// Add atlas texture to the material
material->setTexture(bRenderer::DEFAULT_SHADER_UNIFORM_CHARACTER_MAP(), font->getAtlas());
setMaterial(material);
setProperties(properties);
}
void GroundPlane::prepRenderImage( SceneRenderState* state )
{
PROFILE_SCOPE( GroundPlane_prepRenderImage );
// TODO: Should we skip rendering the ground plane into
// the shadows? Its not like you can ever get under it.
if ( !mMaterial )
return;
// If we don't have a material instance after the override then
// we can skip rendering all together.
BaseMatInstance *matInst = state->getOverrideMaterial( mMaterial );
if ( !matInst )
return;
PROFILE_SCOPE( GroundPlane_prepRender );
// Update the geometry.
createGeometry( state->getCullingFrustum() );
if( mVertexBuffer.isNull() )
return;
// Add a render instance.
RenderPassManager* pass = state->getRenderPass();
MeshRenderInst* ri = pass->allocInst< MeshRenderInst >();
ri->type = RenderPassManager::RIT_Mesh;
ri->vertBuff = &mVertexBuffer;
ri->primBuff = &mPrimitiveBuffer;
ri->prim = &mPrimitive;
ri->matInst = matInst;
ri->objectToWorld = pass->allocUniqueXform( MatrixF::Identity );
ri->worldToCamera = pass->allocSharedXform( RenderPassManager::View );
ri->projection = pass->allocSharedXform( RenderPassManager::Projection );
ri->visibility = 1.0f;
ri->translucentSort = matInst->getMaterial()->isTranslucent();
ri->defaultKey = matInst->getStateHint();
if( ri->translucentSort )
ri->type = RenderPassManager::RIT_Translucent;
// If we need lights then set them up.
if ( matInst->isForwardLit() )
{
LightQuery query;
query.init( getWorldSphere() );
query.getLights( ri->lights, 8 );
}
pass->addInst( ri );
}
SGPolyLineNode::SGPolyLineNode( const QVector<QPointF>& points ) noexcept :
QSGGeometryNode{}
{
setFlag( QSGNode::OwnedByParent, true );
try {
_material = new qgl::SGPolyLineAAMaterial{};
setFlag( QSGNode::OwnsMaterial );
setMaterial( _material );
markDirty( QSGNode::DirtyMaterial );
} catch (...) { }
createGeometry(points);
}
void
TerrainTileEditable::_updateRenderQueue(Ogre::RenderQueue* queue)
{
if (mGeometryOutOfDate)
{
if (mVertexDatas.empty())
initBuffers(mOwner->getData(), mXBase, mZBase, mXSize, mZSize);
createGeometry(mOwner->getData(), mXBase, mZBase, mXSize, mZSize);
}
queueRenderables(queue, mRenderables);
}
/**
* @brief Default Constructor
*/
Sphere()
{
initGL();
resetModelMatrix();
createGeometry();
color << 1.0, 0.48, 0.16, 1.0;
sphere_shader.setShaderName("sphereShader");
sphere_shader.initializeFromStrings(sphere_vertex_code, sphere_fragment_code);
}
DebugDrawer::DebugDrawer(osg::ref_ptr<osg::Group> parentNode, btCollisionWorld *world)
: mParentNode(parentNode),
mWorld(world),
mDebugOn(true)
{
mGeode = new osg::Geode;
mParentNode->addChild(mGeode);
mGeode->setNodeMask(Mask_Debug);
createGeometry();
mParentNode->addChild(mGeode);
}
////////////////////////////////////////////////////////////////////////////////
// SoftShadowsRenderer::initRendering()
////////////////////////////////////////////////////////////////////////////////
void SoftShadowsRenderer::initRendering()
{
GLint depthBits;
glGetIntegerv(GL_DEPTH_BITS, &depthBits);
LOGI("depth bits = %d\n", depthBits);
// Setup the eye's view parameters
initCamera(
NvCameraXformType::MAIN,
nv::vec3f(-0.644995f, 0.614183f, 0.660632f) * 1.5f, // position
nv::vec3f(0.0f, 0.0f, 0.0f)); // look at point
// Setup the light's view parameters
initCamera(
NvCameraXformType::SECONDARY,
nv::vec3f(3.57088f, 6.989f, 5.19698f) * 1.5f, // position
nv::vec3f(0.0f, 0.0f, 0.0f)); // look at point
// Generate the samplers
glGenSamplers(5, m_samplers);
CHECK_GL_ERROR();
for (GLuint unit = 0; unit < NumTextureUnits; ++unit)
{
glBindSampler(unit, m_samplers[unit]);
}
// Create resources
createShadowMap();
createGeometry();
createTextures();
createShaders();
// Set states that don't change
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glDepthFunc(GL_LESS);
glCullFace(GL_BACK);
glDisable(GL_BLEND);
glClearColor(
m_backgroundColor.x,
m_backgroundColor.y,
m_backgroundColor.z,
m_backgroundColor.w);
glClearDepthf(1.0f);
for (GLuint unit = 0; unit < NumTextureUnits; ++unit)
{
glBindSampler(unit, 0);
}
}
