Merge branch 'master' of github.com:supertuxkart/stk-code
This commit is contained in:
hiker
commit
5918f43ce6
@ -1,24 +1,19 @@
|
||||
#version 130
|
||||
uniform sampler2D tex;
|
||||
uniform vec2 screen;
|
||||
uniform vec2 dir;
|
||||
uniform vec2 dir2;
|
||||
|
||||
in vec2 uv;
|
||||
in vec2 edger_uv;
|
||||
in vec2 uv_bis;
|
||||
in float camdist;
|
||||
|
||||
out vec4 FragColor;
|
||||
const float maxlen = 0.02;
|
||||
|
||||
void main()
|
||||
{
|
||||
vec2 tc = uv;
|
||||
|
||||
vec4 col = vec4(0.0);
|
||||
const float maxlen = 0.02;
|
||||
|
||||
float horiz = texture(tex, tc + dir).x;
|
||||
float vert = texture(tex, (tc.yx + dir2) * vec2(0.9)).x;
|
||||
float horiz = texture(tex, uv + dir).x;
|
||||
float vert = texture(tex, (uv.yx + dir2) * vec2(0.9)).x;
|
||||
|
||||
vec2 offset = vec2(horiz, vert);
|
||||
offset *= 2.0;
|
||||
@ -28,14 +23,14 @@ void main()
|
||||
float fade = 1.0 - smoothstep(1.0, 100.0, camdist);
|
||||
|
||||
// Fade according to distance from the edges
|
||||
vec2 edger = edger_uv;
|
||||
const float mindist = 0.1;
|
||||
fade *= smoothstep(0.0, mindist, edger.x) * smoothstep(0.0, mindist, edger.y) *
|
||||
(1.0 - smoothstep(1.0 - mindist, 1.0, edger.x)) *
|
||||
(1.0 - smoothstep(1.0 - mindist, 1.0, edger.y));
|
||||
fade *= smoothstep(0.0, mindist, uv_bis.x) * smoothstep(0.0, mindist, uv_bis.y) *
|
||||
(1.0 - smoothstep(1.0 - mindist, 1.0, uv_bis.x)) *
|
||||
(1.0 - smoothstep(1.0 - mindist, 1.0, uv_bis.y));
|
||||
|
||||
offset *= 50.0 * fade * maxlen;
|
||||
|
||||
vec4 col;
|
||||
col.r = step(offset.x, 0.0) * -offset.x;
|
||||
col.g = step(0.0, offset.x) * offset.x;
|
||||
col.b = step(offset.y, 0.0) * -offset.y;
|
||||
|
||||
@ -1,16 +1,17 @@
|
||||
#version 130
|
||||
uniform mat4 ModelViewProjectionMatrix;
|
||||
uniform mat4 ModelViewMatrix;
|
||||
uniform mat4 ProjectionMatrix;
|
||||
|
||||
in vec3 Position;
|
||||
in vec2 Texcoord;
|
||||
in vec2 SecondTexcoord;
|
||||
out vec2 uv;
|
||||
out vec2 edger_uv;
|
||||
out vec2 uv_bis;
|
||||
out float camdist;
|
||||
|
||||
void main() {
|
||||
vec4 position = ModelViewMatrix * gl_Vertex;
|
||||
gl_Position = ProjectionMatrix * position;
|
||||
uv = gl_MultiTexCoord0.xy;
|
||||
edger_uv = gl_MultiTexCoord1.xy;
|
||||
|
||||
camdist = length(position.xyz);
|
||||
gl_Position = ModelViewProjectionMatrix * vec4(Position, 1.);
|
||||
uv = Texcoord;
|
||||
uv_bis = SecondTexcoord;
|
||||
camdist = length(ModelViewMatrix * vec4(Position, 1.));
|
||||
}
|
||||
|
||||
@ -16,5 +16,6 @@ void main(void)
|
||||
vec3 SpecularComponent = texture(SpecularMap, tc).xyz;
|
||||
float ao = texture(SSAO, tc).x;
|
||||
vec3 LightFactor = ao * ambient + DiffuseComponent + SpecularComponent * (1. - color.a);
|
||||
FragColor = vec4(color.xyz * LightFactor, 1.);
|
||||
|
||||
FragColor = vec4(color.xyz * LightFactor * ao, 1.);
|
||||
}
|
||||
|
||||
@ -601,26 +601,29 @@ void DisplaceProvider::OnSetConstants(IMaterialRendererServices *srv, int)
|
||||
srv->setVertexShaderConstant("ProjectionMatrix", ProjectionMatrix.pointer(), 16);
|
||||
srv->setVertexShaderConstant("ModelViewMatrix", ModelViewMatrix.pointer(), 16);
|
||||
|
||||
const float time = irr_driver->getDevice()->getTimer()->getTime() / 1000.0f;
|
||||
const float speed = World::getWorld()->getTrack()->getDisplacementSpeed();
|
||||
|
||||
float strength = time;
|
||||
strength = fabsf(noise2d(strength / 10.0f)) * 0.006f + 0.002f;
|
||||
|
||||
vector3df wind = irr_driver->getWind() * strength * speed;
|
||||
m_dir[0] += wind.X;
|
||||
m_dir[1] += wind.Z;
|
||||
|
||||
strength = time * 0.56f + sinf(time);
|
||||
strength = fabsf(noise2d(0.0, strength / 6.0f)) * 0.0095f + 0.0025f;
|
||||
|
||||
wind = irr_driver->getWind() * strength * speed;
|
||||
wind.rotateXZBy(cosf(time));
|
||||
m_dir2[0] += wind.X;
|
||||
m_dir2[1] += wind.Z;
|
||||
|
||||
srv->setVertexShaderConstant("dir", m_dir, 2);
|
||||
srv->setVertexShaderConstant("dir2", m_dir2, 2);
|
||||
|
||||
srv->setVertexShaderConstant("screen", m_screen, 2);
|
||||
}
|
||||
|
||||
void DisplaceProvider::update()
|
||||
{
|
||||
const float time = irr_driver->getDevice()->getTimer()->getTime() / 1000.0f;
|
||||
const float speed = World::getWorld()->getTrack()->getDisplacementSpeed();
|
||||
|
||||
float strength = time;
|
||||
strength = fabsf(noise2d(strength / 10.0f)) * 0.006f + 0.002f;
|
||||
|
||||
vector3df wind = irr_driver->getWind() * strength * speed;
|
||||
m_dir[0] += wind.X;
|
||||
m_dir[1] += wind.Z;
|
||||
|
||||
strength = time * 0.56f + sinf(time);
|
||||
strength = fabsf(noise2d(0.0, strength / 6.0f)) * 0.0095f + 0.0025f;
|
||||
|
||||
wind = irr_driver->getWind() * strength * speed;
|
||||
wind.rotateXZBy(cosf(time));
|
||||
m_dir2[0] += wind.X;
|
||||
m_dir2[1] += wind.Z;
|
||||
}
|
||||
@ -555,6 +555,28 @@ public:
|
||||
m_dir[0] = m_dir[1] = m_dir2[0] = m_dir2[1] = 0;
|
||||
}
|
||||
|
||||
void update();
|
||||
|
||||
float getDirX() const
|
||||
{
|
||||
return m_dir[0];
|
||||
}
|
||||
|
||||
float getDirY() const
|
||||
{
|
||||
return m_dir[1];
|
||||
}
|
||||
|
||||
float getDir2X() const
|
||||
{
|
||||
return m_dir2[0];
|
||||
}
|
||||
|
||||
float getDir2Y() const
|
||||
{
|
||||
return m_dir2[1];
|
||||
}
|
||||
|
||||
private:
|
||||
float m_screen[2];
|
||||
float m_dir[2], m_dir2[2];
|
||||
|
||||
@ -296,6 +296,16 @@ void bindUniformToTextureUnit(GLuint location, GLuint texid, unsigned textureUni
|
||||
glUniform1i(location, textureUnit);
|
||||
}
|
||||
|
||||
void setTexture(unsigned TextureUnit, GLuint TextureId, GLenum MagFilter, GLenum MinFilter)
|
||||
{
|
||||
glActiveTexture(GL_TEXTURE0 + TextureUnit);
|
||||
glBindTexture(GL_TEXTURE_2D, TextureId);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, MagFilter);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, MinFilter);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
||||
}
|
||||
|
||||
static GLuint TexturedQuadShader;
|
||||
static GLuint TexturedQuadAttribPosition;
|
||||
static GLuint TexturedQuadAttribTexCoord;
|
||||
|
||||
@ -22,7 +22,7 @@ void initGL();
|
||||
GLuint LoadProgram(const char * vertex_file_path, const char * fragment_file_path);
|
||||
GLuint LoadTFBProgram(const char * vertex_file_path, const char **varyings, unsigned varyingscount);
|
||||
void bindUniformToTextureUnit(GLuint location, GLuint texid, unsigned textureUnit);
|
||||
|
||||
void setTexture(unsigned TextureUnit, GLuint TextureId, GLenum MagFilter, GLenum MinFilter);
|
||||
|
||||
// already includes glext.h, which defines useful GL constants.
|
||||
// COpenGLDriver has already loaded the extension GL functions we use (e.g glBeginQuery)
|
||||
|
||||
@ -12,136 +12,8 @@ GLuint getTextureGLuint(irr::video::ITexture *tex) {
|
||||
|
||||
#define COMPONENTCOUNT 8
|
||||
|
||||
|
||||
namespace SimpleSimulationShader
|
||||
{
|
||||
GLuint Program;
|
||||
GLuint attrib_position, attrib_velocity, attrib_lifetime, attrib_initial_position, attrib_initial_velocity, attrib_initial_lifetime, attrib_size, attrib_initial_size;
|
||||
GLuint uniform_sourcematrix, uniform_dt, uniform_level, uniform_size_increase_factor;
|
||||
|
||||
void init()
|
||||
{
|
||||
initGL();
|
||||
const char *varyings[] = {
|
||||
"new_particle_position",
|
||||
"new_lifetime",
|
||||
"new_particle_velocity",
|
||||
"new_size",
|
||||
};
|
||||
Program = LoadTFBProgram(file_manager->getAsset("shaders/pointemitter.vert").c_str(), varyings, 4);
|
||||
|
||||
uniform_dt = glGetUniformLocation(Program, "dt");
|
||||
uniform_sourcematrix = glGetUniformLocation(Program, "sourcematrix");
|
||||
uniform_level = glGetUniformLocation(Program, "level");
|
||||
uniform_size_increase_factor = glGetUniformLocation(Program, "size_increase_factor");
|
||||
|
||||
attrib_position = glGetAttribLocation(Program, "particle_position");
|
||||
attrib_lifetime = glGetAttribLocation(Program, "lifetime");
|
||||
attrib_velocity = glGetAttribLocation(Program, "particle_velocity");
|
||||
attrib_size = glGetAttribLocation(Program, "size");
|
||||
attrib_initial_position = glGetAttribLocation(Program, "particle_position_initial");
|
||||
attrib_initial_lifetime = glGetAttribLocation(Program, "lifetime_initial");
|
||||
attrib_initial_velocity = glGetAttribLocation(Program, "particle_velocity_initial");
|
||||
attrib_initial_size = glGetAttribLocation(Program, "size_initial");
|
||||
}
|
||||
}
|
||||
|
||||
namespace HeightmapSimulationShader
|
||||
{
|
||||
GLuint Program;
|
||||
GLuint attrib_position, attrib_velocity, attrib_lifetime, attrib_initial_position, attrib_initial_velocity, attrib_initial_lifetime, attrib_size, attrib_initial_size;
|
||||
GLuint uniform_sourcematrix, uniform_dt, uniform_level, uniform_size_increase_factor;
|
||||
GLuint uniform_track_x, uniform_track_z, uniform_track_x_len, uniform_track_z_len, uniform_heightmap;
|
||||
|
||||
void init()
|
||||
{
|
||||
initGL();
|
||||
const char *varyings[] = {
|
||||
"new_particle_position",
|
||||
"new_lifetime",
|
||||
"new_particle_velocity",
|
||||
"new_size",
|
||||
};
|
||||
Program = LoadTFBProgram(file_manager->getAsset("shaders/particlesimheightmap.vert").c_str(), varyings, 4);
|
||||
|
||||
uniform_dt = glGetUniformLocation(Program, "dt");
|
||||
uniform_sourcematrix = glGetUniformLocation(Program, "sourcematrix");
|
||||
uniform_level = glGetUniformLocation(Program, "level");
|
||||
uniform_size_increase_factor = glGetUniformLocation(Program, "size_increase_factor");
|
||||
|
||||
attrib_position = glGetAttribLocation(Program, "particle_position");
|
||||
attrib_lifetime = glGetAttribLocation(Program, "lifetime");
|
||||
attrib_velocity = glGetAttribLocation(Program, "particle_velocity");
|
||||
attrib_size = glGetAttribLocation(Program, "size");
|
||||
attrib_initial_position = glGetAttribLocation(Program, "particle_position_initial");
|
||||
attrib_initial_lifetime = glGetAttribLocation(Program, "lifetime_initial");
|
||||
attrib_initial_velocity = glGetAttribLocation(Program, "particle_velocity_initial");
|
||||
attrib_initial_size = glGetAttribLocation(Program, "size_initial");
|
||||
|
||||
uniform_heightmap = glGetUniformLocation(Program, "heightmap");
|
||||
uniform_track_x = glGetUniformLocation(Program, "track_x");
|
||||
uniform_track_x_len = glGetUniformLocation(Program, "track_x_len");
|
||||
uniform_track_z = glGetUniformLocation(Program, "track_z");
|
||||
uniform_track_z_len = glGetUniformLocation(Program, "track_z_len");
|
||||
}
|
||||
}
|
||||
|
||||
namespace SimpleParticleRender
|
||||
{
|
||||
GLuint Program;
|
||||
GLuint attrib_pos, attrib_lf, attrib_quadcorner, attrib_texcoord, attrib_sz;
|
||||
GLuint uniform_matrix, uniform_viewmatrix, uniform_tex, uniform_normal_and_depths, uniform_screen, uniform_invproj;
|
||||
|
||||
void init()
|
||||
{
|
||||
initGL();
|
||||
Program = LoadProgram(file_manager->getAsset("shaders/particle.vert").c_str(), file_manager->getAsset("shaders/particle.frag").c_str());
|
||||
attrib_pos = glGetAttribLocation(Program, "position");
|
||||
attrib_sz = glGetAttribLocation(Program, "size");
|
||||
attrib_lf = glGetAttribLocation(Program, "lifetime");
|
||||
attrib_quadcorner = glGetAttribLocation(Program, "quadcorner");
|
||||
attrib_texcoord = glGetAttribLocation(Program, "texcoord");
|
||||
|
||||
|
||||
uniform_matrix = glGetUniformLocation(Program, "ProjectionMatrix");
|
||||
uniform_viewmatrix = glGetUniformLocation(Program, "ViewMatrix");
|
||||
uniform_tex = glGetUniformLocation(Program, "tex");
|
||||
uniform_invproj = glGetUniformLocation(Program, "invproj");
|
||||
uniform_screen = glGetUniformLocation(Program, "screen");
|
||||
uniform_normal_and_depths = glGetUniformLocation(Program, "normals_and_depth");
|
||||
}
|
||||
}
|
||||
|
||||
namespace FlipParticleRender
|
||||
{
|
||||
GLuint Program;
|
||||
GLuint attrib_pos, attrib_lf, attrib_quadcorner, attrib_texcoord, attrib_sz, attrib_rotationvec, attrib_anglespeed;
|
||||
GLuint uniform_matrix, uniform_viewmatrix, uniform_tex, uniform_normal_and_depths, uniform_screen, uniform_invproj;
|
||||
|
||||
void init()
|
||||
{
|
||||
initGL();
|
||||
Program = LoadProgram(file_manager->getAsset("shaders/flipparticle.vert").c_str(), file_manager->getAsset("shaders/particle.frag").c_str());
|
||||
attrib_pos = glGetAttribLocation(Program, "position");
|
||||
attrib_sz = glGetAttribLocation(Program, "size");
|
||||
attrib_lf = glGetAttribLocation(Program, "lifetime");
|
||||
attrib_quadcorner = glGetAttribLocation(Program, "quadcorner");
|
||||
attrib_texcoord = glGetAttribLocation(Program, "texcoord");
|
||||
attrib_anglespeed = glGetAttribLocation(Program, "anglespeed");
|
||||
attrib_rotationvec = glGetAttribLocation(Program, "rotationvec");
|
||||
|
||||
uniform_matrix = glGetUniformLocation(Program, "ProjectionMatrix");
|
||||
uniform_viewmatrix = glGetUniformLocation(Program, "ViewMatrix");
|
||||
uniform_tex = glGetUniformLocation(Program, "tex");
|
||||
uniform_invproj = glGetUniformLocation(Program, "invproj");
|
||||
uniform_screen = glGetUniformLocation(Program, "screen");
|
||||
uniform_normal_and_depths = glGetUniformLocation(Program, "normals_and_depth");
|
||||
}
|
||||
}
|
||||
|
||||
GPUParticle::GPUParticle(scene::ISceneNode *parent, scene::ISceneManager* mgr, ITexture *tex)
|
||||
: scene::ISceneNode(parent, mgr, -1) {
|
||||
initGL();
|
||||
fakemat.Lighting = false;
|
||||
fakemat.ZWriteEnable = false;
|
||||
fakemat.MaterialType = irr_driver->getShader(ES_RAIN);
|
||||
@ -193,7 +65,6 @@ ParticleSystemProxy::ParticleSystemProxy(bool createDefaultEmitter,
|
||||
const core::vector3df& position,
|
||||
const core::vector3df& rotation,
|
||||
const core::vector3df& scale) : CParticleSystemSceneNode(createDefaultEmitter, parent, mgr, id, position, rotation, scale), m_alpha_additive(false) {
|
||||
initGL();
|
||||
fakemat.Lighting = false;
|
||||
fakemat.ZWriteEnable = false;
|
||||
fakemat.MaterialType = irr_driver->getShader(ES_RAIN);
|
||||
@ -204,6 +75,8 @@ ParticleSystemProxy::ParticleSystemProxy(bool createDefaultEmitter,
|
||||
glGenBuffers(1, &initial_values_buffer);
|
||||
glGenBuffers(2, tfb_buffers);
|
||||
glGenBuffers(1, &quaternionsbuffer);
|
||||
glGenVertexArrays(1, ¤t_rendering_vao);
|
||||
glGenVertexArrays(1, &non_current_rendering_vao);
|
||||
size_increase_factor = 0.;
|
||||
if (quad_vertex_buffer)
|
||||
return;
|
||||
@ -251,14 +124,22 @@ void ParticleSystemProxy::setFlip() {
|
||||
glGenBuffers(1, &quaternionsbuffer);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, quaternionsbuffer);
|
||||
glBufferData(GL_ARRAY_BUFFER, 4 * count * sizeof(float), quaternions, GL_STATIC_DRAW);
|
||||
|
||||
glGenVertexArrays(1, ¤t_rendering_flip_vao);
|
||||
glBindVertexArray(current_rendering_flip_vao);
|
||||
FlipParticleVAOBind(tfb_buffers[0], quaternionsbuffer);
|
||||
glGenVertexArrays(1, &non_current_rendering_flip_vao);
|
||||
glBindVertexArray(non_current_rendering_flip_vao);
|
||||
FlipParticleVAOBind(tfb_buffers[1], quaternionsbuffer);
|
||||
glBindVertexArray(0);
|
||||
|
||||
delete[] quaternions;
|
||||
}
|
||||
|
||||
void ParticleSystemProxy::setHeightmap(const std::vector<std::vector<float> > &hm,
|
||||
float f1, float f2, float f3, float f4) {
|
||||
track_x = f1, track_z = f2, track_x_len = f3, track_z_len = f4;
|
||||
printf("track_x is %f, track_x_len is %f, track_z is %f, track_z_len is %f\n",
|
||||
track_x, track_x_len, track_z, track_z_len);
|
||||
|
||||
unsigned width = hm.size();
|
||||
unsigned height = hm[0].size();
|
||||
float *hm_array = new float[width * height];
|
||||
@ -277,6 +158,17 @@ void ParticleSystemProxy::setHeightmap(const std::vector<std::vector<float> > &h
|
||||
glBindTexture(GL_TEXTURE_BUFFER, heightmaptexture);
|
||||
glTexBuffer(GL_TEXTURE_BUFFER, GL_R32F, heighmapbuffer);
|
||||
glBindBuffer(GL_TEXTURE_BUFFER, 0);
|
||||
|
||||
glGenVertexArrays(1, ¤t_hm_simulation_vao);
|
||||
glBindVertexArray(current_hm_simulation_vao);
|
||||
HeightmapSimulationBind(tfb_buffers[0], initial_values_buffer);
|
||||
|
||||
glGenVertexArrays(1, &non_currenthm__simulation_vao);
|
||||
glBindVertexArray(non_currenthm__simulation_vao);
|
||||
HeightmapSimulationBind(tfb_buffers[1], initial_values_buffer);
|
||||
|
||||
glBindVertexArray(0);
|
||||
|
||||
delete[] hm_array;
|
||||
}
|
||||
|
||||
@ -421,6 +313,101 @@ static bool isGPUParticleType(scene::E_PARTICLE_EMITTER_TYPE type)
|
||||
}
|
||||
}
|
||||
|
||||
void ParticleSystemProxy::FlipParticleVAOBind(GLuint PositionBuffer, GLuint QuaternionBuffer)
|
||||
{
|
||||
glEnableVertexAttribArray(ParticleShader::FlipParticleRender::attrib_pos);
|
||||
glEnableVertexAttribArray(ParticleShader::FlipParticleRender::attrib_lf);
|
||||
glEnableVertexAttribArray(ParticleShader::FlipParticleRender::attrib_quadcorner);
|
||||
glEnableVertexAttribArray(ParticleShader::FlipParticleRender::attrib_texcoord);
|
||||
glEnableVertexAttribArray(ParticleShader::FlipParticleRender::attrib_sz);
|
||||
|
||||
glEnableVertexAttribArray(ParticleShader::FlipParticleRender::attrib_rotationvec);
|
||||
glEnableVertexAttribArray(ParticleShader::FlipParticleRender::attrib_anglespeed);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, QuaternionBuffer);
|
||||
glVertexAttribPointer(ParticleShader::FlipParticleRender::attrib_rotationvec, 3, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
|
||||
glVertexAttribPointer(ParticleShader::FlipParticleRender::attrib_anglespeed, 1, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (GLvoid *)(3 * sizeof(float)));
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, quad_vertex_buffer);
|
||||
glVertexAttribPointer(ParticleShader::FlipParticleRender::attrib_quadcorner, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
|
||||
glVertexAttribPointer(ParticleShader::FlipParticleRender::attrib_texcoord, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (GLvoid *)(2 * sizeof(float)));
|
||||
glBindBuffer(GL_ARRAY_BUFFER, PositionBuffer);
|
||||
glVertexAttribPointer(ParticleShader::FlipParticleRender::attrib_pos, 3, GL_FLOAT, GL_FALSE, sizeof(ParticleData), 0);
|
||||
glVertexAttribPointer(ParticleShader::FlipParticleRender::attrib_lf, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid *)(3 * sizeof(float)));
|
||||
glVertexAttribPointer(ParticleShader::FlipParticleRender::attrib_sz, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid *)(7 * sizeof(float)));
|
||||
|
||||
glVertexAttribDivisor(ParticleShader::FlipParticleRender::attrib_lf, 1);
|
||||
glVertexAttribDivisor(ParticleShader::FlipParticleRender::attrib_pos, 1);
|
||||
glVertexAttribDivisor(ParticleShader::FlipParticleRender::attrib_sz, 1);
|
||||
glVertexAttribDivisor(ParticleShader::FlipParticleRender::attrib_rotationvec, 1);
|
||||
glVertexAttribDivisor(ParticleShader::FlipParticleRender::attrib_anglespeed, 1);
|
||||
}
|
||||
|
||||
void ParticleSystemProxy::SimpleParticleVAOBind(GLuint PositionBuffer)
|
||||
{
|
||||
glEnableVertexAttribArray(ParticleShader::SimpleParticleRender::attrib_pos);
|
||||
glEnableVertexAttribArray(ParticleShader::SimpleParticleRender::attrib_lf);
|
||||
glEnableVertexAttribArray(ParticleShader::SimpleParticleRender::attrib_quadcorner);
|
||||
glEnableVertexAttribArray(ParticleShader::SimpleParticleRender::attrib_texcoord);
|
||||
glEnableVertexAttribArray(ParticleShader::SimpleParticleRender::attrib_sz);
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, quad_vertex_buffer);
|
||||
glVertexAttribPointer(ParticleShader::SimpleParticleRender::attrib_quadcorner, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
|
||||
glVertexAttribPointer(ParticleShader::SimpleParticleRender::attrib_texcoord, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (GLvoid *)(2 * sizeof(float)));
|
||||
glBindBuffer(GL_ARRAY_BUFFER, PositionBuffer);
|
||||
glVertexAttribPointer(ParticleShader::SimpleParticleRender::attrib_pos, 3, GL_FLOAT, GL_FALSE, sizeof(ParticleData), 0);
|
||||
glVertexAttribPointer(ParticleShader::SimpleParticleRender::attrib_lf, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid *)(3 * sizeof(float)));
|
||||
glVertexAttribPointer(ParticleShader::SimpleParticleRender::attrib_sz, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid *)(7 * sizeof(float)));
|
||||
|
||||
glVertexAttribDivisor(ParticleShader::SimpleParticleRender::attrib_lf, 1);
|
||||
glVertexAttribDivisor(ParticleShader::SimpleParticleRender::attrib_pos, 1);
|
||||
glVertexAttribDivisor(ParticleShader::SimpleParticleRender::attrib_sz, 1);
|
||||
}
|
||||
|
||||
void ParticleSystemProxy::SimpleSimulationBind(GLuint PositionBuffer, GLuint InitialValuesBuffer)
|
||||
{
|
||||
glEnableVertexAttribArray(ParticleShader::SimpleSimulationShader::attrib_position);
|
||||
glEnableVertexAttribArray(ParticleShader::SimpleSimulationShader::attrib_lifetime);
|
||||
glEnableVertexAttribArray(ParticleShader::SimpleSimulationShader::attrib_velocity);
|
||||
glEnableVertexAttribArray(ParticleShader::SimpleSimulationShader::attrib_size);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, PositionBuffer);
|
||||
glVertexAttribPointer(ParticleShader::SimpleSimulationShader::attrib_position, 3, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)0);
|
||||
glVertexAttribPointer(ParticleShader::SimpleSimulationShader::attrib_lifetime, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(3 * sizeof(float)));
|
||||
glVertexAttribPointer(ParticleShader::SimpleSimulationShader::attrib_velocity, 4, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(4 * sizeof(float)));
|
||||
glVertexAttribPointer(ParticleShader::SimpleSimulationShader::attrib_size, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(7 * sizeof(float)));
|
||||
glEnableVertexAttribArray(ParticleShader::SimpleSimulationShader::attrib_initial_position);
|
||||
glEnableVertexAttribArray(ParticleShader::SimpleSimulationShader::attrib_initial_lifetime);
|
||||
glEnableVertexAttribArray(ParticleShader::SimpleSimulationShader::attrib_initial_velocity);
|
||||
glEnableVertexAttribArray(ParticleShader::SimpleSimulationShader::attrib_initial_size);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, InitialValuesBuffer);
|
||||
glVertexAttribPointer(ParticleShader::SimpleSimulationShader::attrib_initial_position, 3, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)0);
|
||||
glVertexAttribPointer(ParticleShader::SimpleSimulationShader::attrib_initial_lifetime, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(3 * sizeof(float)));
|
||||
glVertexAttribPointer(ParticleShader::SimpleSimulationShader::attrib_initial_velocity, 4, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(4 * sizeof(float)));
|
||||
glVertexAttribPointer(ParticleShader::SimpleSimulationShader::attrib_initial_size, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(7 * sizeof(float)));
|
||||
}
|
||||
|
||||
void ParticleSystemProxy::HeightmapSimulationBind(GLuint PositionBuffer, GLuint InitialValuesBuffer)
|
||||
{
|
||||
glEnableVertexAttribArray(ParticleShader::HeightmapSimulationShader::attrib_position);
|
||||
glEnableVertexAttribArray(ParticleShader::HeightmapSimulationShader::attrib_lifetime);
|
||||
glEnableVertexAttribArray(ParticleShader::HeightmapSimulationShader::attrib_velocity);
|
||||
// glEnableVertexAttribArray(ParticleShader::HeightmapSimulationShader::attrib_size);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, PositionBuffer);
|
||||
glVertexAttribPointer(ParticleShader::HeightmapSimulationShader::attrib_position, 3, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)0);
|
||||
glVertexAttribPointer(ParticleShader::HeightmapSimulationShader::attrib_lifetime, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(3 * sizeof(float)));
|
||||
glVertexAttribPointer(ParticleShader::HeightmapSimulationShader::attrib_velocity, 4, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(4 * sizeof(float)));
|
||||
//glVertexAttribPointer(ParticleShader::HeightmapSimulationShader::attrib_size, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(7 * sizeof(float)));
|
||||
glEnableVertexAttribArray(ParticleShader::HeightmapSimulationShader::attrib_initial_position);
|
||||
glEnableVertexAttribArray(ParticleShader::HeightmapSimulationShader::attrib_initial_lifetime);
|
||||
glEnableVertexAttribArray(ParticleShader::HeightmapSimulationShader::attrib_initial_velocity);
|
||||
glEnableVertexAttribArray(ParticleShader::HeightmapSimulationShader::attrib_initial_size);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, InitialValuesBuffer);
|
||||
glVertexAttribPointer(ParticleShader::HeightmapSimulationShader::attrib_initial_position, 3, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)0);
|
||||
glVertexAttribPointer(ParticleShader::HeightmapSimulationShader::attrib_initial_lifetime, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(3 * sizeof(float)));
|
||||
glVertexAttribPointer(ParticleShader::HeightmapSimulationShader::attrib_initial_velocity, 4, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(4 * sizeof(float)));
|
||||
glVertexAttribPointer(ParticleShader::HeightmapSimulationShader::attrib_initial_size, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(7 * sizeof(float)));
|
||||
}
|
||||
|
||||
|
||||
void ParticleSystemProxy::setEmitter(scene::IParticleEmitter* emitter)
|
||||
{
|
||||
CParticleSystemSceneNode::setEmitter(emitter);
|
||||
@ -450,15 +437,24 @@ void ParticleSystemProxy::setEmitter(scene::IParticleEmitter* emitter)
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
|
||||
glBindVertexArray(current_rendering_vao);
|
||||
SimpleParticleVAOBind(tfb_buffers[0]);
|
||||
|
||||
glBindVertexArray(non_current_rendering_vao);
|
||||
SimpleParticleVAOBind(tfb_buffers[1]);
|
||||
|
||||
glGenVertexArrays(1, ¤t_simulation_vao);
|
||||
glBindVertexArray(current_simulation_vao);
|
||||
SimpleSimulationBind(tfb_buffers[0], initial_values_buffer);
|
||||
|
||||
glGenVertexArrays(1, &non_current_simulation_vao);
|
||||
glBindVertexArray(non_current_simulation_vao);
|
||||
SimpleSimulationBind(tfb_buffers[1], initial_values_buffer);
|
||||
|
||||
glBindVertexArray(0);
|
||||
|
||||
texture = getTextureGLuint(getMaterial(0).getTexture(0));
|
||||
normal_and_depth = getTextureGLuint(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH));
|
||||
|
||||
if (SimpleSimulationShader::Program && SimpleParticleRender::Program && FlipParticleRender::Program && HeightmapSimulationShader::Program)
|
||||
return;
|
||||
SimpleSimulationShader::init();
|
||||
HeightmapSimulationShader::init();
|
||||
SimpleParticleRender::init();
|
||||
FlipParticleRender::init();
|
||||
}
|
||||
|
||||
void ParticleSystemProxy::simulateHeightmap()
|
||||
@ -466,53 +462,33 @@ void ParticleSystemProxy::simulateHeightmap()
|
||||
int timediff = int(GUIEngine::getLatestDt() * 1000.f);
|
||||
int active_count = getEmitter()->getMaxLifeTime() * getEmitter()->getMaxParticlesPerSecond() / 1000;
|
||||
core::matrix4 matrix = getAbsoluteTransformation();
|
||||
glUseProgram(HeightmapSimulationShader::Program);
|
||||
glUseProgram(ParticleShader::HeightmapSimulationShader::Program);
|
||||
glEnable(GL_RASTERIZER_DISCARD);
|
||||
glEnableVertexAttribArray(HeightmapSimulationShader::attrib_position);
|
||||
glEnableVertexAttribArray(HeightmapSimulationShader::attrib_lifetime);
|
||||
glEnableVertexAttribArray(HeightmapSimulationShader::attrib_velocity);
|
||||
// glEnableVertexAttribArray(HeightmapSimulationShader::attrib_size);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, tfb_buffers[0]);
|
||||
glVertexAttribPointer(HeightmapSimulationShader::attrib_position, 3, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)0);
|
||||
glVertexAttribPointer(HeightmapSimulationShader::attrib_lifetime, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(3 * sizeof(float)));
|
||||
glVertexAttribPointer(HeightmapSimulationShader::attrib_velocity, 4, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(4 * sizeof(float)));
|
||||
//glVertexAttribPointer(HeightmapSimulationShader::attrib_size, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(7 * sizeof(float)));
|
||||
glEnableVertexAttribArray(HeightmapSimulationShader::attrib_initial_position);
|
||||
glEnableVertexAttribArray(HeightmapSimulationShader::attrib_initial_lifetime);
|
||||
glEnableVertexAttribArray(HeightmapSimulationShader::attrib_initial_velocity);
|
||||
glEnableVertexAttribArray(HeightmapSimulationShader::attrib_initial_size);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, initial_values_buffer);
|
||||
glVertexAttribPointer(HeightmapSimulationShader::attrib_initial_position, 3, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)0);
|
||||
glVertexAttribPointer(HeightmapSimulationShader::attrib_initial_lifetime, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(3 * sizeof(float)));
|
||||
glVertexAttribPointer(HeightmapSimulationShader::attrib_initial_velocity, 4, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(4 * sizeof(float)));
|
||||
glVertexAttribPointer(HeightmapSimulationShader::attrib_initial_size, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(7 * sizeof(float)));
|
||||
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfb_buffers[1]);
|
||||
|
||||
glUniform1i(HeightmapSimulationShader::uniform_dt, timediff);
|
||||
glUniform1i(HeightmapSimulationShader::uniform_level, active_count);
|
||||
glUniformMatrix4fv(HeightmapSimulationShader::uniform_sourcematrix, 1, GL_FALSE, matrix.pointer());
|
||||
glUniform1f(HeightmapSimulationShader::uniform_size_increase_factor, size_increase_factor);
|
||||
glUniform1i(ParticleShader::HeightmapSimulationShader::uniform_dt, timediff);
|
||||
glUniform1i(ParticleShader::HeightmapSimulationShader::uniform_level, active_count);
|
||||
glUniformMatrix4fv(ParticleShader::HeightmapSimulationShader::uniform_sourcematrix, 1, GL_FALSE, matrix.pointer());
|
||||
glUniform1f(ParticleShader::HeightmapSimulationShader::uniform_size_increase_factor, size_increase_factor);
|
||||
glActiveTexture(GL_TEXTURE2);
|
||||
glBindTexture(GL_TEXTURE_BUFFER, heightmaptexture);
|
||||
glUniform1i(HeightmapSimulationShader::uniform_heightmap, 2);
|
||||
glUniform1f(HeightmapSimulationShader::uniform_track_x, track_x);
|
||||
glUniform1f(HeightmapSimulationShader::uniform_track_z, track_z);
|
||||
glUniform1f(HeightmapSimulationShader::uniform_track_x_len, track_x_len);
|
||||
glUniform1f(HeightmapSimulationShader::uniform_track_z_len, track_z_len);
|
||||
glUniform1i(ParticleShader::HeightmapSimulationShader::uniform_heightmap, 2);
|
||||
glUniform1f(ParticleShader::HeightmapSimulationShader::uniform_track_x, track_x);
|
||||
glUniform1f(ParticleShader::HeightmapSimulationShader::uniform_track_z, track_z);
|
||||
glUniform1f(ParticleShader::HeightmapSimulationShader::uniform_track_x_len, track_x_len);
|
||||
glUniform1f(ParticleShader::HeightmapSimulationShader::uniform_track_z_len, track_z_len);
|
||||
|
||||
glBindVertexArray(current_hm_simulation_vao);
|
||||
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfb_buffers[1]);
|
||||
|
||||
glBeginTransformFeedback(GL_POINTS);
|
||||
glDrawArrays(GL_POINTS, 0, count);
|
||||
glEndTransformFeedback();
|
||||
glDisableVertexAttribArray(HeightmapSimulationShader::attrib_position);
|
||||
glDisableVertexAttribArray(HeightmapSimulationShader::attrib_lifetime);
|
||||
glDisableVertexAttribArray(HeightmapSimulationShader::attrib_velocity);
|
||||
// glDisableVertexAttribArray(HeightmapSimulationShader::attrib_size);
|
||||
glDisableVertexAttribArray(HeightmapSimulationShader::attrib_initial_position);
|
||||
glDisableVertexAttribArray(HeightmapSimulationShader::attrib_initial_lifetime);
|
||||
glDisableVertexAttribArray(HeightmapSimulationShader::attrib_initial_velocity);
|
||||
glDisableVertexAttribArray(HeightmapSimulationShader::attrib_initial_size);
|
||||
glBindVertexArray(0);
|
||||
|
||||
glDisable(GL_RASTERIZER_DISCARD);
|
||||
std::swap(tfb_buffers[0], tfb_buffers[1]);
|
||||
std::swap(current_rendering_flip_vao, non_current_rendering_flip_vao);
|
||||
std::swap(current_hm_simulation_vao, non_currenthm__simulation_vao);
|
||||
}
|
||||
|
||||
void ParticleSystemProxy::simulateNoHeightmap()
|
||||
@ -520,46 +496,26 @@ void ParticleSystemProxy::simulateNoHeightmap()
|
||||
int timediff = int(GUIEngine::getLatestDt() * 1000.f);
|
||||
int active_count = getEmitter()->getMaxLifeTime() * getEmitter()->getMaxParticlesPerSecond() / 1000;
|
||||
core::matrix4 matrix = getAbsoluteTransformation();
|
||||
glUseProgram(SimpleSimulationShader::Program);
|
||||
glUseProgram(ParticleShader::SimpleSimulationShader::Program);
|
||||
glEnable(GL_RASTERIZER_DISCARD);
|
||||
glEnableVertexAttribArray(SimpleSimulationShader::attrib_position);
|
||||
glEnableVertexAttribArray(SimpleSimulationShader::attrib_lifetime);
|
||||
glEnableVertexAttribArray(SimpleSimulationShader::attrib_velocity);
|
||||
glEnableVertexAttribArray(SimpleSimulationShader::attrib_size);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, tfb_buffers[0]);
|
||||
glVertexAttribPointer(SimpleSimulationShader::attrib_position, 3, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)0);
|
||||
glVertexAttribPointer(SimpleSimulationShader::attrib_lifetime, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(3 * sizeof(float)));
|
||||
glVertexAttribPointer(SimpleSimulationShader::attrib_velocity, 4, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(4 * sizeof(float)));
|
||||
glVertexAttribPointer(SimpleSimulationShader::attrib_size, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(7 * sizeof(float)));
|
||||
glEnableVertexAttribArray(SimpleSimulationShader::attrib_initial_position);
|
||||
glEnableVertexAttribArray(SimpleSimulationShader::attrib_initial_lifetime);
|
||||
glEnableVertexAttribArray(SimpleSimulationShader::attrib_initial_velocity);
|
||||
glEnableVertexAttribArray(SimpleSimulationShader::attrib_initial_size);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, initial_values_buffer);
|
||||
glVertexAttribPointer(SimpleSimulationShader::attrib_initial_position, 3, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)0);
|
||||
glVertexAttribPointer(SimpleSimulationShader::attrib_initial_lifetime, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(3 * sizeof(float)));
|
||||
glVertexAttribPointer(SimpleSimulationShader::attrib_initial_velocity, 4, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(4 * sizeof(float)));
|
||||
glVertexAttribPointer(SimpleSimulationShader::attrib_initial_size, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(7 * sizeof(float)));
|
||||
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfb_buffers[1]);
|
||||
|
||||
glUniform1i(SimpleSimulationShader::uniform_dt, timediff);
|
||||
glUniform1i(SimpleSimulationShader::uniform_level, active_count);
|
||||
glUniformMatrix4fv(SimpleSimulationShader::uniform_sourcematrix, 1, GL_FALSE, matrix.pointer());
|
||||
glUniform1f(SimpleSimulationShader::uniform_size_increase_factor, size_increase_factor);
|
||||
glUniform1i(ParticleShader::SimpleSimulationShader::uniform_dt, timediff);
|
||||
glUniform1i(ParticleShader::SimpleSimulationShader::uniform_level, active_count);
|
||||
glUniformMatrix4fv(ParticleShader::SimpleSimulationShader::uniform_sourcematrix, 1, GL_FALSE, matrix.pointer());
|
||||
glUniform1f(ParticleShader::SimpleSimulationShader::uniform_size_increase_factor, size_increase_factor);
|
||||
|
||||
glBindVertexArray(current_simulation_vao);
|
||||
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfb_buffers[1]);
|
||||
|
||||
glBeginTransformFeedback(GL_POINTS);
|
||||
glDrawArrays(GL_POINTS, 0, count);
|
||||
glEndTransformFeedback();
|
||||
glDisableVertexAttribArray(SimpleSimulationShader::attrib_position);
|
||||
glDisableVertexAttribArray(SimpleSimulationShader::attrib_lifetime);
|
||||
glDisableVertexAttribArray(SimpleSimulationShader::attrib_velocity);
|
||||
glDisableVertexAttribArray(SimpleSimulationShader::attrib_size);
|
||||
glDisableVertexAttribArray(SimpleSimulationShader::attrib_initial_position);
|
||||
glDisableVertexAttribArray(SimpleSimulationShader::attrib_initial_lifetime);
|
||||
glDisableVertexAttribArray(SimpleSimulationShader::attrib_initial_velocity);
|
||||
glDisableVertexAttribArray(SimpleSimulationShader::attrib_initial_size);
|
||||
glBindVertexArray(0);
|
||||
|
||||
glDisable(GL_RASTERIZER_DISCARD);
|
||||
std::swap(tfb_buffers[0], tfb_buffers[1]);
|
||||
std::swap(current_rendering_vao, non_current_rendering_vao);
|
||||
std::swap(current_simulation_vao, non_current_simulation_vao);
|
||||
}
|
||||
|
||||
void ParticleSystemProxy::simulate()
|
||||
@ -580,59 +536,22 @@ void ParticleSystemProxy::drawFlip()
|
||||
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
|
||||
else
|
||||
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
||||
glUseProgram(FlipParticleRender::Program);
|
||||
glEnableVertexAttribArray(FlipParticleRender::attrib_pos);
|
||||
glEnableVertexAttribArray(FlipParticleRender::attrib_lf);
|
||||
glEnableVertexAttribArray(FlipParticleRender::attrib_quadcorner);
|
||||
glEnableVertexAttribArray(FlipParticleRender::attrib_texcoord);
|
||||
glEnableVertexAttribArray(FlipParticleRender::attrib_sz);
|
||||
glUseProgram(ParticleShader::FlipParticleRender::Program);
|
||||
|
||||
float screen[2] = {
|
||||
(float)UserConfigParams::m_width,
|
||||
(float)UserConfigParams::m_height
|
||||
};
|
||||
|
||||
bindUniformToTextureUnit(FlipParticleRender::uniform_tex, texture, 0);
|
||||
bindUniformToTextureUnit(FlipParticleRender::uniform_normal_and_depths, normal_and_depth, 1);
|
||||
setTexture(0, texture, GL_LINEAR, GL_LINEAR);
|
||||
setTexture(1, normal_and_depth, GL_NEAREST, GL_NEAREST);
|
||||
|
||||
glUniformMatrix4fv(FlipParticleRender::uniform_invproj, 1, GL_FALSE, irr_driver->getInvProjMatrix().pointer());
|
||||
glUniform2f(FlipParticleRender::uniform_screen, screen[0], screen[1]);
|
||||
glUniformMatrix4fv(FlipParticleRender::uniform_matrix, 1, GL_FALSE, irr_driver->getProjMatrix().pointer());
|
||||
glUniformMatrix4fv(FlipParticleRender::uniform_viewmatrix, 1, GL_FALSE, irr_driver->getViewMatrix().pointer());
|
||||
|
||||
glEnableVertexAttribArray(FlipParticleRender::attrib_rotationvec);
|
||||
glEnableVertexAttribArray(FlipParticleRender::attrib_anglespeed);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, quaternionsbuffer);
|
||||
glVertexAttribPointer(FlipParticleRender::attrib_rotationvec, 3, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
|
||||
glVertexAttribPointer(FlipParticleRender::attrib_anglespeed, 1, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (GLvoid *)(3 * sizeof(float)));
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, quad_vertex_buffer);
|
||||
glVertexAttribPointer(FlipParticleRender::attrib_quadcorner, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
|
||||
glVertexAttribPointer(FlipParticleRender::attrib_texcoord, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (GLvoid *)(2 * sizeof(float)));
|
||||
glBindBuffer(GL_ARRAY_BUFFER, tfb_buffers[0]);
|
||||
glVertexAttribPointer(FlipParticleRender::attrib_pos, 3, GL_FLOAT, GL_FALSE, sizeof(ParticleData), 0);
|
||||
glVertexAttribPointer(FlipParticleRender::attrib_lf, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid *)(3 * sizeof(float)));
|
||||
glVertexAttribPointer(FlipParticleRender::attrib_sz, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid *)(7 * sizeof(float)));
|
||||
|
||||
glVertexAttribDivisor(FlipParticleRender::attrib_lf, 1);
|
||||
glVertexAttribDivisor(FlipParticleRender::attrib_pos, 1);
|
||||
glVertexAttribDivisor(FlipParticleRender::attrib_sz, 1);
|
||||
glVertexAttribDivisor(FlipParticleRender::attrib_rotationvec, 1);
|
||||
glVertexAttribDivisor(FlipParticleRender::attrib_anglespeed, 1);
|
||||
ParticleShader::FlipParticleRender::setUniforms(irr_driver->getViewMatrix(), irr_driver->getProjMatrix(), irr_driver->getInvProjMatrix(), screen[0], screen[1], 0, 1);
|
||||
|
||||
glBindVertexArray(current_rendering_flip_vao);
|
||||
glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, count);
|
||||
glVertexAttribDivisor(FlipParticleRender::attrib_lf, 0);
|
||||
glVertexAttribDivisor(FlipParticleRender::attrib_pos, 0);
|
||||
glVertexAttribDivisor(FlipParticleRender::attrib_sz, 0);
|
||||
glVertexAttribDivisor(FlipParticleRender::attrib_rotationvec, 0);
|
||||
glVertexAttribDivisor(FlipParticleRender::attrib_anglespeed, 0);
|
||||
glDisableVertexAttribArray(FlipParticleRender::attrib_pos);
|
||||
glDisableVertexAttribArray(FlipParticleRender::attrib_lf);
|
||||
glDisableVertexAttribArray(FlipParticleRender::attrib_quadcorner);
|
||||
glDisableVertexAttribArray(FlipParticleRender::attrib_texcoord);
|
||||
glDisableVertexAttribArray(FlipParticleRender::attrib_sz);
|
||||
glDisableVertexAttribArray(FlipParticleRender::attrib_rotationvec);
|
||||
glDisableVertexAttribArray(FlipParticleRender::attrib_anglespeed);
|
||||
|
||||
glBindVertexArray(0);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
glActiveTexture(GL_TEXTURE0);
|
||||
glDisable(GL_BLEND);
|
||||
@ -649,47 +568,22 @@ void ParticleSystemProxy::drawNotFlip()
|
||||
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
|
||||
else
|
||||
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
||||
glUseProgram(SimpleParticleRender::Program);
|
||||
glEnableVertexAttribArray(SimpleParticleRender::attrib_pos);
|
||||
glEnableVertexAttribArray(SimpleParticleRender::attrib_lf);
|
||||
glEnableVertexAttribArray(SimpleParticleRender::attrib_quadcorner);
|
||||
glEnableVertexAttribArray(SimpleParticleRender::attrib_texcoord);
|
||||
glEnableVertexAttribArray(SimpleParticleRender::attrib_sz);
|
||||
glUseProgram(ParticleShader::SimpleParticleRender::Program);
|
||||
|
||||
float screen[2] = {
|
||||
(float)UserConfigParams::m_width,
|
||||
(float)UserConfigParams::m_height
|
||||
};
|
||||
|
||||
bindUniformToTextureUnit(SimpleParticleRender::uniform_tex, texture, 0);
|
||||
bindUniformToTextureUnit(SimpleParticleRender::uniform_normal_and_depths, normal_and_depth, 1);
|
||||
setTexture(0, texture, GL_LINEAR, GL_LINEAR);
|
||||
setTexture(1, normal_and_depth, GL_NEAREST, GL_NEAREST);
|
||||
|
||||
glUniformMatrix4fv(SimpleParticleRender::uniform_invproj, 1, GL_FALSE, irr_driver->getInvProjMatrix().pointer());
|
||||
glUniform2f(SimpleParticleRender::uniform_screen, screen[0], screen[1]);
|
||||
glUniformMatrix4fv(SimpleParticleRender::uniform_matrix, 1, GL_FALSE, irr_driver->getProjMatrix().pointer());
|
||||
glUniformMatrix4fv(SimpleParticleRender::uniform_viewmatrix, 1, GL_FALSE, irr_driver->getViewMatrix().pointer());
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, quad_vertex_buffer);
|
||||
glVertexAttribPointer(SimpleParticleRender::attrib_quadcorner, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
|
||||
glVertexAttribPointer(SimpleParticleRender::attrib_texcoord, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (GLvoid *)(2 * sizeof(float)));
|
||||
glBindBuffer(GL_ARRAY_BUFFER, tfb_buffers[0]);
|
||||
glVertexAttribPointer(SimpleParticleRender::attrib_pos, 3, GL_FLOAT, GL_FALSE, sizeof(ParticleData), 0);
|
||||
glVertexAttribPointer(SimpleParticleRender::attrib_lf, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid *)(3 * sizeof(float)));
|
||||
glVertexAttribPointer(SimpleParticleRender::attrib_sz, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid *)(7 * sizeof(float)));
|
||||
|
||||
glVertexAttribDivisor(SimpleParticleRender::attrib_lf, 1);
|
||||
glVertexAttribDivisor(SimpleParticleRender::attrib_pos, 1);
|
||||
glVertexAttribDivisor(SimpleParticleRender::attrib_sz, 1);
|
||||
ParticleShader::SimpleParticleRender::setUniforms(irr_driver->getViewMatrix(), irr_driver->getProjMatrix(), irr_driver->getInvProjMatrix(), screen[0], screen[1], 0, 1);
|
||||
|
||||
glBindVertexArray(current_rendering_vao);
|
||||
glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, count);
|
||||
glVertexAttribDivisor(SimpleParticleRender::attrib_lf, 0);
|
||||
glVertexAttribDivisor(SimpleParticleRender::attrib_pos, 0);
|
||||
glVertexAttribDivisor(SimpleParticleRender::attrib_sz, 0);
|
||||
glDisableVertexAttribArray(SimpleParticleRender::attrib_pos);
|
||||
glDisableVertexAttribArray(SimpleParticleRender::attrib_lf);
|
||||
glDisableVertexAttribArray(SimpleParticleRender::attrib_quadcorner);
|
||||
glDisableVertexAttribArray(SimpleParticleRender::attrib_texcoord);
|
||||
glDisableVertexAttribArray(SimpleParticleRender::attrib_sz);
|
||||
|
||||
glBindVertexArray(0);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
glActiveTexture(GL_TEXTURE0);
|
||||
glDisable(GL_BLEND);
|
||||
|
||||
@ -28,6 +28,10 @@ class ParticleSystemProxy : public scene::CParticleSystemSceneNode {
|
||||
protected:
|
||||
video::SMaterial fakemat;
|
||||
GLuint tfb_buffers[2], initial_values_buffer, heighmapbuffer, heightmaptexture, quaternionsbuffer;
|
||||
GLuint current_simulation_vao, non_current_simulation_vao;
|
||||
GLuint current_hm_simulation_vao, non_currenthm__simulation_vao;
|
||||
GLuint current_rendering_vao, non_current_rendering_vao;
|
||||
GLuint current_rendering_flip_vao, non_current_rendering_flip_vao;
|
||||
bool m_alpha_additive, has_height_map, flip;
|
||||
float size_increase_factor, track_x, track_z, track_x_len, track_z_len;
|
||||
|
||||
@ -35,6 +39,10 @@ protected:
|
||||
|
||||
GLuint texture, normal_and_depth;
|
||||
unsigned count;
|
||||
static void SimpleParticleVAOBind(GLuint PositionBuffer);
|
||||
static void FlipParticleVAOBind(GLuint PositionBuffer, GLuint QuaternionBuffer);
|
||||
static void SimpleSimulationBind(GLuint PositionBuffer, GLuint InitialValuesBuffer);
|
||||
static void HeightmapSimulationBind(GLuint PositionBuffer, GLuint InitialValuesBuffer);
|
||||
|
||||
void simulateHeightmap();
|
||||
void simulateNoHeightmap();
|
||||
|
||||
@ -292,16 +292,10 @@ void IrrDriver::renderGLSL(float dt)
|
||||
}
|
||||
PROFILER_POP_CPU_MARKER();
|
||||
|
||||
// Render fog on top of solid
|
||||
if (World::getWorld()->getTrack()->isFogEnabled())
|
||||
{
|
||||
PROFILER_PUSH_CPU_MARKER("- Fog", 0xFF, 0x00, 0x00);
|
||||
m_post_processing->renderFog(camnode->getAbsolutePosition(), irr_driver->getInvProjViewMatrix());
|
||||
PROFILER_POP_CPU_MARKER();
|
||||
}
|
||||
|
||||
// We need to re-render camera due to the per-cam-node hack.
|
||||
PROFILER_PUSH_CPU_MARKER("- Transparent Pass", 0xFF, 0x00, 0x00);
|
||||
irr_driver->setPhase(3);
|
||||
m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_TRANSPARENT;
|
||||
m_scene_manager->drawAll(m_renderpass);
|
||||
PROFILER_POP_CPU_MARKER();
|
||||
@ -311,6 +305,13 @@ void IrrDriver::renderGLSL(float dt)
|
||||
m_scene_manager->drawAll(m_renderpass);
|
||||
PROFILER_POP_CPU_MARKER();
|
||||
|
||||
if (World::getWorld()->getTrack()->isFogEnabled())
|
||||
{
|
||||
PROFILER_PUSH_CPU_MARKER("- Fog", 0xFF, 0x00, 0x00);
|
||||
m_post_processing->renderFog(camnode->getAbsolutePosition(), irr_driver->getInvProjViewMatrix());
|
||||
PROFILER_POP_CPU_MARKER();
|
||||
}
|
||||
|
||||
PROFILER_PUSH_CPU_MARKER("- Displacement", 0xFF, 0x00, 0x00);
|
||||
// Handle displacing nodes, if any
|
||||
const u32 displacingcount = m_displacing.size();
|
||||
@ -827,10 +828,7 @@ void IrrDriver::renderDisplacement(video::SOverrideMaterial &overridemat,
|
||||
{
|
||||
m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_DISPLACE), false, false);
|
||||
glClearColor(0, 0, 0, 0);
|
||||
glClear(GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
|
||||
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
|
||||
glStencilFunc(GL_ALWAYS, 1, ~0);
|
||||
glEnable(GL_STENCIL_TEST);
|
||||
glClear(GL_COLOR_BUFFER_BIT);
|
||||
|
||||
overridemat.Enabled = 1;
|
||||
overridemat.EnableFlags = video::EMF_MATERIAL_TYPE | video::EMF_TEXTURE0;
|
||||
@ -844,9 +842,14 @@ void IrrDriver::renderDisplacement(video::SOverrideMaterial &overridemat,
|
||||
overridemat.Material.TextureLayer[0].TextureWrapU =
|
||||
overridemat.Material.TextureLayer[0].TextureWrapV = video::ETC_REPEAT;
|
||||
|
||||
DisplaceProvider * const cb = (DisplaceProvider *)irr_driver->getCallback(ES_DISPLACE);
|
||||
cb->update();
|
||||
|
||||
const int displacingcount = m_displacing.size();
|
||||
irr_driver->setPhase(4);
|
||||
for (int i = 0; i < displacingcount; i++)
|
||||
{
|
||||
|
||||
m_scene_manager->setCurrentRendertime(scene::ESNRP_SOLID);
|
||||
m_displacing[i]->render();
|
||||
|
||||
@ -857,9 +860,6 @@ void IrrDriver::renderDisplacement(video::SOverrideMaterial &overridemat,
|
||||
overridemat.Enabled = 0;
|
||||
|
||||
// Blur it
|
||||
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
|
||||
glStencilFunc(GL_EQUAL, 1, ~0);
|
||||
|
||||
video::SMaterial minimat;
|
||||
minimat.Lighting = false;
|
||||
minimat.ZWriteEnable = false;
|
||||
@ -871,6 +871,5 @@ void IrrDriver::renderDisplacement(video::SOverrideMaterial &overridemat,
|
||||
|
||||
m_post_processing->renderGaussian3Blur(m_rtts->getRTT(RTT_DISPLACE), m_rtts->getRTT(RTT_TMP2), 1.f / UserConfigParams::m_width, 1.f / UserConfigParams::m_height);
|
||||
|
||||
glDisable(GL_STENCIL_TEST);
|
||||
m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_COLOR), false, false);
|
||||
}
|
||||
|
||||
@ -248,6 +248,11 @@ void Shaders::loadShaders()
|
||||
MeshShader::GrassPass2Shader::init();
|
||||
MeshShader::BubbleShader::init();
|
||||
MeshShader::TransparentShader::init();
|
||||
MeshShader::DisplaceShader::init();
|
||||
ParticleShader::FlipParticleRender::init();
|
||||
ParticleShader::HeightmapSimulationShader::init();
|
||||
ParticleShader::SimpleParticleRender::init();
|
||||
ParticleShader::SimpleSimulationShader::init();
|
||||
}
|
||||
|
||||
Shaders::~Shaders()
|
||||
@ -641,6 +646,216 @@ namespace MeshShader
|
||||
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer());
|
||||
glUniform3f(uniform_col, r, g, b);
|
||||
}
|
||||
|
||||
GLuint DisplaceShader::Program;
|
||||
GLuint DisplaceShader::attrib_position;
|
||||
GLuint DisplaceShader::attrib_texcoord;
|
||||
GLuint DisplaceShader::attrib_second_texcoord;
|
||||
GLuint DisplaceShader::uniform_MVP;
|
||||
GLuint DisplaceShader::uniform_MV;
|
||||
GLuint DisplaceShader::uniform_tex;
|
||||
GLuint DisplaceShader::uniform_dir;
|
||||
GLuint DisplaceShader::uniform_dir2;
|
||||
|
||||
void DisplaceShader::init()
|
||||
{
|
||||
Program = LoadProgram(file_manager->getAsset("shaders/displace.vert").c_str(), file_manager->getAsset("shaders/displace.frag").c_str());
|
||||
attrib_position = glGetAttribLocation(Program, "Position");
|
||||
attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
|
||||
attrib_second_texcoord = glGetAttribLocation(Program, "SecondTexcoord");
|
||||
uniform_MVP = glGetUniformLocation(Program, "ModelViewProjectionMatrix");
|
||||
uniform_MV = glGetUniformLocation(Program, "ModelViewMatrix");
|
||||
uniform_tex = glGetUniformLocation(Program, "tex");
|
||||
uniform_dir = glGetUniformLocation(Program, "dir");
|
||||
uniform_dir2 = glGetUniformLocation(Program, "dir2");
|
||||
}
|
||||
|
||||
void DisplaceShader::setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &ModelViewMatrix, float dirX, float dirY, float dir2X, float dir2Y, unsigned TU_tex)
|
||||
{
|
||||
glUniformMatrix4fv(uniform_MVP, 1, GL_FALSE, ModelViewProjectionMatrix.pointer());
|
||||
glUniformMatrix4fv(uniform_MV, 1, GL_FALSE, ModelViewMatrix.pointer());
|
||||
glUniform2f(uniform_dir, dirX, dirY);
|
||||
glUniform2f(uniform_dir2, dir2X, dir2Y);
|
||||
glUniform1i(uniform_tex, TU_tex);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
namespace ParticleShader
|
||||
{
|
||||
GLuint SimpleSimulationShader::Program;
|
||||
GLuint SimpleSimulationShader::attrib_position;
|
||||
GLuint SimpleSimulationShader::attrib_velocity;
|
||||
GLuint SimpleSimulationShader::attrib_lifetime;
|
||||
GLuint SimpleSimulationShader::attrib_initial_position;
|
||||
GLuint SimpleSimulationShader::attrib_initial_velocity;
|
||||
GLuint SimpleSimulationShader::attrib_initial_lifetime;
|
||||
GLuint SimpleSimulationShader::attrib_size;
|
||||
GLuint SimpleSimulationShader::attrib_initial_size;
|
||||
GLuint SimpleSimulationShader::uniform_sourcematrix;
|
||||
GLuint SimpleSimulationShader::uniform_dt;
|
||||
GLuint SimpleSimulationShader::uniform_level;
|
||||
GLuint SimpleSimulationShader::uniform_size_increase_factor;
|
||||
|
||||
void SimpleSimulationShader::init()
|
||||
{
|
||||
const char *varyings[] = {
|
||||
"new_particle_position",
|
||||
"new_lifetime",
|
||||
"new_particle_velocity",
|
||||
"new_size",
|
||||
};
|
||||
Program = LoadTFBProgram(file_manager->getAsset("shaders/pointemitter.vert").c_str(), varyings, 4);
|
||||
|
||||
uniform_dt = glGetUniformLocation(Program, "dt");
|
||||
uniform_sourcematrix = glGetUniformLocation(Program, "sourcematrix");
|
||||
uniform_level = glGetUniformLocation(Program, "level");
|
||||
uniform_size_increase_factor = glGetUniformLocation(Program, "size_increase_factor");
|
||||
|
||||
attrib_position = glGetAttribLocation(Program, "particle_position");
|
||||
attrib_lifetime = glGetAttribLocation(Program, "lifetime");
|
||||
attrib_velocity = glGetAttribLocation(Program, "particle_velocity");
|
||||
attrib_size = glGetAttribLocation(Program, "size");
|
||||
attrib_initial_position = glGetAttribLocation(Program, "particle_position_initial");
|
||||
attrib_initial_lifetime = glGetAttribLocation(Program, "lifetime_initial");
|
||||
attrib_initial_velocity = glGetAttribLocation(Program, "particle_velocity_initial");
|
||||
attrib_initial_size = glGetAttribLocation(Program, "size_initial");
|
||||
}
|
||||
|
||||
GLuint HeightmapSimulationShader::Program;
|
||||
GLuint HeightmapSimulationShader::attrib_position;
|
||||
GLuint HeightmapSimulationShader::attrib_velocity;
|
||||
GLuint HeightmapSimulationShader::attrib_lifetime;
|
||||
GLuint HeightmapSimulationShader::attrib_initial_position;
|
||||
GLuint HeightmapSimulationShader::attrib_initial_velocity;
|
||||
GLuint HeightmapSimulationShader::attrib_initial_lifetime;
|
||||
GLuint HeightmapSimulationShader::attrib_size;
|
||||
GLuint HeightmapSimulationShader::attrib_initial_size;
|
||||
GLuint HeightmapSimulationShader::uniform_sourcematrix;
|
||||
GLuint HeightmapSimulationShader::uniform_dt;
|
||||
GLuint HeightmapSimulationShader::uniform_level;
|
||||
GLuint HeightmapSimulationShader::uniform_size_increase_factor;
|
||||
GLuint HeightmapSimulationShader::uniform_track_x;
|
||||
GLuint HeightmapSimulationShader::uniform_track_z;
|
||||
GLuint HeightmapSimulationShader::uniform_track_x_len;
|
||||
GLuint HeightmapSimulationShader::uniform_track_z_len;
|
||||
GLuint HeightmapSimulationShader::uniform_heightmap;
|
||||
|
||||
void HeightmapSimulationShader::init()
|
||||
{
|
||||
const char *varyings[] = {
|
||||
"new_particle_position",
|
||||
"new_lifetime",
|
||||
"new_particle_velocity",
|
||||
"new_size",
|
||||
};
|
||||
Program = LoadTFBProgram(file_manager->getAsset("shaders/particlesimheightmap.vert").c_str(), varyings, 4);
|
||||
|
||||
uniform_dt = glGetUniformLocation(Program, "dt");
|
||||
uniform_sourcematrix = glGetUniformLocation(Program, "sourcematrix");
|
||||
uniform_level = glGetUniformLocation(Program, "level");
|
||||
uniform_size_increase_factor = glGetUniformLocation(Program, "size_increase_factor");
|
||||
|
||||
attrib_position = glGetAttribLocation(Program, "particle_position");
|
||||
attrib_lifetime = glGetAttribLocation(Program, "lifetime");
|
||||
attrib_velocity = glGetAttribLocation(Program, "particle_velocity");
|
||||
attrib_size = glGetAttribLocation(Program, "size");
|
||||
attrib_initial_position = glGetAttribLocation(Program, "particle_position_initial");
|
||||
attrib_initial_lifetime = glGetAttribLocation(Program, "lifetime_initial");
|
||||
attrib_initial_velocity = glGetAttribLocation(Program, "particle_velocity_initial");
|
||||
attrib_initial_size = glGetAttribLocation(Program, "size_initial");
|
||||
|
||||
uniform_heightmap = glGetUniformLocation(Program, "heightmap");
|
||||
uniform_track_x = glGetUniformLocation(Program, "track_x");
|
||||
uniform_track_x_len = glGetUniformLocation(Program, "track_x_len");
|
||||
uniform_track_z = glGetUniformLocation(Program, "track_z");
|
||||
uniform_track_z_len = glGetUniformLocation(Program, "track_z_len");
|
||||
}
|
||||
|
||||
GLuint SimpleParticleRender::Program;
|
||||
GLuint SimpleParticleRender::attrib_pos;
|
||||
GLuint SimpleParticleRender::attrib_lf;
|
||||
GLuint SimpleParticleRender::attrib_quadcorner;
|
||||
GLuint SimpleParticleRender::attrib_texcoord;
|
||||
GLuint SimpleParticleRender::attrib_sz;
|
||||
GLuint SimpleParticleRender::uniform_matrix;
|
||||
GLuint SimpleParticleRender::uniform_viewmatrix;
|
||||
GLuint SimpleParticleRender::uniform_tex;
|
||||
GLuint SimpleParticleRender::uniform_normal_and_depths;
|
||||
GLuint SimpleParticleRender::uniform_screen;
|
||||
GLuint SimpleParticleRender::uniform_invproj;
|
||||
|
||||
void SimpleParticleRender::init()
|
||||
{
|
||||
Program = LoadProgram(file_manager->getAsset("shaders/particle.vert").c_str(), file_manager->getAsset("shaders/particle.frag").c_str());
|
||||
attrib_pos = glGetAttribLocation(Program, "position");
|
||||
attrib_sz = glGetAttribLocation(Program, "size");
|
||||
attrib_lf = glGetAttribLocation(Program, "lifetime");
|
||||
attrib_quadcorner = glGetAttribLocation(Program, "quadcorner");
|
||||
attrib_texcoord = glGetAttribLocation(Program, "texcoord");
|
||||
|
||||
|
||||
uniform_matrix = glGetUniformLocation(Program, "ProjectionMatrix");
|
||||
uniform_viewmatrix = glGetUniformLocation(Program, "ViewMatrix");
|
||||
uniform_tex = glGetUniformLocation(Program, "tex");
|
||||
uniform_invproj = glGetUniformLocation(Program, "invproj");
|
||||
uniform_screen = glGetUniformLocation(Program, "screen");
|
||||
uniform_normal_and_depths = glGetUniformLocation(Program, "normals_and_depth");
|
||||
}
|
||||
|
||||
void SimpleParticleRender::setUniforms(const core::matrix4 &ViewMatrix, const core::matrix4 &ProjMatrix, const core::matrix4 InvProjMatrix, float width, float height, unsigned TU_tex, unsigned TU_normal_and_depth)
|
||||
{
|
||||
glUniformMatrix4fv(uniform_invproj, 1, GL_FALSE, InvProjMatrix.pointer());
|
||||
glUniform2f(uniform_screen, width, height);
|
||||
glUniformMatrix4fv(uniform_matrix, 1, GL_FALSE, irr_driver->getProjMatrix().pointer());
|
||||
glUniformMatrix4fv(uniform_viewmatrix, 1, GL_FALSE, irr_driver->getViewMatrix().pointer());
|
||||
glUniform1i(uniform_tex, TU_tex);
|
||||
glUniform1i(uniform_normal_and_depths, TU_normal_and_depth);
|
||||
}
|
||||
|
||||
GLuint FlipParticleRender::Program;
|
||||
GLuint FlipParticleRender::attrib_pos;
|
||||
GLuint FlipParticleRender::attrib_lf;
|
||||
GLuint FlipParticleRender::attrib_quadcorner;
|
||||
GLuint FlipParticleRender::attrib_texcoord;
|
||||
GLuint FlipParticleRender::attrib_sz;
|
||||
GLuint FlipParticleRender::attrib_rotationvec;
|
||||
GLuint FlipParticleRender::attrib_anglespeed;
|
||||
GLuint FlipParticleRender::uniform_matrix;
|
||||
GLuint FlipParticleRender::uniform_viewmatrix;
|
||||
GLuint FlipParticleRender::uniform_tex;
|
||||
GLuint FlipParticleRender::uniform_normal_and_depths;
|
||||
GLuint FlipParticleRender::uniform_screen;
|
||||
GLuint FlipParticleRender::uniform_invproj;
|
||||
|
||||
void FlipParticleRender::init()
|
||||
{
|
||||
Program = LoadProgram(file_manager->getAsset("shaders/flipparticle.vert").c_str(), file_manager->getAsset("shaders/particle.frag").c_str());
|
||||
attrib_pos = glGetAttribLocation(Program, "position");
|
||||
attrib_sz = glGetAttribLocation(Program, "size");
|
||||
attrib_lf = glGetAttribLocation(Program, "lifetime");
|
||||
attrib_quadcorner = glGetAttribLocation(Program, "quadcorner");
|
||||
attrib_texcoord = glGetAttribLocation(Program, "texcoord");
|
||||
attrib_anglespeed = glGetAttribLocation(Program, "anglespeed");
|
||||
attrib_rotationvec = glGetAttribLocation(Program, "rotationvec");
|
||||
|
||||
uniform_matrix = glGetUniformLocation(Program, "ProjectionMatrix");
|
||||
uniform_viewmatrix = glGetUniformLocation(Program, "ViewMatrix");
|
||||
uniform_tex = glGetUniformLocation(Program, "tex");
|
||||
uniform_invproj = glGetUniformLocation(Program, "invproj");
|
||||
uniform_screen = glGetUniformLocation(Program, "screen");
|
||||
uniform_normal_and_depths = glGetUniformLocation(Program, "normals_and_depth");
|
||||
}
|
||||
|
||||
void FlipParticleRender::setUniforms(const core::matrix4 &ViewMatrix, const core::matrix4 &ProjMatrix, const core::matrix4 InvProjMatrix, float width, float height, unsigned TU_tex, unsigned TU_normal_and_depth)
|
||||
{
|
||||
glUniformMatrix4fv(uniform_invproj, 1, GL_FALSE, InvProjMatrix.pointer());
|
||||
glUniform2f(uniform_screen, width, height);
|
||||
glUniformMatrix4fv(uniform_matrix, 1, GL_FALSE, irr_driver->getProjMatrix().pointer());
|
||||
glUniformMatrix4fv(uniform_viewmatrix, 1, GL_FALSE, irr_driver->getViewMatrix().pointer());
|
||||
glUniform1i(uniform_tex, TU_tex);
|
||||
glUniform1i(uniform_normal_and_depths, TU_normal_and_depth);
|
||||
}
|
||||
}
|
||||
|
||||
static GLuint createVAO(GLuint Program)
|
||||
|
||||
@ -159,6 +159,66 @@ public:
|
||||
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, float r, float g, float b);
|
||||
};
|
||||
|
||||
class DisplaceShader
|
||||
{
|
||||
public:
|
||||
static GLuint Program;
|
||||
static GLuint attrib_position, attrib_texcoord, attrib_second_texcoord;
|
||||
static GLuint uniform_MVP, uniform_MV, uniform_tex, uniform_dir, uniform_dir2;
|
||||
|
||||
static void init();
|
||||
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &ModelViewMatrix, float dirX, float dirY, float dir2X, float dir2Y, unsigned TU_tex);
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
namespace ParticleShader
|
||||
{
|
||||
|
||||
class SimpleSimulationShader
|
||||
{
|
||||
public:
|
||||
static GLuint Program;
|
||||
static GLuint attrib_position, attrib_velocity, attrib_lifetime, attrib_initial_position, attrib_initial_velocity, attrib_initial_lifetime, attrib_size, attrib_initial_size;
|
||||
static GLuint uniform_sourcematrix, uniform_dt, uniform_level, uniform_size_increase_factor;
|
||||
|
||||
static void init();
|
||||
};
|
||||
|
||||
|
||||
|
||||
class HeightmapSimulationShader
|
||||
{
|
||||
public:
|
||||
static GLuint Program;
|
||||
static GLuint attrib_position, attrib_velocity, attrib_lifetime, attrib_initial_position, attrib_initial_velocity, attrib_initial_lifetime, attrib_size, attrib_initial_size;
|
||||
static GLuint uniform_sourcematrix, uniform_dt, uniform_level, uniform_size_increase_factor;
|
||||
static GLuint uniform_track_x, uniform_track_z, uniform_track_x_len, uniform_track_z_len, uniform_heightmap;
|
||||
|
||||
static void init();
|
||||
};
|
||||
|
||||
class SimpleParticleRender
|
||||
{
|
||||
public:
|
||||
static GLuint Program;
|
||||
static GLuint attrib_pos, attrib_lf, attrib_quadcorner, attrib_texcoord, attrib_sz;
|
||||
static GLuint uniform_matrix, uniform_viewmatrix, uniform_tex, uniform_normal_and_depths, uniform_screen, uniform_invproj;
|
||||
|
||||
static void init();
|
||||
static void setUniforms(const core::matrix4 &ViewMatrix, const core::matrix4 &ProjMatrix, const core::matrix4 InvProjMatrix, float width, float height, unsigned TU_tex, unsigned TU_normal_and_depth);
|
||||
};
|
||||
|
||||
class FlipParticleRender
|
||||
{
|
||||
public:
|
||||
static GLuint Program;
|
||||
static GLuint attrib_pos, attrib_lf, attrib_quadcorner, attrib_texcoord, attrib_sz, attrib_rotationvec, attrib_anglespeed;
|
||||
static GLuint uniform_matrix, uniform_viewmatrix, uniform_tex, uniform_normal_and_depths, uniform_screen, uniform_invproj;
|
||||
|
||||
static void init();
|
||||
static void setUniforms(const core::matrix4 &ViewMatrix, const core::matrix4 &ProjMatrix, const core::matrix4 InvProjMatrix, float width, float height, unsigned TU_tex, unsigned TU_normal_and_depth);
|
||||
};
|
||||
}
|
||||
|
||||
namespace FullScreenShader
|
||||
|
||||
@ -204,17 +204,6 @@ void STKMesh::drawObjectPass1(const GLMesh &mesh)
|
||||
glDrawElements(ptype, count, itype, 0);
|
||||
}
|
||||
|
||||
static void
|
||||
setTexture(unsigned TextureUnit, GLuint TextureId, GLenum MagFilter, GLenum MinFilter)
|
||||
{
|
||||
glActiveTexture(GL_TEXTURE0 + TextureUnit);
|
||||
glBindTexture(GL_TEXTURE_2D, TextureId);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, MagFilter);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, MinFilter);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
||||
}
|
||||
|
||||
void STKMesh::drawObjectRefPass1(const GLMesh &mesh)
|
||||
{
|
||||
GLenum ptype = mesh.PrimitiveType;
|
||||
@ -396,25 +385,6 @@ void STKMesh::drawObjectPass2(const GLMesh &mesh)
|
||||
glDrawElements(ptype, count, itype, 0);
|
||||
}
|
||||
|
||||
void STKMesh::drawGlow(const GLMesh &mesh, float r, float g, float b)
|
||||
{
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
glDisable(GL_ALPHA_TEST);
|
||||
glDepthMask(GL_FALSE);
|
||||
glDisable(GL_BLEND);
|
||||
GLenum ptype = mesh.PrimitiveType;
|
||||
GLenum itype = mesh.IndexType;
|
||||
size_t count = mesh.IndexCount;
|
||||
|
||||
glUseProgram(MeshShader::ColorizeShader::Program);
|
||||
MeshShader::ColorizeShader::setUniforms(ModelViewProjectionMatrix, r, g, b);
|
||||
|
||||
glBindVertexArray(mesh.vao_glow_pass);
|
||||
glDrawElements(ptype, count, itype, 0);
|
||||
glBindVertexArray(0);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
}
|
||||
|
||||
void STKMesh::drawTransparentObject(const GLMesh &mesh)
|
||||
{
|
||||
GLenum ptype = mesh.PrimitiveType;
|
||||
@ -450,6 +420,51 @@ void STKMesh::drawBubble(const GLMesh &mesh)
|
||||
glDrawElements(ptype, count, itype, 0);
|
||||
}
|
||||
|
||||
void STKMesh::drawGlow(const GLMesh &mesh)
|
||||
{
|
||||
ColorizeProvider * const cb = (ColorizeProvider *)irr_driver->getCallback(ES_COLORIZE);
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
glDisable(GL_ALPHA_TEST);
|
||||
glDepthMask(GL_FALSE);
|
||||
glDisable(GL_BLEND);
|
||||
GLenum ptype = mesh.PrimitiveType;
|
||||
GLenum itype = mesh.IndexType;
|
||||
size_t count = mesh.IndexCount;
|
||||
|
||||
computeMVP(ModelViewProjectionMatrix);
|
||||
glUseProgram(MeshShader::ColorizeShader::Program);
|
||||
MeshShader::ColorizeShader::setUniforms(ModelViewProjectionMatrix, cb->getRed(), cb->getGreen(), cb->getBlue());
|
||||
|
||||
glBindVertexArray(mesh.vao_glow_pass);
|
||||
glDrawElements(ptype, count, itype, 0);
|
||||
glBindVertexArray(0);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
}
|
||||
|
||||
void STKMesh::drawDisplace(const GLMesh &mesh)
|
||||
{
|
||||
DisplaceProvider * const cb = (DisplaceProvider *)irr_driver->getCallback(ES_DISPLACE);
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
glDisable(GL_ALPHA_TEST);
|
||||
glDepthMask(GL_FALSE);
|
||||
glDisable(GL_BLEND);
|
||||
GLenum ptype = mesh.PrimitiveType;
|
||||
GLenum itype = mesh.IndexType;
|
||||
size_t count = mesh.IndexCount;
|
||||
|
||||
computeMVP(ModelViewProjectionMatrix);
|
||||
core::matrix4 ModelViewMatrix = irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW);
|
||||
ModelViewMatrix *= irr_driver->getVideoDriver()->getTransform(video::ETS_WORLD);
|
||||
setTexture(0, static_cast<irr::video::COpenGLTexture*>(irr_driver->getTexture(FileManager::TEXTURE, "displace.png"))->getOpenGLTextureName(), GL_LINEAR, GL_LINEAR);
|
||||
glUseProgram(MeshShader::DisplaceShader::Program);
|
||||
MeshShader::DisplaceShader::setUniforms(ModelViewProjectionMatrix, ModelViewMatrix, cb->getDirX(), cb->getDirY(), cb->getDir2X(), cb->getDir2Y(), 0);
|
||||
|
||||
glBindVertexArray(mesh.vao_displace_pass);
|
||||
glDrawElements(ptype, count, itype, 0);
|
||||
glBindVertexArray(0);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
}
|
||||
|
||||
void STKMesh::drawTransparent(const GLMesh &mesh, video::E_MATERIAL_TYPE type)
|
||||
{
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
@ -517,11 +532,9 @@ void STKMesh::drawSolid(const GLMesh &mesh, video::E_MATERIAL_TYPE type)
|
||||
drawObjectPass2(mesh);
|
||||
break;
|
||||
}
|
||||
case 2:
|
||||
default:
|
||||
{
|
||||
ColorizeProvider * const cb = (ColorizeProvider *)irr_driver->getCallback(ES_COLORIZE);
|
||||
drawGlow(mesh, cb->getRed(), cb->getGreen(), cb->getBlue());
|
||||
break;
|
||||
assert(0 && "wrong pass");
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -551,65 +564,86 @@ static bool isObject(video::E_MATERIAL_TYPE type)
|
||||
|
||||
static void initvaostate(GLMesh &mesh, video::E_MATERIAL_TYPE type)
|
||||
{
|
||||
if (mesh.vao_first_pass)
|
||||
switch (irr_driver->getPhase())
|
||||
{
|
||||
case 0: // Solid Pass 1
|
||||
if (mesh.vao_first_pass)
|
||||
return;
|
||||
if (type == irr_driver->getShader(ES_NORMAL_MAP))
|
||||
{
|
||||
mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
|
||||
MeshShader::NormalMapShader::attrib_position, MeshShader::NormalMapShader::attrib_texcoord, -1, -1, MeshShader::NormalMapShader::attrib_tangent, MeshShader::NormalMapShader::attrib_bitangent, -1, mesh.Stride);
|
||||
}
|
||||
else if (type == irr_driver->getShader(ES_OBJECTPASS_REF))
|
||||
{
|
||||
mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
|
||||
MeshShader::ObjectPass1Shader::attrib_position, MeshShader::ObjectRefPass1Shader::attrib_texcoord, -1, MeshShader::ObjectPass1Shader::attrib_normal, -1, -1, -1, mesh.Stride);
|
||||
}
|
||||
else if (type == irr_driver->getShader(ES_GRASS) || type == irr_driver->getShader(ES_GRASS_REF))
|
||||
{
|
||||
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
|
||||
{
|
||||
mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
|
||||
MeshShader::ObjectPass1Shader::attrib_position, -1, -1, MeshShader::ObjectPass1Shader::attrib_normal, -1, -1, -1, mesh.Stride);
|
||||
}
|
||||
return;
|
||||
case 1: // Solid pass 2
|
||||
if (mesh.vao_second_pass)
|
||||
return;
|
||||
if (type == irr_driver->getShader(ES_SPHERE_MAP))
|
||||
{
|
||||
mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
|
||||
MeshShader::SphereMapShader::attrib_position, -1, -1, MeshShader::SphereMapShader::attrib_normal, -1, -1, -1, mesh.Stride);
|
||||
}
|
||||
else if (type == irr_driver->getShader(ES_SPLATTING))
|
||||
{
|
||||
mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
|
||||
MeshShader::SplattingShader::attrib_position, MeshShader::SplattingShader::attrib_texcoord, MeshShader::SplattingShader::attrib_second_texcoord, -1, -1, -1, -1, mesh.Stride);
|
||||
}
|
||||
else if (type == irr_driver->getShader(ES_OBJECTPASS_REF))
|
||||
{
|
||||
mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
|
||||
MeshShader::ObjectRefPass2Shader::attrib_position, MeshShader::ObjectRefPass2Shader::attrib_texcoord, -1, -1, -1, -1, -1, mesh.Stride);
|
||||
}
|
||||
else if (type == irr_driver->getShader(ES_GRASS) || type == irr_driver->getShader(ES_GRASS_REF))
|
||||
{
|
||||
mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
|
||||
MeshShader::GrassPass2Shader::attrib_position, MeshShader::GrassPass2Shader::attrib_texcoord, -1, -1, -1, -1, MeshShader::GrassPass2Shader::attrib_color, mesh.Stride);
|
||||
}
|
||||
else
|
||||
{
|
||||
mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
|
||||
MeshShader::ObjectPass2Shader::attrib_position, MeshShader::ObjectPass2Shader::attrib_texcoord, -1, -1, -1, -1, -1, mesh.Stride);
|
||||
}
|
||||
return;
|
||||
case 2: // Glow
|
||||
if (mesh.vao_glow_pass)
|
||||
return;
|
||||
mesh.vao_glow_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::ColorizeShader::attrib_position, -1, -1, -1, -1, -1, -1, mesh.Stride);
|
||||
return;
|
||||
case 3: // Transparent
|
||||
if (mesh.vao_first_pass)
|
||||
return;
|
||||
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);
|
||||
}
|
||||
return;
|
||||
case 4:
|
||||
if (mesh.vao_displace_pass)
|
||||
return;
|
||||
mesh.vao_displace_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::DisplaceShader::attrib_position, MeshShader::DisplaceShader::attrib_texcoord, MeshShader::DisplaceShader::attrib_second_texcoord, -1, -1, -1, -1, mesh.Stride);
|
||||
return;
|
||||
if (type == irr_driver->getShader(ES_NORMAL_MAP))
|
||||
{
|
||||
mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
|
||||
MeshShader::NormalMapShader::attrib_position, MeshShader::NormalMapShader::attrib_texcoord, -1, -1, MeshShader::NormalMapShader::attrib_tangent, MeshShader::NormalMapShader::attrib_bitangent, -1, mesh.Stride);
|
||||
}
|
||||
else if (type == irr_driver->getShader(ES_OBJECTPASS_REF))
|
||||
{
|
||||
mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
|
||||
MeshShader::ObjectPass1Shader::attrib_position, MeshShader::ObjectRefPass1Shader::attrib_texcoord, -1, MeshShader::ObjectPass1Shader::attrib_normal, -1, -1, -1, mesh.Stride);
|
||||
}
|
||||
else if (type == irr_driver->getShader(ES_GRASS) || type == irr_driver->getShader(ES_GRASS_REF))
|
||||
{
|
||||
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,
|
||||
MeshShader::ObjectPass1Shader::attrib_position, -1, -1, MeshShader::ObjectPass1Shader::attrib_normal, -1, -1, -1, mesh.Stride);
|
||||
}
|
||||
|
||||
if (type == irr_driver->getShader(ES_SPHERE_MAP))
|
||||
{
|
||||
mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
|
||||
MeshShader::SphereMapShader::attrib_position, -1, -1, MeshShader::SphereMapShader::attrib_normal, -1, -1, -1, mesh.Stride);
|
||||
}
|
||||
else if (type == irr_driver->getShader(ES_SPLATTING))
|
||||
{
|
||||
mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
|
||||
MeshShader::SplattingShader::attrib_position, MeshShader::SplattingShader::attrib_texcoord, MeshShader::SplattingShader::attrib_second_texcoord, -1, -1, -1, -1, mesh.Stride);
|
||||
}
|
||||
else if (type == irr_driver->getShader(ES_OBJECTPASS_REF))
|
||||
{
|
||||
mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
|
||||
MeshShader::ObjectRefPass2Shader::attrib_position, MeshShader::ObjectRefPass2Shader::attrib_texcoord, -1, -1, -1, -1, -1, mesh.Stride);
|
||||
}
|
||||
else if (type == irr_driver->getShader(ES_GRASS) || type == irr_driver->getShader(ES_GRASS_REF))
|
||||
{
|
||||
mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
|
||||
MeshShader::GrassPass2Shader::attrib_position, MeshShader::GrassPass2Shader::attrib_texcoord, -1, -1, -1, -1, MeshShader::GrassPass2Shader::attrib_color, mesh.Stride);
|
||||
}
|
||||
else
|
||||
{
|
||||
mesh.vao_second_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
|
||||
MeshShader::ObjectPass2Shader::attrib_position, MeshShader::ObjectPass2Shader::attrib_texcoord, -1, -1, -1, -1, -1, mesh.Stride);
|
||||
}
|
||||
mesh.vao_glow_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, MeshShader::ColorizeShader::attrib_position, -1, -1, -1, -1, -1, -1, mesh.Stride);
|
||||
}
|
||||
|
||||
void STKMesh::render()
|
||||
@ -637,9 +671,29 @@ void STKMesh::render()
|
||||
video::IMaterialRenderer* rnd = driver->getMaterialRenderer(material.MaterialType);
|
||||
bool transparent = (rnd && rnd->isTransparent());
|
||||
|
||||
if (isTransparentPass != transparent)
|
||||
continue;
|
||||
if (irr_driver->getPhase() == 4)
|
||||
{
|
||||
initvaostate(GLmeshes[i], material.MaterialType);
|
||||
drawDisplace(GLmeshes[i]);
|
||||
continue;
|
||||
}
|
||||
if (!isObject(material.MaterialType))
|
||||
{
|
||||
driver->setMaterial(material);
|
||||
driver->drawMeshBuffer(mb);
|
||||
continue;
|
||||
}
|
||||
|
||||
// only render transparent buffer if this is the transparent render pass
|
||||
// and solid only in solid pass
|
||||
if (isObject(material.MaterialType) && isTransparentPass == transparent)
|
||||
if (irr_driver->getPhase() == 2)
|
||||
{
|
||||
initvaostate(GLmeshes[i], material.MaterialType);
|
||||
drawGlow(GLmeshes[i]);
|
||||
}
|
||||
else
|
||||
{
|
||||
initvaostate(GLmeshes[i], material.MaterialType);
|
||||
if (transparent)
|
||||
@ -656,11 +710,6 @@ void STKMesh::render()
|
||||
irr_driver->getVideoDriver()->setMaterial(material);
|
||||
static_cast<irr::video::COpenGLDriver*>(irr_driver->getVideoDriver())->setRenderStates3DMode();
|
||||
}
|
||||
else if (transparent == isTransparentPass)
|
||||
{
|
||||
driver->setMaterial(material);
|
||||
driver->drawMeshBuffer(mb);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -12,6 +12,7 @@ struct GLMesh {
|
||||
GLuint vao_first_pass;
|
||||
GLuint vao_second_pass;
|
||||
GLuint vao_glow_pass;
|
||||
GLuint vao_displace_pass;
|
||||
GLuint vertex_buffer;
|
||||
GLuint index_buffer;
|
||||
GLuint textures[6];
|
||||
@ -47,8 +48,9 @@ protected:
|
||||
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);
|
||||
// Misc passes shaders (glow, displace...)
|
||||
void drawGlow(const GLMesh &mesh);
|
||||
void drawDisplace(const GLMesh &mesh);
|
||||
public:
|
||||
STKMesh(irr::scene::IMesh* mesh, ISceneNode* parent, irr::scene::ISceneManager* mgr, irr::s32 id,
|
||||
const irr::core::vector3df& position = irr::core::vector3df(0,0,0),
|
||||
|
||||
@ -186,7 +186,9 @@ TrackObjectPresentationMesh::TrackObjectPresentationMesh(const XMLNode& xml_node
|
||||
|
||||
bool animated = skeletal_animation && (UserConfigParams::m_graphical_effects ||
|
||||
World::getWorld()->getIdent() == IDENT_CUSTSCENE);
|
||||
|
||||
bool displacing = false;
|
||||
xml_node.get("displacing", &displacing);
|
||||
animated &= !displacing;
|
||||
|
||||
if (animated)
|
||||
{
|
||||
@ -251,6 +253,9 @@ void TrackObjectPresentationMesh::init(const XMLNode* xml_node, scene::ISceneNod
|
||||
|
||||
bool animated = skeletal_animation && (UserConfigParams::m_graphical_effects ||
|
||||
World::getWorld()->getIdent() == IDENT_CUSTSCENE);
|
||||
bool displacing = false;
|
||||
xml_node->get("displacing", &displacing);
|
||||
animated &= !displacing;
|
||||
|
||||
m_mesh->grab();
|
||||
irr_driver->grabAllTextures(m_mesh);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user