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

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

Browse Source
This commit is contained in:
hiker
2014-01-21 08:13:55 +11:00
parent 0cefc1d79c a67f5bf511
commit 6c02f99bca
10 changed files with 226 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
data/shaders/bubble.vert
View File

@@ -20,14 +20,17 @@
#version 130
uniform mat4 ModelViewProjectionMatrix;
uniform float time;
in vec3 Position;
in vec2 Texcoord;
out vec2 uv;
void main()
{
gl_Position = ModelViewProjectionMatrix * gl_Vertex;
gl_Position = ModelViewProjectionMatrix * vec4(Position, 1.);
float delta_x = cos(time*3.0) * sin( 4.0 * gl_TexCoord[0].st.s * 6.28318531 );
float delta_y = cos(time*2.0) * sin( 3.0 * gl_TexCoord[0].st.t * 6.28318531 );
float delta_x = cos(time*3.0) * sin( 4.0 * Texcoord.x * 6.28318531 );
float delta_y = cos(time*2.0) * sin( 3.0 * Texcoord.y * 6.28318531 );
uv = gl_MultiTexCoord0.st + vec2(0.02*delta_x, 0.02*delta_y);
uv = Texcoord + vec2(0.02*delta_x, 0.02*delta_y);
}

9
data/shaders/ssao.frag
View File

@@ -15,9 +15,9 @@ const float radius = .4f;
const float invSamples = strengh / SAMPLES;
float rand(vec2 co)
vec3 rand(vec2 co)
{
return texture(noise_texture, co).x;
return texture(noise_texture, co).xyz;
}
void main(void)
@@ -33,10 +33,7 @@ void main(void)
float len = dot(vec3(1.0), abs(cur.xyz));
if (len < 0.2 || curdepth > 0.999) discard;
// Make a tangent as random as possible
vec3 randvect;
randvect.x = rand(uv);
randvect.y = rand(vec2(randvect.x, FragPos.z));
randvect.z = rand(randvect.xy);
vec3 randvect = rand(uv);
vec3 tangent = normalize(cross(norm, randvect));
vec3 bitangent = cross(norm, tangent);

10
data/shaders/transparent.frag Normal file
View File

@@ -0,0 +1,10 @@
#version 130
uniform sampler2D tex;
in vec2 uv;
out vec4 FragColor;
void main()
{
FragColor = texture(tex, uv);
}

12
data/shaders/transparent.vert Normal file
View File

@@ -0,0 +1,12 @@
#version 130
uniform mat4 ModelViewProjectionMatrix;
in vec3 Position;
in vec2 Texcoord;
out vec2 uv;
void main()
{
uv = Texcoord;
gl_Position = ModelViewProjectionMatrix * vec4(Position, 1.);
}

18
src/graphics/render.cpp
View File

@@ -192,6 +192,7 @@ void IrrDriver::renderGLSL(float dt)
// Fire up the MRT
m_video_driver->setRenderTarget(m_mrt, false, false);
PROFILER_PUSH_CPU_MARKER("- Solid Pass 1", 0xFF, 0x00, 0x00);
m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_SOLID;
irr_driver->setPhase(0);
glClear(GL_STENCIL_BUFFER_BIT);
@@ -205,6 +206,8 @@ void IrrDriver::renderGLSL(float dt)
irr_driver->setViewMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW));
irr_driver->genProjViewMatrix();
PROFILER_POP_CPU_MARKER();
// Todo : reenable glow and shadows
//ShadowImportanceProvider * const sicb = (ShadowImportanceProvider *)
// irr_driver->getCallback(ES_SHADOW_IMPORTANCE);
@@ -225,6 +228,9 @@ void IrrDriver::renderGLSL(float dt)
// Lights
renderLights(cambox, camnode, overridemat, cam, dt);
PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Solid Pass 2", 0xFF, 0x00, 0x00);
irr_driver->setPhase(1);
m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_SOLID;
glStencilFunc(GL_EQUAL, 0, ~0);
@@ -295,11 +301,15 @@ void IrrDriver::renderGLSL(float dt)
}
// We need to re-render camera due to the per-cam-node hack.
PROFILER_PUSH_CPU_MARKER("- SceneManager::drawAll", 0xFF, 0x00, 0x00);
m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_TRANSPARENT |
scene::ESNRP_TRANSPARENT_EFFECT;
PROFILER_PUSH_CPU_MARKER("- Transparent Pass", 0xFF, 0x00, 0x00);
m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_TRANSPARENT;
m_scene_manager->drawAll(m_renderpass);
PROFILER_POP_CPU_MARKER();
PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Particles", 0xFF, 0x00, 0x00);
m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_TRANSPARENT_EFFECT;
m_scene_manager->drawAll(m_renderpass);
PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Displacement", 0xFF, 0x00, 0x00);
// Handle displacing nodes, if any

49
src/graphics/shaders.cpp
View File

@@ -246,6 +246,8 @@ void Shaders::loadShaders()
MeshShader::SplattingShader::init();
MeshShader::GrassPass1Shader::init();
MeshShader::GrassPass2Shader::init();
MeshShader::BubbleShader::init();
MeshShader::TransparentShader::init();
}
Shaders::~Shaders()
@@ -574,6 +576,53 @@ namespace MeshShader
glUniform3f(uniform_ambient, s.r, s.g, s.b);
}
GLuint BubbleShader::Program;
GLuint BubbleShader::attrib_position;
GLuint BubbleShader::attrib_texcoord;
GLuint BubbleShader::uniform_MVP;
GLuint BubbleShader::uniform_tex;
GLuint BubbleShader::uniform_time;
GLuint BubbleShader::uniform_transparency;
void BubbleShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/bubble.vert").c_str(), file_manager->getAsset("shaders/bubble.frag").c_str());
attrib_position = glGetAttribLocation(Program, "Position");
attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
uniform_MVP = glGetUniformLocation(Program, "ModelViewProjectionMatrix");
uniform_tex = glGetUniformLocation(Program, "tex");
uniform_time = glGetUniformLocation(Program, "time");
uniform_transparency = glGetUniformLocation(Program, "transparency");
}
void BubbleShader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, unsigned TU_tex, float time, float transparency)
{
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer());
glUniform1i(uniform_tex, TU_tex);
glUniform1f(uniform_time, time);
glUniform1f(uniform_transparency, transparency);
}
GLuint TransparentShader::Program;
GLuint TransparentShader::attrib_position;
GLuint TransparentShader::attrib_texcoord;
GLuint TransparentShader::uniform_MVP;
GLuint TransparentShader::uniform_tex;
void TransparentShader::init()
{
Program = LoadProgram(file_manager->getAsset("shaders/transparent.vert").c_str(), file_manager->getAsset("shaders/transparent.frag").c_str());
attrib_position = glGetAttribLocation(Program, "Position");
attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
uniform_MVP = glGetUniformLocation(Program, "ModelViewProjectionMatrix");
uniform_tex = glGetUniformLocation(Program, "tex");
}
void TransparentShader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, unsigned TU_tex)
{
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer());
glUniform1i(uniform_tex, TU_tex);
}
GLuint ColorizeShader::Program;
GLuint ColorizeShader::attrib_position;
GLuint ColorizeShader::uniform_MVP;

23
src/graphics/shaders.hpp
View File

@@ -125,6 +125,29 @@ public:
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, unsigned TU_tex_layout, unsigned TU_tex_detail0, unsigned TU_tex_detail1, unsigned TU_tex_detail2, unsigned TU_tex_detail3, unsigned TU_DiffuseMap, unsigned TU_SpecularMap, unsigned TU_SSAO);
};
class BubbleShader
{
public:
static GLuint Program;
static GLuint attrib_position, attrib_texcoord;
static GLuint uniform_MVP, uniform_tex, uniform_time, uniform_transparency;
static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, unsigned TU_tex, float time, float transparency);
};
class TransparentShader
{
public:
static GLuint Program;
static GLuint attrib_position, attrib_texcoord;
static GLuint uniform_MVP, uniform_tex;
static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, unsigned TU_tex);
};
class ColorizeShader
{
public:

134
src/graphics/stkmesh.cpp
View File

@@ -415,8 +415,61 @@ void STKMesh::drawGlow(const GLMesh &mesh, float r, float g, float b)
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
void STKMesh::draw(const GLMesh &mesh, video::E_MATERIAL_TYPE type)
void STKMesh::drawTransparentObject(const GLMesh &mesh)
{
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
computeMVP(ModelViewProjectionMatrix);
setTexture(0, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR);
glUseProgram(MeshShader::TransparentShader::Program);
MeshShader::TransparentShader::setUniforms(ModelViewProjectionMatrix, 0);
glBindVertexArray(mesh.vao_first_pass);
glDrawElements(ptype, count, itype, 0);
}
void STKMesh::drawBubble(const GLMesh &mesh)
{
const float time = irr_driver->getDevice()->getTimer()->getTime() / 1000.0f;
float transparency = 1.;
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
computeMVP(ModelViewProjectionMatrix);
setTexture(0, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR);
glUseProgram(MeshShader::BubbleShader::Program);
MeshShader::BubbleShader::setUniforms(ModelViewProjectionMatrix, 0, time, transparency);
glBindVertexArray(mesh.vao_first_pass);
glDrawElements(ptype, count, itype, 0);
}
void STKMesh::drawTransparent(const GLMesh &mesh, video::E_MATERIAL_TYPE type)
{
glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST);
glDepthMask(GL_FALSE);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
if (type == video::EMT_TRANSPARENT_ALPHA_CHANNEL)
drawTransparentObject(mesh);
if (type == irr_driver->getShader(ES_BUBBLES))
drawBubble(mesh);
return;
}
void STKMesh::drawSolid(const GLMesh &mesh, video::E_MATERIAL_TYPE type)
{
if (!mesh.textures[0])
return;
switch (irr_driver->getPhase())
@@ -439,36 +492,30 @@ void STKMesh::draw(const GLMesh &mesh, video::E_MATERIAL_TYPE type)
drawGrassPass1(mesh);
else
drawObjectPass1(mesh);
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glStencilFunc(GL_ALWAYS, 1, ~0);
irr_driver->getVideoDriver()->setRenderTarget(irr_driver->getMainSetup(), false, false);
break;
}
case 1:
{
irr_driver->getVideoDriver()->setRenderTarget(irr_driver->getRTT(RTT_COLOR), false, false);
irr_driver->getVideoDriver()->setRenderTarget(irr_driver->getRTT(RTT_COLOR), false, false);
glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST);
glDepthMask(GL_FALSE);
glDisable(GL_BLEND);
if (type == irr_driver->getShader(ES_SPHERE_MAP))
drawSphereMap(mesh);
else if (type == irr_driver->getShader(ES_SPLATTING))
drawSplatting(mesh);
else if (type == irr_driver->getShader(ES_OBJECTPASS_REF))
drawObjectRefPass2(mesh);
else if (type == irr_driver->getShader(ES_GRASS) || type == irr_driver->getShader(ES_GRASS_REF))
drawGrassPass2(mesh);
else
drawObjectPass2(mesh);
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
break;
glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST);
glDepthMask(GL_FALSE);
glDisable(GL_BLEND);
if (type == irr_driver->getShader(ES_SPHERE_MAP))
drawSphereMap(mesh);
else if (type == irr_driver->getShader(ES_SPLATTING))
drawSplatting(mesh);
else if (type == irr_driver->getShader(ES_OBJECTPASS_REF))
drawObjectRefPass2(mesh);
else if (type == irr_driver->getShader(ES_GRASS) || type == irr_driver->getShader(ES_GRASS_REF))
drawGrassPass2(mesh);
else
drawObjectPass2(mesh);
break;
}
case 2:
{
@@ -477,15 +524,6 @@ void STKMesh::draw(const GLMesh &mesh, video::E_MATERIAL_TYPE type)
break;
}
}
video::SMaterial material;
material.MaterialType = irr_driver->getShader(ES_RAIN);
material.BlendOperation = video::EBO_NONE;
material.ZWriteEnable = true;
material.Lighting = false;
irr_driver->getVideoDriver()->setMaterial(material);
static_cast<irr::video::COpenGLDriver*>(irr_driver->getVideoDriver())->setRenderStates3DMode();
}
static bool isObject(video::E_MATERIAL_TYPE type)
@@ -504,6 +542,10 @@ static bool isObject(video::E_MATERIAL_TYPE type)
return true;
if (type == irr_driver->getShader(ES_GRASS_REF))
return true;
if (type == irr_driver->getShader(ES_BUBBLES))
return true;
if (type == video::EMT_TRANSPARENT_ALPHA_CHANNEL)
return true;
return false;
}
@@ -526,6 +568,16 @@ static void initvaostate(GLMesh &mesh, video::E_MATERIAL_TYPE type)
mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
MeshShader::GrassPass1Shader::attrib_position, MeshShader::GrassPass1Shader::attrib_texcoord, -1, MeshShader::GrassPass1Shader::attrib_normal, -1, -1, MeshShader::GrassPass1Shader::attrib_color, mesh.Stride);
}
else if (type == irr_driver->getShader(ES_BUBBLES))
{
mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
MeshShader::BubbleShader::attrib_position, MeshShader::BubbleShader::attrib_texcoord, -1, -1, -1, -1, -1, mesh.Stride);
}
else if (type == video::EMT_TRANSPARENT_ALPHA_CHANNEL)
{
mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
MeshShader::TransparentShader::attrib_position, MeshShader::TransparentShader::attrib_texcoord, -1, -1, -1, -1, -1, mesh.Stride);
}
else
{
mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
@@ -587,10 +639,22 @@ void STKMesh::render()
// only render transparent buffer if this is the transparent render pass
// and solid only in solid pass
if (isObject(material.MaterialType) && !isTransparentPass && !transparent)
if (isObject(material.MaterialType) && isTransparentPass == transparent)
{
initvaostate(GLmeshes[i], material.MaterialType);
draw(GLmeshes[i], material.MaterialType);
if (transparent)
drawTransparent(GLmeshes[i], material.MaterialType);
else
drawSolid(GLmeshes[i], material.MaterialType);
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
video::SMaterial material;
material.MaterialType = irr_driver->getShader(ES_RAIN);
material.BlendOperation = video::EBO_NONE;
material.ZWriteEnable = true;
material.Lighting = false;
irr_driver->getVideoDriver()->setMaterial(material);
static_cast<irr::video::COpenGLDriver*>(irr_driver->getVideoDriver())->setRenderStates3DMode();
}
else if (transparent == isTransparentPass)
{

7
src/graphics/stkmesh.hpp
View File

@@ -27,7 +27,8 @@ protected:
std::vector<GLMesh> GLmeshes;
core::matrix4 ModelViewProjectionMatrix, TransposeInverseModelView;
core::vector3df windDir;
void draw(const GLMesh &mesh, video::E_MATERIAL_TYPE type);
void drawSolid(const GLMesh &mesh, video::E_MATERIAL_TYPE type);
void drawTransparent(const GLMesh &mesh, video::E_MATERIAL_TYPE type);
// Pass 1 shader (ie shaders that outputs normals and depth)
void drawObjectPass1(const GLMesh &mesh);
@@ -42,6 +43,10 @@ protected:
void drawObjectRefPass2(const GLMesh &mesh);
void drawGrassPass2(const GLMesh &mesh);
// Forward pass (for transparents meshes)
void drawTransparentObject(const GLMesh &mesh);
void drawBubble(const GLMesh &mesh);
// Pass 3 shader (glow)
void drawGlow(const GLMesh &mesh, float r, float g, float b);
public:

5
src/utils/profiler.cpp
View File

@@ -17,6 +17,7 @@
#include "profiler.hpp"
#include "graphics/irr_driver.hpp"
#include "graphics/glwrap.hpp"
#include "guiengine/event_handler.hpp"
#include "guiengine/engine.hpp"
#include "guiengine/scalable_font.hpp"
@@ -231,7 +232,7 @@ void Profiler::draw()
pos.UpperLeftCorner.Y += m.layer;
pos.LowerRightCorner.Y -= m.layer;
driver->draw2DRectangle(m.color, pos);
GL32_draw2DRectangle(m.color, pos);
// If the mouse cursor is over the marker, get its information
if(pos.isPointInside(mouse_pos))
@@ -314,5 +315,5 @@ void Profiler::drawBackground()
(int)((MARGIN_Y + 3.0f*LINE_HEIGHT) * screen_size.Height));
video::SColor color(0xFF, 0xFF, 0xFF, 0xFF);
driver->draw2DRectangle(color, background_rect);
GL32_draw2DRectangle(color, background_rect);
}