void Entity::addToRender(SceneRenderer &out, Color color) const {
//PROFILE("Entity::addToRender");
IRect rect = m_sprite.getRect(m_seq_idx, m_frame_idx, m_dir_idx);
if(!areOverlapping(out.targetRect(), rect + (int2)worldToScreen(m_pos)))
return;
FBox bbox = boundingBox() - pos();
if(shrinkRenderedBBox() && bbox.height() >= 2.0f)
bbox = {float3(bbox.x(), min(bbox.y() + 1.0f, bbox.ey() - 0.5f), bbox.z()), bbox.max()};
bool as_overlay = renderAsOverlay();
FRect tex_rect;
auto tex = m_sprite.getFrame(m_seq_idx, m_frame_idx, m_dir_idx, tex_rect);
bool added = out.add(tex, rect, m_pos, bbox, color, tex_rect, as_overlay);
if(added && m_oseq_idx != -1 && m_oframe_idx != -1) {
//TODO: overlay may be visible, while normal sprite is not!
rect = m_sprite.getRect(m_oseq_idx, m_oframe_idx, m_dir_idx);
auto ov_tex = m_sprite.getFrame(m_oseq_idx, m_oframe_idx, m_dir_idx, tex_rect);
out.add(ov_tex, rect, m_pos, bbox, color, tex_rect, true);
}
// if(findAny(boundingBox(), {Flags::all | Flags::colliding, ref()}))
// out.addBox(bbox + pos(), ColorId::red);
}
//! Drawable:: Called after drawing
void BillboardParticles::postDraw(SceneRenderer & renderer)
{
renderer.setDepthMask(true);
renderer.setBlend(false);
renderer.getProgram().disableArrayPtr("in_position");
renderer.getProgram().disableArrayPtr("in_texcoord");
renderer.getProgram().disableArrayPtr("in_color");
}
//! Drawable:: Draw one occurrence
void BillboardParticles::drawOccurrence(SceneRenderer & renderer, SceneNode & node)
{
Mat4 model_view = node.getScene().getCamera().getTransform() * node.getCachedTransformRef();
Mat4 model_view_projection = node.getScene().getCamera().getProjection() * model_view;
renderer.getProgram().setParamMat4("model_view_projection_matrix", model_view_projection);
renderer.getProgram().setVertexData(vbo.get(), current_node * sizeof(VertexTemplate) * particle_count * 4);
renderer.drawElements(GL_TRIANGLE_STRIP, particle_count * 6, ibo);
current_node++;
}
void SphereSceneNode::addShadowNodes(
SceneRenderer& renderer)
{
renderNode.setHighResolution(false);
renderNode.setBaseIndex(0);
renderer.addShadowNode(&renderNode);
}
void WorldViewer::addToRender(SceneRenderer &renderer) const {
vector<int> inds;
inds.reserve(8192);
const TileMap &tile_map = m_world->tileMap();
tile_map.findAll(inds, renderer.targetRect(), Flags::all | Flags::visible);
for(int n = 0; n < (int)inds.size(); n++)
tile_map[inds[n]].ptr->addToRender(renderer, (int3)tile_map[inds[n]].bbox.min);
for(int n = 0; n < (int)m_entities.size(); n++) {
const VisEntity &vis_entity = m_entities[n];
if(vis_entity.mode == VisEntity::invisible)
continue;
float blend_value = 1.0f;
if(vis_entity.mode == VisEntity::blending_in)
blend_value = vis_entity.blend_value / blend_time;
else if(vis_entity.mode == VisEntity::blending_out)
blend_value = 1.0f - vis_entity.blend_value / blend_time;
const Entity *entity = vis_entity.mode == VisEntity::shadowed?
vis_entity.shadow.get() : m_world->refEntity(vis_entity.ref);
if(entity && m_occluder_config.isVisible(vis_entity.occluder_id))
entity->addToRender(renderer, (IColor)FColor(1.0f, 1.0f, 1.0f, blend_value));
}
}
/**
* OpenGL display function.
*
* This function is called every 25 milliseconds by the update
* function.
*/
void glutDisplay (void)
{
/**
* Update every node of OpenNI.
*/
g_Context.WaitOneUpdateAll(g_DepthGenerator);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(40.0, 1.05, 1.0, 10000.0);
gluLookAt(320.0, -300.0, 4200.0,
320.0, 240.0, 1500.0,
0.0,-1.0, 0.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix();
// Checking fot game starting and finishing
g_SFBgame.checkUsers();
if (g_SFBgame.isGameOn()) {
g_UserDetector.changeStopDetection(true);
g_SFBgame.checkGameOver();
if (!g_SFBgame.isGameOver()) {
g_BusterDetector -> detectPose();
g_IceRodDetector -> detectPose();
}
else {
STATUS_CHECK(g_Context.StopGeneratingAll(),
"Context generation shutdown");
}
}
else {
// Detects poses
g_ZamusDetector -> detectPose();
g_LinqDetector -> detectPose();
}
/**
* Use the draw functions of every class to display the game with
* OpenGL.
*/
g_SceneRenderer.drawScene();
g_SFBgame.drawFireBalls();
g_SFBgame.drawGameInfo();
g_SFBgame.nextFrame();
glPopMatrix();
glutSwapBuffers();
}
void SphereSceneNode::addRenderNodes(
SceneRenderer& renderer)
{
const GLfloat* sphere = getSphere();
const ViewFrustum& view = renderer.getViewFrustum();
const float size = sphere[3] * view.getAreaFactor() /
getDistance(view.getEye());
const int lod = (size < 100.0f) ? 0 : 1;
renderNode.setHighResolution(lod != 0);
const GLfloat* eye = view.getEye();
const float azimuth = atan2f(sphere[1] - eye[1], eye[0] - sphere[0]);
const int numSlices = (lod == 1) ? NumSlices : SphereLowRes;
renderNode.setBaseIndex(int(float(numSlices) *
(1.0f + 0.5f * azimuth / M_PI)) % numSlices);
renderer.addRenderNode(&renderNode, &gstate);
}
namespace game
{
SceneRenderer scene;
Renderer::Renderer()
{
this->window = new WindowClass();
if (window == nullptr) throw std::string("Failed to open OpenGL context window");
logger << Log::INFO << "Opening window" << Log::ENDL;
// set window configuration
WindowConfig wndconf("Tetris", 800, 600);
wndconf.vsync = true;
// open window
window->open(wndconf);
/// initialize scene renderer ///
scene.init(*window);
}
Renderer::~Renderer()
{
if (window) delete window;
}
bool renderTetris(WindowClass& wnd, double dtime, double timeElapsed);
void Renderer::start(Game& game)
{
/// start game ///
logger << Log::INFO << "Game started" << Log::ENDL;
this->game = &game;
window->startRenderingLoop(*this, 1.0);
// close window after renderloop
window->close();
}
bool Renderer::render(WindowClass& wnd, double dtime, double time)
{
glClearColor(0.1, 0.1, 0.1, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
scene.render(*game, time, dtime);
// run the gameloop, which also can exit the game (if it returns false)
bool ret = game->gameHandler(time, dtime);
glfwSwapBuffers(wnd.window());
return ret;
}
}
bool Renderer::render(WindowClass& wnd, double dtime, double time)
{
glClearColor(0.1, 0.1, 0.1, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
scene.render(*game, time, dtime);
// run the gameloop, which also can exit the game (if it returns false)
bool ret = game->gameHandler(time, dtime);
glfwSwapBuffers(wnd.window());
return ret;
}
Renderer::Renderer()
{
this->window = new WindowClass();
if (window == nullptr) throw std::string("Failed to open OpenGL context window");
logger << Log::INFO << "Opening window" << Log::ENDL;
// set window configuration
WindowConfig wndconf("Tetris", 800, 600);
wndconf.vsync = true;
// open window
window->open(wndconf);
/// initialize scene renderer ///
scene.init(*window);
}
//! Drawable:: Called upon drawing
void BillboardParticles::preDraw(SceneRenderer & renderer)
{
renderer.useProgram("BillboardParticleShader.shader");
renderer.setDepthMask(false);
renderer.setBlend(true);
renderer.setBlendFunc(GL_SRC_ALPHA, GL_ONE);
renderer.useTexture(emitter->properties->texture);
renderer.getProgram().setVertexData(tbo.get());
current_node = 0;
}
//[-------------------------------------------------------]
//[ Private virtual PLEngine::EngineApplication functions ]
//[-------------------------------------------------------]
void Application67::OnCreateScene(SceneContainer &cContainer)
{
// Create a scene container with our 'concrete sound scene' using the default sound API
SceneNode *pSceneContainerNode = cContainer.Create("PLSound::SCSound", "SoundScene");
if (pSceneContainerNode && pSceneContainerNode->IsInstanceOf("PLScene::SceneContainer")) {
SceneContainer *pSceneContainer = static_cast<SceneContainer*>(pSceneContainerNode);
// Protect this important container!
pSceneContainer->SetProtected(true);
// Populate the scene container
// Setup scene surface painter
SurfacePainter *pPainter = GetPainter();
if (pPainter && pPainter->IsInstanceOf("PLScene::SPScene")) {
SPScene *pSPScene = static_cast<SPScene*>(pPainter);
pSPScene->SetRootContainer(cContainer.GetContainer());
pSPScene->SetSceneContainer(pSceneContainer);
// Get the scene context
SceneContext *pSceneContext = GetSceneContext();
if (pSceneContext) {
// Create us a scene renderer
SceneRenderer *pSceneRenderer = pSceneContext->GetSceneRendererManager().Create("2DGame");
if (pSceneRenderer) {
// Add begin scene renderer pass
pSceneRenderer->Create("PLCompositing::SRPBegin", "Begin", "TextureFormat=\"R8G8B8A8\" Flags=\"Inactive\"");
// Add our own scene renderer pass
pSceneRenderer->Create("SRP2DGame", "2DGame");
// Add post processing scene renderer pass
pSceneRenderer->Create("PLCompositing::SRPPostProcessing", "PostProcessing");
// Add end scene renderer pass
pSceneRenderer->Create("PLCompositing::SRPEnd", "End");
// Make this scene renderer to the default scene renderer of our scene surface painter
pSPScene->SetDefaultSceneRenderer(pSceneRenderer->GetName());
}
}
}
// Set scene container
SetScene(pSceneContainer);
// Start the game
Restart();
}
}
//--------------------------------------------------------------------------------------
// This callback function will be called immediately after the Direct3D device has
// been destroyed, which generally happens as a result of application termination or
// windowed/full screen toggles.
//--------------------------------------------------------------------------------------
void CALLBACK OnD3D11DestroyDevice(void* pUserContext)
{
DXUTTRACE(L"OnD3D11DestroyDevice called\n");
g_DialogResourceManager.OnD3D11DestroyDevice();
g_SettingsDlg.OnD3D11DestroyDevice();
DXUTGetGlobalResourceCache().OnDestroyDevice();
SAFE_DELETE(g_pTxtHelper);
g_pSceneRenderer.OnDestroyDevice();
for (int i = 0; i < ARRAYSIZE(g_MeshDesc); i++)
{
g_SceneMeshes[i].OnDestroyDevice();
}
ReleaseRenderTargets();
ReleaseDepthBuffer();
g_AORenderer.Release();
}
//--------------------------------------------------------------------------------------
// Create any D3D11 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D11CreateDevice(ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext)
{
HRESULT hr;
DXUTTRACE(L"OnD3D11CreateDevice called\n");
SetCursor(LoadCursor(0, IDC_ARROW));
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext(); // does not addref
V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice(pd3dDevice, pd3dImmediateContext) );
V_RETURN( g_SettingsDlg.OnD3D11CreateDevice(pd3dDevice) );
g_pTxtHelper = new CDXUTTextHelper(pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, g_TextLineHeight);
// Setup orbital camera
D3DXVECTOR3 vecEye(0.0f, 2.0f, 0.0f);
D3DXVECTOR3 vecAt (0.0f, 0.0f, 0.0f);
g_OrbitalCamera.SetViewParams(&vecEye, &vecAt);
g_OrbitalCamera.SetRadius(1.5f, 0.01f);
// Setup first-person camera
D3DXVECTOR3 sibenikVecEye(0.0960150138f, 0.0273544509f, -0.0185411610f);
D3DXVECTOR3 sibenikVecAt (-0.623801112f, -0.649074197f, -0.174454257f);
g_FirstPersonCamera.SetViewParams(&sibenikVecEye, &sibenikVecAt);
g_FirstPersonCamera.SetEnablePositionMovement(1);
g_FirstPersonCamera.SetScalers(0.001f, 0.05f);
// Load Scene3D.fx
g_pSceneRenderer.OnCreateDevice(pd3dDevice);
// Load meshes and bin files
LoadScenes(pd3dDevice);
GFSDK_SSAO_Status status;
status = g_AORenderer.Create(pd3dDevice);
assert(status == GFSDK_SSAO_OK);
return S_OK;
}
void TracerSceneNode::addLight(SceneRenderer& renderer)
{
renderer.addLight(light);
}
//[-------------------------------------------------------]
//[ Public virtual PLRenderer::SurfacePainter functions ]
//[-------------------------------------------------------]
void SPScene::OnPaint(Surface &cSurface)
{
// Get the used renderer
Renderer &cRenderer = GetRenderer();
// Get camera
SNCamera *pCamera = nullptr;
SceneRenderer *pSceneRenderer = nullptr;
if (m_pCameraNodeHandler->GetElement()) {
pCamera = static_cast<SNCamera*>(m_pCameraNodeHandler->GetElement());
if (pCamera)
pSceneRenderer = pCamera->GetSceneRenderer();
}
SNCamera::SetCamera(pCamera, &cRenderer);
// Check the used scene renderer
if (!pSceneRenderer)
pSceneRenderer = GetDefaultSceneRenderer();
// Check the used scene renderer
if (pSceneRenderer) {
// Get the root scene container
SceneContainer *pRootContainer = GetRootContainer();
if (pRootContainer) {
// Get the cull query
SQCull *pCullQuery = static_cast<SQCull*>(m_pCullQuery->GetElement());
if (pCullQuery) {
// Set camera (can be a null pointer)
if (pCamera) {
// Setup render query
SceneContainer *pCameraContainer = pCamera->GetContainer();
pCullQuery->SetCameraContainer((pCameraContainer && pCameraContainer->IsCell()) ? pCameraContainer : nullptr);
pCullQuery->SetCameraPosition(pCamera->GetTransform().GetPosition());
pCullQuery->SetViewFrustum(pCamera->GetFrustum(cRenderer.GetViewport()));
pCullQuery->SetProjectionMatrix(pCamera->GetProjectionMatrix(cRenderer.GetViewport()));
pCullQuery->SetViewMatrix(pCamera->GetViewMatrix());
pCullQuery->SetViewProjectionMatrix(pCullQuery->GetProjectionMatrix()*pCamera->GetViewMatrix());
} else {
// Set default states
pCullQuery->SetCameraContainer(nullptr);
pCullQuery->SetCameraPosition(Vector3::Zero);
Matrix4x4 mProj;
mProj.PerspectiveFov(static_cast<float>(90.0f*Math::DegToRad), 1.0f, 0.001f, 10000.0f);
Frustum cFrustum;
cFrustum.CreateViewPlanes(mProj, false);
pCullQuery->SetViewFrustum(cFrustum);
}
// Perform the visibility determination
pCullQuery->PerformQuery();
}
// Get the scene container (can be a null pointer)
SceneContainer *pContainer = GetSceneContainer();
// Pre all scene nodes
DrawPre(cRenderer, *pRootContainer);
// Draw all scene nodes solid
DrawSolid(cRenderer, *pRootContainer);
// Draw the scene container (if there's one)
if (pContainer && pCullQuery)
pSceneRenderer->DrawScene(cRenderer, *pCullQuery);
// Draw all scene nodes transparent
DrawTransparent(cRenderer, *pRootContainer);
// Debug all scene nodes
DrawDebug(cRenderer, *pRootContainer);
// Post all scene nodes
DrawPost(cRenderer, *pRootContainer);
}
}
}
//--------------------------------------------------------------------------------------
void RenderAOFromMesh(ID3D11Device* pd3dDevice,
ID3D11DeviceContext* pd3dImmediateContext,
ID3D11RenderTargetView* pBackBufferRTV,
SceneMesh *pMesh)
{
UINT SampleCount = g_MSAADesc[g_MSAACurrentSettings].SampleCount;
SceneViewInfo ViewInfo;
pd3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
pd3dImmediateContext->RSSetViewports(1, &g_FullViewport);
//--------------------------------------------------------------------------------------
// Clear render target and depth buffer
//--------------------------------------------------------------------------------------
float BgColor[4] = { 1.0f, 1.0f, 1.0f };
pd3dImmediateContext->ClearRenderTargetView(g_ColorRTV, BgColor);
pd3dImmediateContext->ClearDepthStencilView(g_DepthStencilDSV, D3D11_CLEAR_DEPTH, 1.0, 0);
//--------------------------------------------------------------------------------------
// Render color and depth with the Scene3D class
//--------------------------------------------------------------------------------------
pd3dImmediateContext->OMSetRenderTargets(1, &g_ColorRTV, g_DepthStencilDSV);
if (g_UseOrbitalCamera)
{
ViewInfo.WorldViewMatrix = (*g_OrbitalCamera.GetWorldMatrix()) * (*g_OrbitalCamera.GetViewMatrix());
ViewInfo.ProjectionMatrix = *g_OrbitalCamera.GetProjMatrix();
}
else
{
D3DXMATRIX WorldMatrix;
D3DXMatrixRotationX(&WorldMatrix, -D3DX_PI * 0.5f);
ViewInfo.WorldViewMatrix = WorldMatrix * (*g_FirstPersonCamera.GetViewMatrix());
ViewInfo.ProjectionMatrix = *g_FirstPersonCamera.GetProjMatrix();
}
g_pSceneRenderer.OnFrameRender(&ViewInfo, pMesh);
//--------------------------------------------------------------------------------------
// Render the SSAO
//--------------------------------------------------------------------------------------
GFSDK_SSAO_InputDepthData InputDepthData;
InputDepthData.pFullResDepthTextureSRV = g_DepthStencilSRV;
InputDepthData.pProjectionMatrix = (CONST FLOAT*)ViewInfo.ProjectionMatrix;
InputDepthData.ProjectionMatrixLayout = GFSDK_SSAO_ROW_MAJOR_ORDER;
InputDepthData.MetersToViewSpaceUnits = pMesh->GetSceneScale();
GFSDK_SSAO_Status status;
status = g_AORenderer.RenderAO(pd3dImmediateContext, &InputDepthData, &g_AOParams, g_ColorRTV);
assert(status == GFSDK_SSAO_OK);
//--------------------------------------------------------------------------------------
// Copy/resolve colors to the 1xAA backbuffer
//--------------------------------------------------------------------------------------
pd3dImmediateContext->OMSetRenderTargets(1, &pBackBufferRTV, NULL);
ID3D11Texture2D* pBackBufferTexture;
pBackBufferRTV->GetResource((ID3D11Resource**)&pBackBufferTexture);
if (SampleCount > 1)
{
pd3dImmediateContext->ResolveSubresource(pBackBufferTexture, 0, g_ColorTexture, 0, DXGI_FORMAT_R8G8B8A8_UNORM);
}
else
{
pd3dImmediateContext->CopyResource(pBackBufferTexture, g_ColorTexture);
}
SAFE_RELEASE(pBackBufferTexture);
}
void EighthDBaseSceneNode::addRenderNodes(SceneRenderer& renderer)
{
EighthDimSceneNode::addRenderNodes(renderer);
renderer.addRenderNode(&renderNode, &gstate);
}
void RadarRenderer::render(SceneRenderer& renderer,
bool blank)
{
const int ox = renderer.getWindow().getOriginX();
const int oy = renderer.getWindow().getOriginY();
float opacity = renderer.getPanelOpacity();
if ((opacity < 1.0f) && (opacity > 0.0f)) {
glScissor(ox + x - 2, oy + y - 2, w + 4, h + 4);
glColor4f(0.0f, 0.0f, 0.0f, opacity);
glRectf((float) x, (float) y, (float)(x + w), (float)(y + h));
}
glScissor(ox + x, oy + y, w, h);
LocalPlayer *myTank = LocalPlayer::getMyTank();
if (opacity == 1.0f)
{
// glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
// glClear(GL_COLOR_BUFFER_BIT);
}
if (blank)
return;
// prepare transforms
float worldSize = BZDB.eval(StateDatabase::BZDB_WORLDSIZE);
float range = BZDB.eval("displayRadarRange") * worldSize;
// when burrowed, limit radar range
if (myTank && (myTank->getFlag() == Flags::Burrow) &&
(myTank->getPosition()[2] < 0.0f)) {
#ifdef _MSC_VER
range = min(range, worldSize / 4.0f);
#else
range = std::min(range, worldSize / 4.0f);
#endif
}
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
const int xSize = renderer.getWindow().getWidth();
const int ySize = renderer.getWindow().getHeight();
const double xCenter = double(x) + 0.5 * double(w);
const double yCenter = double(y) + 0.5 * double(h);
const double xUnit = 2.0 * range / double(w);
const double yUnit = 2.0 * range / double(h);
glOrtho(-xCenter * xUnit, (xSize - xCenter) * xUnit, -yCenter * yUnit, (ySize - yCenter) * yUnit, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
OpenGLGState::resetState();
TextureManager &tm = TextureManager::instance();
int noiseTexture = tm.getTextureID( "noise" );
// if jammed then draw white noise. occasionally draw a good frame.
if (jammed && bzfrand() > decay)
{
glColor3f(1.0,1.0,1.0);
if (noiseTexture >= 0 && renderer.useQuality() > 0)
{
const int sequences = 10;
static float np[] = { 0, 0, 1, 1,
1, 1, 0, 0,
0.5f, 0.5f, 1.5f, 1.5f,
1.5f, 1.5f, 0.5f, 0.5f,
0.25f, 0.25f, 1.25f, 1.25f,
1.25f, 1.25f, 0.25f, 0.25f,
0, 0.5f, 1, 1.5f,
1, 1.5f, 0, 0.5f,
0.5f, 0, 1.5f, 1,
1.4f, 1, 0.5f, 0,
0.75f, 0.75f, 1.75f, 1.75f,
1.75f, 1.75f, 0.75f, 0.75f,
};
int noisePattern = 4 * int(floor(sequences * bzfrand()));
glEnable(GL_TEXTURE_2D);
tm.bind(noiseTexture);
glBegin(GL_QUADS);
glTexCoord2f(np[noisePattern+0],np[noisePattern+1]);
glVertex2f(-range,-range);
glTexCoord2f(np[noisePattern+2],np[noisePattern+1]);
glVertex2f( range,-range);
glTexCoord2f(np[noisePattern+2],np[noisePattern+3]);
glVertex2f( range, range);
glTexCoord2f(np[noisePattern+0],np[noisePattern+3]);
glVertex2f(-range, range);
glEnd();
glDisable(GL_TEXTURE_2D);
}
else if (noiseTexture >= 0 && BZDBCache::texture && renderer.useQuality() == 0)
{
glEnable(GL_TEXTURE_2D);
tm.bind(noiseTexture);
glBegin(GL_QUADS);
glTexCoord2f(0,0);
glVertex2f(-range,-range);
glTexCoord2f(1,0);
glVertex2f( range,-range);
glTexCoord2f(1,1);
glVertex2f( range, range);
glTexCoord2f(0,1);
glVertex2f(-range, range);
glEnd();
glDisable(GL_TEXTURE_2D);
}
if (decay > 0.015f)
decay *= 0.5f;
}
else if (myTank) // only draw if there's a local player
{
// if decay is sufficiently small then boost it so it's more
// likely a jammed radar will get a few good frames closely
// spaced in time. value of 1 guarantees at least two good
// frames in a row.
if (decay <= 0.015f)
decay = 1.0f;
else
decay *= 0.5f;
// get size of pixel in model space (assumes radar is square)
ps = 2.0f * range / GLfloat(w);
// relative to my tank
const LocalPlayer* myTank = LocalPlayer::getMyTank();
const float* pos = myTank->getPosition();
float angle = myTank->getAngle();
// draw the view angle blewow stuff
// view frustum edges
glColor3f(1.0f, 0.625f, 0.125f);
const float fovx = renderer.getViewFrustum().getFOVx();
const float viewWidth = range * tanf(0.5f * fovx);
glBegin(GL_LINE_STRIP);
glVertex2f(-viewWidth, range);
glVertex2f(0.0f, 0.0f);
glVertex2f(viewWidth, range);
glEnd();
glPushMatrix();
glRotatef(90.0f - angle * 180.0f / M_PI, 0.0f, 0.0f, 1.0f);
glPushMatrix();
glTranslatef(-pos[0], -pos[1], 0.0f);
// Redraw buildings
makeList( renderer);
// draw my shots
int maxShots = world.getMaxShots();
int i;
float muzzleHeight = BZDB.eval(StateDatabase::BZDB_MUZZLEHEIGHT);
for (i = 0; i < maxShots; i++)
{
const ShotPath* shot = myTank->getShot(i);
if (shot)
{
const float cs = colorScale(shot->getPosition()[2], muzzleHeight, BZDBCache::enhancedRadar);
glColor3f(1.0f * cs, 1.0f * cs, 1.0f * cs);
shot->radarRender();
}
}
//draw world weapon shots
WorldPlayer *worldWeapons = World::getWorld()->getWorldWeapons();
maxShots = worldWeapons->getMaxShots();
for (i = 0; i < maxShots; i++)
{
const ShotPath* shot = worldWeapons->getShot(i);
if (shot)
{
const float cs = colorScale(shot->getPosition()[2], muzzleHeight, BZDBCache::enhancedRadar);
glColor3f(1.0f * cs, 1.0f * cs, 1.0f * cs);
shot->radarRender();
}
}
// draw other tanks (and any flags on them)
// note about flag drawing. each line segment is drawn twice
// (once in each direction); this degrades the antialiasing
// but on systems that don't do correct filtering of endpoints
// not doing it makes (half) the endpoints jump wildly.
const int curMaxPlayers = world.getCurMaxPlayers();
for (i = 0; i < curMaxPlayers; i++) {
RemotePlayer* player = world.getPlayer(i);
if (!player || !player->isAlive() || ((player->getFlag() == Flags::Stealth) &&
(myTank->getFlag() != Flags::Seer)))
continue;
GLfloat x = player->getPosition()[0];
GLfloat y = player->getPosition()[1];
GLfloat z = player->getPosition()[2];
if (player->getFlag() != Flags::Null) {
glColor3fv(player->getFlag()->getColor());
drawFlagOnTank(x, y, z);
}
if (player->isPaused() || player->isNotResponding()) {
const float dimfactor = 0.4f;
const float *color = Team::getRadarColor(myTank->getFlag() ==
Flags::Colorblindness ? RogueTeam : player->getTeam());
float dimmedcolor[3];
dimmedcolor[0] = color[0] * dimfactor;
dimmedcolor[1] = color[1] * dimfactor;
dimmedcolor[2] = color[2] * dimfactor;
glColor3fv(dimmedcolor);
} else {
glColor3fv(Team::getRadarColor(myTank->getFlag() ==
Flags::Colorblindness ? RogueTeam : player->getTeam()));
}
// If this tank is hunted flash it on the radar
if (player->isHunted() && myTank->getFlag() != Flags::Colorblindness) {
if (flashTank.isOn()) {
if (!toggleTank) {
float flashcolor[3];
flashcolor[0] = 0.0f;
flashcolor[1] = 0.8f;
flashcolor[2] = 0.9f;
glColor3fv(flashcolor);
}
} else {
toggleTank = !toggleTank;
flashTank.setClock(0.2f);
}
}
drawTank(x, y, z);
}
bool coloredShot = BZDB.isTrue("coloredradarshots");
// draw other tanks' shells
maxShots = World::getWorld()->getMaxShots();
for (i = 0; i < curMaxPlayers; i++) {
RemotePlayer* player = world.getPlayer(i);
if (!player) continue;
for (int j = 0; j < maxShots; j++) {
const ShotPath* shot = player->getShot(j);
if (shot && shot->getFlag() != Flags::InvisibleBullet) {
const float *shotcolor;
if (coloredShot) {
if (myTank->getFlag() == Flags::Colorblindness)
shotcolor = Team::getRadarColor(RogueTeam);
else
shotcolor = Team::getRadarColor(player->getTeam());
const float cs = colorScale(shot->getPosition()[2],
muzzleHeight, BZDBCache::enhancedRadar);
glColor3f(shotcolor[0] * cs, shotcolor[1] * cs, shotcolor[2] * cs);
} else {
glColor3f(1.0f, 1.0f, 1.0f);
}
shot->radarRender();
}
}
}
// draw flags not on tanks.
const int maxFlags = world.getMaxFlags();
const bool drawNormalFlags = BZDB.isTrue("displayRadarFlags");
for (i = 0; i < maxFlags; i++) {
const Flag& flag = world.getFlag(i);
// don't draw flags that don't exist or are on a tank
if (flag.status == FlagNoExist || flag.status == FlagOnTank)
continue;
// don't draw normal flags if we aren't supposed to
if (flag.type->flagTeam == NoTeam && !drawNormalFlags)
continue;
// Flags change color by height
const float cs = colorScale(flag.position[2], muzzleHeight, BZDBCache::enhancedRadar);
const float *flagcolor = flag.type->getColor();
glColor3f(flagcolor[0] * cs, flagcolor[1] * cs, flagcolor[2] * cs);
drawFlag(flag.position[0], flag.position[1], flag.position[2]);
}
// draw antidote flag
const float* antidotePos =
LocalPlayer::getMyTank()->getAntidoteLocation();
if (antidotePos) {
glColor3f(1.0f, 1.0f, 0.0f);
drawFlag(antidotePos[0], antidotePos[1], antidotePos[2]);
}
// draw these markers above all others always centered
glPopMatrix();
// north marker
GLfloat ns = 0.05f * range, ny = 0.9f * range;
glColor3f(1.0f, 1.0f, 1.0f);
glBegin(GL_LINE_STRIP);
glVertex2f(-ns, ny - ns);
glVertex2f(-ns, ny + ns);
glVertex2f(ns, ny - ns);
glVertex2f(ns, ny + ns);
glEnd();
// always up
glPopMatrix();
// get size of pixel in model space (assumes radar is square)
GLfloat ps = 2.0f * range / GLfloat(w);
// forward tick
glBegin(GL_LINES);
glVertex2f(0.0f, range - ps);
glVertex2f(0.0f, range - 4.0f * ps);
glEnd();
// my tank
glColor3f(1.0f, 1.0f, 1.0f);
drawTank(0.0f, 0.0f, myTank->getPosition()[2]);
// my flag
if (myTank->getFlag() != Flags::Null) {
glColor3fv(myTank->getFlag()->getColor());
drawFlagOnTank(0.0f, 0.0f, myTank->getPosition()[2]);
}
}
// restore GL state
glPopMatrix();
}
int main(int argc, char** argv)
{
GLFWwindow* window = initGLWindow();
movement = new CameraMovement(window);
initGL();
int width, height;
glfwGetFramebufferSize(window, &width, &height);
renderer.init(width, height);
camera.init(width/(float)height, 60.f, .1f, 100.f);
camera.setCameraProjection(PROJECTION_PERSPECTIVE);
// Floor
std::shared_ptr<Mesh> floorMesh = std::make_shared<Mesh>(UnitQuad::CreateUnitQuad());
floorMesh->material.diffuse = glm::vec4(0.3f, 0.6f, 0.7f, 1.0f);
floorMesh->material.ambient = glm::vec4(0.01f, 0.01f, 0.01f, 1.0f);
floorMesh->material.specular = glm::vec4(0.1f, 0.1f, 0.1f, 1.0f);
floorMesh->material.shininess = 100.0f;
std::shared_ptr<SceneNode> floor(new SceneNode);
floor->init(floorMesh);
floor->position = glm::vec3(0.0,-1.0, 0.0);
floor->rotation = glm::rotate(glm::mat4(1.0f),-90.0f, glm::vec3(1.0, 0.0, 0.0));
floor->scale = glm::scale(glm::mat4(1.0), glm::vec3(100.0f));
LightProperties lightProperties = LightFactory::Bright(glm::vec3(1.0, 1.0, 1.0));
lightProperties.position = glm::vec4(-2.0f, 2.0f, -1.0f, 1.0);
lightProperties.direction = glm::vec4(0.0, -0.1, -1.0, 0.0);
std::shared_ptr<Light> light(new Light);
light->properties = lightProperties;
renderer.lights.push_back(light);
LightProperties lightProperties1 = LightFactory::Bright(glm::vec3(1.0, 1.0, 1.0));
lightProperties1.position = glm::vec4(4.0f, 2.0f, -3.0f, 1.0);
lightProperties1.direction = glm::vec4(-1.0, -0.1, 0.0, 0.0);
std::shared_ptr<Light> light1(new Light);
light1->properties = lightProperties1;
renderer.lights.push_back(light1);
std::string path(MODEL_PATH);
path.append("cooldragon.off");
auto node = createSceneNode(path);
node->position = glm::vec3(0.0f, 0.0f, -3.0f);
renderer.nodes.push_back(node);
renderer.nodes.push_back(floor);
std::thread first (startGui, argc, argv);
glfwSwapInterval(1); //0 to disable vsync, 1 to enable it
while (!glfwWindowShouldClose(window))
{
if(shouldFlipNormals) {
renderer.nodes[0]->mesh->flipNormals();
shouldFlipNormals = false;
}
if(shouldLoadFile) {
std::string path(MODEL_PATH);
path.append(filename);
renderer.nodes[0] = createSceneNode(path);
renderer.nodes[0]->position = glm::vec3(-2.0f, -0.5f, -3.0f);
gui->material = &renderer.nodes[0]->mesh->material;
shouldLoadFile = false;
}
updateInput(window);
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glClearColor(0.0, 0.0, 0.0, 0.0);
light->properties.position = glm::translate(glm::mat4(1.0f), glm::vec3(-2.5f + cosf(glfwGetTime()), 0.5f, -0.0f)) * glm::vec4(1.0f);
camera.position = movement->position;
camera.target = camera.position + movement->lookatDirection;
camera.update();
renderer.proj = camera.getCameraProjectionTransform();
renderer.view = camera.getCameraViewTransform();
renderer.renderScene();
glfwSwapBuffers(window);
glfwPollEvents();
}
delete movement;
glfwDestroyWindow(window);
glfwTerminate();
exit(EXIT_SUCCESS);
}
/******************************************************************************
* This is the high-level rendering function, which invokes the renderer to generate one or more
* output images of the scene. All rendering parameters are specified in the RenderSettings object.
******************************************************************************/
bool DataSet::renderScene(RenderSettings* settings, Viewport* viewport, QSharedPointer<FrameBuffer> frameBuffer, FrameBufferWindow* frameBufferWindow)
{
OVITO_CHECK_OBJECT_POINTER(settings);
OVITO_CHECK_OBJECT_POINTER(viewport);
// If the caller did not supply a frame buffer, get the default frame buffer for the output image, or create a temporary one if necessary.
if(!frameBuffer) {
if(Application::instance().guiMode()) {
OVITO_ASSERT(mainWindow());
frameBufferWindow = mainWindow()->frameBufferWindow();
frameBuffer = frameBufferWindow->frameBuffer();
}
if(!frameBuffer) {
frameBuffer.reset(new FrameBuffer(settings->outputImageWidth(), settings->outputImageHeight()));
}
}
// Get the selected scene renderer.
SceneRenderer* renderer = settings->renderer();
if(!renderer) throw Exception(tr("No renderer has been selected."));
bool wasCanceled = false;
try {
// Set up the frame buffer for the output image.
if(frameBufferWindow && frameBufferWindow->frameBuffer() != frameBuffer) {
frameBufferWindow->setFrameBuffer(frameBuffer);
frameBufferWindow->resize(frameBufferWindow->sizeHint());
}
if(frameBuffer->size() != QSize(settings->outputImageWidth(), settings->outputImageHeight())) {
frameBuffer->setSize(QSize(settings->outputImageWidth(), settings->outputImageHeight()));
frameBuffer->clear();
if(frameBufferWindow)
frameBufferWindow->resize(frameBufferWindow->sizeHint());
}
if(frameBufferWindow) {
if(frameBufferWindow->isHidden()) {
// Center frame buffer window in main window.
if(frameBufferWindow->parentWidget()) {
QSize s = frameBufferWindow->frameGeometry().size();
frameBufferWindow->move(frameBufferWindow->parentWidget()->geometry().center() - QPoint(s.width() / 2, s.height() / 2));
}
frameBufferWindow->show();
}
frameBufferWindow->activateWindow();
}
// Show progress dialog.
std::unique_ptr<QProgressDialog> progressDialog;
if(Application::instance().guiMode()) {
progressDialog.reset(new QProgressDialog(frameBufferWindow ? (QWidget*)frameBufferWindow : (QWidget*)mainWindow()));
progressDialog->setWindowModality(Qt::WindowModal);
progressDialog->setAutoClose(false);
progressDialog->setAutoReset(false);
progressDialog->setMinimumDuration(0);
progressDialog->setValue(0);
}
// Don't update viewports while rendering.
ViewportSuspender noVPUpdates(this);
// Initialize the renderer.
if(renderer->startRender(this, settings)) {
VideoEncoder* videoEncoder = nullptr;
#ifdef OVITO_VIDEO_OUTPUT_SUPPORT
QScopedPointer<VideoEncoder> videoEncoderPtr;
// Initialize video encoder.
if(settings->saveToFile() && settings->imageInfo().isMovie()) {
if(settings->imageFilename().isEmpty())
throw Exception(tr("Cannot save rendered images to movie file. Output filename has not been specified."));
videoEncoderPtr.reset(new VideoEncoder());
videoEncoder = videoEncoderPtr.data();
videoEncoder->openFile(settings->imageFilename(), settings->outputImageWidth(), settings->outputImageHeight(), animationSettings()->framesPerSecond());
}
#endif
if(settings->renderingRangeType() == RenderSettings::CURRENT_FRAME) {
// Render a single frame.
TimePoint renderTime = animationSettings()->time();
int frameNumber = animationSettings()->timeToFrame(renderTime);
if(frameBufferWindow)
frameBufferWindow->setWindowTitle(tr("Frame %1").arg(frameNumber));
if(!renderFrame(renderTime, frameNumber, settings, renderer, viewport, frameBuffer.data(), videoEncoder, progressDialog.get()))
wasCanceled = true;
}
else if(settings->renderingRangeType() == RenderSettings::ANIMATION_INTERVAL || settings->renderingRangeType() == RenderSettings::CUSTOM_INTERVAL) {
// Render an animation interval.
TimePoint renderTime;
int firstFrameNumber, numberOfFrames;
if(settings->renderingRangeType() == RenderSettings::ANIMATION_INTERVAL) {
renderTime = animationSettings()->animationInterval().start();
firstFrameNumber = animationSettings()->timeToFrame(animationSettings()->animationInterval().start());
numberOfFrames = (animationSettings()->timeToFrame(animationSettings()->animationInterval().end()) - firstFrameNumber + 1);
}
else {
firstFrameNumber = settings->customRangeStart();
renderTime = animationSettings()->frameToTime(firstFrameNumber);
numberOfFrames = (settings->customRangeEnd() - firstFrameNumber + 1);
}
numberOfFrames = (numberOfFrames + settings->everyNthFrame() - 1) / settings->everyNthFrame();
if(numberOfFrames < 1)
throw Exception(tr("Invalid rendering range: Frame %1 to %2").arg(settings->customRangeStart()).arg(settings->customRangeEnd()));
if(progressDialog)
progressDialog->setMaximum(numberOfFrames);
// Render frames, one by one.
for(int frameIndex = 0; frameIndex < numberOfFrames; frameIndex++) {
if(progressDialog)
progressDialog->setValue(frameIndex);
int frameNumber = firstFrameNumber + frameIndex * settings->everyNthFrame() + settings->fileNumberBase();
if(frameBufferWindow)
frameBufferWindow->setWindowTitle(tr("Frame %1").arg(animationSettings()->timeToFrame(renderTime)));
if(!renderFrame(renderTime, frameNumber, settings, renderer, viewport, frameBuffer.data(), videoEncoder, progressDialog.get())) {
wasCanceled = true;
break;
}
if(progressDialog && progressDialog->wasCanceled())
break;
// Go to next animation frame.
renderTime += animationSettings()->ticksPerFrame() * settings->everyNthFrame();
}
}
#ifdef OVITO_VIDEO_OUTPUT_SUPPORT
// Finalize movie file.
if(videoEncoder)
videoEncoder->closeFile();
#endif
}
// Shutdown renderer.
renderer->endRender();
if(progressDialog && progressDialog->wasCanceled())
wasCanceled = true;
}
catch(...) {
// Shutdown renderer.
renderer->endRender();
throw;
}
return !wasCanceled;
}
void TracerSceneNode::addRenderNodes(
SceneRenderer& renderer)
{
renderer.addRenderNode(&renderNode, &gstate);
}
void SphereFragmentSceneNode::addShadowNodes(
SceneRenderer& renderer)
{
renderer.addShadowNode(&renderNode);
}
static void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
renderer.updateResolution(width, height);
}
void SphereFragmentSceneNode::addRenderNodes
(SceneRenderer& renderer)
{
renderer.addRenderNode(&renderNode, &parentSphere->gstate);
}
