void Drawable::compileGLObjects(RenderInfo& renderInfo) const
{
#ifdef OSG_GL_DISPLAYLISTS_AVAILABLE
if (!renderInfo.getState()->useVertexBufferObject(_supportsVertexBufferObjects && _useVertexBufferObjects) && _useDisplayList)
{
// get the contextID (user defined ID of 0 upwards) for the
// current OpenGL context.
unsigned int contextID = renderInfo.getContextID();
// get the globj for the current contextID.
GLuint& globj = _globjList[contextID];
// call the globj if already set otherwise compile and execute.
if( globj != 0 )
{
glDeleteLists( globj, 1 );
}
globj = generateDisplayList(contextID, getGLObjectSizeHint());
glNewList( globj, GL_COMPILE );
drawInner(renderInfo);
glEndList();
}
#endif
}
void NullModel::render(const RenderInfo& info) const {
if (info.checkFlag(RENDER_TEXTURE_2D))
{
aabb_draw_solid(_aabbLocal, info.getFlags());
}
else
{
aabb_draw_wire(_aabbLocal);
}
}
void Drawable::compileGLObjects(RenderInfo& renderInfo) const
{
if (!_useDisplayList) return;
#ifdef OSG_GL_DISPLAYLISTS_AVAILABLE
// get the contextID (user defined ID of 0 upwards) for the
// current OpenGL context.
unsigned int contextID = renderInfo.getContextID();
// get the globj for the current contextID.
GLuint& globj = _globjList[contextID];
// call the globj if already set otherwise compile and execute.
if( globj != 0 )
{
glDeleteLists( globj, 1 );
}
globj = generateDisplayList(contextID, getGLObjectSizeHint());
glNewList( globj, GL_COMPILE );
if (_drawCallback.valid())
_drawCallback->drawImplementation(renderInfo,this);
else
drawImplementation(renderInfo);
glEndList();
#else
OSG_NOTICE<<"Warning: Drawable::compileGLObjects(RenderInfo&) - not supported."<<std::endl;
#endif
}
void RenderablePatchFixedWireframe::render(const RenderInfo& info) const
{
if (_tess.vertices.empty() || _tess.indices.empty()) return;
// No colour changing
glDisableClientState(GL_COLOR_ARRAY);
if (info.checkFlag(RENDER_VERTEX_COLOUR))
{
glColor3f(1, 1, 1);
}
if (_needsUpdate)
{
_needsUpdate = false;
// Create a VBO and add the vertex data
VertexBuffer_T currentVBuf;
currentVBuf.addVertices(_tess.vertices.begin(), _tess.vertices.end());
// Submit index batches
const RenderIndex* strip_indices = &_tess.indices.front();
for (std::size_t i = 0;
i < _tess.m_numStrips;
i++, strip_indices += _tess.m_lenStrips)
{
currentVBuf.addIndexBatch(strip_indices, _tess.m_lenStrips);
}
// Render all index batches
_vertexBuf.replaceData(currentVBuf);
}
_vertexBuf.renderAllBatches(GL_QUAD_STRIP);
}
// Back-end render function
void RenderablePicoSurface::render(const RenderInfo& info) const
{
// Invoke appropriate display list
if (info.checkFlag(RENDER_PROGRAM))
{
if (info.checkFlag(RENDER_VERTEX_COLOUR))
{
glCallList(_dlProgramVcol);
}
else
{
glCallList(_dlProgramNoVCol);
}
}
else
{
glCallList(_dlRegular);
}
}
//// Drawable functions ////
void DMesh::draw( RenderInfo& r) {
glPushMatrix();
glMultMatrixf(m_transform);
// Material
r.material( Drawable::m_material );
r.state( 1 + (getNormalPointer()? 2:0) + (getTexCoordPointer()?4:0) );
glVertexPointer(3, GL_FLOAT, getStride(), getVertexPointer());
glNormalPointer( GL_FLOAT, getStride(), getNormalPointer());
glTexCoordPointer(2, GL_FLOAT, getStride(), getTexCoordPointer());
// Tangents?
if(getTangentPointer() && base::Shader::current().ready()) {
base::Shader::current().AttributePointer("tangent", 3, GL_FLOAT, 0, getStride(), getTangentPointer());
}
// Draw it
if(hasIndices()) glDrawElements( getMode(), getSize(), GL_UNSIGNED_SHORT, getIndexPointer());
else glDrawArrays( getMode(), 0, getSize());
glPopMatrix();
}
// Back-end render
void MD5Surface::render(const RenderInfo& info) const
{
if (info.checkFlag(RENDER_BUMP))
{
glCallList(_lightingList);
}
else
{
glCallList(_normalList);
}
}
void RenderablePatchSolid::render(const RenderInfo& info) const
{
#ifdef PATCHES_USE_VBO
glBindBuffer(GL_ARRAY_BUFFER, _vboData);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vboIdx);
glNormalPointer(GL_DOUBLE, sizeof(ArbitraryMeshVertex), BUFFER_OFFSET(16));
glClientActiveTexture(GL_TEXTURE0);
glTexCoordPointer(2, GL_DOUBLE, sizeof(ArbitraryMeshVertex), BUFFER_OFFSET(0));
glVertexPointer(3, GL_DOUBLE, sizeof(ArbitraryMeshVertex), BUFFER_OFFSET(40));
const RenderIndex* strip_indices = 0;
for (std::size_t i = 0; i < m_tess.m_numStrips; i++, strip_indices += m_tess.m_lenStrips)
{
glDrawElements(GL_QUAD_STRIP, GLsizei(m_tess.m_lenStrips), RenderIndexTypeID, strip_indices);
}
GlobalOpenGL().assertNoErrors();
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
#else
if (m_tess.vertices.empty() || m_tess.indices.empty()) return;
if (info.checkFlag(RENDER_BUMP))
{
glVertexAttribPointerARB(11, 3, GL_DOUBLE, 0, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().normal);
glVertexAttribPointerARB(8, 2, GL_DOUBLE, 0, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().texcoord);
glVertexAttribPointerARB(9, 3, GL_DOUBLE, 0, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().tangent);
glVertexAttribPointerARB(10, 3, GL_DOUBLE, 0, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().bitangent);
}
else
{
glNormalPointer(GL_DOUBLE, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().normal);
glTexCoordPointer(2, GL_DOUBLE, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().texcoord);
}
glVertexPointer(3, GL_DOUBLE, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().vertex);
const RenderIndex* strip_indices = &m_tess.indices.front();
for(std::size_t i = 0; i<m_tess.m_numStrips; i++, strip_indices += m_tess.m_lenStrips)
{
glDrawElements(GL_QUAD_STRIP, GLsizei(m_tess.m_lenStrips), RenderIndexTypeID, strip_indices);
}
#if defined(_DEBUG)
//RenderNormals();
#endif
#endif
}
void RenderablePatchSolid::render(const RenderInfo& info) const
{
if (_tess.vertices.empty() || _tess.indices.empty()) return;
if (!info.checkFlag(RENDER_BUMP))
{
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
// No colour changing
glDisableClientState(GL_COLOR_ARRAY);
if (info.checkFlag(RENDER_VERTEX_COLOUR))
{
glColor3f(1, 1, 1);
}
if (_needsUpdate)
{
_needsUpdate = false;
// Add vertex geometry to vertex buffer
VertexBuffer_T currentVBuf;
currentVBuf.addVertices(_tess.vertices.begin(), _tess.vertices.end());
// Submit indices
const RenderIndex* strip_indices = &_tess.indices.front();
for (std::size_t i = 0;
i < _tess.m_numStrips;
i++, strip_indices += _tess.m_lenStrips)
{
currentVBuf.addIndexBatch(strip_indices, _tess.m_lenStrips);
}
// Render all batches
_vertexBuf.replaceData(currentVBuf);
}
_vertexBuf.renderAllBatches(GL_QUAD_STRIP, info.checkFlag(RENDER_BUMP));
}
void Drawable::draw(RenderInfo& renderInfo) const
{
State& state = *renderInfo.getState();
bool useVertexArrayObject = state.useVertexArrayObject(_useVertexArrayObject);
if (useVertexArrayObject)
{
unsigned int contextID = renderInfo.getContextID();
VertexArrayState* vas = _vertexArrayStateList[contextID].get();
if (!vas)
{
_vertexArrayStateList[contextID] = vas = createVertexArrayState(renderInfo, true);
// OSG_NOTICE<<" Geometry::draw() "<<this<<", assigned _vertexArrayStateList[renderInfo.getContextID()]="<<_vertexArrayStateList[renderInfo.getContextID()].get()<<", vas="<<vas<< std::endl;
}
else
{
// vas->setRequiresSetArrays(getDataVariance()==osg::Object::DYNAMIC);
// OSG_NOTICE<<" Geometry::draw() "<<this<<", reusing _vertexArrayStateList[renderInfo.getContextID()]="<<_vertexArrayStateList[renderInfo.getContextID()].get()<<", vas="<<vas<< std::endl;
}
State::SetCurrentVertexArrayStateProxy setVASProxy(state, vas);
vas->bindVertexArrayObject();
drawInner(renderInfo);
vas->setRequiresSetArrays(getDataVariance()==osg::Object::DYNAMIC);
return;
}
// TODO, add check against whether VAO is active and supported
if (state.getCurrentVertexArrayState()) state.getCurrentVertexArrayState()->bindVertexArrayObject();
#ifdef OSG_GL_DISPLAYLISTS_AVAILABLE
if (!state.useVertexBufferObject(_supportsVertexBufferObjects && _useVertexBufferObjects) && _useDisplayList)
{
// get the contextID (user defined ID of 0 upwards) for the
// current OpenGL context.
unsigned int contextID = renderInfo.getContextID();
// get the globj for the current contextID.
GLuint& globj = _globjList[contextID];
if( globj == 0 )
{
// compile the display list
globj = generateDisplayList(contextID, getGLObjectSizeHint());
glNewList( globj, GL_COMPILE );
drawInner(renderInfo);
glEndList();
}
// call the display list
glCallList( globj);
}
else
#endif
{
// if state.previousVertexArrayState() is different than currentVertexArrayState bind current
// OSG_NOTICE<<"Fallback drawInner()........................"<<std::endl;
drawInner(renderInfo);
}
}
void Model::render(const RenderInfo& info) {
if (info.renderMode() == RenderInfo::SHADOW) {
if (!shadow_cast_) {
return;
}
current_shader_ = simple_shader_;
} else {
current_shader_ = model_shader_;
}
auto& meshes = mesh_->meshes();
auto& info_matrix = info.transform();
for (int i = 0; i < meshes.size(); ++i) {
auto& mesh = meshes.at(i);
cross::RenderSystem::resetBufferBind();
mesh->bind();
// 親の姿勢行列にメッシュの姿勢行列を掛けて最終的な行列を作成
Mtx44 transform = info_matrix * mesh->matrix();
current_shader_->use();
current_shader_->setUniform(SHADER_UNIF_PMV, transform);
current_shader_->setUniform(SHADER_UNIF_SAMPLER, 0);
current_shader_->setUniform(SHADER_UNIF_SHADOW_SAMPLER, 1);
bool draw_flag = info.renderMode() == RenderInfo::SHADOW ? false : true;
// シェーダに描画フラグ設定
current_shader_->setUniform("draw_flag", draw_flag);
current_shader_->setUniform("draw_shadow", shadow_receive_);
// 影用行列生成
Mtx44 shadow_bias;
Mtx44::makeShadowBias(shadow_bias);
Mtx44 shadow_mtx;
shadow_mtx = shadow_bias * info.projMatrix()* info.lightMatrix();
current_shader_->setUniform(SHADER_UNIF_SHADOW_MTX, shadow_mtx);
// 頂点設定
current_shader_->bindAttributeLocation(0, SHADER_ATTR_POSITION);
// 法線設定
current_shader_->bindAttributeLocation(1, SHADER_ATTR_NORMAL);
// UV設定
current_shader_->bindAttributeLocation(2, SHADER_ATTR_UV);
// 出力カラー設定
current_shader_->bindFragmentDataLocation(0, SHADER_OUT_COLOR);
auto& material = mesh->material();
if (material) {
// マテリアルを持っているので設定
auto& model_texture = material->diffuseMap();
// テクスチャを設定
if (model_texture) {
cross::RenderSystem::setActiveTextureUnit(
cross::RenderSystem::TextureUnit::UNIT0
);
model_texture->bind();
current_shader_->setUniform(SHADER_UNIF_USE_TEXTURE_FLAG, true);
} else {
current_shader_->setUniform(SHADER_UNIF_USE_TEXTURE_FLAG, false);
}
// カラー設定
const auto& diffuse = material->diffuse();
current_shader_->setUniform(SHADER_UNIF_COLOR_DIFFUSE, diffuse.redFloat(), diffuse.greenFloat(), diffuse.blueFloat(), diffuse.alphaFloat());
}
cross::RenderSystem::setActiveTextureUnit(
cross::RenderSystem::TextureUnit::UNIT1
);
auto& shadow_texture = info.shadowTexture();
if (shadow_texture) {
shadow_texture->bind();
}
cross::RenderSystem::setCullingMode(culling_mode_);
cross::RenderSystem::drawElements(
cross::RenderSystem::DrawMode::MODE_TRIANGLES,
mesh->indexCount(),
sizeof(uint32_t)
);
mesh->unbind();
}
}
void ComputeDispatch::drawImplementation(RenderInfo& renderInfo) const
{
renderInfo.getState()->get<GLExtensions>()->glDispatchCompute(_numGroupsX, _numGroupsY, _numGroupsZ);
}
void Winding::render(const RenderInfo& info) const
{
// Do not render if there are no points
if (empty())
{
return;
}
// Our vertex colours are always white, if requested
glDisableClientState(GL_COLOR_ARRAY);
if (info.checkFlag(RENDER_VERTEX_COLOUR))
{
glColor3f(1, 1, 1);
}
// A shortcut pointer to the first array element to avoid
// massive calls to std::vector<>::begin()
const WindingVertex& firstElement = front();
// Set the vertex pointer first
glVertexPointer(3, GL_DOUBLE, sizeof(WindingVertex), &firstElement.vertex);
// Check render flags. Multiple flags may be set, so the order matters.
if (info.checkFlag(RENDER_TEXTURE_CUBEMAP))
{
// In cube-map mode, we submit the vertex coordinate as the texture
// coordinate. The RenderSystem will set the appropriate texture matrix
// etc.
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(
3, GL_DOUBLE, sizeof(WindingVertex), &firstElement.vertex
);
}
else if (info.checkFlag(RENDER_BUMP))
{
// Lighting mode, submit normals, tangents and texcoords to the shader
// program.
glVertexAttribPointer(
ATTR_NORMAL, 3, GL_DOUBLE, 0, sizeof(WindingVertex), &firstElement.normal
);
glVertexAttribPointer(
ATTR_TEXCOORD, 2, GL_DOUBLE, 0, sizeof(WindingVertex), &firstElement.texcoord
);
glVertexAttribPointer(
ATTR_TANGENT, 3, GL_DOUBLE, 0, sizeof(WindingVertex), &firstElement.tangent
);
glVertexAttribPointer(
ATTR_BITANGENT, 3, GL_DOUBLE, 0, sizeof(WindingVertex), &firstElement.bitangent
);
}
else
{
// Submit normals in lighting mode
if (info.checkFlag(RENDER_LIGHTING))
{
glNormalPointer(GL_DOUBLE, sizeof(WindingVertex), &firstElement.normal);
}
// Set texture coordinates in 2D texture mode
if (info.checkFlag(RENDER_TEXTURE_2D))
{
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(
2, GL_DOUBLE, sizeof(WindingVertex), &firstElement.texcoord
);
}
}
// Submit all data to OpenGL
glDrawArrays(GL_POLYGON, 0, GLsizei(size()));
}
void PanoDrawable::drawImplementation(RenderInfo& ri) const
{
if(ComController::instance()->isMaster() && !_renderOnMaster)
{
return;
}
int context = ri.getContextID();
_initLock.lock();
if(badinit)
{
if(_doDelete)
{
if(_contextinit[ri.getContextID()] > 0)
{
for(int i = 0; i < rows; i++)
{
for(int j = 0; j < cols; j++)
{
if(_contextinit[ri.getContextID()] & RIGHT)
{
glDeleteTextures(1, rtextures[context][i][j]);
delete rtextures[context][i][j];
}
if(_contextinit[ri.getContextID()] & LEFT)
{
glDeleteTextures(1, ltextures[context][i][j]);
delete ltextures[context][i][j];
}
}
}
_contextinit[ri.getContextID()] = -1;
}
bool tempb = true;
for(map<int, int>::iterator it = _contextinit.begin(); it != _contextinit.end(); it++)
{
if(it->second > 0)
{
tempb = false;
}
}
_deleteDone = tempb;
}
_initLock.unlock();
return;
}
/*string host;
int vx, vy, context;
context = ri.getContextID();
vx = (int)ri.getCurrentCamera()->getViewport()->x();
vy = (int)ri.getCurrentCamera()->getViewport()->y();
char hostname[51];
gethostname(hostname, 50);
host = hostname;*/
int eye = 0;
if(!getNumParents())
{
_initLock.unlock();
return;
}
osg::Node::NodeMask nm = getParent(0)->getNodeMask();
//std::cerr << "Node Mask: " << nm << std::endl;
if((nm & CULL_MASK) || (nm & CULL_MASK_LEFT) )
{
//std::cerr << "LEFT" << std::endl;
if(ScreenBase::getEyeSeparation() >= 0.0)
{
eye = LEFT;
}
else
{
eye = RIGHT;
}
}
else
{
//std::cerr << "RIGHT" << std::endl;
if(ScreenBase::getEyeSeparation() >= 0.0)
{
eye = RIGHT;
}
else
{
eye = LEFT;
}
}
if(_contextinit[ri.getContextID()] >= 0)
{
if(!(_contextinit[ri.getContextID()] & eye))
{
_initLock.unlock();
bool val = initTexture((PanoDrawable::eye)eye, context);
_initLock.lock();
if(val)
{
_contextinit[ri.getContextID()] |= eye;
}
else
{
badinit = 1;
_initLock.unlock();
return;
}
}
}
if(_doDelete)
{
if(_contextinit[ri.getContextID()] > 0)
{
for(int i = 0; i < rows; i++)
{
for(int j = 0; j < cols; j++)
{
if(_contextinit[ri.getContextID()] & RIGHT)
{
glDeleteTextures(1, rtextures[context][i][j]);
delete rtextures[context][i][j];
}
if(_contextinit[ri.getContextID()] & LEFT)
{
glDeleteTextures(1, ltextures[context][i][j]);
delete ltextures[context][i][j];
}
}
}
_contextinit[ri.getContextID()] = -1;
}
bool tempb = true;
for(map<int, int>::iterator it = _contextinit.begin(); it != _contextinit.end(); it++)
{
if(it->second > 0)
{
tempb = false;
}
}
_deleteDone = tempb;
_initLock.unlock();
return;
}
_initLock.unlock();
_rcLock.lock();
drawShape((PanoDrawable::eye)eye, context);
_rcLock.unlock();
}
bool BufferInfo::AddMesh(Mesh * mesh, GLenum drawType,VertexFormats vertFormat)
{
if (m_isFull) return false;
//int id = m_id;
if (mesh == nullptr)
{
printf("Mesh is nullptr\n");
return false;
}
GLsizei totalIndexSizeBytes = mesh->GetIndexSizeInBytes();
GLsizei numIndices = mesh->GetNumIndices();
GLsizei numVerts = mesh->GetNumVerts();
GLsizei totalVertSizeBytes = mesh->GetVertSizeInBytes();
GLsizei indexOffsetBytes = 0;
GLsizei vertOffset = 0;
GLsizei vertByteOffset = 0;
RenderInfo * meshRenderInfo = mesh->GetRenderInfo();
if (m_sizeOfVerts + totalVertSizeBytes > m_vertexBufferSize || m_sizeOfIndices + totalIndexSizeBytes > m_vertexBufferSize) {
if (m_hasData)
{
m_isFull = true;
return false;
}
else
{
totalVertSizeBytes = m_vertexBufferSize = totalVertSizeBytes;
totalIndexSizeBytes = m_indexBufferSize = totalIndexSizeBytes;
m_isFull = true;
}
}
if (!m_hasData)
{
CreateBuffers();
}
//glBindBuffer(GL_ARRAY_BUFFER, m_vertBufferID);
//glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBufferID);
//printf("\n\n\n\n\n\n\nAddMesh: INDEX SIZE ENUM Retrieved: %d\n\n\n\n\n\n", mesh->m_renderInfo.m_isb);
if (m_headRenderInfoPtr == nullptr)
{
m_headRenderInfoPtr = &mesh->m_renderInfo;
indexOffsetBytes = 0;
vertOffset = 0;
meshRenderInfo->m_vertOffset = 0;
meshRenderInfo->SetRenderInfo(m_vertBufferID, m_indexBufferID, totalIndexSizeBytes, indexOffsetBytes, numIndices, numVerts, vertOffset, true, nullptr, drawType, vertFormat);
m_tailRenderInfoPtr = meshRenderInfo;
}
else
{
//meshRenderInfo = mesh->GetRenderInfo();
GetCurrentOffsets(&indexOffsetBytes, &vertOffset);
meshRenderInfo->m_vertOffset = vertOffset;
meshRenderInfo->SetRenderInfo(m_vertBufferID, m_indexBufferID, totalIndexSizeBytes, indexOffsetBytes, numIndices, numVerts, vertOffset,true,nullptr, drawType,vertFormat);
//meshRenderInfo->SetIndexSizeEnum(mesh->GetIndexSizeEnum());
m_headRenderInfoPtr->SetNextRenderInfoPtr(m_tailRenderInfoPtr);
m_tailRenderInfoPtr = meshRenderInfo;
}
//----------------------IMPORTANT?-----------------------------
meshRenderInfo->SetIndexSizeEnum(mesh->GetIndexSizeEnum());
//-------------------------------------------------------------
meshRenderInfo->m_vertBufferID = m_vertBufferID;
meshRenderInfo->m_indBufferID = m_indexBufferID;
vertByteOffset = vertOffset * mesh->GetStride();
if (mesh->m_renderInfo.m_stride == 0)mesh->m_renderInfo.m_stride = mesh->GetStride();
//mesh->m_renderInfo.m_draw_mode = drawType;
//mesh->m_renderInfo.m_vertexFormat = vertFormat;
//mesh->m_renderInfo.m_vertexFormat =
InsertVertexSubBuffer(m_vertBufferID, mesh, vertByteOffset);
if (mesh->m_renderInfo.m_indexed)
{
InsertIndexSubBuffer(m_indexBufferID, mesh, indexOffsetBytes);
}
//InsertIndexSubBuffer
//GLsizei indexSize, GLsizei indexOffsetBytes, GLsizei numIndices, GLsizei numVerts, bool enabled = true, RenderInfo * nextPtr = nullpt
//Log stats
GameLogger::Log(LogMsgType::cInfo, "--------BufferInfo::AddMesh() Added mesh successfully-------");
GameLogger::Log(LogMsgType::cInfo, "");
GameLogger::Log(LogMsgType::cInfo, "--------------------| START BUFFER MESH INFO |-------------------------------------");
GameLogger::Log(LogMsgType::cInfo, "BufferInfo::AddMesh(): NUM VERTS-----------------[%u]", numVerts);
GameLogger::Log(LogMsgType::cInfo, "BufferInfo::AddMesh(): NUM INDICES---------------[%u]", numIndices);
GameLogger::Log(LogMsgType::cInfo, "BufferInfo::AddMesh(): VERT OFFSET---------------[%u]", mesh->GetRenderInfo()->m_vertOffset);
GameLogger::Log(LogMsgType::cInfo, "BufferInfo::AddMesh(): INDICES OFFSET (BYTES)----[%u]", mesh->GetRenderInfo()->m_indexOffsetBytes);
GameLogger::Log(LogMsgType::cInfo, "--------------------| END BUFFER MESH INFO |--------------------------------------");
GameLogger::Log(LogMsgType::cInfo, "\n");
//void * t_buff = mesh->m_mesh;
/*GLfloat * m_buffer = new GLfloat[500];
glGetBufferSubData(GL_ARRAY_BUFFER, (GLintptr)0, 500, m_buffer);
for (int j = 0; j < 500; j++)
{
printf("Val[%d]: %f\n",j ,*m_buffer);
++m_buffer;
}
delete[] m_buffer;
*/
m_hasData = true;
return true;
}
void RenderablePatchWireframe::render(const RenderInfo& info) const
{
// No colour changing
glDisableClientState(GL_COLOR_ARRAY);
if (info.checkFlag(RENDER_VERTEX_COLOUR))
{
glColor3f(1, 1, 1);
}
if (_tess.vertices.empty()) return;
if (_needsUpdate)
{
_needsUpdate = false;
const std::vector<ArbitraryMeshVertex>& patchVerts = _tess.vertices;
// Vertex buffer to receive and render vertices
VertexBuffer_T currentVBuf;
std::size_t firstIndex = 0;
for (std::size_t i = 0; i <= _tess.curveTreeV.size(); ++i)
{
currentVBuf.addBatch(patchVerts.begin() + firstIndex,
_tess.m_nArrayWidth);
if (i == _tess.curveTreeV.size()) break;
if (!_tess.curveTreeV[i]->isLeaf())
{
currentVBuf.addBatch(
patchVerts.begin() + GLint(_tess.curveTreeV[i]->index),
_tess.m_nArrayWidth
);
}
firstIndex += (_tess.arrayHeight[i] * _tess.m_nArrayWidth);
}
const ArbitraryMeshVertex* p = &patchVerts.front();
std::size_t uStride = _tess.m_nArrayWidth;
for (std::size_t i = 0; i <= _tess.curveTreeU.size(); ++i)
{
currentVBuf.addBatch(p, _tess.m_nArrayHeight, uStride);
if (i == _tess.curveTreeU.size()) break;
if (!_tess.curveTreeU[i]->isLeaf())
{
currentVBuf.addBatch(
patchVerts.begin() + _tess.curveTreeU[i]->index,
_tess.m_nArrayHeight, uStride
);
}
p += _tess.arrayWidth[i];
}
// Render all vertex batches
_vertexBuf.replaceData(currentVBuf);
}
_vertexBuf.renderAllBatches(GL_LINE_STRIP);
}
//-------------------------------------------------------
RenderCapabilitiesUPtr RenderCapabilities::Create(const RenderInfo& renderInfo) noexcept
{
return RenderCapabilitiesUPtr(new RenderCapabilities(renderInfo.IsShadowMappingSupported(), renderInfo.IsDepthTextureSupported(), renderInfo.IsMapBufferSupported(),
renderInfo.IsHighPrecisionFloatsSupported(), renderInfo.GetMaxTextureSize(), renderInfo.GetNumTextureUnits()));
}
void coVolumeDrawable::drawImplementation(RenderInfo &renderInfo) const
{
vvDebugMsg::msg(3, "coVolumeDrawable::drawImplementation()");
const unsigned ctx = renderInfo.getState()->getContextID();
while (ctx >= contextState.size())
{
// this will delete the old renderer contextState.resize(ctx+1);
ContextState *nc = new ContextState;
contextState.push_back(nc);
}
vvRenderer *&renderer = contextState[ctx]->renderer;
if (vd && !renderer)
{
// Debug level value may be either [NO_MESSAGES|FEW_MESSAGES|MOST_MESSAGES|ALL_MESSAGES]
// Or, in the same order and meaning the same as the string equivalents [0|1|2|3]
bool debugLevelExists = false;
const int debugLevelInt = covise::coCoviseConfig::getInt("COVER.Plugin.Volume.DebugLevel", 0, &debugLevelExists);
if (debugLevelExists)
{
if ((debugLevelInt >= 0) && (debugLevelInt <= 9))
{
vvDebugMsg::setDebugLevel(debugLevelInt);
}
else
{
// In that case, the debug level was specified as a string literal
std::string debugLevelStr = covise::coCoviseConfig::getEntry("COVER.Plugin.Volume.DebugLevel");
if (!debugLevelStr.empty())
{
if (strcasecmp(debugLevelStr.c_str(), "NO_MESSAGES") == 0)
{
vvDebugMsg::setDebugLevel(vvDebugMsg::NO_MESSAGES);
}
else if (strcasecmp(debugLevelStr.c_str(), "FEW_MESSAGES") == 0)
{
vvDebugMsg::setDebugLevel(vvDebugMsg::FEW_MESSAGES);
}
else if (strcasecmp(debugLevelStr.c_str(), "MOST_MESSAGES") == 0)
{
vvDebugMsg::setDebugLevel(vvDebugMsg::MOST_MESSAGES);
}
else if (strcasecmp(debugLevelStr.c_str(), "ALL_MESSAGES") == 0)
{
vvDebugMsg::setDebugLevel(vvDebugMsg::ALL_MESSAGES);
}
}
}
}
bool imageScalingExists = false;
const bool useOffscreenBuffer = covise::coCoviseConfig::isOn("imageScaling", "COVER.Plugin.Volume.Renderer", false, &imageScalingExists);
bool numGPUSlavesExists = false;
const char **displayNames = NULL;
virvo::BufferPrecision multiGpuPrecision = virvo::Short;
const int numGPUSlaves = covise::coCoviseConfig::getInt("COVER.Plugin.Volume.MultiGPU.NumSlaves", -1, &numGPUSlavesExists);
std::vector<const char *> hostnames;
std::vector<int> ports;
std::vector<const char *> alternativeFilenames;
const bool useMultiGPU = numGPUSlavesExists;
if (useMultiGPU)
{
// Buffer precision for multi gpu rendering slaves.
// As with debug level. May either be [BYTE|SHORT|FLOAT]
// or equivalently [8|16|32]
bool bufferPrecisionExists;
const int precisionInt = covise::coCoviseConfig::getInt("COVER.Plugin.Volume.MultiGPU.BufferPrecision", 16, &bufferPrecisionExists);
if (bufferPrecisionExists)
{
if ((precisionInt == 8) || (precisionInt == 16) || (precisionInt == 32))
{
if (precisionInt == 8)
multiGpuPrecision = virvo::Byte;
else if (precisionInt == 16)
multiGpuPrecision = virvo::Short;
else
multiGpuPrecision = virvo::Float;
}
else
{
// In that case, the buffer precision was specified as a string literal
std::string precisionStr = covise::coCoviseConfig::getEntry("COVER.Plugin.Volume.MultiGPU.BufferPrecision");
if (strcasecmp(precisionStr.c_str(), "BYTE") == 0)
{
multiGpuPrecision = virvo::Byte;
}
else if (strcasecmp(precisionStr.c_str(), "SHORT") == 0)
{
multiGpuPrecision = virvo::Short;
}
else if (strcasecmp(precisionStr.c_str(), "FLOAT") == 0)
{
multiGpuPrecision = virvo::Float;
}
}
}
displayNames = new const char *[numGPUSlaves];
for (int i = 0; i < numGPUSlaves; ++i)
{
std::stringstream disp;
disp << "COVER.Plugin.Volume.MultiGPU.GPU:";
disp << i;
std::string entry = covise::coCoviseConfig::getEntry("display", disp.str());
#ifdef VERBOSE
cerr << "Use additional GPU for rendering on display: " << entry << endl;
#endif
char *cstr = new char[strlen(entry.c_str()) + 1];
strncpy(cstr, entry.c_str(), strlen(entry.c_str()));
displayNames[i] = cstr;
}
}
renderer = vvRendererFactory::create(vd, renderState, geoType.c_str(), voxType.c_str());
if (renderer)
{
renderer->setParameter(vvRenderer::VV_OFFSCREENBUFFER, useOffscreenBuffer);
}
}
// if a renderer exists, process regular rendering procedure
if (renderer)
{
for (std::vector<vvRenderState::ParameterType>::iterator it = contextState[ctx]->parameterChanges.begin();
it != contextState[ctx]->parameterChanges.end();
++it)
{
renderer->setParameter(*it, renderState.getParameter(*it));
}
contextState[ctx]->parameterChanges.clear();
if (contextState[ctx]->applyTF)
{
renderer->updateTransferFunction();
contextState[ctx]->applyTF = false;
}
ref_ptr<StateSet> currentState = new StateSet;
renderInfo.getState()->captureCurrentState(*currentState);
renderInfo.getState()->pushStateSet(currentState.get());
renderer->setCurrentFrame(currentFrame);
//renderer->setQuality(quality);
renderer->setViewingDirection(viewDir);
renderer->setObjectDirection(objDir);
renderer->renderFrame();
renderInfo.getState()->popStateSet();
}
else
{
//cerr << "vd==NULL" << endl;
}
}
