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

Test converting code to home-brew Tuple so that STK compiles again on my mac, where clang does not include tuple

Browse Source
This commit is contained in:
Marianne Gagnon
2014-07-15 19:48:34 -04:00
parent a3dbb53540
commit 797dcf845e
7 changed files with 189 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
src/graphics/render_geometry.cpp
View File

@@ -28,6 +28,7 @@
#include "utils/helpers.hpp"
#include "utils/log.hpp"
#include "utils/profiler.hpp"
#include "utils/tuple.hpp"
#include <algorithm>
@@ -36,9 +37,9 @@ template<unsigned N>
struct unroll_args_instance
{
template<typename T, typename ...TupleTypes, typename ...Args>
static void exec(const T *Shader, const std::tuple<TupleTypes...> &t, Args... args)
static void exec(const T *Shader, const STK::Tuple<TupleTypes...> &t, Args... args)
{
unroll_args_instance<N - 1>::template exec<T>(Shader, t, std::get<N - 1>(t), args...);
unroll_args_instance<N - 1>::template exec<T>(Shader, t, STK::tuple_get<N - 1>(t), args...);
}
};
@@ -46,26 +47,27 @@ template<>
struct unroll_args_instance<0>
{
template<typename T, typename ...TupleTypes, typename ...Args>
static void exec(const T *Shader, const std::tuple<TupleTypes...> &t, Args... args)
static void exec(const T *Shader, const STK::Tuple<TupleTypes...> &t, Args... args)
{
draw<T>(Shader, args...);
}
};
template<typename T, typename... TupleType>
void apply_instance(const T *Shader, const std::tuple<TupleType...> &arg)
void apply_instance(const T *Shader, const STK::Tuple<TupleType...> &arg)
{
unroll_args_instance<std::tuple_size<std::tuple<TupleType...> >::value >::template exec<T>(Shader, arg);
unroll_args_instance<sizeof...(TupleType)>::template exec<T>(Shader, arg);
//unroll_args_instance<STK::TupleSize<STK::Tuple<TupleType...> >::value >::template exec<T>(Shader, arg);
}
template<typename Shader, enum E_VERTEX_TYPE VertexType, typename... TupleType>
void renderMeshes1stPass(const std::vector<GLuint> &TexUnits, std::vector<std::tuple<TupleType...> > &meshes)
void renderMeshes1stPass(const std::vector<GLuint> &TexUnits, std::vector<STK::Tuple<TupleType...> > &meshes)
{
glUseProgram(Shader::getInstance<Shader>()->Program);
glBindVertexArray(getVAO(VertexType));
for (unsigned i = 0; i < meshes.size(); i++)
{
GLMesh &mesh = *(std::get<0>(meshes[i]));
GLMesh &mesh = *(STK::tuple_get<0>(meshes[i]));
for (unsigned j = 0; j < TexUnits.size(); j++)
{
if (!mesh.textures[j])
@@ -118,13 +120,13 @@ void IrrDriver::renderSolidFirstPass()
}
template<typename T, enum E_VERTEX_TYPE VertexType, typename... TupleType>
void renderMeshes2ndPass(const T *Shader, const std::vector<GLuint> &TexUnits, std::vector<std::tuple<TupleType...> > &meshes)
void renderMeshes2ndPass(const T *Shader, const std::vector<GLuint> &TexUnits, std::vector<STK::Tuple<TupleType...> > &meshes)
{
glUseProgram(Shader->Program);
glBindVertexArray(getVAO(VertexType));
for (unsigned i = 0; i < meshes.size(); i++)
{
GLMesh &mesh = *(std::get<0>(meshes[i]));
GLMesh &mesh = *(STK::tuple_get<0>(meshes[i]));
for (unsigned j = 0; j < TexUnits.size(); j++)
{
if (!mesh.textures[j])
@@ -266,8 +268,8 @@ void IrrDriver::renderTransparent()
irr_driver->getFBO(FBO_TMP1_WITH_DS).Bind();
for (unsigned i = 0; i < ListDisplacement::Arguments.size(); i++)
{
const GLMesh &mesh = *(std::get<0>(ListDisplacement::Arguments[i]));
const core::matrix4 &AbsoluteTransformation = std::get<1>(ListDisplacement::Arguments[i]);
const GLMesh &mesh = *(STK::tuple_get<0>(ListDisplacement::Arguments[i]));
const core::matrix4 &AbsoluteTransformation = STK::tuple_get<1>(ListDisplacement::Arguments[i]);
if (mesh.VAOType != video::EVT_2TCOORDS)
{
#ifdef DEBUG
@@ -290,8 +292,8 @@ void IrrDriver::renderTransparent()
displaceTex = irr_driver->getTexture(FileManager::TEXTURE, "displace.png");
for (unsigned i = 0; i < ListDisplacement::Arguments.size(); i++)
{
const GLMesh &mesh = *(std::get<0>(ListDisplacement::Arguments[i]));
const core::matrix4 &AbsoluteTransformation = std::get<1>(ListDisplacement::Arguments[i]);
const GLMesh &mesh = *(STK::tuple_get<0>(ListDisplacement::Arguments[i]));
const core::matrix4 &AbsoluteTransformation = STK::tuple_get<1>(ListDisplacement::Arguments[i]);
if (mesh.VAOType != video::EVT_2TCOORDS)
continue;
@@ -319,13 +321,13 @@ void IrrDriver::renderTransparent()
}
template<typename T, enum E_VERTEX_TYPE VertexType, typename... Args>
void drawShadow(const T *Shader, const std::vector<GLuint> TextureUnits, const std::vector<std::tuple<GLMesh *, core::matrix4, Args...> >&t)
void drawShadow(const T *Shader, const std::vector<GLuint> TextureUnits, const std::vector<STK::Tuple<GLMesh *, core::matrix4, Args...> >&t)
{
glUseProgram(Shader->Program);
glBindVertexArray(getVAO(VertexType));
for (unsigned i = 0; i < t.size(); i++)
{
const GLMesh *mesh = std::get<0>(t[i]);
const GLMesh *mesh = STK::tuple_get<0>(t[i]);
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh->PrimitiveType;
GLenum itype = mesh->IndexType;
@@ -336,18 +338,18 @@ void drawShadow(const T *Shader, const std::vector<GLuint> TextureUnits, const s
setTexture(TextureUnits[j], getTextureGLuint(mesh->textures[j]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
}
Shader->setUniforms(std::get<1>(t[i]));
Shader->setUniforms(STK::tuple_get<1>(t[i]));
glDrawElementsInstancedBaseVertex(ptype, count, itype, (GLvoid *)mesh->vaoOffset, 4, mesh->vaoBaseVertex);
}
}
static void drawShadowGrass(const std::vector<GLuint> TextureUnits, const std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, core::vector3df> > &t)
static void drawShadowGrass(const std::vector<GLuint> TextureUnits, const std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::vector3df> > &t)
{
glUseProgram(MeshShader::GrassShadowShaderInstance->Program);
glBindVertexArray(getVAO(EVT_STANDARD));
for (unsigned i = 0; i < t.size(); i++)
{
const GLMesh *mesh = std::get<0>(t[i]);
const GLMesh *mesh = STK::tuple_get<0>(t[i]);
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh->PrimitiveType;
GLenum itype = mesh->IndexType;
@@ -358,25 +360,25 @@ static void drawShadowGrass(const std::vector<GLuint> TextureUnits, const std::v
setTexture(TextureUnits[j], getTextureGLuint(mesh->textures[j]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
}
MeshShader::GrassShadowShaderInstance->setUniforms(std::get<1>(t[i]), std::get<3>(t[i]));
MeshShader::GrassShadowShaderInstance->setUniforms(STK::tuple_get<1>(t[i]), STK::tuple_get<3>(t[i]));
glDrawElementsInstancedBaseVertex(ptype, count, itype, (GLvoid *)mesh->vaoOffset, 4, mesh->vaoBaseVertex);
}
}
template<enum E_VERTEX_TYPE VertexType, typename... Args>
void drawRSM(const core::matrix4 & rsm_matrix, const std::vector<GLuint> TextureUnits, const std::vector<std::tuple<GLMesh *, core::matrix4, Args...> >&t)
void drawRSM(const core::matrix4 & rsm_matrix, const std::vector<GLuint> TextureUnits, const std::vector<STK::Tuple<GLMesh *, core::matrix4, Args...> >&t)
{
glUseProgram(MeshShader::RSMShader::Program);
glBindVertexArray(getVAO(VertexType));
for (unsigned i = 0; i < t.size(); i++)
{
const GLMesh *mesh = std::get<0>(t[i]);
const GLMesh *mesh = STK::tuple_get<0>(t[i]);
for (unsigned j = 0; j < TextureUnits.size(); j++)
{
compressTexture(mesh->textures[j], true);
setTexture(TextureUnits[j], getTextureGLuint(mesh->textures[j]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
}
draw<MeshShader::RSMShader>(mesh, rsm_matrix, std::get<1>(t[i]));
draw<MeshShader::RSMShader>(mesh, rsm_matrix, STK::tuple_get<1>(t[i]));
}
}

25
src/graphics/stkanimatedmesh.cpp
View File

@@ -8,6 +8,7 @@
#include "tracks/track.hpp"
#include "graphics/camera.hpp"
#include "utils/profiler.hpp"
#include "utils/tuple.hpp"
using namespace irr;
@@ -145,13 +146,13 @@ void STKAnimatedMesh::render()
GLMesh* mesh;
for_in(mesh, GeometricMesh[FPSM_DEFAULT_STANDARD])
ListDefaultStandardG::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel));
ListDefaultStandardG::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, invmodel));
for_in(mesh, GeometricMesh[FPSM_DEFAULT_2TCOORD])
ListDefault2TCoordG::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel));
ListDefault2TCoordG::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, invmodel));
for_in(mesh, GeometricMesh[FPSM_ALPHA_REF_TEXTURE])
ListAlphaRefG::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix));
ListAlphaRefG::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix));
return;
}
@@ -163,19 +164,19 @@ void STKAnimatedMesh::render()
GLMesh* mesh;
for_in(mesh, ShadedMesh[SM_DEFAULT_STANDARD])
ListDefaultStandardSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
ListDefaultStandardSM::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
for_in(mesh, ShadedMesh[SM_DEFAULT_TANGENT])
ListDefaultTangentSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
ListDefaultTangentSM::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
for_in(mesh, ShadedMesh[SM_ALPHA_REF_TEXTURE])
ListAlphaRefSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
ListAlphaRefSM::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
for_in (mesh, ShadedMesh[SM_UNLIT])
ListUnlitSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation));
ListUnlitSM::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation));
for_in(mesh, ShadedMesh[SM_DETAILS])
ListDetailSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, irr_driver->getSceneManager()->getAmbientLight()));
ListDetailSM::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, irr_driver->getSceneManager()->getAmbientLight()));
return;
}
@@ -206,20 +207,20 @@ void STKAnimatedMesh::render()
for_in(mesh, TransparentMesh[TM_DEFAULT])
ListBlendTransparentFog::Arguments.push_back(
std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix,
STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix,
fogmax, startH, endH, start, end, col));
for_in(mesh, TransparentMesh[TM_ADDITIVE])
ListAdditiveTransparentFog::Arguments.push_back(
std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix,
STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix,
fogmax, startH, endH, start, end, col));
}
else
{
for_in(mesh, TransparentMesh[TM_DEFAULT])
ListBlendTransparent::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix));
ListBlendTransparent::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix));
for_in(mesh, TransparentMesh[TM_ADDITIVE])
ListAdditiveTransparent::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix));
ListAdditiveTransparent::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix));
}
return;
}

36
src/graphics/stkmesh.cpp
View File

@@ -307,22 +307,22 @@ bool isObject(video::E_MATERIAL_TYPE type)
return false;
}
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > ListDefaultStandardG::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > ListDefault2TCoordG::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > ListAlphaRefG::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > ListNormalG::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, core::vector3df> > ListGrassG::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > ListDefaultStandardG::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > ListDefault2TCoordG::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > ListAlphaRefG::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > ListNormalG::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::vector3df> > ListGrassG::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > ListDefaultStandardSM::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > ListDefaultTangentSM::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > ListAlphaRefSM::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, video::SColorf> > ListSplattingSM::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > ListSphereMapSM::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4> > ListUnlitSM::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, video::SColorf> > ListDetailSM::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > ListBlendTransparent::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > ListAdditiveTransparent::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4> > ListDisplacement::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > ListBlendTransparentFog::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > ListAdditiveTransparentFog::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::vector3df, video::SColorf> > ListGrassSM::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > ListDefaultStandardSM::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > ListDefaultTangentSM::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > ListAlphaRefSM::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, video::SColorf> > ListSplattingSM::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > ListSphereMapSM::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4> > ListUnlitSM::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, video::SColorf> > ListDetailSM::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > ListBlendTransparent::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > ListAdditiveTransparent::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4> > ListDisplacement::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > ListBlendTransparentFog::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > ListAdditiveTransparentFog::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::vector3df, video::SColorf> > ListGrassSM::Arguments;

39
src/graphics/stkmesh.hpp
View File

@@ -3,12 +3,13 @@
#include "graphics/glwrap.hpp"
#include "graphics/irr_driver.hpp"
#include "utils/tuple.hpp"
#include <IMeshSceneNode.h>
#include <IMesh.h>
#include "../lib/irrlicht/source/Irrlicht/CMeshSceneNode.h"
#include <tuple>
//#include <STK::Tuple>
#include <vector>
enum GeometricMaterial
@@ -72,31 +73,31 @@ core::vector3df getWind();
class ListDefaultStandardG
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
};
class ListDefault2TCoordG
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
};
class ListAlphaRefG
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > Arguments;
};
class ListNormalG
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
};
class ListGrassG
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, core::vector3df> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::vector3df> > Arguments;
};
template<typename Shader, typename...uniforms>
@@ -128,79 +129,79 @@ void draw(const T *Shader, const GLMesh *mesh, uniforms... Args)
class ListDefaultStandardSM
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > Arguments;
};
class ListDefaultTangentSM
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > Arguments;
};
class ListAlphaRefSM
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > Arguments;
};
class ListSphereMapSM
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > Arguments;
};
class ListSplattingSM
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, video::SColorf> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, video::SColorf> > Arguments;
};
class ListUnlitSM
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4> > Arguments;
};
class ListDetailSM
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, video::SColorf> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, video::SColorf> > Arguments;
};
class ListGrassSM
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::vector3df, video::SColorf> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::vector3df, video::SColorf> > Arguments;
};
class ListBlendTransparent
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
};
class ListAdditiveTransparent
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
};
class ListBlendTransparentFog
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > Arguments;
};
class ListAdditiveTransparentFog
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > Arguments;
};
class ListDisplacement
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4> > Arguments;
};
// Forward pass (for transparents meshes)

39
src/graphics/stkmeshscenenode.cpp
View File

@@ -6,9 +6,10 @@
#include <IMaterialRenderer.h>
#include "config/user_config.hpp"
#include "graphics/callbacks.hpp"
#include "utils/helpers.hpp"
#include "graphics/camera.hpp"
#include "modes/world.hpp"
#include "utils/helpers.hpp"
#include "utils/tuple.hpp"
STKMeshSceneNode::STKMeshSceneNode(irr::scene::IMesh* mesh, ISceneNode* parent, irr::scene::ISceneManager* mgr, irr::s32 id,
const irr::core::vector3df& position,
@@ -248,20 +249,20 @@ void STKMeshSceneNode::render()
GLMesh* mesh;
for_in(mesh, GeometricMesh[FPSM_DEFAULT_STANDARD])
ListDefaultStandardG::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel));
ListDefaultStandardG::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, invmodel));
for_in(mesh, GeometricMesh[FPSM_DEFAULT_2TCOORD])
ListDefault2TCoordG::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel));
ListDefault2TCoordG::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, invmodel));
for_in(mesh, GeometricMesh[FPSM_ALPHA_REF_TEXTURE])
ListAlphaRefG::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix));
ListAlphaRefG::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix));
for_in(mesh, GeometricMesh[FPSM_NORMAL_MAP])
ListNormalG::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel));
ListNormalG::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, invmodel));
windDir = getWind();
for_in(mesh, GeometricMesh[FPSM_GRASS])
ListGrassG::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel, windDir));
ListGrassG::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, invmodel, windDir));
return;
}
@@ -299,28 +300,28 @@ void STKMeshSceneNode::render()
GLMesh* mesh;
for_in(mesh, ShadedMesh[SM_DEFAULT_STANDARD])
ListDefaultStandardSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
ListDefaultStandardSM::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
for_in(mesh, ShadedMesh[SM_DEFAULT_TANGENT])
ListDefaultTangentSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
ListDefaultTangentSM::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
for_in(mesh, ShadedMesh[SM_ALPHA_REF_TEXTURE])
ListAlphaRefSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
ListAlphaRefSM::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
for_in(mesh, ShadedMesh[SM_SPHEREMAP])
ListSphereMapSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel, irr_driver->getSceneManager()->getAmbientLight()));
ListSphereMapSM::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, invmodel, irr_driver->getSceneManager()->getAmbientLight()));
for_in(mesh, ShadedMesh[SM_SPLATTING])
ListSplattingSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, irr_driver->getSceneManager()->getAmbientLight()));
ListSplattingSM::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, irr_driver->getSceneManager()->getAmbientLight()));
for_in(mesh, ShadedMesh[SM_UNLIT])
ListUnlitSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation));
ListUnlitSM::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation));
for_in(mesh, ShadedMesh[SM_DETAILS])
ListDetailSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, irr_driver->getSceneManager()->getAmbientLight()));
ListDetailSM::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, irr_driver->getSceneManager()->getAmbientLight()));
for_in(mesh, ShadedMesh[SM_GRASS])
ListGrassSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, windDir, irr_driver->getSceneManager()->getAmbientLight()));
ListGrassSM::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, windDir, irr_driver->getSceneManager()->getAmbientLight()));
return;
}
@@ -427,24 +428,24 @@ void STKMeshSceneNode::render()
for_in(mesh, TransparentMesh[TM_DEFAULT])
ListBlendTransparentFog::Arguments.push_back(
std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix,
STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix,
fogmax, startH, endH, start, end, col));
for_in(mesh, TransparentMesh[TM_ADDITIVE])
ListAdditiveTransparentFog::Arguments.push_back(
std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix,
STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix,
fogmax, startH, endH, start, end, col));
}
else
{
for_in(mesh, TransparentMesh[TM_DEFAULT])
ListBlendTransparent::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix));
ListBlendTransparent::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix));
for_in(mesh, TransparentMesh[TM_ADDITIVE])
ListAdditiveTransparent::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix));
ListAdditiveTransparent::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix));
}
for_in(mesh, TransparentMesh[TM_DISPLACEMENT])
ListDisplacement::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation));
ListDisplacement::Arguments.push_back(STK::make_tuple(mesh, AbsoluteTransformation));
if (!TransparentMesh[TM_BUBBLE].empty())
glUseProgram(MeshShader::BubbleShader::Program);

7
src/main.cpp
View File

@@ -201,6 +201,7 @@
#include "utils/leak_check.hpp"
#include "utils/log.hpp"
#include "utils/translation.hpp"
#include "utils/tuple.hpp"
static void cleanSuperTuxKart();
static void cleanUserConfig();
@@ -1162,6 +1163,12 @@ void askForInternetPermission()
// ----------------------------------------------------------------------------
int main(int argc, char *argv[] )
{
STK::Tuple<int, float, std::string> tup(1, 3.14f, "Hello");
auto tup2 = STK::make_tuple(1, 3.14f, "Hello");
Log::info("TEST", "Tuple 1 : %i %f %s", STK::tuple_get<0>(tup), STK::tuple_get<1>(tup), STK::tuple_get<2>(tup).c_str());
Log::info("TEST", "Tuple 2 : %i %f %s", STK::tuple_get<0>(tup2), STK::tuple_get<1>(tup2), STK::tuple_get<2>(tup2));
CommandLine::init(argc, argv);
CrashReporting::installHandlers();

87
src/utils/tuple.hpp Normal file
View File

@@ -0,0 +1,87 @@
#ifndef __STK_TUPLE_HPP__
#define __STK_TUPLE_HPP__
namespace STK {
// tuple
template<typename... _Types> class Tuple;
// empty tuple
template<> class Tuple<> {};
// recursive tuple definition
template<typename _This, typename... _Rest>
class Tuple<_This, _Rest...> : private Tuple<_Rest...>
{
public:
_This _Elem;
Tuple()
{
}
Tuple(_This val, _Rest... rest) : Tuple<_Rest...>(rest...)
{
_Elem = val;
}
};
// tuple_element
template<size_t _Index, typename _Tuple> struct tuple_element;
// select first element
template<typename _This, typename... _Rest>
struct tuple_element<0, Tuple<_This, _Rest...>>
{
typedef _This& type;
typedef Tuple<_This, _Rest...> _Ttype;
};
// recursive tuple_element definition
template <size_t _Index, typename _This, typename... _Rest>
struct tuple_element<_Index, Tuple<_This, _Rest...>>
: public tuple_element<_Index - 1, Tuple<_Rest...> >
{
};
template<size_t _Index, class... _Types> inline
typename tuple_element<_Index, Tuple<_Types...>>::type
tuple_get(Tuple<_Types...>& _Tuple)
{
typedef typename tuple_element<_Index, Tuple<_Types...>>::_Ttype _Ttype;
return (((_Ttype&)_Tuple)._Elem);
}
template<size_t _Index, class... _Types> inline
typename const tuple_element<_Index, Tuple<_Types...>>::type
tuple_get(const Tuple<_Types...>& _Tuple)
{
typedef typename tuple_element<_Index, Tuple<_Types...>>::_Ttype _Ttype;
return (((_Ttype&)_Tuple)._Elem);
}
template<typename... T> inline
Tuple<T...> make_tuple(T... values)
{
return Tuple<T...>(values...);
}
//template<typename... T>
//int tuple_size(Tuple<T...> tuple)
//{
// return sizeof...(T);
//}
template<typename... T>
struct TupleSize
{
int value;
TupleSize()
{
value = sizeof...(T);
}
};
}
#endif