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

motion blur

Browse Source
This commit is contained in:
milek7
2018-07-23 01:22:36 +02:00
parent cfb066f678
commit d5ce1d57e7
32 changed files with 358 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
DynObj.cpp
View File

@@ -3304,7 +3304,12 @@ bool TDynamicObject::Update(double dt, double dt1)
dDOMoveLen = GetdMoveLen() + MoverParameters->ComputeMovement(dt, dt1, ts, tp, tmpTraction, l, r);
if( Mechanik )
Mechanik->MoveDistanceAdd( dDOMoveLen ); // dodanie aktualnego przemieszczenia
glm::dvec3 old_pos = vPosition;
Move(dDOMoveLen);
m_last_movement = glm::dvec3(vPosition) - old_pos;
if (!bEnabled) // usuwane pojazdy nie mają toru
{ // pojazd do usunięcia
bDynamicRemove = true; // sprawdzić
@@ -4596,18 +4601,15 @@ void TDynamicObject::LoadMMediaFile( std::string BaseDir, std::string TypeName,
if( GfxRenderer.Material( m_materialdata.replacable_skins[ 1 ] ).get_or_guess_opacity() == 0.0f ) {
// tekstura -1 z kanałem alfa - nie renderować w cyklu nieprzezroczystych
WriteLog("alpha");
m_materialdata.textures_alpha = 0x31310031;
}
else {
// wszystkie tekstury nieprzezroczyste - nie renderować w cyklu przezroczystych
WriteLog("opaque");
m_materialdata.textures_alpha = 0x30300030;
}
if( ( m_materialdata.replacable_skins[ 2 ] )
&& ( GfxRenderer.Material( m_materialdata.replacable_skins[ 2 ] ).get_or_guess_opacity() == 0.0f ) ) {
WriteLog("alpha");
// tekstura -2 z kanałem alfa - nie renderować w cyklu nieprzezroczystych
m_materialdata.textures_alpha |= 0x02020002;
}

6
DynObj.h
View File

@@ -177,6 +177,8 @@ private: // położenie pojazdu w świecie oraz parametry ruchu
Math3D::vector3 modelRot; // obrot pudła względem świata - do przeanalizowania, czy potrzebne!!!
TDynamicObject * ABuFindNearestObject( TTrack *Track, TDynamicObject *MyPointer, int &CouplNr );
glm::dvec3 m_last_movement;
public:
// parametry położenia pojazdu dostępne publicznie
std::string asTrack; // nazwa toru początkowego; wywalić?
@@ -604,6 +606,10 @@ private:
int RouteWish(TTrack *tr);
void DestinationSet(std::string to, std::string numer);
void OverheadTrack(float o);
glm::dvec3 get_last_movement() const
{
return m_last_movement;
}
double MED[9][8]; // lista zmiennych do debugowania hamulca ED
static std::string const MED_labels[ 8 ];

5
Globals.cpp
View File

@@ -671,6 +671,11 @@ global_settings::ConfigParse(cParser &Parser) {
Parser.getTokens( 1 );
Parser >> captureonstart;
}
else if (token == "gfx.postfx.motionblur.shutter")
{
Parser.getTokens(1);
Parser >> gfx_postfx_motionblur_shutter;
}
} while ((token != "") && (token != "endconfig")); //(!Parser->EndOfFile)
// na koniec trochę zależności
if (!bLoadTraction) // wczytywanie drutów i słupów

2
Globals.h
View File

@@ -177,6 +177,8 @@ struct global_settings {
bool dds_upper_origin = false;
bool captureonstart = true;
float gfx_postfx_motionblur_shutter = 0.01f;
// methods
void LoadIniFile( std::string asFileName );
void ConfigParse( cParser &parser );

4
Track.h
View File

@@ -124,8 +124,8 @@ private:
};
// trajektoria ruchu - opakowanie
class TTrack : public scene::basic_node {
class TTrack : public scene::basic_node
{
friend opengl_renderer;
// NOTE: temporary arrangement
friend ui_layer;

4
Traction.h
View File

@@ -19,8 +19,8 @@ http://mozilla.org/MPL/2.0/.
class TTractionPowerSource;
class TTraction : public scene::basic_node {
class TTraction : public scene::basic_node
{
friend opengl_renderer;
public: // na razie

29
gl/framebuffer.cpp
View File

@@ -55,16 +55,37 @@ void gl::framebuffer::clear(GLbitfield mask)
glClear(mask);
}
void gl::framebuffer::blit_to(framebuffer &other, int w, int h, GLbitfield mask)
void gl::framebuffer::blit_to(framebuffer &other, int w, int h, GLbitfield mask, GLenum attachment)
{
other.clear(mask);
glBindFramebuffer(GL_READ_FRAMEBUFFER, *this);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, other);
if (mask & GL_COLOR_BUFFER_BIT)
{
glReadBuffer(attachment);
glDrawBuffer(attachment);
}
glBlitFramebuffer(0, 0, w, h, 0, 0, w, h, mask, GL_NEAREST);
unbind();
}
void gl::framebuffer::blit_from(framebuffer &other, int w, int h, GLbitfield mask)
void gl::framebuffer::blit_from(framebuffer &other, int w, int h, GLbitfield mask, GLenum attachment)
{
other.blit_to(*this, w, h, mask);
other.blit_to(*this, w, h, mask, attachment);
}
void gl::framebuffer::setup_drawing(int attachments)
{
bind();
GLenum a[8] =
{
GL_COLOR_ATTACHMENT0,
GL_COLOR_ATTACHMENT1,
GL_COLOR_ATTACHMENT2,
GL_COLOR_ATTACHMENT3,
GL_COLOR_ATTACHMENT4,
GL_COLOR_ATTACHMENT5,
GL_COLOR_ATTACHMENT6,
GL_COLOR_ATTACHMENT7
};
glDrawBuffers(std::min(attachments, 8), &a[0]);
}

5
gl/framebuffer.h
View File

@@ -17,12 +17,13 @@ namespace gl
void attach(const opengl_texture &tex, GLenum location);
void attach(const cubemap &tex, int face, GLenum location);
void attach(const renderbuffer &rb, GLenum location);
void setup_drawing(int attachments);
void detach(GLenum location);
void clear(GLbitfield mask);
bool is_complete();
void blit_to(framebuffer &other, int w, int h, GLbitfield mask);
void blit_from(framebuffer &other, int w, int h, GLbitfield mask);
void blit_to(framebuffer &other, int w, int h, GLbitfield mask, GLenum attachment);
void blit_from(framebuffer &other, int w, int h, GLbitfield mask, GLenum attachment);
using bindable::bind;
static void bind(GLuint id);

2
gl/glsl_common.h
View File

@@ -43,7 +43,7 @@ namespace gl
mat3 modelviewnormal;
vec4 param[MAX_PARAMS];
vec3 velocity;
mat4 future;
float opacity;
float emission;
};

13
gl/postfx.cpp
View File

@@ -22,6 +22,11 @@ gl::postfx::postfx(const shader &s)
}
void gl::postfx::apply(opengl_texture &src, framebuffer *dst)
{
apply({&src}, dst);
}
void gl::postfx::apply(std::vector<opengl_texture *> src, framebuffer *dst)
{
if (dst)
{
@@ -33,8 +38,12 @@ void gl::postfx::apply(opengl_texture &src, framebuffer *dst)
program.bind();
vao->bind();
src.bind(0);
size_t unit = 0;
for (opengl_texture *tex : src)
tex->bind(unit++);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glDepthMask(GL_FALSE);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}

3
gl/postfx.h
View File

@@ -17,6 +17,9 @@ namespace gl
public:
postfx(const std::string &s);
postfx(const shader &s);
void attach();
void apply(opengl_texture &src, framebuffer *dst);
void apply(std::vector<opengl_texture*> src, framebuffer *dst);
};
}

4
gl/ubo.h
View File

@@ -52,7 +52,7 @@ namespace gl
glm::mat3x4 modelviewnormal;
glm::vec4 param[MAX_PARAMS];
glm::vec3 velocity;
glm::mat4 future;
float opacity;
float emission;
UBS_PAD(12);
@@ -64,7 +64,7 @@ namespace gl
}
};
static_assert(sizeof(model_ubs) == 144 + 16 * MAX_PARAMS, "bad size of ubs");
static_assert(sizeof(model_ubs) == 196 + 16 * MAX_PARAMS, "bad size of ubs");
struct light_element_ubs
{

226
renderer.cpp
View File

@@ -173,11 +173,15 @@ bool opengl_renderer::Init(GLFWwindow *Window)
m_msaa_rbc = std::make_unique<gl::renderbuffer>();
m_msaa_rbc->alloc(GL_RGB16F, Global.render_width, Global.render_height, samples);
m_msaa_rbv = std::make_unique<gl::renderbuffer>();
m_msaa_rbv->alloc(GL_RG16F, Global.render_width, Global.render_height, samples);
m_msaa_rbd = std::make_unique<gl::renderbuffer>();
m_msaa_rbd->alloc(GL_DEPTH_COMPONENT24, Global.render_width, Global.render_height, samples);
m_msaa_fb = std::make_unique<gl::framebuffer>();
m_msaa_fb->attach(*m_msaa_rbc, GL_COLOR_ATTACHMENT0);
m_msaa_fb->attach(*m_msaa_rbv, GL_COLOR_ATTACHMENT1);
m_msaa_fb->attach(*m_msaa_rbd, GL_DEPTH_ATTACHMENT);
if (!m_msaa_fb->is_complete())
@@ -186,12 +190,26 @@ bool opengl_renderer::Init(GLFWwindow *Window)
m_main_tex = std::make_unique<opengl_texture>();
m_main_tex->alloc_rendertarget(GL_RGB16F, GL_RGB, GL_FLOAT, Global.render_width, Global.render_height);
m_main_texv = std::make_unique<opengl_texture>();
m_main_texv->alloc_rendertarget(GL_RG16F, GL_RG, GL_FLOAT, Global.render_width, Global.render_height);
m_main_fb = std::make_unique<gl::framebuffer>();
m_main_fb->attach(*m_main_tex, GL_COLOR_ATTACHMENT0);
m_main_fb->attach(*m_main_texv, GL_COLOR_ATTACHMENT1);
m_main_fb->setup_drawing(2);
if (!m_main_fb->is_complete())
return false;
m_pfx = std::make_unique<gl::postfx>("tonemapping");
m_main2_tex = std::make_unique<opengl_texture>();
m_main2_tex->alloc_rendertarget(GL_RGB16F, GL_RGB, GL_FLOAT, Global.render_width, Global.render_height);
m_main2_fb = std::make_unique<gl::framebuffer>();
m_main2_fb->attach(*m_main2_tex, GL_COLOR_ATTACHMENT0);
if (!m_main2_fb->is_complete())
return false;
m_pfx_tonemapping = std::make_unique<gl::postfx>("tonemapping");
m_pfx_motionblur = std::make_unique<gl::postfx>("motionblur");
m_shadow_fb = std::make_unique<gl::framebuffer>();
m_shadow_tex = std::make_unique<opengl_texture>();
@@ -321,6 +339,8 @@ void opengl_renderer::SwapBuffers()
Timer::subsystem.gfx_swap.stop();
}
// runs jobs needed to generate graphics for specified render pass
void opengl_renderer::Render_pass(rendermode const Mode)
{
@@ -373,21 +393,30 @@ void opengl_renderer::Render_pass(rendermode const Mode)
setup_pass(m_renderpass, Mode); // restore color pass settings
setup_env_map(m_env_tex.get());
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
// setup
m_msaa_fb->bind();
m_msaa_fb->setup_drawing(2);
glViewport(0, 0, Global.render_width, Global.render_height);
glEnable(GL_DEPTH_TEST);
auto const skydomecolour = World.Environment.m_skydome.GetAverageColor();
::glClearColor(skydomecolour.x, skydomecolour.y, skydomecolour.z, 0.f); // kolor nieba
m_msaa_fb->clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// setup
setup_matrices();
// render
setup_drawing(true);
glm::mat4 future;
if (!FreeFlyModeFlag)
{
auto const *vehicle = World.Train->Dynamic();
glm::mat4 mv = OpenGLMatrices.data(GL_MODELVIEW);
future = glm::translate(mv, -glm::vec3(vehicle->get_last_movement())) * glm::inverse(mv);
}
model_ubs.future = glm::mat4();
glDebug("render environment");
scene_ubs.projection = OpenGLMatrices.data(GL_PROJECTION);
@@ -401,12 +430,15 @@ void opengl_renderer::Render_pass(rendermode const Mode)
{
glDebug("render cab opaque");
setup_shadow_map(m_cabshadows_tex.get(), m_cabshadowpass);
auto const *vehicle{World.Train->Dynamic()};
auto const *vehicle = World.Train->Dynamic();
Render_cab(vehicle, false);
}
glDebug("render opaque region");
model_ubs.future = future;
setup_shadow_map(m_shadow_tex.get(), m_shadowpass);
Render(simulation::Region);
@@ -417,6 +449,7 @@ void opengl_renderer::Render_pass(rendermode const Mode)
if (false == FreeFlyModeFlag)
{
glDebug("render translucent cab");
model_ubs.future = glm::mat4();
// cab render is performed without shadows, due to low resolution and number of models without windows :|
setup_shadow_map(m_cabshadows_tex.get(), m_cabshadowpass);
// cache shadow colour in case we need to account for cab light
@@ -427,12 +460,19 @@ void opengl_renderer::Render_pass(rendermode const Mode)
setup_shadow_map(nullptr, m_renderpass);
setup_env_map(nullptr);
m_msaa_fb->blit_to(*m_main_fb.get(), Global.render_width, Global.render_height, GL_COLOR_BUFFER_BIT);
m_main_fb->clear(GL_COLOR_BUFFER_BIT);
m_msaa_fb->blit_to(*m_main_fb.get(), Global.render_width, Global.render_height, GL_COLOR_BUFFER_BIT, GL_COLOR_ATTACHMENT0);
m_msaa_fb->blit_to(*m_main_fb.get(), Global.render_width, Global.render_height, GL_COLOR_BUFFER_BIT, GL_COLOR_ATTACHMENT1);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
model_ubs.param[0].x = m_framerate / (1.0 / Global.gfx_postfx_motionblur_shutter);
model_ubo->update(model_ubs);
m_pfx_motionblur->apply({m_main_tex.get(), m_main_texv.get()}, m_main2_fb.get());
glEnable(GL_FRAMEBUFFER_SRGB);
glViewport(0, 0, Global.iWindowWidth, Global.iWindowHeight);
m_pfx->apply(*m_main_tex, nullptr);
m_pfx_tonemapping->apply(*m_main2_tex, nullptr);
opengl_texture::reset_unit_cache();
glDisable(GL_FRAMEBUFFER_SRGB);
@@ -1322,7 +1362,7 @@ void opengl_renderer::Render(section_sequence::iterator First, section_sequence:
auto const originoffset{section->m_area.center - m_renderpass.camera.position()};
::glTranslated(originoffset.x, originoffset.y, originoffset.z);
// render
for (auto const &shape : section->m_shapes)
for (auto const &shape : section->m_shapes)
{
Render(shape, true);
}
@@ -1403,7 +1443,7 @@ void opengl_renderer::Render(cell_sequence::iterator First, cell_sequence::itera
// render
// opaque non-instanced shapes
for (auto const &shape : cell->m_shapesopaque)
for (auto const &shape : cell->m_shapesopaque)
{
Render(shape, false);
}
@@ -1424,7 +1464,7 @@ void opengl_renderer::Render(cell_sequence::iterator First, cell_sequence::itera
// render
// opaque non-instanced shapes
for (auto const &shape : cell->m_shapesopaque)
for (auto const &shape : cell->m_shapesopaque)
Render(shape, false);
// tracks
Render(std::begin(cell->m_paths), std::end(cell->m_paths));
@@ -1445,7 +1485,7 @@ void opengl_renderer::Render(cell_sequence::iterator First, cell_sequence::itera
// opaque non-instanced shapes
// non-interactive scenery elements get neutral colour
model_ubs.param[0] = colors::none;
for (auto const &shape : cell->m_shapesopaque)
for (auto const &shape : cell->m_shapesopaque)
Render(shape, false);
// tracks
for (auto *path : cell->m_paths)
@@ -1502,7 +1542,7 @@ void opengl_renderer::Render(cell_sequence::iterator First, cell_sequence::itera
}
// vehicles aren't included in scenery picking for the time being
break;
}
}
case rendermode::reflections:
case rendermode::pickcontrols:
default:
@@ -1515,10 +1555,29 @@ void opengl_renderer::Render(cell_sequence::iterator First, cell_sequence::itera
}
}
void opengl_renderer::draw(const gfx::geometry_handle &handle)
{
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
model_ubo->update(model_ubs);
m_geometry.draw(handle);
}
void opengl_renderer::draw(std::vector<gfx::geometrybank_handle>::iterator it, std::vector<gfx::geometrybank_handle>::iterator end)
{
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
model_ubo->update(model_ubs);
while (it != end)
{
m_geometry.draw(*it);
it++;
}
}
void opengl_renderer::Render(scene::shape_node const &Shape, bool const Ignorerange)
{
auto const &data{Shape.data()};
auto const &data{Shape.data()};
if (false == Ignorerange)
{
@@ -1561,10 +1620,8 @@ void opengl_renderer::Render(scene::shape_node const &Shape, bool const Ignorera
break;
}
// render
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
model_ubo->update(model_ubs);
m_geometry.draw(data.geometry);
draw(data.geometry);
// debug data
++m_debugstats.shapes;
++m_debugstats.drawcalls;
@@ -1652,8 +1709,13 @@ bool opengl_renderer::Render(TDynamicObject *Dynamic)
}
}
Dynamic->ABuLittleUpdate(squaredistance); // ustawianie zmiennych submodeli dla wspólnego modelu
::glPushMatrix();
glm::mat4 future_stack = model_ubs.future;
glm::mat4 mv = OpenGLMatrices.data(GL_MODELVIEW);
model_ubs.future *= glm::translate(mv, glm::vec3(Dynamic->get_last_movement())) * glm::inverse(mv);
::glPushMatrix();
::glTranslated(originoffset.x, originoffset.y, originoffset.z);
::glMultMatrixd(Dynamic->mMatrix.getArray());
@@ -1662,12 +1724,15 @@ bool opengl_renderer::Render(TDynamicObject *Dynamic)
case rendermode::color:
{
if (Dynamic->fShade > 0.0f)
if (Dynamic->fShade > 0.0f)
{
// change light level based on light level of the occupied track
m_sunlight.apply_intensity(Dynamic->fShade);
}
m_renderspecular = true; // vehicles are rendered with specular component. static models without, at least for the time being
//calc_motion = true;
//std::cout << glm::to_string(glm::vec3(Dynamic->get_velocity_vec())) << std::endl;
// render
if (Dynamic->mdLowPolyInt)
{
@@ -1699,7 +1764,8 @@ bool opengl_renderer::Render(TDynamicObject *Dynamic)
Render(Dynamic->mdLoad, Dynamic->Material(), squaredistance);
// post-render cleanup
m_renderspecular = false;
//calc_motion = false;
if (Dynamic->fShade > 0.0f)
{
// restore regular light level
@@ -1734,6 +1800,8 @@ bool opengl_renderer::Render(TDynamicObject *Dynamic)
::glPopMatrix();
model_ubs.future = future_stack;
// TODO: check if this reset is needed. In theory each object should render all parts based on its own instance data anyway?
if (Dynamic->btnOn)
Dynamic->TurnOff(); // przywrócenie domyślnych pozycji submodeli
@@ -1882,9 +1950,6 @@ bool opengl_renderer::Render(TModel3d *Model, material_data const *Material, flo
void opengl_renderer::Render(TSubModel *Submodel)
{
// if (Submodel->m_geometry.bank == 5)
// return;
glDebug("Render TSubModel");
if ((Submodel->iVisible) && (TSubModel::fSquareDist >= Submodel->fSquareMinDist) && (TSubModel::fSquareDist < Submodel->fSquareMaxDist))
@@ -1948,12 +2013,6 @@ void opengl_renderer::Render(TSubModel *Submodel)
Bind_Material(Submodel->m_material, Submodel);
}
// ...colors...
if ((true == m_renderspecular) && (m_sunlight.specular.a > 0.01f))
{
// specular strength in legacy models is set uniformly to 150, 150, 150 so we scale it down for opaque elements
}
// ...luminance
if (Global.fLuminance < Submodel->fLight)
{
@@ -1961,10 +2020,7 @@ void opengl_renderer::Render(TSubModel *Submodel)
}
// main draw call
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
model_ubo->update(model_ubs);
m_geometry.draw(Submodel->m_geometry);
draw(Submodel->m_geometry);
model_ubs.emission = 0.0f;
@@ -2002,17 +2058,13 @@ void opengl_renderer::Render(TSubModel *Submodel)
// również 0
Bind_Material_Shadow(Submodel->m_material);
}
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
model_ubo->update(model_ubs);
m_geometry.draw(Submodel->m_geometry);
draw(Submodel->m_geometry);
break;
}
case rendermode::pickscenery:
{
m_pick_shader->bind();
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
model_ubo->update(model_ubs);
m_geometry.draw(Submodel->m_geometry);
m_pick_shader->bind();
draw(Submodel->m_geometry);
break;
}
case rendermode::pickcontrols:
@@ -2021,9 +2073,7 @@ void opengl_renderer::Render(TSubModel *Submodel)
// control picking applies individual colour for each submodel
m_pickcontrolsitems.emplace_back(Submodel);
model_ubs.param[0] = glm::vec4(pick_color(m_pickcontrolsitems.size()), 1.0f);
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
model_ubo->update(model_ubs);
m_geometry.draw(Submodel->m_geometry);
draw(Submodel->m_geometry);
break;
}
default:
@@ -2074,11 +2124,9 @@ void opengl_renderer::Render(TSubModel *Submodel)
// main draw call
model_ubs.param[0] = glm::vec4(glm::vec3(Submodel->f4Diffuse), 0.0f);
model_ubs.emission = lightlevel * anglefactor;
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
model_ubo->update(model_ubs);
m_freespot_shader->bind();
m_geometry.draw(Submodel->m_geometry);
draw(Submodel->m_geometry);
// post-draw reset
model_ubs.emission = 0.0f;
@@ -2110,11 +2158,9 @@ void opengl_renderer::Render(TSubModel *Submodel)
Bind_Material(Submodel->m_material, Submodel);
// main draw call
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
model_ubo->update(model_ubs);
glPointSize(2.0f * 2.0f);
m_geometry.draw(Submodel->m_geometry);
draw(Submodel->m_geometry);
}
break;
}
@@ -2155,8 +2201,6 @@ void opengl_renderer::Render(TTrack *Track)
++m_debugstats.paths;
++m_debugstats.drawcalls;
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
switch (m_renderpass.draw_mode)
{
case rendermode::color:
@@ -2165,15 +2209,13 @@ void opengl_renderer::Render(TTrack *Track)
setup_environment_light(Track->eEnvironment);
if (Track->m_material1 != 0)
{
Bind_Material(Track->m_material1);
model_ubo->update(model_ubs);
m_geometry.draw(std::begin(Track->Geometry1), std::end(Track->Geometry1));
Bind_Material(Track->m_material1);
draw(std::begin(Track->Geometry1), std::end(Track->Geometry1));
}
if (Track->m_material2 != 0)
{
Bind_Material(Track->m_material2);
model_ubo->update(model_ubs);
m_geometry.draw(std::begin(Track->Geometry2), std::end(Track->Geometry2));
Bind_Material(Track->m_material2);
draw(std::begin(Track->Geometry2), std::end(Track->Geometry2));
}
setup_environment_light();
break;
@@ -2188,11 +2230,10 @@ void opengl_renderer::Render(TTrack *Track)
{
m_picksceneryitems.emplace_back(Track);
model_ubs.param[0] = glm::vec4(pick_color(m_picksceneryitems.size() + 1), 1.0f);
model_ubo->update(model_ubs);
m_pick_shader->bind();
m_geometry.draw(std::begin(Track->Geometry1), std::end(Track->Geometry1));
m_geometry.draw(std::begin(Track->Geometry2), std::end(Track->Geometry2));
draw(std::begin(Track->Geometry1), std::end(Track->Geometry1));
draw(std::begin(Track->Geometry2), std::end(Track->Geometry2));
break;
}
case rendermode::pickcontrols:
@@ -2222,8 +2263,6 @@ void opengl_renderer::Render(scene::basic_cell::path_sequence::const_iterator Fi
}
}
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
// first pass, material 1
for (auto first{First}; first != Last; ++first)
{
@@ -2251,9 +2290,8 @@ void opengl_renderer::Render(scene::basic_cell::path_sequence::const_iterator Fi
{
setup_environment_light(track->eEnvironment);
}
Bind_Material(track->m_material1);
model_ubo->update(model_ubs);
m_geometry.draw(std::begin(track->Geometry1), std::end(track->Geometry1));
Bind_Material(track->m_material1);
draw(std::begin(track->Geometry1), std::end(track->Geometry1));
if (track->eEnvironment != e_flat)
{
// restore default lighting
@@ -2269,8 +2307,7 @@ void opengl_renderer::Render(scene::basic_cell::path_sequence::const_iterator Fi
continue;
}
Bind_Material_Shadow(track->m_material1);
model_ubo->update(model_ubs);
m_geometry.draw(std::begin(track->Geometry1), std::end(track->Geometry1));
draw(std::begin(track->Geometry1), std::end(track->Geometry1));
break;
}
case rendermode::pickscenery: // pick scenery mode uses piece-by-piece approach
@@ -2305,9 +2342,8 @@ void opengl_renderer::Render(scene::basic_cell::path_sequence::const_iterator Fi
{
setup_environment_light(track->eEnvironment);
}
Bind_Material(track->m_material2);
model_ubo->update(model_ubs);
m_geometry.draw(std::begin(track->Geometry2), std::end(track->Geometry2));
Bind_Material(track->m_material2);
draw(std::begin(track->Geometry2), std::end(track->Geometry2));
if (track->eEnvironment != e_flat)
{
// restore default lighting
@@ -2323,7 +2359,7 @@ void opengl_renderer::Render(scene::basic_cell::path_sequence::const_iterator Fi
continue;
}
Bind_Material_Shadow(track->m_material2);
m_geometry.draw(std::begin(track->Geometry2), std::end(track->Geometry2));
draw(std::begin(track->Geometry2), std::end(track->Geometry2));
break;
}
case rendermode::pickscenery: // pick scenery mode uses piece-by-piece approach
@@ -2401,7 +2437,7 @@ void opengl_renderer::Render_Alpha(cell_sequence::reverse_iterator First, cell_s
while (first != Last)
{
auto const *cell = first->second;
auto const *cell = first->second;
if (false == cell->m_shapestranslucent.empty())
{
@@ -2411,7 +2447,7 @@ void opengl_renderer::Render_Alpha(cell_sequence::reverse_iterator First, cell_s
::glTranslated(originoffset.x, originoffset.y, originoffset.z);
// render
// NOTE: we can reuse the method used to draw opaque geometry
for (auto const &shape : cell->m_shapestranslucent)
for (auto const &shape : cell->m_shapestranslucent)
{
Render(shape, false);
}
@@ -2452,9 +2488,9 @@ void opengl_renderer::Render_Alpha(cell_sequence::reverse_iterator First, cell_s
{
auto first{First};
while (first != Last)
{
{
auto const *cell = first->second;
auto const *cell = first->second;
if ((false == cell->m_traction.empty() || (false == cell->m_lines.empty())))
{
@@ -2550,15 +2586,13 @@ void opengl_renderer::Render_Alpha(TTraction *Traction)
// McZapkie-261102: kolor zalezy od materialu i zasniedzenia
model_ubs.param[0] = glm::vec4(Traction->wire_color(), linealpha);
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
model_ubo->update(model_ubs);
if (m_renderpass.draw_mode == rendermode::shadows)
Bind_Material_Shadow(null_handle);
else
m_line_shader->bind();
m_geometry.draw(Traction->m_geometry);
draw(Traction->m_geometry);
// debug data
++m_debugstats.traction;
@@ -2569,7 +2603,7 @@ void opengl_renderer::Render_Alpha(scene::lines_node const &Lines)
{
glDebug("Render_Alpha scene::lines_node");
auto const &data{Lines.data()};
auto const &data{Lines.data()};
double distancesquared;
switch (m_renderpass.draw_mode)
@@ -2593,14 +2627,12 @@ void opengl_renderer::Render_Alpha(scene::lines_node const &Lines)
glLineWidth(clamp(0.5f * linealpha + data.line_width * data.area.radius / 1000.f, 1.f, 8.f));
model_ubs.param[0] = glm::vec4(glm::vec3(data.lighting.diffuse * m_sunlight.ambient), linealpha);
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
model_ubo->update(model_ubs);
if (m_renderpass.draw_mode == rendermode::shadows)
Bind_Material_Shadow(null_handle);
else
m_line_shader->bind();
m_geometry.draw(data.geometry);
draw(data.geometry);
++m_debugstats.lines;
++m_debugstats.drawcalls;
@@ -2629,6 +2661,12 @@ bool opengl_renderer::Render_Alpha(TDynamicObject *Dynamic)
}
}
Dynamic->ABuLittleUpdate(squaredistance); // ustawianie zmiennych submodeli dla wspólnego modelu
glm::mat4 future_stack = model_ubs.future;
glm::mat4 mv = OpenGLMatrices.data(GL_MODELVIEW);
model_ubs.future *= glm::translate(mv, glm::vec3(Dynamic->get_last_movement())) * glm::inverse(mv);
::glPushMatrix();
::glTranslated(originoffset.x, originoffset.y, originoffset.z);
@@ -2638,8 +2676,7 @@ bool opengl_renderer::Render_Alpha(TDynamicObject *Dynamic)
{
// change light level based on light level of the occupied track
m_sunlight.apply_intensity(Dynamic->fShade);
}
m_renderspecular = true;
}
// render
if (Dynamic->mdLowPolyInt)
@@ -2666,7 +2703,6 @@ bool opengl_renderer::Render_Alpha(TDynamicObject *Dynamic)
Render_Alpha(Dynamic->mdLoad, Dynamic->Material(), squaredistance);
// post-render cleanup
m_renderspecular = false;
if (Dynamic->fShade > 0.0f)
{
// restore regular light level
@@ -2675,6 +2711,8 @@ bool opengl_renderer::Render_Alpha(TDynamicObject *Dynamic)
::glPopMatrix();
model_ubs.future = future_stack;
if (Dynamic->btnOn)
Dynamic->TurnOff(); // przywrócenie domyślnych pozycji submodeli
@@ -2796,9 +2834,7 @@ void opengl_renderer::Render_Alpha(TSubModel *Submodel)
}
// main draw call
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
model_ubo->update(model_ubs);
m_geometry.draw(Submodel->m_geometry);
draw(Submodel->m_geometry);
model_ubs.emission = 0.0f;
@@ -2834,9 +2870,7 @@ void opengl_renderer::Render_Alpha(TSubModel *Submodel)
{
Bind_Material_Shadow(Submodel->m_material);
}
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
model_ubo->update(model_ubs);
m_geometry.draw(Submodel->m_geometry);
draw(Submodel->m_geometry);
break;
}
default:
@@ -2887,9 +2921,7 @@ void opengl_renderer::Render_Alpha(TSubModel *Submodel)
model_ubs.param[0] = glm::vec4(glm::vec3(Submodel->f4Diffuse), glarelevel);
// main draw call
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
model_ubo->update(model_ubs);
m_geometry.draw(m_billboardgeometry);
draw(m_billboardgeometry);
glDepthMask(GL_TRUE);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

22
renderer.h
View File

@@ -123,7 +123,6 @@ class opengl_camera
// bare-bones render controller, in lack of anything better yet
class opengl_renderer
{
public:
// types
@@ -232,7 +231,7 @@ class opengl_renderer
bool Init_caps();
void setup_pass(renderpass_config &Config, rendermode const Mode, float const Znear = 0.f, float const Zfar = 1.f, bool const Ignoredebug = false);
void setup_matrices();
void setup_drawing(bool const Alpha = false);
void setup_drawing(bool const Alpha = false);
void setup_shadow_map(opengl_texture *tex, renderpass_config conf);
void setup_env_map(gl::cubemap *tex);
void setup_environment_light(TEnvironmentType const Environment = e_flat);
@@ -244,7 +243,7 @@ class opengl_renderer
void Render(scene::basic_region *Region);
void Render(section_sequence::iterator First, section_sequence::iterator Last);
void Render(cell_sequence::iterator First, cell_sequence::iterator Last);
void Render(scene::shape_node const &Shape, bool const Ignorerange);
void Render(scene::shape_node const &Shape, bool const Ignorerange);
void Render(TAnimModel *Instance);
bool Render(TDynamicObject *Dynamic);
bool Render(TModel3d *Model, material_data const *Material, float const Squaredistance, Math3D::vector3 const &Position, glm::vec3 const &Angle);
@@ -258,7 +257,7 @@ class opengl_renderer
void Render_Alpha(cell_sequence::reverse_iterator First, cell_sequence::reverse_iterator Last);
void Render_Alpha(TAnimModel *Instance);
void Render_Alpha(TTraction *Traction);
void Render_Alpha(scene::lines_node const &Lines);
void Render_Alpha(scene::lines_node const &Lines);
bool Render_Alpha(TDynamicObject *Dynamic);
bool Render_Alpha(TModel3d *Model, material_data const *Material, float const Squaredistance, Math3D::vector3 const &Position, glm::vec3 const &Angle);
bool Render_Alpha(TModel3d *Model, material_data const *Material, float const Squaredistance);
@@ -267,6 +266,9 @@ class opengl_renderer
glm::vec3 pick_color(std::size_t const Index);
std::size_t pick_index(glm::ivec3 const &Color);
void draw(const gfx::geometry_handle &handle);
void draw(std::vector<gfx::geometrybank_handle>::iterator begin, std::vector<gfx::geometrybank_handle>::iterator end);
// members
GLFWwindow *m_window{nullptr};
gfx::geometrybank_manager m_geometry;
@@ -325,8 +327,7 @@ class opengl_renderer
glm::vec4 m_shadowcolor{colors::shadow};
// TEnvironmentType m_environment { e_flat };
float m_specularopaquescalefactor{1.f};
float m_speculartranslucentscalefactor{1.f};
bool m_renderspecular{false}; // controls whether to include specular component in the calculations
float m_speculartranslucentscalefactor{1.f};
renderpass_config m_renderpass; // parameters for current render pass
section_sequence m_sectionqueue; // list of sections in current render pass
@@ -362,11 +363,18 @@ class opengl_renderer
std::unique_ptr<gl::framebuffer> m_msaa_fb;
std::unique_ptr<gl::renderbuffer> m_msaa_rbc;
std::unique_ptr<gl::renderbuffer> m_msaa_rbv;
std::unique_ptr<gl::renderbuffer> m_msaa_rbd;
std::unique_ptr<gl::framebuffer> m_main_fb;
std::unique_ptr<opengl_texture> m_main_texv;
std::unique_ptr<opengl_texture> m_main_tex;
std::unique_ptr<gl::postfx> m_pfx;
std::unique_ptr<gl::framebuffer> m_main2_fb;
std::unique_ptr<opengl_texture> m_main2_tex;
std::unique_ptr<gl::postfx> m_pfx_motionblur;
std::unique_ptr<gl::postfx> m_pfx_tonemapping;
std::unique_ptr<gl::framebuffer> m_shadow_fb;
std::unique_ptr<opengl_texture> m_shadow_tex;

7
scenenode.h
View File

@@ -73,7 +73,8 @@ struct node_data {
};
// holds unique piece of geometry, covered with single material
class shape_node {
class shape_node
{
friend class basic_region; // region might want to modify node content when it's being inserted
@@ -163,8 +164,8 @@ shape_node::data() const {
// holds a group of untextured lines
class lines_node {
class lines_node
{
friend class basic_region; // region might want to modify node content when it's being inserted
public:

3
shaders/billboard.frag
View File

@@ -11,5 +11,6 @@ uniform sampler2D tex1;
void main()
{
vec4 tex_color = texture(tex1, f_coord);
gl_FragColor = tex_color * param[0];
gl_FragData[0] = tex_color * param[0];
gl_FragData[1] = vec4(0.0f);
}

3
shaders/color.frag
View File

@@ -6,5 +6,6 @@ in vec3 f_color;
void main()
{
gl_FragColor = vec4(f_color, 1.0f);
gl_FragData[0] = vec4(f_color, 1.0f);
gl_FragData[1] = vec4(0.0f);
}

11
shaders/freespot.frag
View File

@@ -2,6 +2,9 @@
#include <common>
in vec4 f_clip_pos;
in vec4 f_clip_future_pos;
void main()
{
float x = (gl_PointCoord.x - 0.5f) * 2.0f;
@@ -9,5 +12,11 @@ void main()
float dist2 = abs(x * x + y * y);
if (dist2 > 0.5f * 0.5f)
discard;
gl_FragColor = vec4(param[0].rgb * emission, 1.0f);
gl_FragData[0] = vec4(param[0].rgb * emission, 1.0f);
{
vec2 a = (f_clip_future_pos.xy / f_clip_future_pos.w) * 0.5 + 0.5;;
vec2 b = (f_clip_pos.xy / f_clip_pos.w) * 0.5 + 0.5;;
gl_FragData[1] = vec4(a - b, 0.0f, 0.0f);
}
}

8
shaders/freespot.vert
View File

@@ -6,7 +6,13 @@ layout(location = 2) in vec2 v_coord;
#include <common>
out vec4 f_clip_pos;
out vec4 f_clip_future_pos;
void main()
{
gl_Position = (projection * modelview) * vec4(v_vert, 1.0f);
f_clip_pos = (projection * modelview) * vec4(v_vert, 1.0f);
f_clip_future_pos = (projection * future * modelview) * vec4(v_vert, 1.0f);
gl_Position = f_clip_pos;
}

12
shaders/light_common.glsl
View File

@@ -25,9 +25,9 @@ vec3 apply_fog(vec3 color)
{
float sun_amount = 0.0;
if (lights_count >= 1U && lights[0].type == LIGHT_DIR)
sun_amount = max(dot(normalize(f_pos), normalize(-lights[0].dir)), 0.0);
sun_amount = max(dot(normalize(f_pos.xyz), normalize(-lights[0].dir)), 0.0);
vec3 fog_color_v = mix(fog_color, lights[0].color, pow(sun_amount, 30.0));
float fog_amount_v = 1.0 - min(1.0, exp(-length(f_pos) * fog_density));
float fog_amount_v = 1.0 - min(1.0, exp(-length(f_pos.xyz) * fog_density));
return mix(color, fog_color_v, fog_amount_v);
}
@@ -40,7 +40,7 @@ vec2 calc_light(vec3 light_dir)
#else
vec3 normal = normalize(f_normal);
#endif
vec3 view_dir = normalize(vec3(0.0f, 0.0f, 0.0f) - f_pos);
vec3 view_dir = normalize(vec3(0.0f, 0.0f, 0.0f) - f_pos.xyz);
vec3 halfway_dir = normalize(light_dir + view_dir);
float diffuse_v = max(dot(normal, light_dir), 0.0);
@@ -51,10 +51,10 @@ vec2 calc_light(vec3 light_dir)
vec2 calc_point_light(light_s light)
{
vec3 light_dir = normalize(light.pos - f_pos);
vec3 light_dir = normalize(light.pos - f_pos.xyz);
vec2 val = calc_light(light_dir);
float distance = length(light.pos - f_pos);
float distance = length(light.pos - f_pos.xyz);
float atten = 1.0f / (1.0f + light.linear * distance + light.quadratic * (distance * distance));
return val * atten;
@@ -62,7 +62,7 @@ vec2 calc_point_light(light_s light)
vec2 calc_spot_light(light_s light)
{
vec3 light_dir = normalize(light.pos - f_pos);
vec3 light_dir = normalize(light.pos - f_pos.xyz);
float theta = dot(light_dir, normalize(-light.dir));
float epsilon = light.in_cutoff - light.out_cutoff;

5
shaders/mat_clouds.frag
View File

@@ -2,7 +2,7 @@
in vec3 f_normal;
in vec2 f_coord;
in vec3 f_pos;
in vec4 f_pos;
#texture (tex1, 0, sRGB_A)
uniform sampler2D tex1;
@@ -12,5 +12,6 @@ uniform sampler2D tex1;
void main()
{
vec4 tex_color = texture(tex1, f_coord);
gl_FragColor = tex_color * param[0];
gl_FragData[0] = tex_color * param[0];
gl_FragData[1] = vec4(0.0f);
}

15
shaders/mat_colored.frag
View File

@@ -2,9 +2,12 @@
in vec3 f_normal;
in vec2 f_coord;
in vec3 f_pos;
in vec4 f_pos;
in vec4 f_light_pos;
in vec4 f_clip_pos;
in vec4 f_clip_future_pos;
#include <common>
#param (color, 0, 0, 4, diffuse)
@@ -22,7 +25,7 @@ void main()
vec4 tex_color = vec4(param[0].rgb, 1.0f);
vec3 normal = normalize(f_normal);
vec3 refvec = reflect(f_pos, normal);
vec3 refvec = reflect(f_pos.xyz, normal);
vec3 envcolor = texture(envmap, refvec).rgb;
vec3 result = ambient * 0.5 + param[0].rgb * emission;
@@ -49,5 +52,11 @@ void main()
result += light.color * (part.x * param[1].x + part.y * param[1].y);
}
gl_FragColor = vec4(apply_fog(result * tex_color.rgb), tex_color.a);
gl_FragData[0] = vec4(apply_fog(result * tex_color.rgb), tex_color.a);
{
vec2 a = (f_clip_future_pos.xy / f_clip_future_pos.w) * 0.5 + 0.5;;
vec2 b = (f_clip_pos.xy / f_clip_pos.w) * 0.5 + 0.5;;
gl_FragData[1] = vec4(a - b, 0.0f, 0.0f);
}
}

17
shaders/mat_default.frag
View File

@@ -2,9 +2,12 @@
in vec3 f_normal;
in vec2 f_coord;
in vec3 f_pos;
in vec4 f_pos;
in vec4 f_light_pos;
in vec4 f_clip_pos;
in vec4 f_clip_future_pos;
#include <common>
#param (color, 0, 0, 4, diffuse)
@@ -28,7 +31,7 @@ void main()
discard;
vec3 normal = normalize(f_normal);
vec3 refvec = reflect(f_pos, normal);
vec3 refvec = reflect(f_pos.xyz, normal);
vec3 envcolor = texture(envmap, refvec).rgb;
vec3 result = ambient * 0.5 + param[0].rgb * emission;
@@ -55,5 +58,13 @@ void main()
result += light.color * (part.x * param[1].x + part.y * param[1].y);
}
gl_FragColor = vec4(apply_fog(result * tex_color.rgb), tex_color.a);
gl_FragData[0] = vec4(apply_fog(result * tex_color.rgb), tex_color.a);
{
vec2 a = (f_clip_future_pos.xy / f_clip_future_pos.w) * 0.5 + 0.5;;
vec2 b = (f_clip_pos.xy / f_clip_pos.w) * 0.5 + 0.5;;
gl_FragData[1] = vec4(a - b, 0.0f, tex_color.a < 0.9f ? 0.0f : 1.0f);
}
}

3
shaders/mat_invalid.frag
View File

@@ -4,5 +4,6 @@
void main()
{
gl_FragColor = vec4(1.0, 0.0, 1.0, 1.0);
gl_FragData[0] = vec4(1.0, 0.0, 1.0, 1.0);
gl_FragData[1] = vec4(0.0f);
}

15
shaders/mat_normalmap.frag
View File

@@ -2,10 +2,13 @@
in vec3 f_normal;
in vec2 f_coord;
in vec3 f_pos;
in vec4 f_pos;
in mat3 f_tbn;
in vec4 f_light_pos;
in vec4 f_clip_pos;
in vec4 f_clip_future_pos;
#include <common>
#param (color, 0, 0, 4, diffuse)
@@ -33,7 +36,7 @@ void main()
discard;
vec3 normal = f_tbn * normalize(texture(normalmap, f_coord).rgb * 2.0 - 1.0);
vec3 refvec = reflect(f_pos, normal);
vec3 refvec = reflect(f_pos.xyz, normal);
vec3 envcolor = texture(envmap, refvec).rgb;
vec3 result = ambient * 0.5 + param[0].rgb * emission;
@@ -60,5 +63,11 @@ void main()
result += light.color * (part.x * param[1].x + part.y * param[1].y);
}
gl_FragColor = vec4(apply_fog(result * tex_color.rgb), tex_color.a);
gl_FragData[0] = vec4(apply_fog(result * tex_color.rgb), tex_color.a);
{
vec2 a = (f_clip_future_pos.xy / f_clip_future_pos.w) * 0.5 + 0.5;;
vec2 b = (f_clip_pos.xy / f_clip_pos.w) * 0.5 + 0.5;;
gl_FragData[1] = vec4(a - b, 0.0f, 0.0f);
}
}

16
shaders/mat_reflmap.frag
View File

@@ -2,9 +2,12 @@
in vec3 f_normal;
in vec2 f_coord;
in vec3 f_pos;
in vec4 f_pos;
in vec4 f_light_pos;
in vec4 f_clip_pos;
in vec4 f_clip_future_pos;
#include <common>
#param (color, 0, 0, 4, diffuse)
@@ -31,7 +34,7 @@ void main()
discard;
vec3 normal = normalize(f_normal);
vec3 refvec = reflect(f_pos, normal);
vec3 refvec = reflect(f_pos.xyz, normal);
vec3 envcolor = texture(envmap, refvec).rgb;
vec3 result = ambient * 0.5 + param[0].rgb * emission;
@@ -58,5 +61,12 @@ void main()
result += light.color * (part.x * param[1].x + part.y * param[1].y);
}
gl_FragColor = vec4(apply_fog(result * tex_color.rgb), tex_color.a);
gl_FragData[0] = vec4(apply_fog(result * tex_color.rgb), tex_color.a);
{
vec2 a = (f_clip_future_pos.xy / f_clip_future_pos.w) * 0.5 + 0.5;;
vec2 b = (f_clip_pos.xy / f_clip_pos.w) * 0.5 + 0.5;;
gl_FragData[1] = vec4(a - b, 0.0f, 0.0f);
}
}

3
shaders/mat_stars.frag
View File

@@ -13,5 +13,6 @@ void main()
discard;
// color data is shared with normals, ugh
gl_FragColor = vec4(f_normal_raw.bgr, 1.0f);
gl_FragData[0] = vec4(f_normal_raw.bgr, 1.0f);
gl_FragData[1] = vec4(0.0f);
}

30
shaders/postfx_motionblur.frag Normal file
View File

@@ -0,0 +1,30 @@
#version 330 core
in vec2 f_coords;
#texture (color_tex, 0, RGB)
uniform sampler2D color_tex;
#texture (velocity_tex, 1, RG)
uniform sampler2D velocity_tex;
#include <common>
void main()
{
vec2 texelSize = 1.0 / vec2(textureSize(color_tex, 0));
vec2 velocity = texture(velocity_tex, f_coords).rg * param[0].r;
float speed = length(velocity / texelSize);
int nSamples = clamp(int(speed), 1, 64);
vec4 oResult = texture(color_tex, f_coords);
for (int i = 1; i < nSamples; ++i)
{
vec2 offset = velocity * (float(i) / float(nSamples - 1) - 0.5);
oResult += texture(color_tex, f_coords + offset);
}
oResult /= float(nSamples);
gl_FragData[0] = oResult;
}

11
shaders/traction.frag
View File

@@ -2,7 +2,16 @@
#include <common>
in vec4 f_clip_pos;
in vec4 f_clip_future_pos;
void main()
{
gl_FragColor = param[0];
gl_FragData[0] = param[0];
{
vec2 a = (f_clip_future_pos.xy / f_clip_future_pos.w) * 0.5 + 0.5;;
vec2 b = (f_clip_pos.xy / f_clip_pos.w) * 0.5 + 0.5;;
gl_FragData[1] = vec4(a - b, 0.0f, 0.0f);
}
}

8
shaders/traction.vert
View File

@@ -6,7 +6,13 @@ layout(location = 2) in vec2 v_coord;
#include <common>
out vec4 f_clip_pos;
out vec4 f_clip_future_pos;
void main()
{
gl_Position = (projection * modelview) * vec4(v_vert, 1.0f);
f_clip_pos = (projection * modelview) * vec4(v_vert, 1.0f);
f_clip_future_pos = (projection * future * modelview) * vec4(v_vert, 1.0f);
gl_Position = f_clip_pos;
}

15
shaders/vertex.vert
View File

@@ -8,22 +8,29 @@ layout(location = 3) in vec4 v_tangent;
out vec3 f_normal;
flat out vec3 f_normal_raw;
out vec2 f_coord;
out vec3 f_pos;
out vec4 f_pos;
out mat3 f_tbn;
out vec4 f_tangent;
out vec4 f_light_pos;
out vec4 f_clip_pos;
out vec4 f_clip_future_pos;
#include <common>
void main()
{
gl_Position = (projection * modelview) * vec4(v_vert, 1.0f);
f_normal = modelviewnormal * v_normal;
f_normal_raw = v_normal;
f_coord = v_coord;
f_tangent = v_tangent;
f_pos = vec3(modelview * vec4(v_vert, 1.0f));
f_light_pos = lightview * vec4(f_pos, 1.0f);
f_pos = modelview * vec4(v_vert, 1.0f);
f_light_pos = lightview * f_pos;
f_clip_pos = (projection * modelview) * vec4(v_vert, 1.0f);
f_clip_future_pos = (projection * future * modelview) * vec4(v_vert, 1.0f);
gl_Position = f_clip_pos;
vec3 T = normalize(modelviewnormal * v_tangent.xyz);
vec3 B = normalize(modelviewnormal * cross(v_normal, v_tangent.xyz) * v_tangent.w);

2
uilayer.cpp
View File

@@ -1232,8 +1232,6 @@ ui_layer::render_tooltip() {
if( !m_cursorvisible || m_tooltip.empty() ) { return; }
glm::dvec2 mousepos = Application.get_cursor_pos();
ImGui::BeginTooltip();
ImGui::TextUnformatted(m_tooltip.c_str());
ImGui::EndTooltip();