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

Add orientation to grass material

Browse Source
This commit is contained in:
vlj 2014-03-25 16:49:03 +01:00
parent 9fef40318e
commit 71881ac64d
9 changed files with 65 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
data/shaders/instanced_grass.vert
View File

@ -13,11 +13,49 @@ in vec4 Color;
out vec3 nor;
out vec2 uv;
mat4 getWorldMatrix(vec3 origin, vec3 rotation)
{
// from irrlicht
float cr = cos( rotation.x );
float sr = sin( rotation.x );
float cp = cos( rotation.y );
float sp = sin( rotation.y );
float cy = cos( rotation.z );
float sy = sin( rotation.z );
float srsp = sr*sp;
float crsp = cr*sp;
// rotation part
mat4 result = mat4(
vec4(cp * cy, srsp * cy - cr * sy, crsp * cy + sr * sy, 0.),
vec4(cp * sy, srsp * sy + cr * cy, crsp * sy - sr * cy, 0.),
vec4(-sp, sr * cp, cr * cp, 0.),
vec4(0., 0., 0., 1.));
// translation
result[3].xyz += origin;
return result;
/* M[0] = (T)( cp*cy );
M[1] = (T)( cp*sy );
M[2] = (T)( -sp );
const f64 srsp = sr*sp;
const f64 crsp = cr*sp;
M[4] = (T)( srsp*cy-cr*sy );
M[5] = (T)( srsp*sy+cr*cy );
M[6] = (T)( sr*cp );
M[8] = (T)( crsp*cy+sr*sy );
M[9] = (T)( crsp*sy-sr*cy );
M[10] = (T)( cr*cp );*/
}
void main()
{
mat4 ModelMatrix = mat4(1.);
ModelMatrix[3].xyz += Origin;
mat4 ModelMatrix = getWorldMatrix(Origin, Orientation);
mat4 TransposeInverseModelView = transpose(inverse(ViewMatrix * ModelMatrix));
gl_Position = ViewProjectionMatrix * ModelMatrix * vec4(Position + windDir * Color.r, 1.);
nor = (TransposeInverseModelView * vec4(Normal, 0.)).xyz;

11
src/graphics/render.cpp
View File

@ -135,15 +135,6 @@ void IrrDriver::renderGLSL(float dt)
transparent_glow_nodes.push_back(repnode);
}
if (!InstancedBox)
{
InstancedBox = new STKInstancedSceneNode(items->getItemModel(items->getItem(0)->getType()), m_scene_manager->getRootSceneNode(), m_scene_manager, -1);
InstancedBox->addWorldMatrix(core::vector3df(0, 0, 0));
InstancedBox->addWorldMatrix(core::vector3df(1., 0, 0));
InstancedBox->addWorldMatrix(core::vector3df(0, 1., 0));
InstancedBox->addWorldMatrix(core::vector3df(0, 0, 1.));
}
// Start the RTT for post-processing.
// We do this before beginScene() because we want to capture the glClear()
// because of tracks that do not have skyboxes (generally add-on tracks)
@ -215,7 +206,6 @@ void IrrDriver::renderGLSL(float dt)
irr_driver->setProjMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_PROJECTION));
irr_driver->setViewMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW));
irr_driver->genProjViewMatrix();
InstancedBox->render();
PROFILER_POP_CPU_MARKER();
// Todo : reenable glow and shadows
@ -257,7 +247,6 @@ void IrrDriver::renderGLSL(float dt)
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
m_scene_manager->drawAll(m_renderpass);
InstancedBox->render();
PROFILER_POP_CPU_MARKER();
if (World::getWorld()->getTrack()->isFogEnabled())

4
src/graphics/shaders.cpp
View File

@ -534,6 +534,7 @@ namespace MeshShader
GLuint InstancedGrassPass1Shader::attrib_position;
GLuint InstancedGrassPass1Shader::attrib_normal;
GLuint InstancedGrassPass1Shader::attrib_origin;
GLuint InstancedGrassPass1Shader::attrib_orientation;
GLuint InstancedGrassPass1Shader::attrib_texcoord;
GLuint InstancedGrassPass1Shader::attrib_color;
GLuint InstancedGrassPass1Shader::uniform_MP;
@ -548,6 +549,7 @@ namespace MeshShader
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/encode_normal.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/objectref_pass1.frag").c_str());
attrib_origin = glGetAttribLocation(Program, "Origin");
attrib_orientation = glGetAttribLocation(Program, "Orientation");
attrib_position = glGetAttribLocation(Program, "Position");
attrib_normal = glGetAttribLocation(Program, "Normal");
attrib_color = glGetAttribLocation(Program, "Color");
@ -914,6 +916,7 @@ namespace MeshShader
GLuint InstancedGrassPass2Shader::attrib_texcoord;
GLuint InstancedGrassPass2Shader::attrib_color;
GLuint InstancedGrassPass2Shader::attrib_origin;
GLuint InstancedGrassPass2Shader::attrib_orientation;
GLuint InstancedGrassPass2Shader::uniform_VP;
GLuint InstancedGrassPass2Shader::uniform_screen;
GLuint InstancedGrassPass2Shader::uniform_ambient;
@ -930,6 +933,7 @@ namespace MeshShader
attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
attrib_color = glGetAttribLocation(Program, "Color");
attrib_origin = glGetAttribLocation(Program, "Origin");
attrib_orientation = glGetAttribLocation(Program, "Orientation");
uniform_VP = glGetUniformLocation(Program, "ViewProjectionMatrix");
GLuint uniform_Albedo = glGetUniformLocation(Program, "Albedo");
GLuint uniform_DiffuseMap = glGetUniformLocation(Program, "DiffuseMap");

4
src/graphics/shaders.hpp
View File

@ -92,7 +92,7 @@ class InstancedGrassPass1Shader
{
public:
static GLuint Program;
static GLuint attrib_position, attrib_normal, attrib_origin, attrib_color, attrib_texcoord;
static GLuint attrib_position, attrib_normal, attrib_origin, attrib_orientation, attrib_color, attrib_texcoord;
static GLuint uniform_MP, uniform_VM, uniform_windDir, uniform_tex;
static void init();
@ -198,7 +198,7 @@ class InstancedGrassPass2Shader
{
public:
static GLuint Program;
static GLuint attrib_position, attrib_texcoord, attrib_color, attrib_origin;
static GLuint attrib_position, attrib_texcoord, attrib_color, attrib_origin, attrib_orientation;
static GLuint uniform_VP, uniform_TM, uniform_screen, uniform_ambient, uniform_windDir;
static GLuint TU_Albedo;

21
src/graphics/stkinstancedscenenode.cpp
View File

@ -42,8 +42,10 @@ void STKInstancedSceneNode::initinstancedvaostate(GLMesh &mesh, GeometricMateria
glBindBuffer(GL_ARRAY_BUFFER, instances_vbo);
glBufferData(GL_ARRAY_BUFFER, instance_pos.size() * sizeof(float), instance_pos.data(), GL_STATIC_DRAW);
glEnableVertexAttribArray(MeshShader::InstancedGrassPass1Shader::attrib_origin);
glVertexAttribPointer(MeshShader::InstancedGrassPass1Shader::attrib_origin, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), 0);
glVertexAttribPointer(MeshShader::InstancedGrassPass1Shader::attrib_origin, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), 0);
glVertexAttribDivisor(MeshShader::InstancedGrassPass1Shader::attrib_origin, 1);
glVertexAttribPointer(MeshShader::InstancedGrassPass1Shader::attrib_orientation, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (GLvoid*)(3 * sizeof(float)));
glVertexAttribDivisor(MeshShader::InstancedGrassPass1Shader::attrib_orientation, 1);
break;
default:
return;
@ -58,7 +60,7 @@ void STKInstancedSceneNode::initinstancedvaostate(GLMesh &mesh, GeometricMateria
MeshShader::InstancedObjectPass2Shader::attrib_position, MeshShader::InstancedObjectPass2Shader::attrib_texcoord, -1, -1, -1, -1, -1, mesh.Stride);
glBindBuffer(GL_ARRAY_BUFFER, instances_vbo);
glEnableVertexAttribArray(MeshShader::InstancedObjectPass2Shader::attrib_origin);
glVertexAttribPointer(MeshShader::InstancedObjectPass2Shader::attrib_origin, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), 0);
glVertexAttribPointer(MeshShader::InstancedObjectPass2Shader::attrib_origin, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), 0);
glVertexAttribDivisor(MeshShader::InstancedObjectPass2Shader::attrib_origin, 1);
break;
case SM_GRASS:
@ -66,8 +68,10 @@ void STKInstancedSceneNode::initinstancedvaostate(GLMesh &mesh, GeometricMateria
MeshShader::InstancedGrassPass2Shader::attrib_position, MeshShader::InstancedGrassPass2Shader::attrib_texcoord, -1, -1, -1, -1, MeshShader::InstancedGrassPass2Shader::attrib_color, mesh.Stride);
glBindBuffer(GL_ARRAY_BUFFER, instances_vbo);
glEnableVertexAttribArray(MeshShader::InstancedGrassPass2Shader::attrib_origin);
glVertexAttribPointer(MeshShader::InstancedGrassPass2Shader::attrib_origin, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), 0);
glVertexAttribPointer(MeshShader::InstancedGrassPass2Shader::attrib_origin, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), 0);
glVertexAttribDivisor(MeshShader::InstancedGrassPass2Shader::attrib_origin, 1);
glVertexAttribPointer(MeshShader::InstancedGrassPass2Shader::attrib_orientation, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (GLvoid*) (3 * sizeof(float)));
glVertexAttribDivisor(MeshShader::InstancedGrassPass2Shader::attrib_orientation, 1);
break;
default:
return;
@ -99,11 +103,14 @@ void STKInstancedSceneNode::setFirstTimeMaterial()
isMaterialInitialized = true;
}
void STKInstancedSceneNode::addWorldMatrix(const core::vector3df &v)
void STKInstancedSceneNode::addInstance(const core::vector3df &origin, const core::vector3df &orientation)
{
instance_pos.push_back(v.X);
instance_pos.push_back(v.Y);
instance_pos.push_back(v.Z);
instance_pos.push_back(origin.X);
instance_pos.push_back(origin.Y);
instance_pos.push_back(origin.Z);
instance_pos.push_back(orientation.X);
instance_pos.push_back(orientation.Y);
instance_pos.push_back(orientation.Z);
}
static void drawFSPMDefault(GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, size_t instance_count)

2
src/graphics/stkinstancedscenenode.hpp
View File

@ -23,7 +23,7 @@ public:
const irr::core::vector3df& rotation = irr::core::vector3df(0, 0, 0),
const irr::core::vector3df& scale = irr::core::vector3df(1.0f, 1.0f, 1.0f));
virtual void render();
void addWorldMatrix(const core::vector3df &);
void addInstance(const core::vector3df &origin, const core::vector3df &orientation);
};
#endif

4
src/tracks/model_definition_loader.cpp
View File

@ -117,7 +117,7 @@ LODNode* ModelDefinitionLoader::instanciateAsLOD(const XMLNode* node, scene::ISc
// ----------------------------------------------------------------------------
void ModelDefinitionLoader::instanciate(const irr::core::vector3df& position,
const irr::core::matrix4& transform,
const irr::core::vector3df& rotation,
const std::string& name)
{
if (m_instancing_nodes.find(name) == m_instancing_nodes.end())
@ -133,7 +133,7 @@ void ModelDefinitionLoader::instanciate(const irr::core::vector3df& position,
irr_driver->getSceneManager()->getRootSceneNode(), irr_driver->getSceneManager(), -1);
}
m_instancing_nodes[name]->addWorldMatrix(position);
m_instancing_nodes[name]->addInstance(position, rotation);
}
// ----------------------------------------------------------------------------

2
src/tracks/model_definition_loader.hpp
View File

@ -84,7 +84,7 @@ public:
void addModelDefinition(const XMLNode* xml);
LODNode* instanciateAsLOD(const XMLNode* xml_node, scene::ISceneNode* parent);
void instanciate(const core::vector3df& position,
const core::matrix4& transform,
const irr::core::vector3df& rotation,
const std::string& name);
void clear();

2
src/tracks/track_object_presentation.cpp
View File

@ -168,7 +168,7 @@ TrackObjectPresentationInstancing::TrackObjectPresentationInstancing(const XMLNo
m_node->setRotation(m_init_hpr);
m_node->setScale(m_init_scale);
m_node->updateAbsolutePosition();
model_def_loader.instanciate(m_node->getAbsolutePosition(), m_node->getAbsoluteTransformation(), instancing_model);
model_def_loader.instanciate(m_node->getAbsolutePosition(), m_init_hpr, instancing_model);
}
TrackObjectPresentationInstancing::~TrackObjectPresentationInstancing()