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

Moved Materials definition in a separate Materials file

Browse Source
This commit is contained in:
Elderme 2015-11-07 22:10:32 +01:00
parent 928dd8d24d
commit c1eb0bbe73
8 changed files with 341 additions and 344 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
src/graphics/command_buffer.cpp
View File

@ -76,6 +76,7 @@ m_offset(NULL), m_size(NULL), m_poly_count(0)
CommandBuffer::~CommandBuffer()
{
delete[] m_meshes;
glDeleteBuffers(1, &m_draw_indirect_cmd_id);
delete[] m_offset;
delete[] m_size;
@ -85,12 +86,11 @@ CommandBuffer::~CommandBuffer()
template<typename T>
void CommandBuffer::fillMaterial(int material_id,
MeshMap *mesh_map,
std::vector<GLMesh *> &instanced_list,
T *instance_buffer)
{
m_offset[material_id] = m_command_buffer_offset;
FillInstances<T>(mesh_map[material_id],
instanced_list,
m_meshes[material_id],
instance_buffer,
m_draw_indirect_cmd,
m_instance_buffer_offset,
@ -102,16 +102,24 @@ void CommandBuffer::fillMaterial(int material_id,
SolidCommandBuffer::SolidCommandBuffer(): CommandBuffer()
{
m_meshes = new std::vector<GLMesh *>[static_cast<int>(Material::SHADERTYPE_COUNT)];
m_offset = new size_t[static_cast<int>(Material::SHADERTYPE_COUNT)];
m_size = new size_t[static_cast<int>(Material::SHADERTYPE_COUNT)];
}
void SolidCommandBuffer::fill(MeshMap *mesh_map, std::vector<GLMesh *> instanced_lists[])
void SolidCommandBuffer::fill(MeshMap *mesh_map)
{
m_instance_buffer_offset = 0;
m_command_buffer_offset = 0;
m_poly_count = 0;
//clear meshes
for(int i=0;i<Material::SHADERTYPE_COUNT;i++)
{
m_meshes[i].clear();
}
//Dual textures materials
InstanceDataDualTex *instance_buffer_dual_tex;
@ -151,7 +159,6 @@ void SolidCommandBuffer::fill(MeshMap *mesh_map, std::vector<GLMesh *> instanced
material_id = static_cast<int>(dual_tex_materials[i]);
fillMaterial( material_id,
mesh_map,
instanced_lists[material_id],
instance_buffer_dual_tex);
}
@ -186,7 +193,6 @@ void SolidCommandBuffer::fill(MeshMap *mesh_map, std::vector<GLMesh *> instanced
material_id = static_cast<int>(three_tex_materials[i]);
fillMaterial( material_id,
mesh_map,
instanced_lists[material_id],
instance_buffer_three_tex);
}
@ -199,11 +205,12 @@ void SolidCommandBuffer::fill(MeshMap *mesh_map, std::vector<GLMesh *> instanced
ShadowCommandBuffer::ShadowCommandBuffer(): CommandBuffer()
{
m_meshes = new std::vector<GLMesh *>[4 * static_cast<int>(Material::SHADERTYPE_COUNT)];
m_offset = new size_t[4 * static_cast<int>(Material::SHADERTYPE_COUNT)];
m_size = new size_t[4 * static_cast<int>(Material::SHADERTYPE_COUNT)];
}
void ShadowCommandBuffer::fill(MeshMap *mesh_map, std::vector<GLMesh *> instanced_lists[])
void ShadowCommandBuffer::fill(MeshMap *mesh_map)
{
m_instance_buffer_offset = 0;
m_command_buffer_offset = 0;
@ -247,7 +254,6 @@ void ShadowCommandBuffer::fill(MeshMap *mesh_map, std::vector<GLMesh *> instance
material_id = cascade * 7 + static_cast<int>(materials[i]);
fillMaterial( material_id,
mesh_map,
instanced_lists[material_id],
shadow_instance_buffer);
}
}
@ -262,12 +268,13 @@ void ShadowCommandBuffer::fill(MeshMap *mesh_map, std::vector<GLMesh *> instance
ReflectiveShadowMapCommandBuffer::ReflectiveShadowMapCommandBuffer(): CommandBuffer()
{
m_meshes = new std::vector<GLMesh *>[static_cast<int>(Material::SHADERTYPE_COUNT)];
m_offset = new size_t[static_cast<int>(Material::SHADERTYPE_COUNT)];
m_size = new size_t[static_cast<int>(Material::SHADERTYPE_COUNT)];
}
void ReflectiveShadowMapCommandBuffer::fill(MeshMap *mesh_map, std::vector<GLMesh *> instanced_lists[])
void ReflectiveShadowMapCommandBuffer::fill(MeshMap *mesh_map)
{
m_instance_buffer_offset = 0;
m_command_buffer_offset = 0;
@ -308,7 +315,6 @@ void ReflectiveShadowMapCommandBuffer::fill(MeshMap *mesh_map, std::vector<GLMes
material_id = static_cast<int>(materials[i]);
fillMaterial( material_id,
mesh_map,
instanced_lists[material_id],
rsm_instance_buffer);
}
@ -322,11 +328,12 @@ void ReflectiveShadowMapCommandBuffer::fill(MeshMap *mesh_map, std::vector<GLMes
GlowCommandBuffer::GlowCommandBuffer()
{
m_meshes = new std::vector<GLMesh *>[1];
m_offset = new size_t[1];
m_size = new size_t[1];
}
void GlowCommandBuffer::fill(MeshMap *mesh_map, std::vector<GLMesh *> instanced_lists[])
void GlowCommandBuffer::fill(MeshMap *mesh_map)
{
m_instance_buffer_offset = 0;
m_command_buffer_offset = 0;
@ -354,7 +361,6 @@ void GlowCommandBuffer::fill(MeshMap *mesh_map, std::vector<GLMesh *> instanced_
fillMaterial( 0,
mesh_map,
instanced_lists[0],
glow_instance_buffer);
if (!CVS->supportsAsyncInstanceUpload())

10
src/graphics/command_buffer.hpp
View File

@ -107,6 +107,7 @@ void FillInstances( const MeshMap &gathered_GL_mesh,
class CommandBuffer
{
protected:
std::vector<GLMesh *> *m_meshes;
GLuint m_draw_indirect_cmd_id;
DrawElementsIndirectCommand *m_draw_indirect_cmd;
size_t *m_offset;
@ -118,7 +119,6 @@ protected:
template<typename T>
void fillMaterial(int material_id,
MeshMap *mesh_map,
std::vector<GLMesh *> &instanced_list,
T *instance_buffer);
public:
@ -163,28 +163,28 @@ class SolidCommandBuffer: public CommandBuffer
{
public:
SolidCommandBuffer();
void fill(MeshMap *mesh_map, std::vector<GLMesh *> instanced_lists[]);
void fill(MeshMap *mesh_map);
};
class ShadowCommandBuffer: public CommandBuffer
{
public:
ShadowCommandBuffer();
void fill(MeshMap *mesh_map, std::vector<GLMesh *> instanced_lists[]);
void fill(MeshMap *mesh_map);
};
class ReflectiveShadowMapCommandBuffer: public CommandBuffer
{
public:
ReflectiveShadowMapCommandBuffer();
void fill(MeshMap *mesh_map, std::vector<GLMesh *> instanced_lists[]);
void fill(MeshMap *mesh_map);
};
class GlowCommandBuffer: public CommandBuffer
{
public:
GlowCommandBuffer();
void fill(MeshMap *mesh_map, std::vector<GLMesh *> instanced_lists[]);
void fill(MeshMap *mesh_map);
};
#endif //HEADER_COMMAND_BUFFER_HPP

6
src/graphics/draw_calls.cpp
View File

@ -547,16 +547,16 @@ void DrawCalls::prepareDrawCalls( ShadowMatrices& shadow_matrices, scene::ICamer
{
//TODO
std::vector<GLMesh *> instanced_lists[Material::SHADERTYPE_COUNT];
/*std::vector<GLMesh *> instanced_lists[Material::SHADERTYPE_COUNT];
instanced_lists[static_cast<int>(Material::SHADERTYPE_SOLID)] = ListInstancedMatDefault::getInstance()->SolidPass;
instanced_lists[static_cast<int>(Material::SHADERTYPE_ALPHA_TEST)] = ListInstancedMatAlphaRef::getInstance()->SolidPass;
instanced_lists[static_cast<int>(Material::SHADERTYPE_SOLID_UNLIT)] = ListInstancedMatUnlit::getInstance()->SolidPass;
instanced_lists[static_cast<int>(Material::SHADERTYPE_SPHERE_MAP)] = ListInstancedMatSphereMap::getInstance()->SolidPass;
instanced_lists[static_cast<int>(Material::SHADERTYPE_VEGETATION)] = ListInstancedMatGrass::getInstance()->SolidPass;
instanced_lists[static_cast<int>(Material::SHADERTYPE_DETAIL_MAP)] = ListInstancedMatDetails::getInstance()->SolidPass;
instanced_lists[static_cast<int>(Material::SHADERTYPE_NORMAL_MAP)] = ListInstancedMatNormalMap::getInstance()->SolidPass;
instanced_lists[static_cast<int>(Material::SHADERTYPE_NORMAL_MAP)] = ListInstancedMatNormalMap::getInstance()->SolidPass;*/
m_solid_cmd_buffer.fill(m_solid_pass_mesh, instanced_lists);
m_solid_cmd_buffer.fill(m_solid_pass_mesh);
size_t offset = 0, current_cmd = 0;

244
src/graphics/geometry_passes.cpp
View File

@ -19,6 +19,7 @@
#include "graphics/callbacks.hpp"
#include "graphics/draw_tools.hpp"
#include "graphics/glwrap.hpp"
#include "graphics/materials.hpp"
#include "graphics/post_processing.hpp"
#include "graphics/rtts.hpp"
#include "graphics/shaders.hpp"
@ -513,125 +514,6 @@ public:
} // NormalVisualizer
}; // NormalVisualizer
// ============================================================================
struct DefaultMaterial
{
typedef InstancedObjectPass1Shader InstancedFirstPassShader;
typedef InstancedObjectPass2Shader InstancedSecondPassShader;
typedef InstancedShadowShader InstancedShadowPassShader;
typedef CInstancedRSMShader InstancedRSMShader;
typedef ListInstancedMatDefault InstancedList;
typedef Shaders::ObjectPass1Shader FirstPassShader;
typedef Shaders::ObjectPass2Shader SecondPassShader;
typedef ShadowShader ShadowPassShader;
typedef CRSMShader RSMShader;
typedef ListMatDefault List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
static const enum Material::ShaderType MaterialType
= Material::SHADERTYPE_SOLID;
static const enum InstanceType Instance = InstanceTypeDualTex;
static const STK::Tuple<size_t> FirstPassTextures;
static const STK::Tuple<size_t, size_t> SecondPassTextures;
static const STK::Tuple<> ShadowTextures;
static const STK::Tuple<size_t> RSMTextures;
}; // struct DefaultMaterial
const STK::Tuple<size_t> DefaultMaterial::FirstPassTextures
= STK::Tuple<size_t>(1);
const STK::Tuple<size_t, size_t> DefaultMaterial::SecondPassTextures
= STK::Tuple<size_t, size_t>(0, 1);
const STK::Tuple<> DefaultMaterial::ShadowTextures;
const STK::Tuple<size_t> DefaultMaterial::RSMTextures = STK::Tuple<size_t>(0);
// ----------------------------------------------------------------------------
struct AlphaRef
{
typedef InstancedObjectRefPass1Shader InstancedFirstPassShader;
typedef InstancedObjectRefPass2Shader InstancedSecondPassShader;
typedef InstancedRefShadowShader InstancedShadowPassShader;
typedef CInstancedRSMShader InstancedRSMShader;
typedef ListInstancedMatAlphaRef InstancedList;
typedef ObjectRefPass1Shader FirstPassShader;
typedef ObjectRefPass2Shader SecondPassShader;
typedef RefShadowShader ShadowPassShader;
typedef CRSMShader RSMShader;
typedef ListMatAlphaRef List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
static const enum Material::ShaderType MaterialType = Material::SHADERTYPE_ALPHA_TEST;
static const enum InstanceType Instance = InstanceTypeDualTex;
static const STK::Tuple<size_t, size_t> FirstPassTextures;
static const STK::Tuple<size_t, size_t> SecondPassTextures;
static const STK::Tuple<size_t> ShadowTextures;
static const STK::Tuple<size_t> RSMTextures;
}; // struct AlphaRef
// ----------------------------------------------------------------------------
const STK::Tuple<size_t, size_t> AlphaRef::FirstPassTextures
= STK::Tuple<size_t, size_t>(0, 1);
const STK::Tuple<size_t, size_t> AlphaRef::SecondPassTextures
= STK::Tuple<size_t, size_t>(0, 1);
const STK::Tuple<size_t> AlphaRef::ShadowTextures = STK::Tuple<size_t>(0);
const STK::Tuple<size_t> AlphaRef::RSMTextures = STK::Tuple<size_t>(0);
// ----------------------------------------------------------------------------
struct SphereMap
{
typedef InstancedObjectPass1Shader InstancedFirstPassShader;
typedef InstancedSphereMapShader InstancedSecondPassShader;
typedef InstancedShadowShader InstancedShadowPassShader;
typedef CInstancedRSMShader InstancedRSMShader;
typedef ListInstancedMatSphereMap InstancedList;
typedef Shaders::ObjectPass1Shader FirstPassShader;
typedef SphereMapShader SecondPassShader;
typedef ShadowShader ShadowPassShader;
typedef CRSMShader RSMShader;
typedef ListMatSphereMap List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
static const enum Material::ShaderType MaterialType
= Material::SHADERTYPE_SPHERE_MAP;
static const enum InstanceType Instance = InstanceTypeDualTex;
static const STK::Tuple<size_t> FirstPassTextures;
static const STK::Tuple<size_t> SecondPassTextures;
static const STK::Tuple<> ShadowTextures;
static const STK::Tuple<size_t> RSMTextures;
}; // struct SphereMap
// ----------------------------------------------------------------------------
const STK::Tuple<size_t> SphereMap::FirstPassTextures = STK::Tuple<size_t>(1);
const STK::Tuple<size_t> SphereMap::SecondPassTextures = STK::Tuple<size_t>(0);
const STK::Tuple<> SphereMap::ShadowTextures;
const STK::Tuple<size_t> SphereMap::RSMTextures = STK::Tuple<size_t>(0);
// ----------------------------------------------------------------------------
struct UnlitMat
{
typedef InstancedObjectRefPass1Shader InstancedFirstPassShader;
typedef InstancedObjectUnlitShader InstancedSecondPassShader;
typedef InstancedRefShadowShader InstancedShadowPassShader;
typedef CInstancedRSMShader InstancedRSMShader;
typedef ListInstancedMatUnlit InstancedList;
typedef ObjectRefPass1Shader FirstPassShader;
typedef ObjectUnlitShader SecondPassShader;
typedef RefShadowShader ShadowPassShader;
typedef CRSMShader RSMShader;
typedef ListMatUnlit List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
static const enum Material::ShaderType MaterialType =
Material::SHADERTYPE_SOLID_UNLIT;
static const enum InstanceType Instance = InstanceTypeDualTex;
static const STK::Tuple<size_t, size_t> FirstPassTextures;
static const STK::Tuple<size_t> SecondPassTextures;
static const STK::Tuple<size_t> ShadowTextures;
static const STK::Tuple<size_t> RSMTextures;
}; // struct UnlitMat
// ----------------------------------------------------------------------------
const STK::Tuple<size_t, size_t> UnlitMat::FirstPassTextures
= STK::Tuple<size_t, size_t>(0, 1);
const STK::Tuple<size_t> UnlitMat::SecondPassTextures = STK::Tuple<size_t>(0);
const STK::Tuple<size_t> UnlitMat::ShadowTextures = STK::Tuple<size_t>(0);
const STK::Tuple<size_t> UnlitMat::RSMTextures = STK::Tuple<size_t>(0);
// ============================================================================
class GrassPass1Shader : public TextureShader<GrassPass1Shader, 2, core::matrix4,
core::matrix4, core::vector3df>
@ -802,128 +684,8 @@ public:
} // InstancedDetailedObjectPass2Shader
}; // InstancedDetailedObjectPass2Shader
// ============================================================================
// ----------------------------------------------------------------------------
struct GrassMat
{
typedef InstancedGrassPass1Shader InstancedFirstPassShader;
typedef InstancedGrassPass2Shader InstancedSecondPassShader;
typedef InstancedGrassShadowShader InstancedShadowPassShader;
typedef CInstancedRSMShader InstancedRSMShader;
typedef ListInstancedMatGrass InstancedList;
typedef GrassPass1Shader FirstPassShader;
typedef GrassPass2Shader SecondPassShader;
typedef GrassShadowShader ShadowPassShader;
typedef CRSMShader RSMShader;
typedef ListMatGrass List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
static const enum Material::ShaderType MaterialType
= Material::SHADERTYPE_VEGETATION;
static const enum InstanceType Instance = InstanceTypeDualTex;
static const STK::Tuple<size_t, size_t> FirstPassTextures;
static const STK::Tuple<size_t, size_t> SecondPassTextures;
static const STK::Tuple<size_t> ShadowTextures;
static const STK::Tuple<size_t> RSMTextures;
}; // GrassMat
// ----------------------------------------------------------------------------
const STK::Tuple<size_t, size_t> GrassMat::FirstPassTextures
= STK::Tuple<size_t, size_t>(0, 1);
const STK::Tuple<size_t, size_t> GrassMat::SecondPassTextures
= STK::Tuple<size_t, size_t>(0, 1);
const STK::Tuple<size_t> GrassMat::ShadowTextures = STK::Tuple<size_t>(0);
const STK::Tuple<size_t> GrassMat::RSMTextures = STK::Tuple<size_t>(0);
// ----------------------------------------------------------------------------
struct NormalMat
{
typedef InstancedNormalMapShader InstancedFirstPassShader;
typedef InstancedObjectPass2Shader InstancedSecondPassShader;
typedef InstancedShadowShader InstancedShadowPassShader;
typedef CInstancedRSMShader InstancedRSMShader;
typedef ListInstancedMatNormalMap InstancedList;
typedef NormalMapShader FirstPassShader;
typedef Shaders::ObjectPass2Shader SecondPassShader;
typedef ShadowShader ShadowPassShader;
typedef CRSMShader RSMShader;
typedef ListMatNormalMap List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_TANGENTS;
static const enum Material::ShaderType MaterialType
= Material::SHADERTYPE_NORMAL_MAP;
static const enum InstanceType Instance = InstanceTypeThreeTex;
static const STK::Tuple<size_t, size_t> FirstPassTextures;
static const STK::Tuple<size_t, size_t> SecondPassTextures;
static const STK::Tuple<> ShadowTextures;
static const STK::Tuple<size_t> RSMTextures;
}; // NormalMat
// ----------------------------------------------------------------------------
const STK::Tuple<size_t, size_t> NormalMat::FirstPassTextures
= STK::Tuple<size_t, size_t>(2, 1);
const STK::Tuple<size_t, size_t> NormalMat::SecondPassTextures
= STK::Tuple<size_t, size_t>(0, 1);
const STK::Tuple<> NormalMat::ShadowTextures;
const STK::Tuple<size_t> NormalMat::RSMTextures = STK::Tuple<size_t>(0);
// ----------------------------------------------------------------------------
struct DetailMat
{
typedef InstancedObjectPass1Shader InstancedFirstPassShader;
typedef InstancedDetailedObjectPass2Shader InstancedSecondPassShader;
typedef InstancedShadowShader InstancedShadowPassShader;
typedef CInstancedRSMShader InstancedRSMShader;
typedef ListInstancedMatDetails InstancedList;
typedef Shaders::ObjectPass1Shader FirstPassShader;
typedef DetailedObjectPass2Shader SecondPassShader;
typedef ShadowShader ShadowPassShader;
typedef CRSMShader RSMShader;
typedef ListMatDetails List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_2TCOORDS;
static const enum Material::ShaderType MaterialType
= Material::SHADERTYPE_DETAIL_MAP;
static const enum InstanceType Instance = InstanceTypeThreeTex;
static const STK::Tuple<size_t> FirstPassTextures;
static const STK::Tuple<size_t, size_t, size_t> SecondPassTextures;
static const STK::Tuple<> ShadowTextures;
static const STK::Tuple<size_t> RSMTextures;
}; // DetailMat
// ----------------------------------------------------------------------------
const STK::Tuple<size_t> DetailMat::FirstPassTextures = STK::Tuple<size_t>(1);
const STK::Tuple<size_t, size_t, size_t> DetailMat::SecondPassTextures
= STK::Tuple<size_t, size_t, size_t>(0, 2, 1);
const STK::Tuple<> DetailMat::ShadowTextures;
const STK::Tuple<size_t> DetailMat::RSMTextures = STK::Tuple<size_t>(0);
// ----------------------------------------------------------------------------
struct SplattingMat
{
typedef Shaders::ObjectPass1Shader FirstPassShader;
typedef SplattingShader SecondPassShader;
typedef ShadowShader ShadowPassShader;
typedef SplattingRSMShader RSMShader;
typedef ListMatSplatting List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_2TCOORDS;
static const STK::Tuple<size_t> FirstPassTextures;
static const STK::Tuple<size_t, size_t, size_t, size_t, size_t> SecondPassTextures;
static const STK::Tuple<> ShadowTextures;
static const STK::Tuple<size_t, size_t, size_t, size_t, size_t> RSMTextures;
}; // SplattingMat
// ----------------------------------------------------------------------------
const STK::Tuple<size_t> SplattingMat::FirstPassTextures = STK::Tuple<size_t>(6);
const STK::Tuple<size_t, size_t, size_t, size_t, size_t>
SplattingMat::SecondPassTextures
= STK::Tuple<size_t, size_t, size_t, size_t, size_t>(1, 2, 3, 4, 5);
const STK::Tuple<> SplattingMat::ShadowTextures;
const STK::Tuple<size_t, size_t, size_t, size_t, size_t> SplattingMat::RSMTextures
= STK::Tuple<size_t, size_t, size_t, size_t, size_t>(1, 2, 3, 4, 5);
// ============================================================================
namespace RenderGeometry
{
struct TexUnit
@ -1014,6 +776,9 @@ void renderInstancedMeshes1stPass(const DrawCalls& draw_calls, Args...args)
{
std::vector<GLMesh *> &meshes = T::InstancedList::getInstance()->SolidPass;
T::InstancedFirstPassShader::getInstance()->use();
T::InstancedFirstPassShader::getInstance()->setUniforms(args...);
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType, T::Instance));
for (unsigned i = 0; i < meshes.size(); i++)
{
@ -1028,7 +793,6 @@ void renderInstancedMeshes1stPass(const DrawCalls& draw_calls, Args...args)
#endif
TexExpander<typename T::InstancedFirstPassShader>::template expandTex(*mesh, T::FirstPassTextures);
T::InstancedFirstPassShader::getInstance()->setUniforms(args...);
draw_calls.drawIndirectSolidCmd(T::MaterialType, i);
}
} // renderInstancedMeshes1stPass

19
src/graphics/material_type.cpp
View File

@ -1,19 +0,0 @@
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 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.
#include "graphics/material_type.hpp"

66
src/graphics/material_type.hpp
View File

@ -1,66 +0,0 @@
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 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_MATERIAL_TYPE_HPP
#define HEADER_MATERIAL_TYPE_HPP
#include "graphics/shader.hpp"
/*
struct MaterialType
{
Shader *m_first_pass_shader;
Shader *m_second_pass_shader;
Shader *m_shadow_shader;
Shader *m_reflective_shadow_map_shader;
Material::ShaderType m_shader_type;
};*/
/*
// ============================================================================
struct DefaultMaterial
{
typedef InstancedObjectPass1Shader InstancedFirstPassShader;
typedef InstancedObjectPass2Shader InstancedSecondPassShader;
typedef InstancedShadowShader InstancedShadowPassShader;
typedef CInstancedRSMShader InstancedRSMShader;
typedef ListInstancedMatDefault InstancedList;
typedef Shaders::ObjectPass1Shader FirstPassShader;
typedef Shaders::ObjectPass2Shader SecondPassShader;
typedef ShadowShader ShadowPassShader;
typedef CRSMShader RSMShader;
typedef ListMatDefault List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
static const enum Material::ShaderType MaterialType
= Material::SHADERTYPE_SOLID;
static const enum InstanceType Instance = InstanceTypeDualTex;
static const STK::Tuple<size_t> FirstPassTextures;
static const STK::Tuple<size_t, size_t> SecondPassTextures;
static const STK::Tuple<> ShadowTextures;
static const STK::Tuple<size_t> RSMTextures;
}; // struct DefaultMaterial
const STK::Tuple<size_t> DefaultMaterial::FirstPassTextures
= STK::Tuple<size_t>(1);
const STK::Tuple<size_t, size_t> DefaultMaterial::SecondPassTextures
= STK::Tuple<size_t, size_t>(0, 1);
const STK::Tuple<> DefaultMaterial::ShadowTextures;
const STK::Tuple<size_t> DefaultMaterial::RSMTextures = STK::Tuple<size_t>(0);
*/
#endif //HEADER_MATERIAL_TYPE_HPP

78
src/graphics/materials.cpp Normal file
View File

@ -0,0 +1,78 @@
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 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.
#include "graphics/materials.hpp"
const STK::Tuple<size_t> DefaultMaterial::FirstPassTextures
= STK::Tuple<size_t>(1);
const STK::Tuple<size_t, size_t> DefaultMaterial::SecondPassTextures
= STK::Tuple<size_t, size_t>(0, 1);
const STK::Tuple<> DefaultMaterial::ShadowTextures;
const STK::Tuple<size_t> DefaultMaterial::RSMTextures = STK::Tuple<size_t>(0);
// ----------------------------------------------------------------------------
const STK::Tuple<size_t, size_t> AlphaRef::FirstPassTextures
= STK::Tuple<size_t, size_t>(0, 1);
const STK::Tuple<size_t, size_t> AlphaRef::SecondPassTextures
= STK::Tuple<size_t, size_t>(0, 1);
const STK::Tuple<size_t> AlphaRef::ShadowTextures = STK::Tuple<size_t>(0);
const STK::Tuple<size_t> AlphaRef::RSMTextures = STK::Tuple<size_t>(0);
// ----------------------------------------------------------------------------
const STK::Tuple<size_t> SphereMap::FirstPassTextures = STK::Tuple<size_t>(1);
const STK::Tuple<size_t> SphereMap::SecondPassTextures = STK::Tuple<size_t>(0);
const STK::Tuple<> SphereMap::ShadowTextures;
const STK::Tuple<size_t> SphereMap::RSMTextures = STK::Tuple<size_t>(0);
// ----------------------------------------------------------------------------
const STK::Tuple<size_t, size_t> UnlitMat::FirstPassTextures
= STK::Tuple<size_t, size_t>(0, 1);
const STK::Tuple<size_t> UnlitMat::SecondPassTextures = STK::Tuple<size_t>(0);
const STK::Tuple<size_t> UnlitMat::ShadowTextures = STK::Tuple<size_t>(0);
const STK::Tuple<size_t> UnlitMat::RSMTextures = STK::Tuple<size_t>(0);
// ----------------------------------------------------------------------------
const STK::Tuple<size_t, size_t> GrassMat::FirstPassTextures
= STK::Tuple<size_t, size_t>(0, 1);
const STK::Tuple<size_t, size_t> GrassMat::SecondPassTextures
= STK::Tuple<size_t, size_t>(0, 1);
const STK::Tuple<size_t> GrassMat::ShadowTextures = STK::Tuple<size_t>(0);
const STK::Tuple<size_t> GrassMat::RSMTextures = STK::Tuple<size_t>(0);
// ----------------------------------------------------------------------------
const STK::Tuple<size_t, size_t> NormalMat::FirstPassTextures
= STK::Tuple<size_t, size_t>(2, 1);
const STK::Tuple<size_t, size_t> NormalMat::SecondPassTextures
= STK::Tuple<size_t, size_t>(0, 1);
const STK::Tuple<> NormalMat::ShadowTextures;
const STK::Tuple<size_t> NormalMat::RSMTextures = STK::Tuple<size_t>(0);
// ----------------------------------------------------------------------------
const STK::Tuple<size_t> DetailMat::FirstPassTextures = STK::Tuple<size_t>(1);
const STK::Tuple<size_t, size_t, size_t> DetailMat::SecondPassTextures
= STK::Tuple<size_t, size_t, size_t>(0, 2, 1);
const STK::Tuple<> DetailMat::ShadowTextures;
const STK::Tuple<size_t> DetailMat::RSMTextures = STK::Tuple<size_t>(0);
// ----------------------------------------------------------------------------
const STK::Tuple<size_t> SplattingMat::FirstPassTextures = STK::Tuple<size_t>(6);
const STK::Tuple<size_t, size_t, size_t, size_t, size_t>
SplattingMat::SecondPassTextures
= STK::Tuple<size_t, size_t, size_t, size_t, size_t>(1, 2, 3, 4, 5);
const STK::Tuple<> SplattingMat::ShadowTextures;
const STK::Tuple<size_t, size_t, size_t, size_t, size_t> SplattingMat::RSMTextures
= STK::Tuple<size_t, size_t, size_t, size_t, size_t>(1, 2, 3, 4, 5);

234
src/graphics/materials.hpp Normal file
View File

@ -0,0 +1,234 @@
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 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_MATERIAL_TYPE_HPP
#define HEADER_MATERIAL_TYPE_HPP
#include "graphics/shader.hpp"
#include "graphics/shaders.hpp"
#include "graphics/stk_mesh.hpp"
#include "graphics/vao_manager.hpp"
class InstancedObjectPass1Shader;
class InstancedObjectPass2Shader;
class InstancedShadowShader;
class CInstancedRSMShader;
class ListInstancedMatDefault;
class ShadowShader;
class CRSMShader;
class InstancedObjectRefPass1Shader;
class InstancedObjectRefPass2Shader;
class InstancedRefShadowShader;
class ObjectRefPass1Shader;
class ObjectRefPass2Shader;
class RefShadowShader;
class InstancedSphereMapShader;
class SphereMapShader;
class InstancedObjectUnlitShader;
class ObjectUnlitShader;
class InstancedGrassPass1Shader;
class InstancedGrassPass2Shader;
class InstancedGrassShadowShader;
class GrassPass1Shader;
class GrassPass2Shader;
class GrassShadowShader;
class InstancedNormalMapShader;
class NormalMapShader;
class InstancedDetailedObjectPass2Shader;
class DetailedObjectPass2Shader;
class SplattingShader;
class SplattingRSMShader;
// ============================================================================
struct DefaultMaterial
{
typedef InstancedObjectPass1Shader InstancedFirstPassShader;
typedef InstancedObjectPass2Shader InstancedSecondPassShader;
typedef InstancedShadowShader InstancedShadowPassShader;
typedef CInstancedRSMShader InstancedRSMShader;
typedef ListInstancedMatDefault InstancedList;
typedef Shaders::ObjectPass1Shader FirstPassShader;
typedef Shaders::ObjectPass2Shader SecondPassShader;
typedef ShadowShader ShadowPassShader;
typedef CRSMShader RSMShader;
typedef ListMatDefault List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
static const enum Material::ShaderType MaterialType
= Material::SHADERTYPE_SOLID;
static const enum InstanceType Instance = InstanceTypeDualTex;
static const STK::Tuple<size_t> FirstPassTextures;
static const STK::Tuple<size_t, size_t> SecondPassTextures;
static const STK::Tuple<> ShadowTextures;
static const STK::Tuple<size_t> RSMTextures;
}; // struct DefaultMaterial
// ----------------------------------------------------------------------------
struct AlphaRef
{
typedef InstancedObjectRefPass1Shader InstancedFirstPassShader;
typedef InstancedObjectRefPass2Shader InstancedSecondPassShader;
typedef InstancedRefShadowShader InstancedShadowPassShader;
typedef CInstancedRSMShader InstancedRSMShader;
typedef ListInstancedMatAlphaRef InstancedList;
typedef ObjectRefPass1Shader FirstPassShader;
typedef ObjectRefPass2Shader SecondPassShader;
typedef RefShadowShader ShadowPassShader;
typedef CRSMShader RSMShader;
typedef ListMatAlphaRef List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
static const enum Material::ShaderType MaterialType = Material::SHADERTYPE_ALPHA_TEST;
static const enum InstanceType Instance = InstanceTypeDualTex;
static const STK::Tuple<size_t, size_t> FirstPassTextures;
static const STK::Tuple<size_t, size_t> SecondPassTextures;
static const STK::Tuple<size_t> ShadowTextures;
static const STK::Tuple<size_t> RSMTextures;
}; // struct AlphaRef
// ----------------------------------------------------------------------------
struct SphereMap
{
typedef InstancedObjectPass1Shader InstancedFirstPassShader;
typedef InstancedSphereMapShader InstancedSecondPassShader;
typedef InstancedShadowShader InstancedShadowPassShader;
typedef CInstancedRSMShader InstancedRSMShader;
typedef ListInstancedMatSphereMap InstancedList;
typedef Shaders::ObjectPass1Shader FirstPassShader;
typedef SphereMapShader SecondPassShader;
typedef ShadowShader ShadowPassShader;
typedef CRSMShader RSMShader;
typedef ListMatSphereMap List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
static const enum Material::ShaderType MaterialType
= Material::SHADERTYPE_SPHERE_MAP;
static const enum InstanceType Instance = InstanceTypeDualTex;
static const STK::Tuple<size_t> FirstPassTextures;
static const STK::Tuple<size_t> SecondPassTextures;
static const STK::Tuple<> ShadowTextures;
static const STK::Tuple<size_t> RSMTextures;
}; // struct SphereMap
// ----------------------------------------------------------------------------
struct UnlitMat
{
typedef InstancedObjectRefPass1Shader InstancedFirstPassShader;
typedef InstancedObjectUnlitShader InstancedSecondPassShader;
typedef InstancedRefShadowShader InstancedShadowPassShader;
typedef CInstancedRSMShader InstancedRSMShader;
typedef ListInstancedMatUnlit InstancedList;
typedef ObjectRefPass1Shader FirstPassShader;
typedef ObjectUnlitShader SecondPassShader;
typedef RefShadowShader ShadowPassShader;
typedef CRSMShader RSMShader;
typedef ListMatUnlit List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
static const enum Material::ShaderType MaterialType =
Material::SHADERTYPE_SOLID_UNLIT;
static const enum InstanceType Instance = InstanceTypeDualTex;
static const STK::Tuple<size_t, size_t> FirstPassTextures;
static const STK::Tuple<size_t> SecondPassTextures;
static const STK::Tuple<size_t> ShadowTextures;
static const STK::Tuple<size_t> RSMTextures;
}; // struct UnlitMat
// ----------------------------------------------------------------------------
struct GrassMat
{
typedef InstancedGrassPass1Shader InstancedFirstPassShader;
typedef InstancedGrassPass2Shader InstancedSecondPassShader;
typedef InstancedGrassShadowShader InstancedShadowPassShader;
typedef CInstancedRSMShader InstancedRSMShader;
typedef ListInstancedMatGrass InstancedList;
typedef GrassPass1Shader FirstPassShader;
typedef GrassPass2Shader SecondPassShader;
typedef GrassShadowShader ShadowPassShader;
typedef CRSMShader RSMShader;
typedef ListMatGrass List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
static const enum Material::ShaderType MaterialType
= Material::SHADERTYPE_VEGETATION;
static const enum InstanceType Instance = InstanceTypeDualTex;
static const STK::Tuple<size_t, size_t> FirstPassTextures;
static const STK::Tuple<size_t, size_t> SecondPassTextures;
static const STK::Tuple<size_t> ShadowTextures;
static const STK::Tuple<size_t> RSMTextures;
}; // GrassMat
// ----------------------------------------------------------------------------
struct NormalMat
{
typedef InstancedNormalMapShader InstancedFirstPassShader;
typedef InstancedObjectPass2Shader InstancedSecondPassShader;
typedef InstancedShadowShader InstancedShadowPassShader;
typedef CInstancedRSMShader InstancedRSMShader;
typedef ListInstancedMatNormalMap InstancedList;
typedef NormalMapShader FirstPassShader;
typedef Shaders::ObjectPass2Shader SecondPassShader;
typedef ShadowShader ShadowPassShader;
typedef CRSMShader RSMShader;
typedef ListMatNormalMap List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_TANGENTS;
static const enum Material::ShaderType MaterialType
= Material::SHADERTYPE_NORMAL_MAP;
static const enum InstanceType Instance = InstanceTypeThreeTex;
static const STK::Tuple<size_t, size_t> FirstPassTextures;
static const STK::Tuple<size_t, size_t> SecondPassTextures;
static const STK::Tuple<> ShadowTextures;
static const STK::Tuple<size_t> RSMTextures;
}; // NormalMat
// ----------------------------------------------------------------------------
struct DetailMat
{
typedef InstancedObjectPass1Shader InstancedFirstPassShader;
typedef InstancedDetailedObjectPass2Shader InstancedSecondPassShader;
typedef InstancedShadowShader InstancedShadowPassShader;
typedef CInstancedRSMShader InstancedRSMShader;
typedef ListInstancedMatDetails InstancedList;
typedef Shaders::ObjectPass1Shader FirstPassShader;
typedef DetailedObjectPass2Shader SecondPassShader;
typedef ShadowShader ShadowPassShader;
typedef CRSMShader RSMShader;
typedef ListMatDetails List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_2TCOORDS;
static const enum Material::ShaderType MaterialType
= Material::SHADERTYPE_DETAIL_MAP;
static const enum InstanceType Instance = InstanceTypeThreeTex;
static const STK::Tuple<size_t> FirstPassTextures;
static const STK::Tuple<size_t, size_t, size_t> SecondPassTextures;
static const STK::Tuple<> ShadowTextures;
static const STK::Tuple<size_t> RSMTextures;
}; // DetailMat
// ----------------------------------------------------------------------------
struct SplattingMat
{
typedef Shaders::ObjectPass1Shader FirstPassShader;
typedef SplattingShader SecondPassShader;
typedef ShadowShader ShadowPassShader;
typedef SplattingRSMShader RSMShader;
typedef ListMatSplatting List;
static const enum video::E_VERTEX_TYPE VertexType = video::EVT_2TCOORDS;
static const STK::Tuple<size_t> FirstPassTextures;
static const STK::Tuple<size_t, size_t, size_t, size_t, size_t> SecondPassTextures;
static const STK::Tuple<> ShadowTextures;
static const STK::Tuple<size_t, size_t, size_t, size_t, size_t> RSMTextures;
}; // SplattingMat
#endif //HEADER_MATERIAL_TYPE_HPP