ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/supertuxkart/stk-code

Browse Source
This commit is contained in:
Marianne Gagnon 2014-04-14 18:32:36 -04:00
commit 60a3cfb3fd
28 changed files with 330 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
data/shaders/bloom.frag
View File

@ -16,7 +16,7 @@ void main()
vec3 col = texture(tex, uv).xyz;
float luma = getCIEYxy(col).x;
col *= smoothstep(1., 2., luma);
col *= smoothstep(1., 10., luma);
FragColor = vec4(col, 1.0);
}

10
data/shaders/mlaa_color1.frag
View File

@ -13,11 +13,11 @@ void main() {
/**
* Luma calculation requires gamma-corrected colors:
*/
float L = dot(pow(texture(colorMapG, uv).rgb, vec3(1./2.2)), weights);
float Lleft = dot(pow(texture(colorMapG, offset[0].xy).rgb, vec3(1./2.2)), weights);
float Ltop = dot(pow(texture(colorMapG, offset[0].zw).rgb, vec3(1./2.2)), weights);
float Lright = dot(pow(texture(colorMapG, offset[1].xy).rgb, vec3(1./2.2)), weights);
float Lbottom = dot(pow(texture(colorMapG, offset[1].zw).rgb, vec3(1./2.2)), weights);
float L = dot(texture(colorMapG, uv).rgb, weights);
float Lleft = dot(texture(colorMapG, offset[0].xy).rgb, weights);
float Ltop = dot(texture(colorMapG, offset[0].zw).rgb, weights);
float Lright = dot(texture(colorMapG, offset[1].xy).rgb, weights);
float Lbottom = dot(texture(colorMapG, offset[1].zw).rgb, weights);
vec4 delta = abs(vec4(L) - vec4(Lleft, Ltop, Lright, Lbottom));
vec4 edges = step(vec4(threshold), delta);

12
data/shaders/mlaa_neigh3.frag
View File

@ -26,16 +26,16 @@ void main() {
vec4 color = vec4(0.0);
// Add the contributions of the possible 4 lines that can cross this pixel:
vec4 C = pow(texture(colorMap, uv), vec4(1./2.2));
vec4 Cleft = pow(texture(colorMap, offset[0].xy), vec4(1./2.2));
vec4 Ctop = pow(texture(colorMap, offset[0].zw), vec4(1./2.2));
vec4 Cright = pow(texture(colorMap, offset[1].xy), vec4(1./2.2));
vec4 Cbottom = pow(texture(colorMap, offset[1].zw), vec4(1./2.2));
vec4 C = texture(colorMap, uv);
vec4 Cleft = texture(colorMap, offset[0].xy);
vec4 Ctop = texture(colorMap, offset[0].zw);
vec4 Cright = texture(colorMap, offset[1].xy);
vec4 Cbottom = texture(colorMap, offset[1].zw);
color = mix(C, Ctop, a.r) * w.r + color;
color = mix(C, Cbottom, a.g) * w.g + color;
color = mix(C, Cleft, a.b) * w.b + color;
color = mix(C, Cright, a.a) * w.a + color;
// Normalize the resulting color and we are finished!
FragColor = vec4(pow(color / sum, vec4(2.2)));
FragColor = vec4(color / sum);
}

8
data/shaders/ssao.frag
View File

@ -13,8 +13,8 @@ varying vec2 uv;
#define AO gl_FragColor.x
#endif
const float strengh = 4.;
const float radius = .4f;
const float strengh = 3.;
const float radius = 1.f;
#define SAMPLES 16
@ -22,7 +22,7 @@ const float invSamples = strengh / SAMPLES;
vec3 rand(vec2 co)
{
return texture(noise_texture, co*20.16).xyz;
return texture(noise_texture, co * pow(3.14159265359, 2.)).xyz;
}
vec3 DecodeNormal(vec2 n);
@ -61,7 +61,7 @@ void main(void)
occluderPos /= occluderPos.w;
bool isOccluded = isInsideTexture && (sampleProj.z > (2. * occluderFragmentDepth - 1.0)) && (distance(FragPos, occluderPos) < radius);
bl += isOccluded ? smoothstep(radius, 0, distance(samplePos, FragPos)) : 0.;
bl += isOccluded ? samplePoints[i].z * smoothstep(5 * radius, 0, distance(samplePos, FragPos)) : 0.;
}
AO = 1.0 - bl * invSamples;

25
src/config/user_config.hpp
View File

@ -440,6 +440,21 @@ namespace UserConfigParams
PARAM_PREFIX IntUserConfigParam m_max_fps
PARAM_DEFAULT( IntUserConfigParam(120, "max_fps",
&m_video_group, "Maximum fps, should be at least 60") );
PARAM_PREFIX BoolUserConfigParam m_texture_compression
PARAM_DEFAULT(BoolUserConfigParam(true, "enable_texture_compression",
&m_video_group, "Enable Texture Compression"));
PARAM_PREFIX BoolUserConfigParam m_glow
PARAM_DEFAULT(BoolUserConfigParam(false, "enable_glow",
&m_video_group, "Enable Glow"));
PARAM_PREFIX BoolUserConfigParam m_bloom
PARAM_DEFAULT(BoolUserConfigParam(false, "enable_bloom",
&m_video_group, "Enable Bloom"));
PARAM_PREFIX BoolUserConfigParam m_light_shaft
PARAM_DEFAULT(BoolUserConfigParam(false, "enable_light_shaft",
&m_video_group, "Enable Light Shafts"));
PARAM_PREFIX BoolUserConfigParam m_dynamic_lights
PARAM_DEFAULT(BoolUserConfigParam(false, "enable_dynamic_lights",
&m_video_group, "Enable Dynamic Lights"));
// ---- Debug - not saved to config file
/** If gamepad debugging is enabled. */
@ -589,10 +604,6 @@ namespace UserConfigParams
PARAM_DEFAULT( BoolUserConfigParam(false, "vsync",
&m_graphics_quality,
"Whether vertical sync is enabled") );
PARAM_PREFIX BoolUserConfigParam m_pixel_shaders
PARAM_DEFAULT( BoolUserConfigParam(false, "pixel_shaders",
&m_graphics_quality,
"Whether to enable pixel shaders (splatting, normal maps, ...)") );
PARAM_PREFIX BoolUserConfigParam m_motionblur
PARAM_DEFAULT( BoolUserConfigParam(false,
"motionblur_enabled", &m_graphics_quality,
@ -601,10 +612,10 @@ namespace UserConfigParams
PARAM_DEFAULT( BoolUserConfigParam(false,
"mlaa", &m_graphics_quality,
"Whether MLAA anti-aliasing should be enabled") );
PARAM_PREFIX IntUserConfigParam m_ssao
PARAM_DEFAULT( IntUserConfigParam(0,
PARAM_PREFIX BoolUserConfigParam m_ssao
PARAM_DEFAULT(BoolUserConfigParam(false,
"ssao", &m_graphics_quality,
"Whether SSAO is enabled (0 = disabled, 1 = low, 2 = high") );
"Enable Screen Space Ambient Occlusion") );
PARAM_PREFIX IntUserConfigParam m_shadows
PARAM_DEFAULT( IntUserConfigParam(0,
"shadows", &m_graphics_quality,

4
src/graphics/glwrap.cpp
View File

@ -67,6 +67,7 @@ PFNGLTEXIMAGE2DMULTISAMPLEPROC glTexImage2DMultisample;
PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer;
PFNGLGETUNIFORMBLOCKINDEXPROC glGetUniformBlockIndex;
PFNGLUNIFORMBLOCKBINDINGPROC glUniformBlockBinding;
PFNGLBLENDCOLORPROC glBlendColor;
#endif
static bool is_gl_init = false;
@ -213,6 +214,7 @@ void initGL()
glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)IRR_OGL_LOAD_EXTENSION("glBlitFramebuffer");
glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)IRR_OGL_LOAD_EXTENSION("glGetUniformBlockIndex");
glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)IRR_OGL_LOAD_EXTENSION("glUniformBlockBinding");
glBlendColor = (PFNGLBLENDCOLORPROC)IRR_OGL_LOAD_EXTENSION("glBlendColor");
#ifdef DEBUG
glDebugMessageCallbackARB = (PFNGLDEBUGMESSAGECALLBACKARBPROC)IRR_OGL_LOAD_EXTENSION("glDebugMessageCallbackARB");
#endif
@ -324,7 +326,7 @@ void compressTexture(irr::video::ITexture *tex, bool srgb)
else
Format = GL_BGR;
if (irr_driver->getGLSLVersion() < 150)
if (!UserConfigParams::m_texture_compression)
{
if (srgb)
internalFormat = (tex->hasAlpha()) ? GL_SRGB_ALPHA : GL_SRGB;

1
src/graphics/glwrap.hpp
View File

@ -84,6 +84,7 @@ extern PFNGLTEXIMAGE2DMULTISAMPLEPROC glTexImage2DMultisample;
extern PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer;
extern PFNGLGETUNIFORMBLOCKINDEXPROC glGetUniformBlockIndex;
extern PFNGLUNIFORMBLOCKBINDINGPROC glUniformBlockBinding;
extern PFNGLBLENDCOLORPROC glBlendColor;
#ifdef DEBUG
extern PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARB;
#endif

2
src/graphics/irr_driver.cpp
View File

@ -427,7 +427,7 @@ void IrrDriver::initDevice()
glGetIntegerv(GL_MAJOR_VERSION, &GLMajorVersion);
glGetIntegerv(GL_MINOR_VERSION, &GLMinorVersion);
Log::info("IrrDriver", "OPENGL VERSION IS %d.%d", GLMajorVersion, GLMinorVersion);
m_glsl = (GLMajorVersion > 3 || (GLMajorVersion == 3 && GLMinorVersion >= 1)) && UserConfigParams::m_pixel_shaders;
m_glsl = (GLMajorVersion > 3 || (GLMajorVersion == 3 && GLMinorVersion >= 1));
// This remaps the window, so it has to be done before the clear to avoid flicker
m_device->setResizable(false);

121
src/graphics/post_processing.cpp
View File

@ -413,17 +413,13 @@ void PostProcessing::renderSSAO(const core::matrix4 &invprojm, const core::matri
glUseProgram(FullScreenShader::SSAOShader::Program);
glBindVertexArray(FullScreenShader::SSAOShader::vao);
setTexture(0, irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), GL_NEAREST, GL_NEAREST);
setTexture(0, irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), GL_LINEAR, GL_LINEAR);
setTexture(1, irr_driver->getDepthStencilTexture(), GL_LINEAR, GL_LINEAR);
setTexture(2, getTextureGLuint(noise_tex), GL_NEAREST, GL_NEAREST);
setTexture(2, getTextureGLuint(noise_tex), GL_LINEAR, GL_LINEAR);
FullScreenShader::SSAOShader::setUniforms(projm, invprojm, 0, 1, 2);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glEnable(GL_DEPTH_TEST);
}
void PostProcessing::renderFog(const core::matrix4 &ipvmat)
@ -621,46 +617,53 @@ void PostProcessing::render()
// Blit the base to tmp1
blitFBO(irr_driver->getFBO(FBO_COLORS), out_fbo, UserConfigParams::m_width, UserConfigParams::m_height);
const bool globalbloom = World::getWorld()->getTrack()->getBloom();
if (globalbloom)
if (UserConfigParams::m_bloom)
{
glBindFramebuffer(GL_FRAMEBUFFER, irr_driver->getFBO(FBO_TMP2_WITH_DS));
renderBloom(out_rtt);
glClear(GL_STENCIL_BUFFER_BIT);
// To half
glBindFramebuffer(GL_FRAMEBUFFER, irr_driver->getFBO(FBO_HALF1));
glViewport(0, 0, UserConfigParams::m_width / 2, UserConfigParams::m_height / 2);
renderPassThrough(irr_driver->getRenderTargetTexture(RTT_TMP2));
renderGaussian6Blur(irr_driver->getFBO(FBO_HALF1), irr_driver->getRenderTargetTexture(RTT_HALF1),
irr_driver->getFBO(FBO_HALF2), irr_driver->getRenderTargetTexture(RTT_HALF2), UserConfigParams::m_width / 2, UserConfigParams::m_height / 2);
glBindFramebuffer(GL_FRAMEBUFFER, irr_driver->getFBO(FBO_BLOOM_1024));
glViewport(0, 0, 1024, 1024);
renderPassThrough(out_rtt);
// To quarter
glBindFramebuffer(GL_FRAMEBUFFER, irr_driver->getFBO(FBO_QUARTER1));
glViewport(0, 0, UserConfigParams::m_width / 4, UserConfigParams::m_height / 4);
renderPassThrough(irr_driver->getRenderTargetTexture(RTT_HALF1));
renderGaussian6Blur(irr_driver->getFBO(FBO_QUARTER1), irr_driver->getRenderTargetTexture(RTT_QUARTER1),
irr_driver->getFBO(FBO_QUARTER2), irr_driver->getRenderTargetTexture(RTT_QUARTER2), UserConfigParams::m_width / 4, UserConfigParams::m_height / 4);
glBindFramebuffer(GL_FRAMEBUFFER, irr_driver->getFBO(FBO_BLOOM_512));
glViewport(0, 0, 512, 512);
renderBloom(irr_driver->getRenderTargetTexture(RTT_BLOOM_1024));
// To eighth
glBindFramebuffer(GL_FRAMEBUFFER, irr_driver->getFBO(FBO_EIGHTH1));
glViewport(0, 0, UserConfigParams::m_width / 8, UserConfigParams::m_height / 8);
renderPassThrough(irr_driver->getRenderTargetTexture(RTT_QUARTER1));
renderGaussian6Blur(irr_driver->getFBO(FBO_EIGHTH1), irr_driver->getRenderTargetTexture(RTT_EIGHTH1),
irr_driver->getFBO(FBO_EIGHTH2), irr_driver->getRenderTargetTexture(RTT_EIGHTH2), UserConfigParams::m_width / 8, UserConfigParams::m_height / 8);
// Downsample
glBindFramebuffer(GL_FRAMEBUFFER, irr_driver->getFBO(FBO_BLOOM_256));
glViewport(0, 0, 256, 256);
renderPassThrough(irr_driver->getRenderTargetTexture(RTT_BLOOM_512));
glBindFramebuffer(GL_FRAMEBUFFER, irr_driver->getFBO(FBO_BLOOM_128));
glViewport(0, 0, 128, 128);
renderPassThrough(irr_driver->getRenderTargetTexture(RTT_BLOOM_256));
// Blur
glViewport(0, 0, 512, 512);
renderGaussian6Blur(irr_driver->getFBO(FBO_BLOOM_512), irr_driver->getRenderTargetTexture(RTT_BLOOM_512),
irr_driver->getFBO(FBO_TMP_512), irr_driver->getRenderTargetTexture(RTT_TMP_512), 512, 512);
glViewport(0, 0, 256, 256);
renderGaussian6Blur(irr_driver->getFBO(FBO_BLOOM_256), irr_driver->getRenderTargetTexture(RTT_BLOOM_256),
irr_driver->getFBO(FBO_TMP_256), irr_driver->getRenderTargetTexture(RTT_TMP_256), 256, 256);
glViewport(0, 0, 128, 128);
renderGaussian6Blur(irr_driver->getFBO(FBO_BLOOM_128), irr_driver->getRenderTargetTexture(RTT_BLOOM_128),
irr_driver->getFBO(FBO_TMP_128), irr_driver->getRenderTargetTexture(RTT_TMP_128), 128, 128);
glViewport(0, 0, UserConfigParams::m_width, UserConfigParams::m_height);
// Additively blend on top of tmp1
glBindFramebuffer(GL_FRAMEBUFFER, out_fbo);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glBlendFunc(GL_CONSTANT_COLOR, GL_ONE);
glBlendEquation(GL_FUNC_ADD);
renderPassThrough(irr_driver->getRenderTargetTexture(RTT_HALF1));
renderPassThrough(irr_driver->getRenderTargetTexture(RTT_QUARTER1));
renderPassThrough(irr_driver->getRenderTargetTexture(RTT_EIGHTH1));
glBlendColor(.125, .125, .125, .125);
renderPassThrough(irr_driver->getRenderTargetTexture(RTT_BLOOM_128));
glBlendColor(.25, .25, .25, .25);
renderPassThrough(irr_driver->getRenderTargetTexture(RTT_BLOOM_256));
glBlendColor(.5, .5, .5, .5);
renderPassThrough(irr_driver->getRenderTargetTexture(RTT_BLOOM_512));
glDisable(GL_BLEND);
} // end if bloom
@ -669,7 +672,7 @@ void PostProcessing::render()
PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Godrays", 0xFF, 0x00, 0x00);
if (m_sunpixels > 30)//World::getWorld()->getTrack()->hasGodRays() && ) // god rays
if (UserConfigParams::m_light_shaft && m_sunpixels > 30)//World::getWorld()->getTrack()->hasGodRays() && ) // god rays
{
glEnable(GL_DEPTH_TEST);
// Grab the sky
@ -747,28 +750,44 @@ void PostProcessing::render()
PROFILER_POP_CPU_MARKER();
}
if (UserConfigParams::m_mlaa) // MLAA. Must be the last pp filter.
{
PROFILER_PUSH_CPU_MARKER("- MLAA", 0xFF, 0x00, 0x00);
glDisable(GL_BLEND);
blitFBO(in_fbo, irr_driver->getFBO(FBO_MLAA_COLORS), UserConfigParams::m_width, UserConfigParams::m_height);
applyMLAA();
in_rtt = irr_driver->getRenderTargetTexture(RTT_MLAA_COLORS);
PROFILER_POP_CPU_MARKER();
}
computeLogLuminance(in_rtt);
// Final blit
// TODO : Use glBlitFramebuffer
glEnable(GL_FRAMEBUFFER_SRGB);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindFramebuffer(GL_FRAMEBUFFER, out_fbo);
renderColorLevel(in_rtt);
std::swap(in_fbo, out_fbo);
std::swap(in_rtt, out_rtt);
if (irr_driver->getNormals())
{
glEnable(GL_FRAMEBUFFER_SRGB);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
renderPassThrough(irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH));
glDisable(GL_FRAMEBUFFER_SRGB);
}
else if (irr_driver->getSSAOViz())
{
glEnable(GL_FRAMEBUFFER_SRGB);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
renderPassThrough(irr_driver->getRenderTargetTexture(RTT_SSAO));
glDisable(GL_FRAMEBUFFER_SRGB);
}
else if (UserConfigParams::m_mlaa) // MLAA. Must be the last pp filter.
{
PROFILER_PUSH_CPU_MARKER("- MLAA", 0xFF, 0x00, 0x00);
glEnable(GL_FRAMEBUFFER_SRGB);
glBindFramebuffer(GL_FRAMEBUFFER, irr_driver->getFBO(FBO_MLAA_COLORS));
renderPassThrough(in_rtt);
glDisable(GL_FRAMEBUFFER_SRGB);
applyMLAA();
blitFBO(irr_driver->getFBO(FBO_MLAA_COLORS), 0, UserConfigParams::m_width, UserConfigParams::m_height);
PROFILER_POP_CPU_MARKER();
}
else
renderColorLevel(in_rtt);
glDisable(GL_FRAMEBUFFER_SRGB);
{
glEnable(GL_FRAMEBUFFER_SRGB);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
renderPassThrough(in_rtt);
glDisable(GL_FRAMEBUFFER_SRGB);
}
}
} // render

45
src/graphics/render.cpp
View File

@ -184,7 +184,7 @@ void IrrDriver::renderGLSL(float dt)
PROFILER_PUSH_CPU_MARKER("- Shadow", 0x30, 0x6F, 0x90);
// Shadows
if (!m_mipviz && !m_wireframe && UserConfigParams::m_shadows)
if (!m_mipviz && !m_wireframe && UserConfigParams::m_dynamic_lights && UserConfigParams::m_shadows)
//&& World::getWorld()->getTrack()->hasShadows())
{
renderShadows(camnode, camera);
@ -214,7 +214,7 @@ void IrrDriver::renderGLSL(float dt)
PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00);
// Render anything glowing.
if (!m_mipviz && !m_wireframe)
if (!m_mipviz && !m_wireframe && UserConfigParams::m_glow)
{
irr_driver->setPhase(GLOW_PASS);
renderGlow(overridemat, glows, cambox, cam);
@ -225,7 +225,7 @@ void IrrDriver::renderGLSL(float dt)
// Is the lens flare enabled & visible? Check last frame's query.
const bool hasflare = World::getWorld()->getTrack()->hasLensFlare();
const bool hasgodrays = World::getWorld()->getTrack()->hasGodRays();
if (true)//hasflare || hasgodrays)
if (UserConfigParams::m_light_shaft)//hasflare || hasgodrays)
{
irr::video::COpenGLDriver* gl_driver = (irr::video::COpenGLDriver*)m_device->getVideoDriver();
@ -428,6 +428,9 @@ void IrrDriver::renderSolidFirstPass()
m_scene_manager->drawAll(scene::ESNRP_SOLID);
if (!UserConfigParams::m_dynamic_lights)
return;
glUseProgram(MeshShader::ObjectPass1Shader::Program);
for (unsigned i = 0; i < GroupedFPSM<FPSM_DEFAULT>::MeshSet.size(); ++i)
{
@ -452,7 +455,14 @@ void IrrDriver::renderSolidSecondPass()
glClearColor(clearColor.getRed() / 255.f, clearColor.getGreen() / 255.f,
clearColor.getBlue() / 255.f, clearColor.getAlpha() / 255.f);
glClear(GL_COLOR_BUFFER_BIT);
glDepthMask(GL_FALSE);
if (UserConfigParams::m_dynamic_lights)
glDepthMask(GL_FALSE);
else
{
glDepthMask(GL_TRUE);
glClear(GL_DEPTH_BUFFER_BIT);
}
irr_driver->setPhase(SOLID_LIT_PASS);
glEnable(GL_DEPTH_TEST);
@ -502,7 +512,6 @@ void IrrDriver::renderSolidSecondPass()
glUseProgram(MeshShader::UntexturedObjectShader::Program);
for (unsigned i = 0; i < GroupedSM<SM_UNTEXTURED>::MeshSet.size(); i++)
drawUntexturedObject(*GroupedSM<SM_UNTEXTURED>::MeshSet[i], GroupedSM<SM_UNTEXTURED>::MVPSet[i]);
}
void IrrDriver::renderTransparent()
@ -514,7 +523,6 @@ void IrrDriver::renderTransparent()
glDepthMask(GL_FALSE);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
m_scene_manager->drawAll(scene::ESNRP_TRANSPARENT);
}
@ -850,15 +858,21 @@ void IrrDriver::renderLights(const core::aabbox3df& cambox,
video::SOverrideMaterial &overridemat,
int cam, float dt)
{
if (SkyboxCubeMap)
irr_driver->getSceneManager()->setAmbientLight(SColor(0, 0, 0, 0));
for (unsigned i = 0; i < sun_ortho_matrix.size(); i++)
sun_ortho_matrix[i] *= getInvViewMatrix();
glBindFramebuffer(GL_FRAMEBUFFER, m_rtts->getFBO(FBO_COMBINED_TMP1_TMP2));
irr::video::COpenGLDriver* gl_driver = (irr::video::COpenGLDriver*)m_device->getVideoDriver();
GLenum bufs[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
gl_driver->extGlDrawBuffers(2, bufs);
if (!UserConfigParams::m_dynamic_lights)
glClearColor(.5, .5, .5, .5);
glClear(GL_COLOR_BUFFER_BIT);
if (!UserConfigParams::m_dynamic_lights)
return;
if (SkyboxCubeMap)
irr_driver->getSceneManager()->setAmbientLight(SColor(0, 0, 0, 0));
const u32 lightcount = m_lights.size();
const core::vector3df &campos =
@ -935,10 +949,12 @@ void IrrDriver::renderLights(const core::aabbox3df& cambox,
glBindFramebuffer(GL_FRAMEBUFFER, m_rtts->getFBO(FBO_SSAO));
glClearColor(1., 1., 1., 1.);
glClear(GL_COLOR_BUFFER_BIT);
glViewport(0, 0, UserConfigParams::m_width / 2, UserConfigParams::m_height / 2);
m_post_processing->renderSSAO(irr_driver->getInvProjMatrix(), irr_driver->getProjMatrix());
// Blur it to reduce noise.
m_post_processing->renderGaussian6Blur(irr_driver->getFBO(FBO_SSAO), irr_driver->getRenderTargetTexture(RTT_SSAO),
irr_driver->getFBO(FBO_TMP4), irr_driver->getRenderTargetTexture(RTT_TMP4), UserConfigParams::m_width, UserConfigParams::m_height);
irr_driver->getFBO(FBO_HALF1), irr_driver->getRenderTargetTexture(RTT_HALF1), UserConfigParams::m_width / 2, UserConfigParams::m_height / 2);
glViewport(0, 0, UserConfigParams::m_width, UserConfigParams::m_height);
}
}
@ -1313,18 +1329,23 @@ void IrrDriver::generateSkyboxCubemap()
image->drop();
glBindTexture(GL_TEXTURE_CUBE_MAP, SkyboxCubeMap);
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_COMPRESSED_SRGB_ALPHA, w, h, 0, GL_BGRA, GL_UNSIGNED_BYTE, (GLvoid*)rgba[i]);
if (UserConfigParams::m_texture_compression)
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_COMPRESSED_SRGB_ALPHA, w, h, 0, GL_BGRA, GL_UNSIGNED_BYTE, (GLvoid*)rgba[i]);
else
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_SRGB_ALPHA, w, h, 0, GL_BGRA, GL_UNSIGNED_BYTE, (GLvoid*)rgba[i]);
}
testSH(rgba, w, h, blueSHCoeff, greenSHCoeff, redSHCoeff);
for (unsigned i = 0; i < 6; i++)
delete[] rgba[i];
/*for (unsigned i = 0; i < 6; i++)
{
glBindTexture(GL_TEXTURE_CUBE_MAP, ConvolutedSkyboxCubeMap);
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_SRGB_ALPHA, w, h, 0, GL_BGRA, GL_UNSIGNED_BYTE, (GLvoid*)rgba[i]);
}
for (unsigned i = 0; i < 6; i++)
delete[] rgba[i];
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);*/
}

23
src/graphics/rtts.cpp
View File

@ -64,12 +64,11 @@ RTT::RTT()
const dimension2du eighth = res/8;
const dimension2du sixteenth = res/16;
const dimension2du ssaosize = UserConfigParams::m_ssao == 2 ? res : quarter;
const u16 shadowside = 1024;
const dimension2du shadowsize0(shadowside, shadowside);
const dimension2du shadowsize1(shadowside / 2, shadowside / 2);
const dimension2du shadowsize2(shadowside / 4, shadowside / 4);
const dimension2du shadowsize3(shadowside / 8, shadowside / 8);
const dimension2du warpvsize(1, 512);
const dimension2du warphsize(512, 1);
@ -86,9 +85,9 @@ RTT::RTT()
RenderTargetTextures[RTT_TMP4] = generateRTT(res, GL_R16F, GL_RED, GL_FLOAT);
RenderTargetTextures[RTT_NORMAL_AND_DEPTH] = generateRTT(res, GL_RGB16F, GL_RGB, GL_FLOAT);
RenderTargetTextures[RTT_COLOR] = generateRTT(res, GL_RGBA16F, GL_BGRA, GL_FLOAT);
RenderTargetTextures[RTT_MLAA_COLORS] = generateRTT(res, GL_RGBA8, GL_BGRA, GL_UNSIGNED_BYTE);
RenderTargetTextures[RTT_MLAA_COLORS] = generateRTT(res, GL_SRGB, GL_BGR, GL_UNSIGNED_BYTE);
RenderTargetTextures[RTT_LOG_LUMINANCE] = generateRTT(res, GL_R16F, GL_RED, GL_FLOAT);
RenderTargetTextures[RTT_SSAO] = generateRTT(res, GL_R16F, GL_RED, GL_FLOAT);
RenderTargetTextures[RTT_SSAO] = generateRTT(half, GL_R16F, GL_RED, GL_FLOAT);
RenderTargetTextures[RTT_DISPLACE] = generateRTT(res, GL_RGBA16F, GL_BGRA, GL_FLOAT);
RenderTargetTextures[RTT_HALF1] = generateRTT(half, GL_RGBA16F, GL_BGRA, GL_FLOAT);
@ -99,6 +98,14 @@ RTT::RTT()
RenderTargetTextures[RTT_QUARTER2] = generateRTT(quarter, GL_RGBA16F, GL_BGRA, GL_FLOAT);
RenderTargetTextures[RTT_EIGHTH2] = generateRTT(eighth, GL_RGBA16F, GL_BGRA, GL_FLOAT);
RenderTargetTextures[RTT_BLOOM_1024] = generateRTT(shadowsize0, GL_RGB16F, GL_BGR, GL_FLOAT);
RenderTargetTextures[RTT_BLOOM_512] = generateRTT(shadowsize1, GL_RGB16F, GL_BGR, GL_FLOAT);
RenderTargetTextures[RTT_TMP_512] = generateRTT(shadowsize1, GL_RGB16F, GL_BGR, GL_FLOAT);
RenderTargetTextures[RTT_BLOOM_256] = generateRTT(shadowsize2, GL_RGB16F, GL_BGR, GL_FLOAT);
RenderTargetTextures[RTT_TMP_256] = generateRTT(shadowsize2, GL_RGB16F, GL_BGR, GL_FLOAT);
RenderTargetTextures[RTT_BLOOM_128] = generateRTT(shadowsize3, GL_RGB16F, GL_BGR, GL_FLOAT);
RenderTargetTextures[RTT_TMP_128] = generateRTT(shadowsize3, GL_RGB16F, GL_BGR, GL_FLOAT);
FrameBuffers[FBO_SSAO] = generateFBO(RenderTargetTextures[RTT_SSAO]);
// Clear this FBO to 1s so that if no SSAO is computed we can still use it.
glClearColor(1., 1., 1., 1.);
@ -119,6 +126,14 @@ RTT::RTT()
FrameBuffers[FBO_EIGHTH1] = generateFBO(RenderTargetTextures[RTT_EIGHTH1]);
FrameBuffers[FBO_EIGHTH2] = generateFBO(RenderTargetTextures[RTT_EIGHTH2]);
FrameBuffers[FBO_BLOOM_1024] = generateFBO(RenderTargetTextures[RTT_BLOOM_1024]);
FrameBuffers[FBO_BLOOM_512] = generateFBO(RenderTargetTextures[RTT_BLOOM_512]);
FrameBuffers[FBO_TMP_512] = generateFBO(RenderTargetTextures[RTT_TMP_512]);
FrameBuffers[FBO_BLOOM_256] = generateFBO(RenderTargetTextures[RTT_BLOOM_256]);
FrameBuffers[FBO_TMP_256] = generateFBO(RenderTargetTextures[RTT_TMP_256]);
FrameBuffers[FBO_BLOOM_128] = generateFBO(RenderTargetTextures[RTT_BLOOM_128]);
FrameBuffers[FBO_TMP_128] = generateFBO(RenderTargetTextures[RTT_TMP_128]);
FrameBuffers[FBO_COMBINED_TMP1_TMP2] = generateFBO(RenderTargetTextures[RTT_TMP1], DepthStencilTexture);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, RenderTargetTextures[RTT_TMP2], 0);

15
src/graphics/rtts.hpp
View File

@ -64,6 +64,14 @@ enum TypeRTT
RTT_DISPLACE,
RTT_MLAA_COLORS,
RTT_BLOOM_1024,
RTT_BLOOM_512,
RTT_TMP_512,
RTT_BLOOM_256,
RTT_TMP_256,
RTT_BLOOM_128,
RTT_TMP_128,
RTT_COUNT
};
@ -86,6 +94,13 @@ enum TypeFBO
FBO_EIGHTH1,
FBO_EIGHTH2,
FBO_DISPLACE,
FBO_BLOOM_1024,
FBO_BLOOM_512,
FBO_TMP_512,
FBO_BLOOM_256,
FBO_TMP_256,
FBO_BLOOM_128,
FBO_TMP_128,
FBO_COUNT
};

17
src/graphics/stkanimatedmesh.cpp
View File

@ -90,6 +90,7 @@ void STKAnimatedMesh::render()
if (!mb)
continue;
video::E_MATERIAL_TYPE type = mb->getMaterial().MaterialType;
f32 MaterialTypeParam = mb->getMaterial().MaterialTypeParam;
video::IMaterialRenderer* rnd = driver->getMaterialRenderer(type);
if (!isObject(type))
{
@ -101,7 +102,7 @@ void STKAnimatedMesh::render()
GLMesh &mesh = GLmeshes[i];
if (rnd->isTransparent())
{
TransparentMaterial TranspMat = MaterialTypeToTransparentMaterial(type);
TransparentMaterial TranspMat = MaterialTypeToTransparentMaterial(type, MaterialTypeParam);
initvaostate(mesh, TranspMat);
TransparentMesh[TranspMat].push_back(&mesh);
}
@ -254,19 +255,25 @@ void STKAnimatedMesh::render()
if (World::getWorld()->getTrack()->isFogEnabled())
{
if (!TransparentMesh[TM_DEFAULT].empty())
if (!TransparentMesh[TM_DEFAULT].empty() || !TransparentMesh[TM_ADDITIVE].empty())
glUseProgram(MeshShader::TransparentFogShader::Program);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
for_in(mesh, TransparentMesh[TM_DEFAULT])
drawTransparentFogObject(*mesh, ModelViewProjectionMatrix, mesh->TextureMatrix);
glBlendFunc(GL_ONE, GL_ONE);
for_in(mesh, TransparentMesh[TM_ADDITIVE])
drawTransparentFogObject(*mesh, ModelViewProjectionMatrix, mesh->TextureMatrix);
}
else
{
if (!TransparentMesh[TM_DEFAULT].empty())
if (!TransparentMesh[TM_DEFAULT].empty() || !TransparentMesh[TM_ADDITIVE].empty())
glUseProgram(MeshShader::TransparentShader::Program);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
for_in(mesh, TransparentMesh[TM_DEFAULT])
drawTransparentObject(*mesh, ModelViewProjectionMatrix, mesh->TextureMatrix);
glBlendFunc(GL_ONE, GL_ONE);
for_in(mesh, TransparentMesh[TM_ADDITIVE])
drawTransparentObject(*mesh, ModelViewProjectionMatrix, mesh->TextureMatrix);
}
return;
}

19
src/graphics/stkinstancedscenenode.cpp
View File

@ -186,12 +186,27 @@ static void drawFSPMDefault(GLMesh &mesh, size_t instance_count)
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], true);
setTexture(0, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
if (mesh.textures[0])
{
compressTexture(mesh.textures[0], true);
setTexture(0, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
}
else
{
setTexture(0, 0, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, false);
GLint swizzleMask[] = { GL_ONE, GL_ONE, GL_ONE, GL_ONE };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
MeshShader::InstancedObjectPass1Shader::setUniforms(0);
glBindVertexArray(mesh.vao_first_pass);
glDrawElementsInstanced(ptype, count, itype, 0, instance_count);
if (!mesh.textures[0])
{
GLint swizzleMask[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
}
static void drawShadowDefault(GLMesh &mesh, size_t instance_count)

13
src/graphics/stkmesh.cpp
View File

@ -45,12 +45,17 @@ ShadedMaterial MaterialTypeToShadedMaterial(video::E_MATERIAL_TYPE type, video::
return SM_DEFAULT;
}
TransparentMaterial MaterialTypeToTransparentMaterial(video::E_MATERIAL_TYPE type)
TransparentMaterial MaterialTypeToTransparentMaterial(video::E_MATERIAL_TYPE type, f32 MaterialTypeParam)
{
if (type == irr_driver->getShader(ES_BUBBLES))
return TM_BUBBLE;
else
return TM_DEFAULT;
video::E_BLEND_FACTOR srcFact, DstFact;
video::E_MODULATE_FUNC mod;
u32 alpha;
unpack_textureBlendFunc(srcFact, DstFact, mod, alpha, MaterialTypeParam);
if (DstFact == video::EBF_ONE)
return TM_ADDITIVE;
return TM_DEFAULT;
}
GLuint createVAO(GLuint vbo, GLuint idx, GLuint attrib_position, GLuint attrib_texcoord, GLuint attrib_second_texcoord, GLuint attrib_normal, GLuint attrib_tangent, GLuint attrib_bitangent, GLuint attrib_color, size_t stride)
@ -850,10 +855,10 @@ void initvaostate(GLMesh &mesh, TransparentMaterial TranspMat)
MeshShader::BubbleShader::attrib_position, MeshShader::BubbleShader::attrib_texcoord, -1, -1, -1, -1, -1, mesh.Stride);
break;
case TM_DEFAULT:
case TM_ADDITIVE:
if (World::getWorld()->getTrack()->isFogEnabled())
mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
MeshShader::TransparentFogShader::attrib_position, MeshShader::TransparentFogShader::attrib_texcoord, -1, -1, -1, -1, MeshShader::TransparentFogShader::attrib_color, mesh.Stride);
else
mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
MeshShader::TransparentShader::attrib_position, MeshShader::TransparentShader::attrib_texcoord, -1, -1, -1, -1, MeshShader::TransparentShader::attrib_color, mesh.Stride);

3
src/graphics/stkmesh.hpp
View File

@ -35,6 +35,7 @@ enum ShadedMaterial
enum TransparentMaterial
{
TM_DEFAULT,
TM_ADDITIVE,
TM_BUBBLE,
TM_COUNT
};
@ -139,6 +140,6 @@ void drawBubble(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatr
GeometricMaterial MaterialTypeToGeometricMaterial(video::E_MATERIAL_TYPE);
ShadedMaterial MaterialTypeToShadedMaterial(video::E_MATERIAL_TYPE, irr::video::ITexture **textures);
TransparentMaterial MaterialTypeToTransparentMaterial(video::E_MATERIAL_TYPE);
TransparentMaterial MaterialTypeToTransparentMaterial(video::E_MATERIAL_TYPE, f32 MaterialTypeParam);
#endif // STKMESH_H

15
src/graphics/stkmeshscenenode.cpp
View File

@ -46,6 +46,7 @@ void STKMeshSceneNode::setFirstTimeMaterial()
if (!mb)
continue;
video::E_MATERIAL_TYPE type = mb->getMaterial().MaterialType;
f32 MaterialTypeParam = mb->getMaterial().MaterialTypeParam;
video::IMaterialRenderer* rnd = driver->getMaterialRenderer(type);
if (!isObject(type))
{
@ -58,7 +59,7 @@ void STKMeshSceneNode::setFirstTimeMaterial()
GLMesh &mesh = GLmeshes[i];
if (rnd->isTransparent())
{
TransparentMaterial TranspMat = MaterialTypeToTransparentMaterial(type);
TransparentMaterial TranspMat = MaterialTypeToTransparentMaterial(type, MaterialTypeParam);
initvaostate(mesh, TranspMat);
TransparentMesh[TranspMat].push_back(&mesh);
}
@ -500,17 +501,25 @@ void STKMeshSceneNode::render()
if (World::getWorld()->getTrack()->isFogEnabled())
{
if (!TransparentMesh[TM_DEFAULT].empty())
if (!TransparentMesh[TM_DEFAULT].empty() || !TransparentMesh[TM_ADDITIVE].empty())
glUseProgram(MeshShader::TransparentFogShader::Program);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
for_in(mesh, TransparentMesh[TM_DEFAULT])
drawTransparentFogObject(*mesh, ModelViewProjectionMatrix, (*mesh).TextureMatrix);
glBlendFunc(GL_ONE, GL_ONE);
for_in(mesh, TransparentMesh[TM_ADDITIVE])
drawTransparentFogObject(*mesh, ModelViewProjectionMatrix, (*mesh).TextureMatrix);
}
else
{
if (!TransparentMesh[TM_DEFAULT].empty())
if (!TransparentMesh[TM_DEFAULT].empty() || !TransparentMesh[TM_ADDITIVE].empty())
glUseProgram(MeshShader::TransparentShader::Program);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
for_in(mesh, TransparentMesh[TM_DEFAULT])
drawTransparentObject(*mesh, ModelViewProjectionMatrix, (*mesh).TextureMatrix);
glBlendFunc(GL_ONE, GL_ONE);
for_in(mesh, TransparentMesh[TM_ADDITIVE])
drawTransparentObject(*mesh, ModelViewProjectionMatrix, (*mesh).TextureMatrix);
}
return;
}

80
src/race/grand_prix_data.cpp
View File

@ -218,30 +218,49 @@ bool GrandPrixData::checkConsistency(bool chatty) const
/** Returns true if the track is available. This is used to test if Fort Magma
* is available (this way FortMagma is not used in the last Grand Prix in
* story mode, but will be available once all challenges are done and nolok
* is unlocked).
* is unlocked). It also prevents people from using the grand prix editor as
* a way to play tracks that still haven't been unlocked
*/
bool GrandPrixData::isTrackAvailable(const std::string &id) const
bool GrandPrixData::isTrackAvailable(const std::string &id, bool includeLocked) const
{
return id!="fortmagma" ||
!PlayerManager::getCurrentPlayer()->isLocked("fortmagma");
if (includeLocked)
return true;
else if (id == "fortmagma")
return !PlayerManager::getCurrentPlayer()->isLocked("fortmagma");
else
return (!m_editable || !PlayerManager::get()->getCurrentPlayer()->isLocked(id));
} // isTrackAvailable
// ----------------------------------------------------------------------------
void GrandPrixData::getLaps(std::vector<int> *laps) const
std::vector<std::string> GrandPrixData::getTrackNames(bool includeLocked) const
{
laps->clear();
std::vector<std::string> names;
for (unsigned int i = 0; i < m_tracks.size(); i++)
{
if(isTrackAvailable(m_tracks[i], includeLocked))
names.push_back(m_tracks[i]);
} // for i
return names;
} // getTrackNames
// ----------------------------------------------------------------------------
std::vector<int> GrandPrixData::getLaps(bool includeLocked) const
{
std::vector<int> laps;
for (unsigned int i = 0; i< m_tracks.size(); i++)
if(isTrackAvailable(m_tracks[i]))
laps->push_back(m_laps[i]);
if(isTrackAvailable(m_tracks[i], includeLocked))
laps.push_back(m_laps[i]);
return laps;
} // getLaps
// ----------------------------------------------------------------------------
void GrandPrixData::getReverse(std::vector<bool> *reverse) const
std::vector<bool> GrandPrixData::getReverse(bool includeLocked) const
{
reverse->clear();
std::vector<bool> reverse;
for (unsigned int i = 0; i< m_tracks.size(); i++)
if(isTrackAvailable(m_tracks[i]))
reverse->push_back(m_reversed[i]);
if(isTrackAvailable(m_tracks[i], includeLocked))
reverse.push_back(m_reversed[i]);
return reverse;
} // getReverse
// ----------------------------------------------------------------------------
@ -251,15 +270,18 @@ bool GrandPrixData::isEditable() const
} // isEditable
// ----------------------------------------------------------------------------
unsigned int GrandPrixData::getNumberOfTracks() const
unsigned int GrandPrixData::getNumberOfTracks(bool includeLocked) const
{
return m_tracks.size();
if (includeLocked)
return m_tracks.size();
else
return getTrackNames(false).size();
}
// ----------------------------------------------------------------------------
irr::core::stringw GrandPrixData::getTrackName(const unsigned int track) const
{
assert(track < getNumberOfTracks());
assert(track < getNumberOfTracks(true));
Track* t = track_manager->getTrack(m_tracks[track]);
assert(t != NULL);
return t->getName();
@ -268,28 +290,28 @@ irr::core::stringw GrandPrixData::getTrackName(const unsigned int track) const
// ----------------------------------------------------------------------------
const std::string& GrandPrixData::getTrackId(const unsigned int track) const
{
assert(track < getNumberOfTracks());
assert(track < getNumberOfTracks(true));
return m_tracks[track];
}
// ----------------------------------------------------------------------------
unsigned int GrandPrixData::getLaps(const unsigned int track) const
{
assert(track < getNumberOfTracks());
assert(track < getNumberOfTracks(true));
return m_laps[track];
}
// ----------------------------------------------------------------------------
bool GrandPrixData::getReverse(const unsigned int track) const
{
assert(track < getNumberOfTracks());
assert(track < getNumberOfTracks(true));
return m_reversed[track];
}
// ----------------------------------------------------------------------------
void GrandPrixData::moveUp(const unsigned int track)
{
assert (track > 0 && track < getNumberOfTracks());
assert (track > 0 && track < getNumberOfTracks(true));
std::swap(m_tracks[track], m_tracks[track - 1]);
std::swap(m_laps[track], m_laps[track - 1]);
@ -301,7 +323,7 @@ void GrandPrixData::moveUp(const unsigned int track)
// ----------------------------------------------------------------------------
void GrandPrixData::moveDown(const unsigned int track)
{
assert (track < (getNumberOfTracks() - 1));
assert (track < (getNumberOfTracks(true) - 1));
std::swap(m_tracks[track], m_tracks[track + 1]);
std::swap(m_laps[track], m_laps[track + 1]);
@ -316,7 +338,7 @@ void GrandPrixData::addTrack(Track* track, unsigned int laps, bool reverse,
{
int n;
n = getNumberOfTracks();
n = getNumberOfTracks(true);
assert (track != NULL);
assert (laps > 0);
assert (position >= -1 && position < n);
@ -342,7 +364,7 @@ void GrandPrixData::addTrack(Track* track, unsigned int laps, bool reverse,
void GrandPrixData::editTrack(unsigned int t, Track* track,
unsigned int laps, bool reverse)
{
assert (t < getNumberOfTracks());
assert (t < getNumberOfTracks(true));
assert (track != NULL);
assert (laps > 0);
@ -354,23 +376,11 @@ void GrandPrixData::editTrack(unsigned int t, Track* track,
// ----------------------------------------------------------------------------
void GrandPrixData::remove(const unsigned int track)
{
assert (track < getNumberOfTracks());
assert (track < getNumberOfTracks(true));
m_tracks.erase(m_tracks.begin() + track);
m_laps.erase(m_laps.begin() + track);
m_reversed.erase(m_reversed.begin() + track);
}
// ----------------------------------------------------------------------------
const std::vector<std::string>& GrandPrixData::getTrackNames() const
{
m_really_available_tracks.clear();
for (unsigned int i = 0; i < m_tracks.size(); i++)
{
if(isTrackAvailable(m_tracks[i]))
m_really_available_tracks.push_back(m_tracks[i]);
} // for i
return m_really_available_tracks;
} // getTrackNames
/* EOF */

51
src/race/grand_prix_data.hpp
View File

@ -51,15 +51,6 @@ private:
* (ie. 'volcano'). */
std::vector<std::string> m_tracks;
/** This is the list of actually available tracks. In the last GP Fort
* Magma can not be used untill the final challenge. In order to provide
* still 5 tracks/GP, the last GP is only using 4 tracks in story mode,
* but (once nolok is unlocked) Fort Magma is added after that. So this
* list is always re-evaluated depending on the state of Nolok (i.e. if
* nolok is unlocked, Fort Magma is available, otherwise not).
* Mark this member mutable so that getTrackNames can be const. */
mutable std::vector<std::string> m_really_available_tracks;
/** The number of laps that each track should be raced, in the right order */
std::vector<int> m_laps;
@ -69,7 +60,13 @@ private:
/** Wether the user can edit this grand prix or not */
bool m_editable;
bool isTrackAvailable(const std::string &id) const;
/** In the last GP Fort Magma can not be used untill the final challenge.
* In order to provide still 5 tracks/GP, the last GP is only using 4
* tracks in story mode, but once nolok is unlocked Fort Magma becomes
* available (i.e. if nolok is unlocked, Fort Magma is available, otherwise
* not).
*/
bool isTrackAvailable(const std::string &id, bool includeLocked) const;
public:
@ -87,23 +84,23 @@ public:
void reload();
bool writeToFile();
bool checkConsistency(bool chatty=true) const;
const std::vector<std::string>& getTrackNames() const;
void getLaps(std::vector<int> *laps) const;
void getReverse(std::vector<bool> *reverse) const;
bool isEditable() const;
unsigned int getNumberOfTracks() const;
const std::string& getTrackId(const unsigned int track) const;
irr::core::stringw getTrackName(const unsigned int track) const;
unsigned int getLaps(const unsigned int track) const;
bool getReverse(const unsigned int track) const;
void moveUp(const unsigned int track);
void moveDown(const unsigned int track);
void addTrack(Track* track, unsigned int laps,
bool reverse, int position=-1);
void editTrack(unsigned int t, Track* track,
unsigned int laps, bool reverse);
void remove(const unsigned int track);
bool checkConsistency(bool chatty=true) const;
std::vector<std::string> getTrackNames(const bool includeLocked=false) const;
std::vector<int> getLaps(const bool includeLocked=false) const;
std::vector<bool> getReverse(const bool includeLocked=false) const;
bool isEditable() const;
unsigned int getNumberOfTracks(const bool includeLocked=false) const;
const std::string& getTrackId(const unsigned int track) const;
irr::core::stringw getTrackName(const unsigned int track) const;
unsigned int getLaps(const unsigned int track) const;
bool getReverse(const unsigned int track) const;
void moveUp(const unsigned int track);
void moveDown(const unsigned int track);
void addTrack(Track* track, unsigned int laps,
bool reverse, int position=-1);
void editTrack(unsigned int t, Track* track,
unsigned int laps, bool reverse);
void remove(const unsigned int track);
// ------------------------------------------------------------------------
/** @return the (potentially translated) user-visible name of the Grand

4
src/race/race_manager.cpp
View File

@ -284,8 +284,8 @@ void RaceManager::startNew(bool from_overworld)
{
// GP: get tracks, laps and reverse info from grand prix
m_tracks = m_grand_prix.getTrackNames();
m_grand_prix.getLaps(&m_num_laps);
m_grand_prix.getReverse(&m_reverse_track);
m_num_laps = m_grand_prix.getLaps();
m_reverse_track = m_grand_prix.getReverse();
}
//assert(m_player_karts.size() > 0);

6
src/states_screens/dialogs/custom_video_settings.cpp
View File

@ -99,7 +99,7 @@ void CustomVideoSettingsialog::beforeAddingWidgets()
getWidget<CheckBoxWidget>("motionblur")->setState( UserConfigParams::m_motionblur );
getWidget<CheckBoxWidget>("mlaa")->setState( UserConfigParams::m_mlaa );
getWidget<CheckBoxWidget>("pixelshaders")->setState(UserConfigParams::m_pixel_shaders);
// getWidget<CheckBoxWidget>("pixelshaders")->setState(UserConfigParams::m_pixel_shaders);
}
// -----------------------------------------------------------------------------
@ -118,8 +118,8 @@ GUIEngine::EventPropagation CustomVideoSettingsialog::processEvent(const std::st
getWidget<CheckBoxWidget>("motionblur")->getState();
UserConfigParams::m_show_steering_animations =
getWidget<SpinnerWidget>("steering_animations")->getValue();
UserConfigParams::m_pixel_shaders =
getWidget<CheckBoxWidget>("pixelshaders")->getState();
// UserConfigParams::m_pixel_shaders =
// getWidget<CheckBoxWidget>("pixelshaders")->getState();
UserConfigParams::m_mlaa =
getWidget<CheckBoxWidget>("mlaa")->getState();
UserConfigParams::m_ssao =

16
src/states_screens/dialogs/gp_info_dialog.cpp
View File

@ -75,7 +75,7 @@ GPInfoDialog::GPInfoDialog(const std::string& gpIdent, const float w, const floa
// ---- Track listings
const std::vector<std::string>& tracks = gp->getTrackNames();
const std::vector<std::string> tracks = gp->getTrackNames();
const int trackAmount = tracks.size();
int height_of_one_line = (y2 - y1)/(trackAmount+1);
@ -130,7 +130,7 @@ GPInfoDialog::GPInfoDialog(const std::string& gpIdent, const float w, const floa
m_screenshot_widget->m_w = m_area.getWidth()/2;
m_screenshot_widget->m_h = y2 - y1 - 10;
Track* track = track_manager->getTrack(tracks[0]);
Track* track = (tracks.size() == 0 ? NULL : track_manager->getTrack(tracks[0]));
m_screenshot_widget->m_properties[PROP_ICON] = (track != NULL ?
track->getScreenshotFile().c_str() :
@ -152,7 +152,12 @@ GPInfoDialog::GPInfoDialog(const std::string& gpIdent, const float w, const floa
race_manager->getNumberOfKarts(),
race_manager->getNumLocalPlayers());
if (gp_ok)
if (tracks.size() == 0)
{
okBtn->m_properties[PROP_ID] = "cannot_start";
okBtn->setText(_("Sorry, no tracks available"));
}
else if (gp_ok)
{
okBtn->m_properties[PROP_ID] = "start";
okBtn->setText(_("Start Grand Prix"));
@ -265,14 +270,15 @@ void GPInfoDialog::onUpdate(float dt)
const GrandPrixData* gp = grand_prix_manager->getGrandPrix(m_gp_ident);
assert(gp != NULL);
const std::vector<std::string>& tracks = gp->getTrackNames();
const std::vector<std::string> tracks = gp->getTrackNames();
if (frameAfter >= (int)tracks.size())
{
frameAfter = 0;
m_curr_time = 0;
}
Track* track = track_manager->getTrack(tracks[frameAfter]);
Track* track = (tracks.size() == 0 ? NULL :
track_manager->getTrack(tracks[frameAfter]));
std::string fn = track ? track->getScreenshotFile()
: file_manager->getAsset(FileManager::GUI, "main_help.png");
m_screenshot_widget->setImage(fn.c_str(), IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE);

10
src/states_screens/edit_gp_screen.cpp
View File

@ -199,8 +199,8 @@ void EditGPScreen::onConfirm()
if (m_action == "remove")
{
m_gp->remove(m_selected);
setSelected(m_selected >= (int)m_gp->getNumberOfTracks() ?
m_gp->getNumberOfTracks() - 1 : m_selected);
setSelected(m_selected >= (int)m_gp->getNumberOfTracks(true) ?
m_gp->getNumberOfTracks(true) - 1 : m_selected);
loadList(m_selected);
setModified(true);
}
@ -228,7 +228,7 @@ void EditGPScreen::loadList(const int selected)
m_icon_bank->scaleToHeight (64);
m_list->setIcons(m_icon_bank, 64);
for (unsigned int i = 0; i < m_gp->getNumberOfTracks(); i++)
for (unsigned int i = 0; i < m_gp->getNumberOfTracks(true); i++)
{
std::vector<GUIEngine::ListWidget::ListCell> row;
@ -290,8 +290,8 @@ void EditGPScreen::edit()
{
edit_screen->setSelection(track_manager->getTrack(
m_gp->getTrackId(m_selected)),
m_gp->getLaps(m_selected),
m_gp->getReverse(m_selected));
m_gp->getLaps((unsigned int)m_selected),
m_gp->getReverse((unsigned int)m_selected));
StateManager::get()->pushScreen(edit_screen);
}
}

2
src/states_screens/feature_unlocked.cpp
View File

@ -625,7 +625,7 @@ void FeatureUnlockedCutScene::addUnlockedGP(const GrandPrixData* gp)
}
else
{
const std::vector<std::string>& gptracks = gp->getTrackNames();
const std::vector<std::string> gptracks = gp->getTrackNames();
const int trackAmount = gptracks.size();
if (trackAmount == 0)

4
src/states_screens/grand_prix_editor_screen.cpp
View File

@ -171,7 +171,7 @@ void GrandPrixEditorScreen::loadTrackList (const std::string& gpname)
assert(tracks_widget != NULL);
const GrandPrixData* gp = grand_prix_manager->getGrandPrix(gpname);
const std::vector<std::string>& tracks = gp->getTrackNames();
const std::vector<std::string> tracks = gp->getTrackNames(true);
tracks_widget->clearItems();
tracks_widget->setItemCountHint(tracks.size());
@ -209,7 +209,7 @@ void GrandPrixEditorScreen::loadGPList()
for (unsigned int i = 0; i < grand_prix_manager->getNumberOfGrandPrix(); i++)
{
const GrandPrixData* gp = grand_prix_manager->getGrandPrix(i);
const std::vector<std::string>& tracks = gp->getTrackNames();
const std::vector<std::string> tracks = gp->getTrackNames(true);
std::vector<std::string> sshot_files;
for (unsigned int t=0; t<tracks.size(); t++)

9
src/states_screens/options_screen_video.cpp
View File

@ -318,7 +318,8 @@ void OptionsScreenVideo::updateGfxSlider()
UserConfigParams::m_mlaa == GFX_MLAA[l] &&
UserConfigParams::m_ssao == GFX_SSAO[l] &&
UserConfigParams::m_shadows == GFX_SHADOWS[l] &&
UserConfigParams::m_pixel_shaders == GFX_PIXEL_SHADERS[l])
// UserConfigParams::m_pixel_shaders == GFX_PIXEL_SHADERS[l])
true)
{
gfx->setValue(l+1);
found = true;
@ -374,8 +375,8 @@ void OptionsScreenVideo::updateTooltip()
*/
//I18N: in graphical options
tooltip = tooltip + L"\n" + _("Pixel shaders : %s",
UserConfigParams::m_pixel_shaders ? enabled : disabled);
// tooltip = tooltip + L"\n" + _("Pixel shaders : %s",
// UserConfigParams::m_pixel_shaders ? enabled : disabled);
//I18N: in graphical options
tooltip = _("Animated Scenery : %s",
UserConfigParams::m_graphical_effects ? enabled : disabled);
@ -480,7 +481,7 @@ void OptionsScreenVideo::eventCallback(Widget* widget, const std::string& name,
UserConfigParams::m_weather_effects = GFX_WEATHER[level-1];
//UserConfigParams::m_antialiasing = GFX_ANTIALIAS[level-1];
UserConfigParams::m_motionblur = GFX_MOTIONBLUR[level-1];
UserConfigParams::m_pixel_shaders = GFX_PIXEL_SHADERS[level-1];
// UserConfigParams::m_pixel_shaders = GFX_PIXEL_SHADERS[level-1];
UserConfigParams::m_mlaa = GFX_MLAA[level-1];
UserConfigParams::m_ssao = GFX_SSAO[level-1];
UserConfigParams::m_shadows = GFX_SHADOWS[level-1];

6
src/states_screens/race_result_gui.cpp
View File

@ -91,7 +91,7 @@ void RaceResultGUI::init()
(m_sshot_height + SSHOT_SEPARATION))); //Show at least one
// Calculate screenshot scrolling parameters
const std::vector<std::string>& tracks =
const std::vector<std::string> tracks =
race_manager->getGrandPrix()->getTrackNames();
int n_tracks = tracks.size();
int currentTrack = race_manager->getTrackNumber();
@ -103,7 +103,7 @@ void RaceResultGUI::init()
}
else
{
m_start_track = currentTrack;
m_start_track = 0;
m_end_track = tracks.size();
}
} // init
@ -1295,7 +1295,7 @@ void RaceResultGUI::displayHighScores()
// ----------------------------------------------------------------------------
void RaceResultGUI::displayScreenShots()
{
const std::vector<std::string>& tracks =
const std::vector<std::string> tracks =
race_manager->getGrandPrix()->getTrackNames();
int currentTrack = race_manager->getTrackNumber();

2
src/states_screens/tracks_screen.cpp
View File

@ -215,7 +215,7 @@ void TracksScreen::init()
{
const GrandPrixData* gp = grand_prix_manager->getGrandPrix(n);
const std::vector<std::string> &tracks = gp->getTrackNames();
const std::vector<std::string> tracks = gp->getTrackNames(true);
std::vector<std::string> sshot_files;
for (unsigned int t=0; t<tracks.size(); t++)