eu07/maszyna
16
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-07-18 20:29:17 +02:00
Code Issues 121 Wiki Activity

Merge branch 'tmj-dev' into milek-dev

Browse Source
This commit is contained in:
milek7
2018-09-16 22:48:53 +02:00
parent e938466c90 e881092ca0
commit d9687a4e1f
126 changed files with 40430 additions and 6134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

165
renderer.cpp
View File

@@ -12,15 +12,15 @@ http://mozilla.org/MPL/2.0/.
#include "renderer.h"
#include "color.h"
#include "Globals.h"
#include "Camera.h"
#include "Timer.h"
#include "Train.h"
#include "simulation.h"
#include "simulationtime.h"
#include "World.h"
#include "Train.h"
#include "DynObj.h"
#include "AnimModel.h"
#include "Traction.h"
#include "uilayer.h"
#include "application.h"
#include "Logs.h"
#include "utilities.h"
@@ -128,7 +128,7 @@ opengl_renderer::Init( GLFWwindow *Window ) {
std::vector<GLint>{ m_diffusetextureunit } :
std::vector<GLint>{ m_normaltextureunit, m_diffusetextureunit } );
m_textures.assign_units( m_helpertextureunit, m_shadowtextureunit, m_normaltextureunit, m_diffusetextureunit ); // TODO: add reflections unit
UILayer.set_unit( m_diffusetextureunit );
ui_layer::set_unit( m_diffusetextureunit );
select_unit( m_diffusetextureunit );
::glDepthFunc( GL_LEQUAL );
@@ -417,7 +417,7 @@ opengl_renderer::Render() {
glBeginQuery(GL_TIME_ELAPSED, m_gltimequery);
// fetch simulation data
if( World.InitPerformed() ) {
if( simulation::is_ready ) {
m_sunlight = Global.DayLight;
// quantize sun angle to reduce shadow crawl
auto const quantizationstep { 0.004f };
@@ -429,6 +429,9 @@ opengl_renderer::Render() {
m_debugstats = debug_stats();
Render_pass( rendermode::color );
Timer::subsystem.gfx_color.stop();
// add user interface
setup_units( true, false, false );
Application.render_ui();
Timer::subsystem.gfx_swap.start();
glfwSwapBuffers( m_window );
@@ -447,10 +450,14 @@ opengl_renderer::Render() {
m_debugtimestext += "gpu: " + to_string((double)(m_gllasttime / 1000ULL) / 1000.0, 3) + "ms";
m_debugstatstext =
"drawcalls: " + to_string( m_debugstats.drawcalls )
+ "; dyn: " + to_string( m_debugstats.dynamics ) + " mod: " + to_string( m_debugstats.models ) + " sub: " + to_string( m_debugstats.submodels )
+ "; trk: " + to_string( m_debugstats.paths ) + " shp: " + to_string( m_debugstats.shapes )
+ " trc: " + to_string( m_debugstats.traction ) + " lin: " + to_string( m_debugstats.lines );
"drawcalls: " + to_string( m_debugstats.drawcalls ) + "\n"
+ " vehicles: " + to_string( m_debugstats.dynamics ) + "\n"
+ " models: " + to_string( m_debugstats.models ) + "\n"
+ " submodels: " + to_string( m_debugstats.submodels ) + "\n"
+ " paths: " + to_string( m_debugstats.paths ) + "\n"
+ " shapes: " + to_string( m_debugstats.shapes ) + "\n"
+ " traction: " + to_string( m_debugstats.traction ) + "\n"
+ " lines: " + to_string( m_debugstats.lines );
++m_framestamp;
@@ -479,7 +486,7 @@ opengl_renderer::Render_pass( rendermode const Mode ) {
if( ( true == Global.RenderShadows )
&& ( false == Global.bWireFrame )
&& ( true == World.InitPerformed() )
&& ( true == simulation::is_ready )
&& ( m_shadowcolor != colors::white ) ) {
// run shadowmaps pass before color
@@ -489,7 +496,7 @@ opengl_renderer::Render_pass( rendermode const Mode ) {
Render_pass( rendermode::cabshadows );
}
Timer::subsystem.gfx_shadows.stop();
m_debugtimestext += "shadows: " + to_string( Timer::subsystem.gfx_shadows.average(), 2 ) + " msec (" + std::to_string( m_cellqueue.size() ) + " sectors) ";
m_debugtimestext += "shadows: " + to_string( Timer::subsystem.gfx_shadows.average(), 2 ) + " msec (" + std::to_string( m_cellqueue.size() ) + " sectors)\n";
#ifdef EU07_USE_DEBUG_SHADOWMAP
UILayer.set_texture( m_shadowdebugtexture );
#endif
@@ -518,7 +525,7 @@ opengl_renderer::Render_pass( rendermode const Mode ) {
}
if( ( true == m_environmentcubetexturesupport )
&& ( true == World.InitPerformed() ) ) {
&& ( true == simulation::is_ready ) ) {
// potentially update environmental cube map
if( true == Render_reflections() ) {
setup_pass( m_renderpass, Mode ); // restore draw mode. TBD, TODO: render mode stack
@@ -527,8 +534,8 @@ opengl_renderer::Render_pass( rendermode const Mode ) {
::glViewport( 0, 0, Global.iWindowWidth, Global.iWindowHeight );
if( World.InitPerformed() ) {
auto const skydomecolour = World.Environment.m_skydome.GetAverageColor();
if( simulation::is_ready ) {
auto const skydomecolour = simulation::Environment.m_skydome.GetAverageColor();
::glClearColor( skydomecolour.x, skydomecolour.y, skydomecolour.z, 0.f ); // kolor nieba
}
else {
@@ -536,13 +543,13 @@ opengl_renderer::Render_pass( rendermode const Mode ) {
}
::glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
if( World.InitPerformed() ) {
if( simulation::is_ready ) {
// setup
setup_matrices();
// render
setup_drawing( true );
setup_units( true, false, false );
Render( &World.Environment );
Render( &simulation::Environment );
// opaque parts...
setup_drawing( false );
setup_units( true, true, true );
@@ -570,7 +577,7 @@ opengl_renderer::Render_pass( rendermode const Mode ) {
setup_shadow_map( m_cabshadowtexture, m_cabshadowtexturematrix );
// cache shadow colour in case we need to account for cab light
auto const shadowcolor { m_shadowcolor };
auto const *vehicle{ World.Train->Dynamic() };
auto const *vehicle{ simulation::Train->Dynamic() };
if( vehicle->InteriorLightLevel > 0.f ) {
setup_shadow_color( glm::min( colors::white, shadowcolor + glm::vec4( vehicle->InteriorLight * vehicle->InteriorLightLevel, 1.f ) ) );
}
@@ -591,7 +598,7 @@ opengl_renderer::Render_pass( rendermode const Mode ) {
setup_shadow_map( m_cabshadowtexture, m_cabshadowtexturematrix );
// cache shadow colour in case we need to account for cab light
auto const shadowcolor{ m_shadowcolor };
auto const *vehicle{ World.Train->Dynamic() };
auto const *vehicle{ simulation::Train->Dynamic() };
if( vehicle->InteriorLightLevel > 0.f ) {
setup_shadow_color( glm::min( colors::white, shadowcolor + glm::vec4( vehicle->InteriorLight * vehicle->InteriorLightLevel, 1.f ) ) );
}
@@ -610,13 +617,12 @@ opengl_renderer::Render_pass( rendermode const Mode ) {
::glMatrixMode( GL_MODELVIEW );
}
}
UILayer.render();
break;
}
case rendermode::shadows: {
if( World.InitPerformed() ) {
if( simulation::is_ready ) {
// setup
::glEnable( GL_POLYGON_OFFSET_FILL ); // alleviate depth-fighting
::glPolygonOffset( 1.f, 1.f );
@@ -657,7 +663,7 @@ opengl_renderer::Render_pass( rendermode const Mode ) {
case rendermode::cabshadows: {
if( ( World.InitPerformed() )
if( ( simulation::is_ready )
&& ( false == FreeFlyModeFlag ) ) {
// setup
::glEnable( GL_POLYGON_OFFSET_FILL ); // alleviate depth-fighting
@@ -685,8 +691,8 @@ opengl_renderer::Render_pass( rendermode const Mode ) {
#else
setup_units( false, false, false );
#endif
Render_cab( World.Train->Dynamic(), false );
Render_cab( World.Train->Dynamic(), true );
Render_cab( simulation::Train->Dynamic(), false );
Render_cab( simulation::Train->Dynamic(), true );
m_cabshadowpass = m_renderpass;
// post-render restore
@@ -704,7 +710,7 @@ opengl_renderer::Render_pass( rendermode const Mode ) {
::glClearColor( 0.f, 0.f, 0.f, 1.f );
::glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
if( World.InitPerformed() ) {
if( simulation::is_ready ) {
::glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE );
// setup
@@ -712,7 +718,7 @@ opengl_renderer::Render_pass( rendermode const Mode ) {
// render
setup_drawing( true );
setup_units( true, false, false );
Render( &World.Environment );
Render( &simulation::Environment );
// opaque parts...
setup_drawing( false );
setup_units( true, true, true );
@@ -734,7 +740,7 @@ opengl_renderer::Render_pass( rendermode const Mode ) {
}
case rendermode::pickcontrols: {
if( World.InitPerformed() ) {
if( simulation::is_ready ) {
// setup
#ifdef EU07_USE_PICKING_FRAMEBUFFER
::glViewport( 0, 0, EU07_PICKBUFFERSIZE, EU07_PICKBUFFERSIZE );
@@ -749,14 +755,14 @@ opengl_renderer::Render_pass( rendermode const Mode ) {
setup_drawing( false );
setup_units( false, false, false );
// cab render skips translucent parts, so we can do it here
if( World.Train != nullptr ) { Render_cab( World.Train->Dynamic() ); }
if( simulation::Train != nullptr ) { Render_cab( simulation::Train->Dynamic() ); }
// post-render cleanup
}
break;
}
case rendermode::pickscenery: {
if( World.InitPerformed() ) {
if( simulation::is_ready ) {
// setup
m_picksceneryitems.clear();
#ifdef EU07_USE_PICKING_FRAMEBUFFER
@@ -815,12 +821,12 @@ opengl_renderer::setup_pass( renderpass_config &Config, rendermode const Mode, f
Config.draw_mode = Mode;
if( false == World.InitPerformed() ) { return; }
if( false == simulation::is_ready ) { return; }
// setup draw range
switch( Mode ) {
case rendermode::color: { Config.draw_range = Global.BaseDrawRange; break; }
case rendermode::shadows: { Config.draw_range = Global.BaseDrawRange * 0.5f; break; }
case rendermode::cabshadows: { Config.draw_range = ( Global.pWorld->train()->Dynamic()->MoverParameters->ActiveCab != 0 ? 10.f : 20.f ); break; }
case rendermode::cabshadows: { Config.draw_range = ( simulation::Train->Occupied()->ActiveCab != 0 ? 10.f : 20.f ); break; }
case rendermode::reflections: { Config.draw_range = Global.BaseDrawRange; break; }
case rendermode::pickcontrols: { Config.draw_range = 50.f; break; }
case rendermode::pickscenery: { Config.draw_range = Global.BaseDrawRange * 0.5f; break; }
@@ -836,12 +842,12 @@ opengl_renderer::setup_pass( renderpass_config &Config, rendermode const Mode, f
case rendermode::color: {
// modelview
if( ( false == DebugCameraFlag ) || ( true == Ignoredebug ) ) {
camera.position() = Global.pCameraPosition;
World.Camera.SetMatrix( viewmatrix );
camera.position() = Global.pCamera.Pos;
Global.pCamera.SetMatrix( viewmatrix );
}
else {
camera.position() = Global.DebugCameraPosition;
World.DebugCamera.SetMatrix( viewmatrix );
camera.position() = Global.pDebugCamera.Pos;
Global.pDebugCamera.SetMatrix( viewmatrix );
}
// projection
auto const zfar = Config.draw_range * Global.fDistanceFactor * Zfar;
@@ -947,10 +953,10 @@ opengl_renderer::setup_pass( renderpass_config &Config, rendermode const Mode, f
m_sunlight.direction.x,
std::min( m_sunlight.direction.y, -0.2f ),
m_sunlight.direction.z } );
camera.position() = Global.pCameraPosition - glm::dvec3 { lightvector };
camera.position() = Global.pCamera.Pos - glm::dvec3 { lightvector };
viewmatrix *= glm::lookAt(
camera.position(),
glm::dvec3 { Global.pCameraPosition },
glm::dvec3 { Global.pCamera.Pos },
glm::dvec3 { 0.f, 1.f, 0.f } );
// projection
auto const maphalfsize { Config.draw_range * 0.5f };
@@ -973,8 +979,8 @@ opengl_renderer::setup_pass( renderpass_config &Config, rendermode const Mode, f
// modelview
camera.position() = (
( ( true == DebugCameraFlag ) && ( false == Ignoredebug ) ) ?
Global.DebugCameraPosition :
Global.pCameraPosition );
Global.pDebugCamera.Pos :
Global.pCamera.Pos );
glm::dvec3 const cubefacetargetvectors[ 6 ] = { { 1.0, 0.0, 0.0 }, { -1.0, 0.0, 0.0 }, { 0.0, 1.0, 0.0 }, { 0.0, -1.0, 0.0 }, { 0.0, 0.0, 1.0 }, { 0.0, 0.0, -1.0 } };
glm::dvec3 const cubefaceupvectors[ 6 ] = { { 0.0, -1.0, 0.0 }, { 0.0, -1.0, 0.0 }, { 0.0, 0.0, 1.0 }, { 0.0, 0.0, -1.0 }, { 0.0, -1.0, 0.0 }, { 0.0, -1.0, 0.0 } };
auto const cubefaceindex = m_environmentcubetextureface - GL_TEXTURE_CUBE_MAP_POSITIVE_X;
@@ -997,8 +1003,8 @@ opengl_renderer::setup_pass( renderpass_config &Config, rendermode const Mode, f
case rendermode::pickscenery: {
// TODO: scissor test for pick modes
// modelview
camera.position() = Global.pCameraPosition;
World.Camera.SetMatrix( viewmatrix );
camera.position() = Global.pCamera.Pos;
Global.pCamera.SetMatrix( viewmatrix );
// projection
camera.projection() *=
glm::perspective(
@@ -1436,11 +1442,8 @@ opengl_renderer::Render( world_environment *Environment ) {
::glDisable( GL_DEPTH_TEST );
::glDepthMask( GL_FALSE );
::glPushMatrix();
// skydome
Environment->m_skydome.Render();
// skydome uses a custom vbo which could potentially confuse the main geometry system. hardly elegant but, eh
gfx::opengl_vbogeometrybank::reset();
// stars
if( Environment->m_stars.m_stars != nullptr ) {
// setup
@@ -1454,7 +1457,6 @@ opengl_renderer::Render( world_environment *Environment ) {
::glPointSize( 3.f );
::glPopMatrix();
}
// celestial bodies
float const duskfactor = 1.0f - clamp( std::abs( Environment->m_sun.getAngle() ), 0.0f, 12.0f ) / 12.0f;
glm::vec3 suncolor = interpolate(
@@ -1545,30 +1547,30 @@ opengl_renderer::Render( world_environment *Environment ) {
}
::glPopAttrib();
m_sunlight.apply_angle();
m_sunlight.apply_intensity();
// clouds
if( Environment->m_clouds.mdCloud ) {
// setup
Disable_Lights();
::glEnable( GL_LIGHTING );
::glEnable( GL_LIGHT0 ); // other lights will be enabled during lights update
::glLightModelfv(
GL_LIGHT_MODEL_AMBIENT,
glm::value_ptr(
interpolate( Environment->m_skydome.GetAverageColor(), suncolor, duskfactor * 0.25f )
* interpolate( 1.f, 0.35f, Global.Overcast / 2.f ) // overcast darkens the clouds
* 2.5f // arbitrary adjustment factor
* 0.5f // arbitrary adjustment factor
) );
// render
Render( Environment->m_clouds.mdCloud, nullptr, 100.0 );
Render_Alpha( Environment->m_clouds.mdCloud, nullptr, 100.0 );
// post-render cleanup
::glLightModelfv( GL_LIGHT_MODEL_AMBIENT, glm::value_ptr( colors::none ) );
::glEnable( GL_LIGHT0 ); // other lights will be enabled during lights update
::glDisable( GL_LIGHTING );
}
m_sunlight.apply_angle();
m_sunlight.apply_intensity();
::glPopMatrix();
::glDepthMask( GL_TRUE );
::glEnable( GL_DEPTH_TEST );
@@ -1694,7 +1696,7 @@ opengl_renderer::Render( scene::basic_region *Region ) {
Update_Lights( simulation::Lights );
Render( std::begin( m_sectionqueue ), std::end( m_sectionqueue ) );
if( EditorModeFlag && FreeFlyModeFlag ) {
if( EditorModeFlag ) {
// when editor mode is active calculate world position of the cursor
// at this stage the z-buffer is filled with only ground geometry
Update_Mouse_Position();
@@ -2021,7 +2023,7 @@ opengl_renderer::Render( scene::shape_node const &Shape, bool const Ignorerange
switch( m_renderpass.draw_mode ) {
case rendermode::shadows: {
// 'camera' for the light pass is the light source, but we need to draw what the 'real' camera sees
distancesquared = Math3D::SquareMagnitude( ( data.area.center - Global.pCameraPosition ) / Global.ZoomFactor ) / Global.fDistanceFactor;
distancesquared = Math3D::SquareMagnitude( ( data.area.center - Global.pCamera.Pos ) / Global.ZoomFactor ) / Global.fDistanceFactor;
break;
}
default: {
@@ -2075,7 +2077,7 @@ opengl_renderer::Render( TAnimModel *Instance ) {
switch( m_renderpass.draw_mode ) {
case rendermode::shadows: {
// 'camera' for the light pass is the light source, but we need to draw what the 'real' camera sees
distancesquared = Math3D::SquareMagnitude( ( Instance->location() - Global.pCameraPosition ) / Global.ZoomFactor ) / Global.fDistanceFactor;
distancesquared = Math3D::SquareMagnitude( ( Instance->location() - Global.pCamera.Pos ) / Global.ZoomFactor ) / Global.fDistanceFactor;
break;
}
default: {
@@ -2123,13 +2125,13 @@ opengl_renderer::Render( TDynamicObject *Dynamic ) {
++m_debugstats.dynamics;
// setup
TSubModel::iInstance = ( size_t )Dynamic; //żeby nie robić cudzych animacji
TSubModel::iInstance = reinterpret_cast<std::uintptr_t>( Dynamic ); //żeby nie robić cudzych animacji
glm::dvec3 const originoffset = Dynamic->vPosition - m_renderpass.camera.position();
// lod visibility ranges are defined for base (x 1.0) viewing distance. for render we adjust them for actual range multiplier and zoom
float squaredistance;
switch( m_renderpass.draw_mode ) {
case rendermode::shadows: {
squaredistance = glm::length2( glm::vec3{ glm::dvec3{ Dynamic->vPosition - Global.pCameraPosition } } / Global.ZoomFactor ) / Global.fDistanceFactor;
squaredistance = glm::length2( glm::vec3{ glm::dvec3{ Dynamic->vPosition - Global.pCamera.Pos } } / Global.ZoomFactor ) / Global.fDistanceFactor;
break;
}
default: {
@@ -2175,7 +2177,7 @@ opengl_renderer::Render( TDynamicObject *Dynamic ) {
Render( Dynamic->mdModel, Dynamic->Material(), squaredistance );
if( Dynamic->mdLoad ) // renderowanie nieprzezroczystego ładunku
Render( Dynamic->mdLoad, Dynamic->Material(), squaredistance );
Render( Dynamic->mdLoad, Dynamic->Material(), squaredistance, { 0.f, Dynamic->LoadOffset, 0.f }, {} );
// post-render cleanup
m_renderspecular = false;
@@ -2225,7 +2227,7 @@ opengl_renderer::Render_cab( TDynamicObject const *Dynamic, bool const Alpha ) {
return false;
}
TSubModel::iInstance = reinterpret_cast<std::size_t>( Dynamic );
TSubModel::iInstance = reinterpret_cast<std::uintptr_t>( Dynamic );
if( ( true == FreeFlyModeFlag )
|| ( false == Dynamic->bDisplayCab )
@@ -2431,7 +2433,17 @@ opengl_renderer::Render( TSubModel *Submodel ) {
// main draw call
m_geometry.draw( Submodel->m_geometry );
/*
if( DebugModeFlag ) {
auto const & vertices { m_geometry.vertices( Submodel->m_geometry ) };
::glBegin( GL_LINES );
for( auto const &vertex : vertices ) {
::glVertex3fv( glm::value_ptr( vertex.position ) );
::glVertex3fv( glm::value_ptr( vertex.position + vertex.normal * 0.2f ) );
}
::glEnd();
}
*/
// post-draw reset
if( ( true == m_renderspecular ) && ( m_sunlight.specular.a > 0.01f ) ) {
::glMaterialfv( GL_FRONT, GL_SPECULAR, glm::value_ptr( colors::none ) );
@@ -2925,7 +2937,7 @@ opengl_renderer::Render_Alpha( TAnimModel *Instance ) {
switch( m_renderpass.draw_mode ) {
case rendermode::shadows: {
// 'camera' for the light pass is the light source, but we need to draw what the 'real' camera sees
distancesquared = Math3D::SquareMagnitude( ( Instance->location() - Global.pCameraPosition ) / Global.ZoomFactor ) / Global.fDistanceFactor;
distancesquared = Math3D::SquareMagnitude( ( Instance->location() - Global.pCamera.Pos ) / Global.ZoomFactor ) / Global.fDistanceFactor;
break;
}
default: {
@@ -2957,7 +2969,7 @@ opengl_renderer::Render_Alpha( TTraction *Traction ) {
switch( m_renderpass.draw_mode ) {
case rendermode::shadows: {
// 'camera' for the light pass is the light source, but we need to draw what the 'real' camera sees
distancesquared = Math3D::SquareMagnitude( ( Traction->location() - Global.pCameraPosition ) / Global.ZoomFactor ) / Global.fDistanceFactor;
distancesquared = Math3D::SquareMagnitude( ( Traction->location() - Global.pCamera.Pos ) / Global.ZoomFactor ) / Global.fDistanceFactor;
break;
}
default: {
@@ -3018,7 +3030,7 @@ opengl_renderer::Render_Alpha( scene::lines_node const &Lines ) {
switch( m_renderpass.draw_mode ) {
case rendermode::shadows: {
// 'camera' for the light pass is the light source, but we need to draw what the 'real' camera sees
distancesquared = Math3D::SquareMagnitude( ( data.area.center - Global.pCameraPosition ) / Global.ZoomFactor ) / Global.fDistanceFactor;
distancesquared = Math3D::SquareMagnitude( ( data.area.center - Global.pCamera.Pos ) / Global.ZoomFactor ) / Global.fDistanceFactor;
break;
}
default: {
@@ -3066,7 +3078,7 @@ opengl_renderer::Render_Alpha( TDynamicObject *Dynamic ) {
float squaredistance;
switch( m_renderpass.draw_mode ) {
case rendermode::shadows: {
squaredistance = glm::length2( glm::vec3{ glm::dvec3{ Dynamic->vPosition - Global.pCameraPosition } } / Global.ZoomFactor ) / Global.fDistanceFactor;
squaredistance = glm::length2( glm::vec3{ glm::dvec3{ Dynamic->vPosition - Global.pCamera.Pos } } / Global.ZoomFactor ) / Global.fDistanceFactor;
break;
}
default: {
@@ -3110,7 +3122,7 @@ opengl_renderer::Render_Alpha( TDynamicObject *Dynamic ) {
Render_Alpha( Dynamic->mdModel, Dynamic->Material(), squaredistance );
if( Dynamic->mdLoad ) // renderowanie nieprzezroczystego ładunku
Render_Alpha( Dynamic->mdLoad, Dynamic->Material(), squaredistance );
Render_Alpha( Dynamic->mdLoad, Dynamic->Material(), squaredistance, { 0.f, Dynamic->LoadOffset, 0.f }, {} );
// post-render cleanup
m_renderspecular = false;
@@ -3511,7 +3523,8 @@ glm::dvec3
opengl_renderer::Update_Mouse_Position() {
glm::dvec2 mousepos;
glfwGetCursorPos( m_window, &mousepos.x, &mousepos.y );
Application.get_cursor_pos( mousepos.x, mousepos.y );
// glfwGetCursorPos( m_window, &mousepos.x, &mousepos.y );
mousepos.x = clamp<int>( mousepos.x, 0, Global.iWindowWidth - 1 );
mousepos.y = clamp<int>( Global.iWindowHeight - clamp<int>( mousepos.y, 0, Global.iWindowHeight ), 0, Global.iWindowHeight - 1 ) ;
GLfloat pointdepth;
@@ -3531,7 +3544,31 @@ opengl_renderer::Update_Mouse_Position() {
void
opengl_renderer::Update( double const Deltatime ) {
/*
m_pickupdateaccumulator += Deltatime;
if( m_updateaccumulator > 0.5 ) {
m_pickupdateaccumulator = 0.0;
if( ( true == Global.ControlPicking )
&& ( false == FreeFlyModeFlag ) ) {
Update_Pick_Control();
}
else {
m_pickcontrolitem = nullptr;
}
// temporary conditions for testing. eventually will be coupled with editor mode
if( ( true == Global.ControlPicking )
&& ( true == DebugModeFlag )
&& ( true == FreeFlyModeFlag ) ) {
Update_Pick_Node();
}
else {
m_picksceneryitem = nullptr;
}
}
*/
m_updateaccumulator += Deltatime;
if( m_updateaccumulator < 1.0 ) {
@@ -3574,7 +3611,7 @@ opengl_renderer::Update( double const Deltatime ) {
}
if( ( true == Global.ResourceSweep )
&& ( true == World.InitPerformed() ) ) {
&& ( true == simulation::is_ready ) ) {
// garbage collection
m_geometry.update();
m_textures.update();