void frameDraw( const eq::uint128_t& )
{
applyCamera();
initializeLivreFrustum();
requestData();
const eq::fabric::Viewport& vp = _channel->getViewport( );
const Viewport viewport( vp.x, vp.y, vp.w, vp.h );
_renderViewPtr->setViewport( viewport );
livre::Node* node = static_cast< livre::Node* >( _channel->getNode( ));
livre::Window* window = static_cast< livre::Window* >( _channel->getWindow( ));
AvailableSetGenerator generateSet( node->getDashTree( ),
window->getTextureCache( ));
_frameInfo.clear();
generateSet.generateRenderingSet( _currentFrustum, _frameInfo );
EqRenderViewPtr renderViewPtr =
boost::static_pointer_cast< EqRenderView >( _renderViewPtr );
RayCastRendererPtr renderer =
boost::static_pointer_cast< RayCastRenderer >(
renderViewPtr->getRenderer( ));
const livre::Pipe* pipe = static_cast< const livre::Pipe* >( _channel->getPipe( ));
renderer->initTransferFunction(
pipe->getFrameData()->getRenderSettings()->getTransferFunction( ));
RenderBricks renderBricks;
generateRenderBricks( _frameInfo.renderNodes, renderBricks );
renderViewPtr->render( _frameInfo, renderBricks, *_glWidgetPtr );
}
void frameDraw( const eq::uint128_t& )
{
livre::Node* node = static_cast< livre::Node* >( _channel->getNode( ));
const DashRenderStatus& renderStatus = node->getDashTree()->getRenderStatus();
const uint32_t frame = renderStatus.getFrameID();
if( frame >= INVALID_FRAME )
return;
applyCamera();
initializeLivreFrustum();
const DashRenderNodes& visibles = requestData();
const eq::fabric::Viewport& vp = _channel->getViewport( );
const Viewport viewport( vp.x, vp.y, vp.w, vp.h );
_renderViewPtr->setViewport( viewport );
livre::Window* window = static_cast< livre::Window* >( _channel->getWindow( ));
const livre::Pipe* pipe = static_cast< const livre::Pipe* >( _channel->getPipe( ));
const bool isSynchronous = pipe->getFrameData()->getVRParameters()->getSynchronousMode();
// #75: only wait for data in synchronous mode
const bool dashTreeUpdated = window->apply( isSynchronous );
if( dashTreeUpdated )
{
const Frustum& receivedFrustum = renderStatus.getFrustum();
// If there are multiple channels, this may cause the ping-pong
// because every channel will try to update the same DashTree in
// node with their own frustum.
if( !isSynchronous && receivedFrustum != _currentFrustum )
_channel->getConfig()->sendEvent( REDRAW );
}
const AvailableSetGenerator generateSet( node->getDashTree(),
window->getTextureCache( ));
_frameInfo.clear();
for( const auto& visible : visibles )
_frameInfo.allNodes.push_back(visible.getLODNode().getNodeId());
generateSet.generateRenderingSet( _frameInfo );
EqRenderViewPtr renderViewPtr =
boost::static_pointer_cast< EqRenderView >( _renderViewPtr );
RayCastRendererPtr renderer =
boost::static_pointer_cast< RayCastRenderer >(
renderViewPtr->getRenderer( ));
renderer->update( *pipe->getFrameData( ));
RenderBricks renderBricks;
generateRenderBricks( _frameInfo.renderNodes, renderBricks );
renderViewPtr->render( _frameInfo, renderBricks, *_glWidgetPtr );
updateRegions( renderBricks );
}
void drawPhysics()
{
applyCamera();
glColor3ub(0, 255, 0);
b2Transform transform;
transform.SetIdentity();
physicsDraw_->DrawTransform(transform);
b2World *world = game_->getPhysicsService()->getWorld();
world->SetDebugDraw(physicsDraw_.get());
world->DrawDebugData();
}
void drawScene()
{
program_->create();
program_->bind();
applyCamera();
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
game_->getRenderService()->draw();
glDisable(GL_BLEND);
program_->unbind();
}
void frameDraw( const eq::uint128_t& )
{
applyCamera();
initializeLivreFrustum();
requestData();
const eq::fabric::Viewport& vp = _channel->getViewport( );
const Viewportf viewport( Vector2f( vp.x, vp.y ),
Vector2f( vp.w, vp.h ));
_renderViewPtr->setViewport( viewport );
Viewporti pixelViewport;
_glWidgetPtr->setViewport( _renderViewPtr.get( ), pixelViewport );
livre::Node* node = static_cast< livre::Node* >( _channel->getNode( ));
AvailableSetGenerator generateSet( node->getDashTree( ));
FrameInfo frameInfo( _currentFrustum );
generateSet.generateRenderingSet( _currentFrustum,
frameInfo);
EqRenderViewPtr renderViewPtr =
boost::static_pointer_cast< EqRenderView >( _renderViewPtr );
renderViewPtr->setParameters( getFrameData()->getVRParameters( ));
RayCastRendererPtr renderer =
boost::static_pointer_cast< RayCastRenderer >(
renderViewPtr->getRenderer( ));
const livre::Pipe* pipe = static_cast< const livre::Pipe* >( _channel->getPipe());
renderer->initTransferFunction(
pipe->getFrameData()->getRenderSettings()->getTransferFunction( ));
RenderBricks renderBricks;
generateRenderBricks( frameInfo.renderNodeList,
renderBricks );
renderViewPtr->render( frameInfo,
renderBricks,
*_glWidgetPtr );
}
int GLDriver::drawFaces(GeometryList *l, float timeDiff)
{
// Draw faces (type 1)
// Prepare for regular faces
glLoadIdentity();
applyCamera(camera);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
// Draw regular faces
for(int j = 0; j < l->faceCount; ++j)
{
int i = l->faces[j];
Q3Shader* shader = qmap->pMapShader[qmap->pFace[i].texture].pShader;
if(shader->getSurfaceParam() & Sky)
continue;
ShaderUtils::applyShader(shader);
std::vector<Vec3> points;
for(int stage = 1; stage <= shader->getNumberOfStages(); ++stage)
{
Q3ShaderStage* shaderStage = shader->getShaderStage(stage);
ShaderUtils::applyShaderStage(shaderStage, i);
int index = qmap->pFace[i].vertex;
int meshIndex = qmap->pFace[i].meshvert;
shaderStage->lastTcModRotate += shaderStage->tcModRotate * timeDiff / 1000;
if(shaderStage->lastTcModRotate > 360)
shaderStage->lastTcModRotate -= 360;
// Set up vertex data
// fixme - what if 2 faces are using the same shader?
shaderStage->lastTcModScrollS += shaderStage->tcModScrollSspeed * timeDiff / 1000;
shaderStage->lastTcModScrollT += shaderStage->tcModScrollTspeed * timeDiff / 1000;
glBegin(GL_TRIANGLES);
for(int currentMesh = 0; currentMesh < qmap->pFace[i].n_meshverts; ++currentMesh)
{
//int offset = //qmap->pMeshVert[meshIndex + 0].offset;
int offset = qmap->pMeshVert[meshIndex + currentMesh].offset;
glColor4ub(0xFF, 0xFF, 0xFF, 0xFF);
//GLubyte colors[4];
//memcpy(&colors, qmap->pVertex[index + offset].color, 4);
/*if(shaderStage->rgbType == Identity)
glColor4ub(0xFF, 0xFF, 0xFF, 0xFF);
else if(shaderStage->rgbType == IdentityLighting)
glColor4ub(0xFF, 0xFF, 0xFF, 0xFF);
else if(shaderStage->rgbType == Vertex)
glColor4ubv((const GLubyte*)&qmap->pVertex[index + offset]);
else if(shaderStage->rgbType == ExactVertex)
{ Trace("");}
else if(shaderStage->rgbType == OneMinusVertex)
{ Trace("");}
else
{
Trace("");
}*/
// glColor4ubv((GLubyte*)&qmap->pVertex[index + offset].color)
//if(shaderStage->alphaType == Identity)
// ;//colors[3] = 0xff;
//else
// Trace("");
//else if(shaderStage->alphaType == OneMinusVertex)
// Trace("");
//else
// colors[3] = colors[3];
//glColor4ubv((const GLubyte*)&colors);
float tx = qmap->pVertex[index + offset].texCoord.x * shaderStage->tcModScaleS;
float ty = qmap->pVertex[index + offset].texCoord.y * shaderStage->tcModScaleT;
if(shaderStage->textureName == "$lightmap")
{
tx = qmap->pVertex[index + offset].lmCoord.x * shaderStage->tcModScaleS;
ty = qmap->pVertex[index + offset].lmCoord.y * shaderStage->tcModScaleT;
}
if(abs(shaderStage->tcModScrollSspeed - -1) > 0.0001)
tx = tx + shaderStage->lastTcModScrollS;//shaderStage->tcModScrollSspeed + timeDiff / 1000;
if(abs(shaderStage->tcModScrollTspeed - -1) > 0.0001)
ty = ty + shaderStage->lastTcModScrollT;// ty = ty + f;//shaderStage->tcModScrollTspeed + timeDiff / 1000;
if(abs(shaderStage->tcModRotate - -1) > 0.0001)
{
// rotate around center of texture
if(shaderStage->textureId != -1 && shaderStage->textureId != 0)
{
float xCenter = 0.5;
float yCenter = 0.5;
float radians = Math::degreesToRadians(shaderStage->lastTcModRotate);// + f * 100);
float oldX = tx;
float oldY = ty;
tx = xCenter+ ( cos(radians) * (oldX - xCenter) - sin(radians) * (oldY - yCenter) );
ty = yCenter + ( sin(radians) * (oldX - xCenter) + cos(radians) * (oldY- yCenter) );
}
}
glTexCoord2f(tx, ty);
glVertex3f(qmap->pVertex[index + offset].position.x, qmap->pVertex[index + offset].position.y, qmap->pVertex[index + offset].position.z);
}
glEnd();
}
}
return 0;
}
int main(void) {
// Setup window and give pointer
GLFWwindow* window = windowSetup();
// Create objects
render renderMain;
shared sharedMain;
// Create access pointers
render* renderAP = &renderMain;
shared* sharedAP = &sharedMain;
setupDefaultScenario(renderAP, sharedAP);
setupGUI(window, renderAP);
// Create simulation thread
std::thread simThread(startup, sharedAP);
// Main Runtime Loop
while(!glfwWindowShouldClose(window)) {
// Clear screen before drawing
glClear(GL_COLOR_BUFFER_BIT);
sharedAP->updateControl(renderAP->getControl());
if(renderAP->getPaused()) {
updateBody(renderAP); // Update body storage from interface
// Send update to shared
sharedAP->updateBodies(renderAP->getBodies());
} else {
updateUI(renderAP); // Update interface from body store
// Get update from shared
renderAP->updateBodies(sharedAP->getBodies());
}
// Wake sim thread
sharedAP->simWait.notify_all();
// Render scene
renderAP->drawScene();
// Apply camera transform and scale
applyCamera();
// Draw GUI
TwDraw();
// Display is double buffered to prevent screen tearing
// Swap display buffers
glfwSwapBuffers(window);
// Poll and process events
glfwPollEvents();
}
// Unpause and Exit, direct to shared
sharedAP->setPaused(0);
sharedAP->setExit(1);
// Repeat sim wait notify until exit is acknowleged, directly check shared
while(sharedAP->getExit()) {
sharedAP->simWait.notify_all();
}
// Program exit
simThread.join();
// Terminate Libraries
glfwDestroyWindow(window);
glfwTerminate();
#ifdef EXITNOTE
std::cerr << "Main Exit" << std::endl;
#endif
return 0;
}
