diff --git a/src/graphics/glwrap.cpp b/src/graphics/glwrap.cpp index 149a866ec..ac340fc09 100644 --- a/src/graphics/glwrap.cpp +++ b/src/graphics/glwrap.cpp @@ -24,7 +24,6 @@ #include "graphics/central_settings.hpp" #include "graphics/irr_driver.hpp" #include "graphics/shaders.hpp" -#include "graphics/stk_mesh.hpp" #include "utils/profiler.hpp" #include "utils/cpp2011.hpp" #include "utils/string_utils.hpp" diff --git a/src/graphics/irr_driver.cpp b/src/graphics/irr_driver.cpp index d6b6a7f21..ae53fabc9 100644 --- a/src/graphics/irr_driver.cpp +++ b/src/graphics/irr_driver.cpp @@ -27,6 +27,7 @@ #include "graphics/glwrap.hpp" #include "graphics/graphics_restrictions.hpp" #include "graphics/light.hpp" +#include "graphics/material.hpp" #include "graphics/material_manager.hpp" #include "graphics/particle_kind_manager.hpp" #include "graphics/per_camera_node.hpp" @@ -40,7 +41,6 @@ #include "graphics/sp/sp_mesh.hpp" #include "graphics/sp/sp_mesh_node.hpp" #include "graphics/sp/sp_texture_manager.hpp" -#include "graphics/stk_mesh_scene_node.hpp" #include "graphics/stk_tex_manager.hpp" #include "graphics/stk_texture.hpp" #include "graphics/sun.hpp" @@ -1186,9 +1186,8 @@ scene::ISceneNode *IrrDriver::addMesh(scene::IMesh *mesh, } else { - node = new STKMeshSceneNode(mesh, parent, m_scene_manager, -1, - debug_name, core::vector3df(0, 0, 0), core::vector3df(0, 0, 0), - core::vector3df(1.0f, 1.0f, 1.0f), true); + Log::warn("IrrDriver", "Use only spm in glsl"); + return NULL; } node->drop(); diff --git a/src/graphics/shader_based_renderer.cpp b/src/graphics/shader_based_renderer.cpp index 0a739e876..3b4dda64b 100644 --- a/src/graphics/shader_based_renderer.cpp +++ b/src/graphics/shader_based_renderer.cpp @@ -32,7 +32,6 @@ #include "graphics/rtts.hpp" #include "graphics/shaders.hpp" #include "graphics/skybox.hpp" -#include "graphics/stk_mesh_scene_node.hpp" #include "graphics/spherical_harmonics.hpp" #include "graphics/sp/sp_base.hpp" #include "graphics/sp/sp_shader.hpp" diff --git a/src/graphics/stk_mesh.cpp b/src/graphics/stk_mesh.cpp deleted file mode 100644 index 2f456ed91..000000000 --- a/src/graphics/stk_mesh.cpp +++ /dev/null @@ -1,485 +0,0 @@ -// SuperTuxKart - a fun racing game with go-kart -// Copyright (C) 2014-2015 SuperTuxKart-Team -// -// This program is free software; you can redistribute it and/or -// modify it under the terms of the GNU General Public License -// as published by the Free Software Foundation; either version 3 -// of the License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this program; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -#ifndef SERVER_ONLY - -#include "graphics/stk_mesh.hpp" - -#include "graphics/callbacks.hpp" -#include "graphics/central_settings.hpp" -#include "graphics/irr_driver.hpp" -#include "graphics/material_manager.hpp" -#include "graphics/shaders.hpp" -#include "graphics/stk_tex_manager.hpp" - -#include -#include - - -// ============================================================================ -Material::ShaderType getMeshMaterialFromType(video::E_MATERIAL_TYPE material_type, - video::E_VERTEX_TYPE tp, - Material* material, - Material* layer2_material) -{ - if (layer2_material != NULL && - layer2_material->getShaderType() == Material::SHADERTYPE_SPLATTING) - return Material::SHADERTYPE_SPLATTING; - - if (tp == video::EVT_SKINNED_MESH) - { - switch (material->getShaderType()) - { - case Material::SHADERTYPE_SOLID: - if (material_type == Shaders::getShader(ES_NORMAL_MAP)) - return Material::SHADERTYPE_NORMAL_MAP_SKINNED_MESH; - else - return Material::SHADERTYPE_SOLID_SKINNED_MESH; - case Material::SHADERTYPE_ALPHA_TEST: - return Material::SHADERTYPE_ALPHA_TEST_SKINNED_MESH; - case Material::SHADERTYPE_SOLID_UNLIT: - return Material::SHADERTYPE_SOLID_UNLIT_SKINNED_MESH; - default: - return Material::SHADERTYPE_SOLID_SKINNED_MESH; - } - } - - switch (material->getShaderType()) - { - default: - return material->getShaderType(); - case Material::SHADERTYPE_SOLID: - if (material_type == Shaders::getShader(ES_NORMAL_MAP)) - return Material::SHADERTYPE_NORMAL_MAP; - else if (tp == video::EVT_2TCOORDS) - return Material::SHADERTYPE_DETAIL_MAP; - return Material::SHADERTYPE_SOLID; - } -} // getMeshMaterialFromType - -// ---------------------------------------------------------------------------- -TransparentMaterial getTransparentMaterialFromType(video::E_MATERIAL_TYPE type, - video::E_VERTEX_TYPE tp, - f32 MaterialTypeParam, - Material* material) -{ - if (tp == video::EVT_SKINNED_MESH) - return TM_TRANSLUCENT_SKN; - - if (type == Shaders::getShader(ES_DISPLACE)) - { - if (CVS->isDefferedEnabled()) - return TM_DISPLACEMENT; - else if (tp == video::EVT_2TCOORDS) - return TM_TRANSLUCENT_2TC; - else - return TM_TRANSLUCENT_STD; - } - if (material->getShaderType() == Material::SHADERTYPE_ADDITIVE) - return TM_ADDITIVE; - return TM_DEFAULT; -} - -// ---------------------------------------------------------------------------- -video::E_VERTEX_TYPE getVTXTYPEFromStride(size_t stride) -{ - if (stride == sizeof(video::S3DVertex)) - return video::EVT_STANDARD; - else if (stride == sizeof(video::S3DVertex2TCoords)) - return video::EVT_2TCOORDS; - assert(stride == sizeof(video::S3DVertexTangents)); - return video::EVT_TANGENTS; -} // getVTXTYPEFromStride - -// ---------------------------------------------------------------------------- -GLuint createVAO(GLuint vbo, GLuint idx, video::E_VERTEX_TYPE type) -{ - GLuint vao; - glGenVertexArrays(1, &vao); - glBindVertexArray(vao); - assert(vbo); - glBindBuffer(GL_ARRAY_BUFFER, vbo); - switch (type) - { - case video::EVT_STANDARD: - // Position - glEnableVertexAttribArray(0); - glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, - getVertexPitchFromType(type), 0); - // Normal - glEnableVertexAttribArray(1); - glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, - getVertexPitchFromType(type), (GLvoid*)12); - // Color - glEnableVertexAttribArray(2); - glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, GL_TRUE, - getVertexPitchFromType(type), (GLvoid*)24); - // Texcoord - glEnableVertexAttribArray(3); - glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, - getVertexPitchFromType(type), (GLvoid*)28); - break; - case video::EVT_2TCOORDS: - // Position - glEnableVertexAttribArray(0); - glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, - getVertexPitchFromType(type), 0); - // Normal - glEnableVertexAttribArray(1); - glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, - getVertexPitchFromType(type), (GLvoid*)12); - // Color - glEnableVertexAttribArray(2); - glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, GL_TRUE, - getVertexPitchFromType(type), (GLvoid*)24); - // Texcoord - glEnableVertexAttribArray(3); - glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, - getVertexPitchFromType(type), (GLvoid*)28); - // SecondTexcoord - glEnableVertexAttribArray(4); - glVertexAttribPointer(4, 2, GL_FLOAT, GL_FALSE, - getVertexPitchFromType(type), (GLvoid*)36); - break; - case video::EVT_TANGENTS: - // Position - glEnableVertexAttribArray(0); - glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, getVertexPitchFromType(type), 0); - // Normal - glEnableVertexAttribArray(1); - glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, getVertexPitchFromType(type), (GLvoid*)12); - // Color - glEnableVertexAttribArray(2); - glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, GL_TRUE, getVertexPitchFromType(type), (GLvoid*)24); - // Texcoord - glEnableVertexAttribArray(3); - glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, getVertexPitchFromType(type), (GLvoid*)28); - // Tangent - glEnableVertexAttribArray(5); - glVertexAttribPointer(5, 3, GL_FLOAT, GL_FALSE, getVertexPitchFromType(type), (GLvoid*)36); - // Bitangent - glEnableVertexAttribArray(6); - glVertexAttribPointer(6, 4, GL_FLOAT, GL_FALSE, getVertexPitchFromType(type), (GLvoid*)48); - break; - case video::EVT_SKINNED_MESH: - glEnableVertexAttribArray(0); - glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, getVertexPitchFromType(type), 0); - glEnableVertexAttribArray(1); - glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, getVertexPitchFromType(type), (GLvoid*)12); - glEnableVertexAttribArray(2); - glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, GL_TRUE, getVertexPitchFromType(type), (GLvoid*)24); - glEnableVertexAttribArray(3); - glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, getVertexPitchFromType(type), (GLvoid*)28); - glEnableVertexAttribArray(4); - glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, getVertexPitchFromType(type), (GLvoid*)36); - glEnableVertexAttribArray(11); - glVertexAttribPointer(11, 4, GL_FLOAT, GL_FALSE, getVertexPitchFromType(type), (GLvoid*)48); - glEnableVertexAttribArray(5); - glVertexAttribIPointer(5, 4, GL_SHORT, getVertexPitchFromType(type), (GLvoid*)64); - glEnableVertexAttribArray(6); - glVertexAttribPointer(6, 4, GL_HALF_FLOAT, GL_FALSE, getVertexPitchFromType(type), (GLvoid*)72); - break; - default: - assert(0 && "Wrong vertex type"); - } - assert(idx); - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, idx); - return vao; -} // createVAO - -// ---------------------------------------------------------------------------- -GLMesh allocateMeshBuffer(scene::IMeshBuffer* mb, const std::string& debug_name, - RenderInfo* render_info) -{ - GLMesh result = {}; - result.m_material = NULL; - result.m_render_info = NULL; - if (!mb) - return result; - result.mb = mb; - if (render_info != NULL) - { - result.m_render_info = render_info; - result.m_material = material_manager->getMaterialFor(mb - ->getMaterial().getTexture(0), mb); - } -#ifdef DEBUG - result.debug_name = debug_name; -#endif - - result.IndexCount = mb->getIndexCount(); - switch (mb->getIndexType()) - { - case irr::video::EIT_16BIT: - { - result.IndexType = GL_UNSIGNED_SHORT; - break; - } - case irr::video::EIT_32BIT: - { - result.IndexType = GL_UNSIGNED_INT; - break; - } - default: - { - assert(0 && "Wrong index size"); - } - } - result.VAOType = mb->getVertexType(); - result.Stride = getVertexPitchFromType(result.VAOType); - result.IndexCount = mb->getIndexCount(); - switch (mb->getPrimitiveType()) - { - case scene::EPT_POINTS: - result.PrimitiveType = GL_POINTS; - break; - case scene::EPT_TRIANGLE_STRIP: - result.PrimitiveType = GL_TRIANGLE_STRIP; - break; - case scene::EPT_TRIANGLE_FAN: - result.PrimitiveType = GL_TRIANGLE_FAN; - break; - case scene::EPT_LINES: - result.PrimitiveType = GL_LINES; - break; - case scene::EPT_TRIANGLES: - result.PrimitiveType = GL_TRIANGLES; - break; - case scene::EPT_POINT_SPRITES: - case scene::EPT_LINE_LOOP: - case scene::EPT_POLYGON: - case scene::EPT_LINE_STRIP: - case scene::EPT_QUAD_STRIP: - case scene::EPT_QUADS: - assert(0 && "Unsupported primitive type"); - } - for (unsigned i = 0; i < 8; i++) - result.textures[i] = mb->getMaterial().getTexture(i); - result.texture_trans = core::vector2df(0.0f, 0.0f); - - return result; -} // allocateMeshBuffer - -// ---------------------------------------------------------------------------- -static size_t getUnsignedSize(unsigned tp) -{ - switch (tp) - { - case GL_UNSIGNED_SHORT: - return sizeof(u16); - case GL_UNSIGNED_INT: - return sizeof(u32); - default: - assert(0 && "Unsupported index type"); - return 0; - } -} // getUnsignedSize - -// ---------------------------------------------------------------------------- -void fillLocalBuffer(GLMesh &mesh, scene::IMeshBuffer* mb) -{ - glBindVertexArray(0); - glGenBuffers(1, &(mesh.vertex_buffer)); - glGenBuffers(1, &(mesh.index_buffer)); - - glBindBuffer(GL_ARRAY_BUFFER, mesh.vertex_buffer); - - const void* vertices = mb->getVertices(); - const u32 vertexCount = mb->getVertexCount(); - // This can happen for certain debug structures, e.g. ShowCurve - if (vertexCount == 0) - return; - - const c8* vbuf = static_cast(vertices); - glBufferData(GL_ARRAY_BUFFER, vertexCount * mesh.Stride, vbuf, - GL_STREAM_DRAW); - - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.index_buffer); - const void* indices = mb->getIndices(); - mesh.IndexCount = mb->getIndexCount(); - - glBufferData(GL_ELEMENT_ARRAY_BUFFER, - mesh.IndexCount * getUnsignedSize(mesh.IndexType), - indices, GL_STREAM_DRAW); - - glBindBuffer(GL_ARRAY_BUFFER, 0); - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); -} // fillLocalBuffer - -// ---------------------------------------------------------------------------- -core::matrix4 computeMVP(const core::matrix4 &model_matrix) -{ - core::matrix4 ModelViewProjectionMatrix = irr_driver->getProjMatrix(); - ModelViewProjectionMatrix *= irr_driver->getViewMatrix(); - ModelViewProjectionMatrix *= model_matrix; - return ModelViewProjectionMatrix; -} // computeMVP - -// ---------------------------------------------------------------------------- -core::vector3df getWindDir() -{ - const float time = irr_driver->getDevice()->getTimer()->getTime() / 1000.0f; - GrassShaderProvider *gsp = - (GrassShaderProvider *)Shaders::getCallback(ES_GRASS); - return (gsp->getSpeed() * time * vector3df(1., 0., 0.)); -} // getWindDir - -// ---------------------------------------------------------------------------- -bool isObject(video::E_MATERIAL_TYPE type) -{ - if (type == Shaders::getShader(ES_OBJECTPASS)) - return true; - if (type == Shaders::getShader(ES_OBJECTPASS_REF)) - return true; - if (type == Shaders::getShader(ES_OBJECTPASS_RIMLIT)) - return true; - if (type == Shaders::getShader(ES_NORMAL_MAP)) - return true; - if (type == Shaders::getShader(ES_SPHERE_MAP)) - return true; - if (type == Shaders::getShader(ES_SPLATTING)) - return true; - if (type == Shaders::getShader(ES_GRASS)) - return true; - if (type == Shaders::getShader(ES_GRASS_REF)) - return true; - if (type == Shaders::getShader(ES_DISPLACE)) - return true; - if (type == Shaders::getShader(ES_OBJECT_UNLIT)) - return true; - if (type == video::EMT_TRANSPARENT_ALPHA_CHANNEL) - return true; - if (type == video::EMT_ONETEXTURE_BLEND) - return true; - if (type == video::EMT_TRANSPARENT_ADD_COLOR) - return true; - if (type == video::EMT_SOLID) - return true; - if (type == video::EMT_LIGHTMAP_LIGHTING) - return true; - if (type == video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF) - return true; - return false; -} // isObject - -// ---------------------------------------------------------------------------- -static void setTexture(GLMesh &mesh, unsigned i, bool is_srgb, - const std::string &mat_name) -{ - if (!mesh.textures[i]) - { - Log::error("STKMesh", "Missing texture %d for material %s", i, - mat_name.c_str()); - // use unicolor texture to replace missing texture - mesh.textures[i] = - STKTexManager::getInstance()->getUnicolorTexture(video::SColor(255, 127, 127, 127)); - } -#if !defined(USE_GLES2) - if (CVS->isAZDOEnabled()) - { - if (!mesh.TextureHandles[i]) - { - mesh.TextureHandles[i] = mesh.textures[i]->getHandle(); - } - } -#endif -} // setTexture - -// ---------------------------------------------------------------------------- -static std::string getShaderTypeName(Material::ShaderType mat) -{ - switch (mat) - { - default: - case Material::SHADERTYPE_SOLID: - return "Solid"; - case Material::SHADERTYPE_ALPHA_TEST: - return "Alpha Test"; - case Material::SHADERTYPE_VEGETATION: - return "Grass"; - case Material::SHADERTYPE_SPHERE_MAP: - return "Sphere Map"; - case Material::SHADERTYPE_SOLID_UNLIT: - return "Unlit"; - case Material::SHADERTYPE_DETAIL_MAP: - return "Detail"; - case Material::SHADERTYPE_NORMAL_MAP: - return "Normal"; - case Material::SHADERTYPE_SPLATTING: - return "Splatting"; - } -} // getShaderTypeName - -// ---------------------------------------------------------------------------- -void initTextures(GLMesh &mesh, Material::ShaderType mat) -{ - switch (mat) - { - default: - case Material::SHADERTYPE_SOLID: - case Material::SHADERTYPE_ALPHA_TEST: - case Material::SHADERTYPE_SPHERE_MAP: - case Material::SHADERTYPE_SOLID_UNLIT: - case Material::SHADERTYPE_VEGETATION: - case Material::SHADERTYPE_SOLID_SKINNED_MESH: - case Material::SHADERTYPE_ALPHA_TEST_SKINNED_MESH: - case Material::SHADERTYPE_SOLID_UNLIT_SKINNED_MESH: - setTexture(mesh, 0, true, getShaderTypeName(mat)); - setTexture(mesh, 1, false, getShaderTypeName(mat)); - setTexture(mesh, 2, false, getShaderTypeName(mat)); - break; - case Material::SHADERTYPE_DETAIL_MAP: - case Material::SHADERTYPE_NORMAL_MAP: - case Material::SHADERTYPE_NORMAL_MAP_SKINNED_MESH: - setTexture(mesh, 0, true, getShaderTypeName(mat)); - setTexture(mesh, 1, false, getShaderTypeName(mat)); - setTexture(mesh, 2, false, getShaderTypeName(mat)); - setTexture(mesh, 3, false, getShaderTypeName(mat)); - break; - case Material::SHADERTYPE_SPLATTING: - setTexture(mesh, 0, true, getShaderTypeName(mat)); - setTexture(mesh, 1, false, getShaderTypeName(mat)); - setTexture(mesh, 2, true, getShaderTypeName(mat)); - setTexture(mesh, 3, true, getShaderTypeName(mat)); - setTexture(mesh, 4, true, getShaderTypeName(mat)); - setTexture(mesh, 5, true, getShaderTypeName(mat)); - setTexture(mesh, 6, false, getShaderTypeName(mat)); - setTexture(mesh, 7, false, getShaderTypeName(mat)); - break; - } -} // initTextures - -// ---------------------------------------------------------------------------- -void initTexturesTransparent(GLMesh &mesh) -{ - if (!mesh.textures[0]) - { - mesh.textures[0] = STKTexManager::getInstance()->getUnicolorTexture(video::SColor(255, 255, 255, 255)); - } -#if !defined(USE_GLES2) - if (CVS->isAZDOEnabled()) - { - if (!mesh.TextureHandles[0]) - { - mesh.TextureHandles[0] = mesh.textures[0]->getHandle(); - } - } -#endif -} // initTexturesTransparent - -#endif // !SERVER_ONLY - diff --git a/src/graphics/stk_mesh.hpp b/src/graphics/stk_mesh.hpp deleted file mode 100644 index fb6c96735..000000000 --- a/src/graphics/stk_mesh.hpp +++ /dev/null @@ -1,262 +0,0 @@ -// SuperTuxKart - a fun racing game with go-kart -// Copyright (C) 2014-2015 SuperTuxKart-Team -// -// This program is free software; you can redistribute it and/or -// modify it under the terms of the GNU General Public License -// as published by the Free Software Foundation; either version 3 -// of the License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this program; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - - -#ifndef HEADER_STK_MESH_H -#define HEADER_STK_MESH_H - -#include "graphics/irr_driver.hpp" -#include "graphics/material.hpp" -#include "utils/singleton.hpp" -#include - -#include -#include -#include "../lib/irrlicht/source/Irrlicht/CMeshSceneNode.h" - -#include - -class RenderInfo; - -enum TransparentMaterial -{ - TM_DEFAULT, - TM_ADDITIVE, - TM_DISPLACEMENT, - TM_TRANSLUCENT_SKN, - TM_TRANSLUCENT_STD, - TM_TRANSLUCENT_TAN, - TM_TRANSLUCENT_2TC, - TM_COUNT -}; // TransparentMaterial - -struct GLMesh -{ - GLuint vao; - GLuint vertex_buffer; - GLuint index_buffer; - video::ITexture *textures[8]; - GLenum PrimitiveType; - GLenum IndexType; - unsigned int IndexCount; - unsigned int Stride; - core::vector2df texture_trans; - unsigned int vaoBaseVertex; - intptr_t vaoOffset; - video::E_VERTEX_TYPE VAOType; - uint64_t TextureHandles[8]; - scene::IMeshBuffer *mb; - RenderInfo* m_render_info; - Material* m_material; -#ifdef DEBUG - std::string debug_name; -#endif -}; // GLMesh - -// ---------------------------------------------------------------------------- -GLMesh allocateMeshBuffer(scene::IMeshBuffer* mb, - const std::string& debug_name, - RenderInfo* render_info); -void fillLocalBuffer(GLMesh &, scene::IMeshBuffer* mb); -video::E_VERTEX_TYPE getVTXTYPEFromStride(unsigned int stride); -GLuint createVAO(GLuint vbo, GLuint idx, video::E_VERTEX_TYPE type); -core::matrix4 computeMVP(const core::matrix4 &ModelViewProjectionMatrix); -bool isObject(video::E_MATERIAL_TYPE type); -core::vector3df getWindDir(); - - -// ---------------------------------------------------------------------------- -class STKMeshCommon -{ -protected: - std::string m_debug_name; - -public: - PtrVector MeshSolidMaterial[Material::SHADERTYPE_COUNT]; - PtrVector TransparentMesh[TM_COUNT]; - virtual void updateNoGL() = 0; - virtual void updateGL() = 0; - virtual bool glow() const = 0; - virtual bool isImmediateDraw() const { return false; } - const std::string& getMeshDebugName() const { return m_debug_name; } -}; // STKMeshCommon - - -// ---------------------------------------------------------------------------- -template -class MeshList : public Singleton -{ -public: - std::vector > SolidPass, Shadows[4], RSM; - void clear() - { - SolidPass.clear(); - RSM.clear(); - for (unsigned i = 0; i < 4; i++) - Shadows[i].clear(); - } -}; // MeshList - - -// ---------------------------------------------------------------------------- -class ListSkinnedSolid : public MeshList -{}; - -// ---------------------------------------------------------------------------- -class ListSkinnedAlphaRef : public MeshList -{}; - -// ---------------------------------------------------------------------------- -class ListSkinnedNormalMap : public MeshList -{}; - -// ---------------------------------------------------------------------------- -class ListSkinnedUnlit : public MeshList -{}; - -// ---------------------------------------------------------------------------- -class ListMatDefault : public MeshList -{}; - -// ---------------------------------------------------------------------------- -class ListMatAlphaRef : public MeshList -{}; - -// ---------------------------------------------------------------------------- -class ListMatNormalMap : public MeshList -{}; - -// ---------------------------------------------------------------------------- -class ListMatGrass : public MeshList -{}; - -// ---------------------------------------------------------------------------- -class ListMatSphereMap : public MeshList -{}; - -// ---------------------------------------------------------------------------- -class ListMatSplatting : public MeshList -{}; - -// ---------------------------------------------------------------------------- -class ListMatUnlit : public MeshList -{}; - -// ---------------------------------------------------------------------------- -class ListMatDetails : public MeshList -{}; - -// ---------------------------------------------------------------------------- -// Transparent -template -class MiscList : public Singleton, public std::vector > -{}; - -// ---------------------------------------------------------------------------- -class ListBlendTransparent : public MiscList -{}; - -// ---------------------------------------------------------------------------- -class ListAdditiveTransparent : public MiscList -{}; - -// ---------------------------------------------------------------------------- -class ListTranslucentSkinned : public MiscList -{}; - -// ---------------------------------------------------------------------------- -class ListTranslucentStandard : public MiscList -{}; - -// ---------------------------------------------------------------------------- -class ListTranslucentTangents : public MiscList -{}; - -// ---------------------------------------------------------------------------- -class ListTranslucent2TCoords : public MiscList -{}; - -// ---------------------------------------------------------------------------- -class ListBlendTransparentFog : public MiscList -{}; - -// ---------------------------------------------------------------------------- -class ListAdditiveTransparentFog : public MiscList -{}; - -// ---------------------------------------------------------------------------- -class ListDisplacement : public MiscList -{}; - -// ---------------------------------------------------------------------------- -Material::ShaderType getMeshMaterialFromType(video::E_MATERIAL_TYPE MaterialType, - video::E_VERTEX_TYPE tp, - Material* material, - Material* layer2Material); -// ---------------------------------------------------------------------------- -TransparentMaterial getTransparentMaterialFromType(video::E_MATERIAL_TYPE, - video::E_VERTEX_TYPE tp, - f32 MaterialTypeParam, - Material* material); - -// ---------------------------------------------------------------------------- -void initTextures(GLMesh &mesh, Material::ShaderType); -// ---------------------------------------------------------------------------- -void initTexturesTransparent(GLMesh &mesh); - -#endif // STKMESH_H diff --git a/src/graphics/stk_mesh_scene_node.cpp b/src/graphics/stk_mesh_scene_node.cpp deleted file mode 100644 index 79d0f47e3..000000000 --- a/src/graphics/stk_mesh_scene_node.cpp +++ /dev/null @@ -1,309 +0,0 @@ -// SuperTuxKart - a fun racing game with go-kart -// Copyright (C) 2014-2015 SuperTuxKart-Team -// -// This program is free software; you can redistribute it and/or -// modify it under the terms of the GNU General Public License -// as published by the Free Software Foundation; either version 3 -// of the License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this program; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -#ifndef SERVER_ONLY - -#include "graphics/stk_mesh_scene_node.hpp" - -#include "graphics/central_settings.hpp" -#include "graphics/irr_driver.hpp" -#include "graphics/material_manager.hpp" -#include "graphics/render_info.hpp" -#include "graphics/rtts.hpp" -#include "graphics/shaders.hpp" -#include "tracks/track.hpp" -#include "modes/world.hpp" - -#include -#include - -// ============================================================================ -class ColorizeShader : public Shader -{ -public: - ColorizeShader() - { - loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert", - GL_FRAGMENT_SHADER, "colorize.frag"); - assignUniforms("ModelMatrix", "col"); - } - -}; // ColorizeShader - -// ============================================================================ -STKMeshSceneNode::STKMeshSceneNode(irr::scene::IMesh* mesh, ISceneNode* parent, irr::scene::ISceneManager* mgr, - irr::s32 id, const std::string& debug_name, - const irr::core::vector3df& position, - const irr::core::vector3df& rotation, - const irr::core::vector3df& scale, bool createGLMeshes, RenderInfo* render_info, bool all_parts_colorized) : - CMeshSceneNode(mesh, parent, mgr, id, position, rotation, scale) -{ - isDisplacement = false; - immediate_draw = false; - update_each_frame = false; - isGlow = false; - m_got_animated_matrix = false; - - m_debug_name = debug_name; - - if (createGLMeshes) - this->createGLMeshes(render_info, all_parts_colorized); -} - -void STKMeshSceneNode::setReloadEachFrame(bool val) -{ - update_each_frame = val; - if (val) - immediate_draw = true; -} - -void STKMeshSceneNode::createGLMeshes(RenderInfo* render_info, bool all_parts_colorized) -{ - const u32 mb_count = Mesh->getMeshBufferCount(); - for (u32 i = 0; i < mb_count; ++i) - { - scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); - GLmeshes.push_back(allocateMeshBuffer(mb, m_debug_name, NULL)); - } - isMaterialInitialized = false; - isGLInitialized = false; -} - -void STKMeshSceneNode::cleanGLMeshes() -{ - for (u32 i = 0; i < GLmeshes.size(); ++i) - { - GLMesh mesh = GLmeshes[i]; - if (!mesh.vertex_buffer) - continue; - if (mesh.vao) - glDeleteVertexArrays(1, &(mesh.vao)); - if (mesh.vertex_buffer) - glDeleteBuffers(1, &(mesh.vertex_buffer)); - if (mesh.index_buffer) - glDeleteBuffers(1, &(mesh.index_buffer)); - } - GLmeshes.clear(); - for (unsigned i = 0; i < Material::SHADERTYPE_COUNT; i++) - MeshSolidMaterial[i].clearWithoutDeleting(); - for (unsigned i = 0; i < TM_COUNT; i++) - TransparentMesh[i].clearWithoutDeleting(); -} - -void STKMeshSceneNode::setMesh(irr::scene::IMesh* mesh) -{ - CMeshSceneNode::setMesh(mesh); - cleanGLMeshes(); - createGLMeshes(); -} - -STKMeshSceneNode::~STKMeshSceneNode() -{ - cleanGLMeshes(); -} - -void STKMeshSceneNode::drawGlow(const GLMesh &mesh) -{ - assert(mesh.VAOType == video::EVT_STANDARD); - - GLenum ptype = mesh.PrimitiveType; - GLenum itype = mesh.IndexType; - unsigned int count = mesh.IndexCount; - ColorizeShader::getInstance()->setUniforms(AbsoluteTransformation, video::SColorf(glowcolor.getRed() / 255.f, glowcolor.getGreen() / 255.f, glowcolor.getBlue() / 255.f)); - glDrawElementsBaseVertex(ptype, count, itype, (GLvoid *)mesh.vaoOffset, mesh.vaoBaseVertex); -} - -void STKMeshSceneNode::updatevbo() -{ - for (unsigned i = 0; i < Mesh->getMeshBufferCount(); ++i) - { - scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); - if (!mb) - continue; - GLMesh &mesh = GLmeshes[i]; - glDeleteBuffers(1, &(mesh.vertex_buffer)); - glDeleteBuffers(1, &(mesh.index_buffer)); - glDeleteVertexArrays(1, &(mesh.vao)); - - fillLocalBuffer(mesh, mb); - mesh.vao = createVAO(mesh.vertex_buffer, mesh.index_buffer, mb->getVertexType()); - } -} - -void STKMeshSceneNode::updateNoGL() -{ - Box = Mesh->getBoundingBox(); - - if (!isMaterialInitialized) - { - irr::video::IVideoDriver* driver = irr_driver->getVideoDriver(); - for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i) - { - scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); - if (!mb) - continue; - - video::E_MATERIAL_TYPE type = mb->getMaterial().MaterialType; - f32 MaterialTypeParam = mb->getMaterial().MaterialTypeParam; - video::IMaterialRenderer* rnd = driver->getMaterialRenderer(type); - if (!isObject(type)) - { -#ifdef DEBUG - Log::warn("material", "Unhandled (static) material type : %d", type); -#endif - continue; - } - - GLMesh &mesh = GLmeshes[i]; - video::E_VERTEX_TYPE vt = mb->getVertexType(); - Material* material = material_manager->getMaterialFor(mb->getMaterial().getTexture(0), mb); - if (mesh.m_render_info != NULL && mesh.m_render_info->isTransparent() && !rnd->isTransparent()) - { - assert(!immediate_draw); - if (mesh.VAOType == video::EVT_TANGENTS) - TransparentMesh[TM_TRANSLUCENT_TAN].push_back(&mesh); - else - TransparentMesh[TM_TRANSLUCENT_STD].push_back(&mesh); - } - else if (rnd->isTransparent()) - { - TransparentMaterial TranspMat = getTransparentMaterialFromType(type, vt, MaterialTypeParam, material); - if (!immediate_draw) - TransparentMesh[TranspMat].push_back(&mesh); - else - additive = (TranspMat == TM_ADDITIVE); - } - else - { - assert(!isDisplacement); - Material* material2 = NULL; - if (mb->getMaterial().getTexture(1) != NULL) - material2 = material_manager->getMaterialFor(mb->getMaterial().getTexture(1), mb); - Material::ShaderType MatType = getMeshMaterialFromType(type, vt, material, material2); - if (!immediate_draw) - MeshSolidMaterial[MatType].push_back(&mesh); - } - } - isMaterialInitialized = true; - } - - for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i) - { - scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); - if (mb != NULL) - { - // Test if texture matrix needs to be updated every frame - const core::matrix4& mat = getMaterial(i).getTextureMatrix(0); - if (mat.isIdentity() && !m_got_animated_matrix) - continue; - else - { - m_got_animated_matrix = true; - GLmeshes[i].texture_trans.X = mat[8]; - GLmeshes[i].texture_trans.Y = mat[9]; - } - } - } -} - -void STKMeshSceneNode::updateGL() -{ - if (isGLInitialized) - return; - for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i) - { - scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); - if (!mb) - continue; - GLMesh &mesh = GLmeshes[i]; - - irr::video::IVideoDriver* driver = irr_driver->getVideoDriver(); - video::E_MATERIAL_TYPE type = mb->getMaterial().MaterialType; - video::IMaterialRenderer* rnd = driver->getMaterialRenderer(type); - - - if (!rnd->isTransparent()) - { - Material* material = material_manager->getMaterialFor(mb->getMaterial().getTexture(0), mb); - Material* material2 = NULL; - if (mb->getMaterial().getTexture(1) != NULL) - material2 = material_manager->getMaterialFor(mb->getMaterial().getTexture(1), mb); - Material::ShaderType MatType = getMeshMaterialFromType(type, mb->getVertexType(), material, material2); - if (!immediate_draw) - initTextures(mesh, MatType); - } - else if (!immediate_draw) - initTexturesTransparent(mesh); - fillLocalBuffer(mesh, mb); - mesh.vao = createVAO(mesh.vertex_buffer, mesh.index_buffer, mb->getVertexType()); - glBindVertexArray(0); - } - isGLInitialized = true; -} - -void STKMeshSceneNode::OnRegisterSceneNode() -{ - if (isDisplacement) - SceneManager->registerNodeForRendering(this, scene::ESNRP_TRANSPARENT); - else - CMeshSceneNode::OnRegisterSceneNode(); -} - -void STKMeshSceneNode::render() -{ - irr::video::IVideoDriver* driver = irr_driver->getVideoDriver(); - - if (!Mesh || !driver) - return; - - ++PassCount; - - updateNoGL(); - updateGL(); - - if (irr_driver->getPhase() == GLOW_PASS) - { - ColorizeShader::getInstance()->use(); - for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i) - { - scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); - if (!mb) - continue; - glBindVertexArray(GLmeshes[i].vao); - drawGlow(GLmeshes[i]); - } - } - -} - -void STKMeshSceneNode::setIsDisplacement(bool v) -{ - isDisplacement = v; - for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i) - { - scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); - if (!mb) - continue; - - if (isDisplacement) - mb->getMaterial().MaterialType = Shaders::getShader(ES_DISPLACE); - } -} - -#endif // !SERVER_ONLY - diff --git a/src/graphics/stk_mesh_scene_node.hpp b/src/graphics/stk_mesh_scene_node.hpp deleted file mode 100644 index b741e83c3..000000000 --- a/src/graphics/stk_mesh_scene_node.hpp +++ /dev/null @@ -1,73 +0,0 @@ -// SuperTuxKart - a fun racing game with go-kart -// Copyright (C) 2014-2015 SuperTuxKart-Team -// -// This program is free software; you can redistribute it and/or -// modify it under the terms of the GNU General Public License -// as published by the Free Software Foundation; either version 3 -// of the License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this program; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -#ifndef HEADER_STK_MESH_SCENE_NODE -#define HEADER_STK_MESH_SCENE_NODE - -#include "graphics/stk_mesh.hpp" - -#include "utils/ptr_vector.hpp" - -class RenderInfo; - -class STKMeshSceneNode : public irr::scene::CMeshSceneNode, public STKMeshCommon -{ -protected: - PtrVector m_static_render_info; - bool m_got_animated_matrix; - std::vector GLmeshes; - core::matrix4 ModelViewProjectionMatrix; - core::vector3df windDir; - core::vector2df caustic_dir, caustic_dir2; - - // Misc passes shaders (glow, displace...) - void drawGlow(const GLMesh &mesh); - void createGLMeshes(RenderInfo* render_info = NULL, bool all_parts_colorized = false); - void cleanGLMeshes(); - void setFirstTimeMaterial(); - void updatevbo(); - bool isMaterialInitialized; - bool isGLInitialized; - bool immediate_draw; - bool additive; - bool update_each_frame; - bool isDisplacement; - bool isGlow; - video::SColor glowcolor; -public: - virtual void updateNoGL(); - virtual void updateGL(); - void setReloadEachFrame(bool); - STKMeshSceneNode(irr::scene::IMesh* mesh, ISceneNode* parent, irr::scene::ISceneManager* mgr, - irr::s32 id, const std::string& debug_name, - const irr::core::vector3df& position = irr::core::vector3df(0, 0, 0), - 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), - bool createGLMeshes = true, - RenderInfo* render_info = NULL, bool all_parts_colorized = false); - virtual void render(); - virtual void setMesh(irr::scene::IMesh* mesh); - virtual void OnRegisterSceneNode(); - virtual ~STKMeshSceneNode(); - virtual bool isImmediateDraw() const { return immediate_draw; } - void setIsDisplacement(bool v); - virtual bool glow() const { return isGlow; } - void setGlowColors(const video::SColor &c) { isGlow = true; glowcolor = c; } - video::SColor getGlowColor() const { return glowcolor; } -}; - -#endif