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

Merge remote-tracking branch 'origin/glossmap'

Browse Source
This commit is contained in:
Vincent Lejeune
2014-09-20 01:57:55 +02:00
parent f526d194dc 1983fb8fc2
commit f6d2ff92f1
19 changed files with 353 additions and 279 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
data/shaders/instanced_detailledobject_pass2.frag
View File

@@ -5,7 +5,7 @@ uniform sampler2D Detail;
#ifdef GL_ARB_bindless_texture
flat in sampler2D handle;
flat in sampler2D secondhandle;
flat in sampler2D thirdhandle;
#endif
in vec2 uv;
in vec2 uv_bis;
@@ -20,7 +20,7 @@ void main(void)
#ifdef SRGBBindlessFix
color.xyz = pow(color.xyz, vec3(2.2));
#endif
vec4 detail = texture(secondhandle, uv_bis);
vec4 detail = texture(thirdhandle, uv_bis);
#else
vec4 color = texture(Albedo, uv);
vec4 detail = texture(Detail, uv_bis);

12
data/shaders/instanced_normalmap.frag
View File

@@ -1,11 +1,11 @@
#ifndef GL_ARB_bindless_texture
uniform sampler2D normalMap;
uniform sampler2D DiffuseForAlpha;
uniform sampler2D glossMap;
#endif
#ifdef GL_ARB_bindless_texture
flat in sampler2D handle;
flat in sampler2D secondhandle;
flat in sampler2D thirdhandle;
#endif
in vec3 tangent;
in vec3 bitangent;
@@ -18,11 +18,11 @@ void main()
{
// normal in Tangent Space
#ifdef GL_ARB_bindless_texture
vec3 TS_normal = 2.0 * texture(secondhandle, uv).rgb - 1.0;
float alpha = texture(handle, uv).a;
vec3 TS_normal = 2.0 * texture(thirdhandle, uv).rgb - 1.0;
float gloss = texture(secondhandle, uv).x;
#else
vec3 TS_normal = 2.0 * texture(normalMap, uv).rgb - 1.0;
float alpha = texture(DiffuseForAlpha, uv).a;
float gloss = texture(glossMap, uv).x;
#endif
// Because of interpolation, we need to renormalize
vec3 Frag_tangent = normalize(tangent);
@@ -31,5 +31,5 @@ void main()
vec3 FragmentNormal = TS_normal.x * Frag_tangent + TS_normal.y * Frag_bitangent - TS_normal.z * Frag_normal;
EncodedNormal.xy = 0.5 * EncodeNormal(normalize(FragmentNormal)) + 0.5;
EncodedNormal.z = exp2(10. * (1. - alpha) + 1.);
EncodedNormal.z = exp2(10. * gloss + 1.);
}

3
data/shaders/instanced_object_pass.vert
View File

@@ -13,6 +13,7 @@ layout(location = 9) in vec3 Scale;
#ifdef GL_ARB_bindless_texture
layout(location = 10) in sampler2D Handle;
layout(location = 11) in sampler2D SecondHandle;
layout(location = 13) in sampler2D ThirdHandle;
#endif
#else
@@ -37,6 +38,7 @@ out vec4 color;
#ifdef GL_ARB_bindless_texture
flat out sampler2D handle;
flat out sampler2D secondhandle;
flat out sampler2D thirdhandle;
#endif
mat4 getWorldMatrix(vec3 translation, vec3 rotation, vec3 scale);
@@ -56,5 +58,6 @@ void main(void)
#ifdef GL_ARB_bindless_texture
handle = Handle;
secondhandle = SecondHandle;
thirdhandle = ThirdHandle;
#endif
}

6
data/shaders/instanced_object_pass1.frag
View File

@@ -1,9 +1,11 @@
#ifndef GL_ARB_bindless_texture
uniform sampler2D tex;
uniform sampler2D glosstex;
#endif
#ifdef GL_ARB_bindless_texture
flat in sampler2D handle;
flat in sampler2D secondhandle;
#endif
in vec3 nor;
in vec2 uv;
@@ -15,9 +17,11 @@ void main(void)
{
#ifdef GL_ARB_bindless_texture
vec4 col = texture(handle, uv);
float glossmap = texture(secondhandle, uv).x;
#else
vec4 col = texture(tex, uv);
float glossmap = texture(glosstex, uv).x;
#endif
EncodedNormal.xy = 0.5 * EncodeNormal(normalize(nor)) + 0.5;
EncodedNormal.z = exp2(10. * (1. - col.a) + 1.);
EncodedNormal.z = exp2(10. * glossmap + 1.);
}

6
data/shaders/instanced_objectref_pass1.frag
View File

@@ -1,9 +1,11 @@
#ifndef GL_ARB_bindless_texture
uniform sampler2D tex;
uniform sampler2D glosstex;
#endif
#ifdef GL_ARB_bindless_texture
flat in sampler2D handle;
flat in sampler2D secondhandle;
#endif
in vec3 nor;
in vec2 uv;
@@ -14,12 +16,14 @@ vec2 EncodeNormal(vec3 n);
void main() {
#ifdef GL_ARB_bindless_texture
vec4 col = texture(handle, uv);
float glossmap = texture(secondhandle, uv).x;
#else
vec4 col = texture(tex, uv);
float glossmap = texture(glosstex, uv).x;
#endif
if (col.a < 0.5)
discard;
EncodedNormal.xy = 0.5 * EncodeNormal(normalize(nor)) + 0.5;
EncodedNormal.z = 1.;
EncodedNormal.z = exp2(10. * glossmap + 1.);
}

2
src/graphics/glwrap.hpp
View File

@@ -16,7 +16,7 @@ namespace HardwareStats
void initGL();
GLuint LoadTFBProgram(const char * vertex_file_path, const char **varyings, unsigned varyingscount);
video::ITexture* getUnicolorTexture(video::SColor c);
video::ITexture* getUnicolorTexture(const video::SColor &c);
void setTexture(unsigned TextureUnit, GLuint TextureId, GLenum MagFilter, GLenum MinFilter, bool allowAF = false);
GLuint LoadShader(const char * file, unsigned type);

337
src/graphics/material.cpp
View File

@@ -37,6 +37,7 @@
#include "modes/world.hpp"
#include "tracks/track.hpp"
#include "utils/log.hpp"
#include "graphics/glwrap.hpp"
#include <IMaterialRendererServices.h>
#include <ISceneNode.h>
@@ -50,9 +51,8 @@ const unsigned int VCLAMP = 2;
//-----------------------------------------------------------------------------
/** Create a new material using the parameters specified in the xml file.
* \param node Node containing the parameters for this material.
* \param index Index in material_manager.
*/
Material::Material(const XMLNode *node, int index, bool deprecated)
Material::Material(const XMLNode *node, bool deprecated)
{
m_shader_type = SHADERTYPE_SOLID;
m_deprecated = deprecated;
@@ -64,7 +64,7 @@ Material::Material(const XMLNode *node, int index, bool deprecated)
throw std::runtime_error("[Material] No texture name specified "
"in file\n");
}
init(index);
init();
bool b = false;
@@ -396,26 +396,25 @@ Material::Material(const XMLNode *node, int index, bool deprecated)
//-----------------------------------------------------------------------------
/** Create a standard material using the default settings for materials.
* \param fname Name of the texture file.
* \param index Unique index in material_manager.
* \param is_full_path If the fname contains the full path.
*/
Material::Material(const std::string& fname, int index, bool is_full_path,
bool complain_if_not_found)
Material::Material(const std::string& fname, bool is_full_path,
bool complain_if_not_found, bool load_texture)
{
m_deprecated = false;
m_texname = fname;
init(index);
install(is_full_path, complain_if_not_found);
init();
if (load_texture)
install(is_full_path, complain_if_not_found);
} // Material
//-----------------------------------------------------------------------------
/** Inits all material data with the default settings.
* \param Index of this material in the material_manager index array.
*/
void Material::init(unsigned int index)
void Material::init()
{
m_index = index;
m_clamp_tex = 0;
m_shader_type = SHADERTYPE_SOLID;
//m_lightmap = false;
@@ -679,10 +678,6 @@ void Material::setSFXSpeed(SFXBase *sfx, float speed, bool should_be_paused) con
*/
void Material::setMaterialProperties(video::SMaterial *m, scene::IMeshBuffer* mb)
{
// !!======== This method is only called for materials that can be found in
// materials.xml, if you want to set flags for all surfaces, see
// 'MaterialManager::setAllMaterialFlags'
if (m_deprecated ||
(m->getTexture(0) != NULL &&
((core::stringc)m->getTexture(0)->getName()).find("deprecated") != -1))
@@ -691,20 +686,138 @@ void Material::setMaterialProperties(video::SMaterial *m, scene::IMeshBuffer* m
m_texname.c_str());
}
if (m_shader_type == SHADERTYPE_SOLID_UNLIT)
if (irr_driver->isGLSL())
{
if (irr_driver->isGLSL())
ITexture *tex;
ITexture *glossytex;
if (m_gloss_map.size() > 0)
{
m->MaterialType = irr_driver->getShader(ES_OBJECT_UNLIT);
glossytex = irr_driver->getTexture(m_gloss_map);
}
else
{
m->AmbientColor = video::SColor(255, 255, 255, 255);
m->DiffuseColor = video::SColor(255, 255, 255, 255);
m->EmissiveColor = video::SColor(255, 255, 255, 255);
m->SpecularColor = video::SColor(255, 255, 255, 255);
glossytex = getUnicolorTexture(SColor(0., 0., 0., 0.));
}
switch (m_shader_type)
{
case SHADERTYPE_SOLID_UNLIT:
m->MaterialType = irr_driver->getShader(ES_OBJECT_UNLIT);
m->setTexture(1, glossytex);
return;
case SHADERTYPE_ALPHA_TEST:
m->MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
m->setTexture(1, glossytex);
return;
case SHADERTYPE_ALPHA_BLEND:
m->MaterialType = video::EMT_ONETEXTURE_BLEND;
m->MaterialTypeParam =
pack_textureBlendFunc(video::EBF_SRC_ALPHA,
video::EBF_ONE_MINUS_SRC_ALPHA,
video::EMFN_MODULATE_1X,
video::EAS_TEXTURE | video::EAS_VERTEX_COLOR);
return;
case SHADERTYPE_ADDITIVE:
m->MaterialType = video::EMT_ONETEXTURE_BLEND;
m->MaterialTypeParam = pack_textureBlendFunc(video::EBF_SRC_ALPHA,
video::EBF_ONE,
video::EMFN_MODULATE_1X,
video::EAS_TEXTURE |
video::EAS_VERTEX_COLOR);
return;
case SHADERTYPE_SPHERE_MAP:
m->MaterialType = irr_driver->getShader(ES_SPHERE_MAP);
m->setTexture(1, glossytex);
return;
case SHADERTYPE_SPLATTING:
tex = irr_driver->getTexture(m_splatting_texture_1);
m->setTexture(2, tex);
if (m_splatting_texture_2.size() > 0)
{
tex = irr_driver->getTexture(m_splatting_texture_2);
}
m->setTexture(3, tex);
if (m_splatting_texture_3.size() > 0)
{
tex = irr_driver->getTexture(m_splatting_texture_3);
}
m->setTexture(4, tex);
if (m_splatting_texture_4.size() > 0)
{
tex = irr_driver->getTexture(m_splatting_texture_4);
}
m->setTexture(5, tex);
m->setTexture(6, glossytex);
// Material and shaders
m->MaterialType = irr_driver->getShader(ES_SPLATTING);
return;
case SHADERTYPE_WATER:
m->setTexture(1, irr_driver->getTexture(FileManager::TEXTURE,
"waternormals.jpg"));
m->setTexture(2, irr_driver->getTexture(FileManager::TEXTURE,
"waternormals2.jpg"));
((WaterShaderProvider *)irr_driver->getCallback(ES_WATER))->
setSpeed(m_water_shader_speed_1 / 100.0f, m_water_shader_speed_2 / 100.0f);
m->MaterialType = irr_driver->getShader(ES_WATER);
return;
case SHADERTYPE_VEGETATION:
// Only one grass speed & amplitude per map for now
((GrassShaderProvider *)irr_driver->getCallback(ES_GRASS))->
setSpeed(m_grass_speed);
((GrassShaderProvider *)irr_driver->getCallback(ES_GRASS))->
setAmplitude(m_grass_amplitude);
m->MaterialType = irr_driver->getShader(ES_GRASS_REF);
m->setTexture(1, glossytex);
return;
case SHADERTYPE_BUBBLE:
if (mb)
{
BubbleEffectProvider * bubble = (BubbleEffectProvider *)
irr_driver->getCallback(ES_BUBBLES);
bubble->addBubble(mb);
m->MaterialType = irr_driver->getShader(ES_BUBBLES);
m->BlendOperation = video::EBO_ADD;
}
return;
}
if (!m->getTexture(0))
m->setTexture(0, getUnicolorTexture(SColor(255, 255, 255, 255)));
if (m_normal_map_tex.size() > 0)
{
tex = irr_driver->getTexture(m_normal_map_tex);
m->setTexture(2, tex);
// Material and shaders
m->MaterialType = irr_driver->getShader(ES_NORMAL_MAP);
m->setTexture(1, glossytex);
return;
}
// Detail map : move it to slot 3 and add glossy to slot 2
if (mb && mb->getVertexType() == video::EVT_2TCOORDS)
{
m->setTexture(2, m->getTexture(1));
if (!m->getTexture(2))
m->setTexture(2, getUnicolorTexture(SColor(255, 255, 255, 255)));
}
m->setTexture(1, glossytex);
}
if (m_shader_type == SHADERTYPE_SOLID_UNLIT)
{
m->AmbientColor = video::SColor(255, 255, 255, 255);
m->DiffuseColor = video::SColor(255, 255, 255, 255);
m->EmissiveColor = video::SColor(255, 255, 255, 255);
m->SpecularColor = video::SColor(255, 255, 255, 255);
}
if (m_shader_type == SHADERTYPE_ALPHA_TEST)
@@ -725,127 +838,33 @@ void Material::setMaterialProperties(video::SMaterial *m, scene::IMeshBuffer* m
video::EAS_TEXTURE | video::EAS_VERTEX_COLOR);
}
if (m_shader_type == SHADERTYPE_SPHERE_MAP)
{
if (irr_driver->isGLSL())
{
m->MaterialType = irr_driver->getShader(ES_SPHERE_MAP);
}
else
{
m->MaterialType = video::EMT_SPHERE_MAP;
}
}
//if (m_lightmap)
//{
// m->MaterialType = video::EMT_LIGHTMAP;
//}
if (m_shader_type == SHADERTYPE_ADDITIVE)
{
// EMT_TRANSPARENT_ADD_COLOR doesn't include vertex color alpha into
// account, which messes up fading in/out effects. So we use the
// more customizable EMT_ONETEXTURE_BLEND instead
m->MaterialType = video::EMT_ONETEXTURE_BLEND ;
m->MaterialType = video::EMT_ONETEXTURE_BLEND;
m->MaterialTypeParam = pack_textureBlendFunc(video::EBF_SRC_ALPHA,
video::EBF_ONE,
video::EMFN_MODULATE_1X,
video::EAS_TEXTURE |
video::EAS_VERTEX_COLOR);
video::EBF_ONE,
video::EMFN_MODULATE_1X,
video::EAS_TEXTURE |
video::EAS_VERTEX_COLOR);
}
if (m_shader_type == SHADERTYPE_SPHERE_MAP)
{
m->MaterialType = video::EMT_SPHERE_MAP;
}
if (m_shader_type == SHADERTYPE_SOLID && m_normal_map_tex.size() > 0)
{
if (irr_driver->isGLSL())
{
// FIXME; cannot perform this check atm, because setMaterialProperties
// is sometimes called before calculating tangents
//if (mb->getVertexType() != video::EVT_TANGENTS)
//{
// Log::warn("material", "Requiring normal map without tangent enabled mesh for <%s>",
// m_texname.c_str());
//}
ITexture* tex = irr_driver->getTexture(m_normal_map_tex);
m->setTexture(1, tex);
bool with_lightmap = false;
//if (m_normal_map_shader_lightmap.size() > 0)
//{
// ITexture* lm_tex = irr_driver->getTexture(m_normal_map_shader_lightmap);
// m->setTexture(2, lm_tex);
// with_lightmap = true;
//}
// Material and shaders
m->MaterialType = irr_driver->getShader(
with_lightmap ? ES_NORMAL_MAP_LIGHTMAP : ES_NORMAL_MAP);
m->Lighting = false;
m->ZWriteEnable = true;
}
else
{
// remove normal map texture so that it's not blended with the rest
m->setTexture(1, NULL);
}
// remove normal map texture so that it's not blended with the rest
m->setTexture(1, NULL);
}
//if (m_parallax_map)
//{
// video::ITexture* tex = irr_driver->getTexture(m_normal_map_tex);
// if (m_is_heightmap)
// {
// irr_driver->getVideoDriver()->makeNormalMapTexture( tex );
// }
// m->setTexture(1, tex);
// m->MaterialType = video::EMT_PARALLAX_MAP_SOLID;
// m->MaterialTypeParam = m_parallax_height;
// m->SpecularColor.set(0,0,0,0);
// modes++;
//}
//if(m_graphical_effect == GE_SKYBOX && irr_driver->isGLSL())
//{
// ITexture* tex = irr_driver->getTexture("cloud_mask.png");
// m->setTexture(1, tex);
//
//
// m->MaterialType = irr_driver->getShader(ES_SKYBOX);
//}
if (m_shader_type == SHADERTYPE_SPLATTING)
{
if (irr_driver->supportsSplatting())
{
ITexture* tex = irr_driver->getTexture(m_splatting_texture_1);
m->setTexture(2, tex);
if (m_splatting_texture_2.size() > 0)
{
tex = irr_driver->getTexture(m_splatting_texture_2);
}
m->setTexture(3, tex);
if (m_splatting_texture_3.size() > 0)
{
tex = irr_driver->getTexture(m_splatting_texture_3);
}
m->setTexture(4, tex);
if (m_splatting_texture_4.size() > 0)
{
tex = irr_driver->getTexture(m_splatting_texture_4);
}
m->setTexture(5, tex);
// Material and shaders
m->MaterialType = irr_driver->getShader(ES_SPLATTING);
}
else
{
m->MaterialType = video::EMT_SOLID;
}
m->MaterialType = video::EMT_SOLID;
}
@@ -861,62 +880,9 @@ void Material::setMaterialProperties(video::SMaterial *m, scene::IMeshBuffer* m
m->SpecularColor = video::SColor(255, 255, 255, 255);
}
if (m_shader_type == SHADERTYPE_BUBBLE && mb != NULL)
{
if (irr_driver->isGLSL())
{
BubbleEffectProvider * bubble = (BubbleEffectProvider *)
irr_driver->getCallback(ES_BUBBLES);
bubble->addBubble(mb);
m->MaterialType = irr_driver->getShader(ES_BUBBLES);
m->BlendOperation = video::EBO_ADD;
}
}
if (m_shader_type == SHADERTYPE_WATER)
{
if (irr_driver->isGLSL())
{
m->setTexture(1, irr_driver->getTexture(FileManager::TEXTURE,
"waternormals.jpg"));
m->setTexture(2, irr_driver->getTexture(FileManager::TEXTURE,
"waternormals2.jpg"));
((WaterShaderProvider *) irr_driver->getCallback(ES_WATER))->
setSpeed(m_water_shader_speed_1/100.0f, m_water_shader_speed_2/100.0f);
m->MaterialType = irr_driver->getShader(ES_WATER);
}
}
if (m_shader_type == SHADERTYPE_VEGETATION)
{
if (UserConfigParams::m_weather_effects &&
irr_driver->isGLSL())
{
// Only one grass speed & amplitude per map for now
((GrassShaderProvider *) irr_driver->getCallback(ES_GRASS))->
setSpeed(m_grass_speed);
((GrassShaderProvider *) irr_driver->getCallback(ES_GRASS))->
setAmplitude(m_grass_amplitude);
// Material and shaders
//if (m_alpha_testing)
//{
m->MaterialType = irr_driver->getShader(ES_GRASS_REF);
//}
//else
//{
// m->MaterialType = irr_driver->getShader(ES_GRASS);
// m->BlendOperation = video::EBO_ADD;
//}
}
else
{
m->MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
}
m->MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
}
if (m_disable_z_write)
@@ -985,9 +951,6 @@ void Material::setMaterialProperties(video::SMaterial *m, scene::IMeshBuffer* m
}
#endif
//if (UserConfigParams::m_fullscreen_antialiasing)
// m->AntiAliasing = video::EAAM_LINE_SMOOTH;
} // setMaterialProperties
//-----------------------------------------------------------------------------

13
src/graphics/material.hpp
View File

@@ -81,7 +81,7 @@ public:
private:
video::ITexture *m_texture;
unsigned int m_index;
//unsigned int m_index;
std::string m_texname;
/** Name of a special sfx to play when a kart is on this terrain, or
* "" if no special sfx exists. */
@@ -228,16 +228,17 @@ private:
bool m_deprecated;
void init (unsigned int index);
void init ();
void install (bool is_full_path=false, bool complain_if_not_found=true);
void initCustomSFX(const XMLNode *sfx);
void initParticlesEffect(const XMLNode *node);
public:
Material(const XMLNode *node, int index, bool deprecated);
Material(const std::string& fname, int index,
Material(const XMLNode *node, bool deprecated);
Material(const std::string& fname,
bool is_full_path=false,
bool complain_if_not_found=true);
bool complain_if_not_found=true,
bool load_texture = true);
~Material ();
void setSFXSpeed(SFXBase *sfx, float speed, bool should_be_paused) const;
@@ -261,7 +262,7 @@ public:
bool highTireAdhesion () const { return m_high_tire_adhesion; }
const std::string&
getTexFname () const { return m_texname; }
int getIndex () const { return m_index; }
//int getIndex () const { return m_index; }
bool isTransparent () const
{

18
src/graphics/material_manager.cpp
View File

@@ -40,6 +40,7 @@ MaterialManager::MaterialManager()
{
/* Create list - and default material zero */
m_default_material = NULL;
m_materials.reserve(256);
// We can't call init/loadMaterial here, since the global variable
// material_manager has not yet been initialised, and
@@ -95,6 +96,11 @@ void MaterialManager::setAllMaterialFlags(video::ITexture* t,
return;
}
if (m_default_material == NULL)
m_default_material = new Material("", false, false, false);
m_default_material->setMaterialProperties(&(mb->getMaterial()), mb);
/*
// This material does not appear in materials.xml. Set some common flags...
if (UserConfigParams::m_anisotropic > 0)
{
@@ -132,7 +138,7 @@ void MaterialManager::setAllMaterialFlags(video::ITexture* t,
//if (UserConfigParams::m_fullscreen_antialiasing)
// mb->getMaterial().AntiAliasing = video::EAAM_LINE_SMOOTH;
*/
} // setAllMaterialFlags
//-----------------------------------------------------------------------------
@@ -156,7 +162,7 @@ void MaterialManager::adjustForFog(video::ITexture* t,
//-----------------------------------------------------------------------------
void MaterialManager::setAllUntexturedMaterialFlags(scene::IMeshBuffer *mb) const
void MaterialManager::setAllUntexturedMaterialFlags(scene::IMeshBuffer *mb)
{
irr::video::SMaterial& material = mb->getMaterial();
if (material.getTexture(0) == NULL)
@@ -169,6 +175,10 @@ void MaterialManager::setAllUntexturedMaterialFlags(scene::IMeshBuffer *mb) cons
material.ColorMaterial = irr::video::ECM_DIFFUSE_AND_AMBIENT;
material.MaterialType = irr::video::EMT_SOLID;
}
if (m_default_material == NULL)
m_default_material = new Material("", false, false, false);
m_default_material->setMaterialProperties(&(mb->getMaterial()), mb);
}
//-----------------------------------------------------------------------------
int MaterialManager::addEntity(Material *m)
@@ -244,7 +254,7 @@ bool MaterialManager::pushTempMaterial(const XMLNode *root,
}
try
{
m_materials.push_back(new Material(node, m_materials.size(), deprecated));
m_materials.push_back(new Material(node, deprecated));
}
catch(std::exception& e)
{
@@ -311,7 +321,7 @@ Material *MaterialManager::getMaterial(const std::string& fname,
}
// Add the new material
Material* m=new Material(fname, m_materials.size(), is_full_path, complain_if_not_found);
Material* m = new Material(fname, is_full_path, complain_if_not_found);
m_materials.push_back(m);
if(make_permanent)
{

5
src/graphics/material_manager.hpp
View File

@@ -47,6 +47,9 @@ private:
int m_shared_material_index;
std::vector<Material*> m_materials;
Material* m_default_material;
public:
MaterialManager();
~MaterialManager();
@@ -60,7 +63,7 @@ public:
scene::ISceneNode* parent,
bool use_fog) const;
void setAllUntexturedMaterialFlags(scene::IMeshBuffer *mb) const;
void setAllUntexturedMaterialFlags(scene::IMeshBuffer *mb);
int addEntity (Material *m);
Material *getMaterial (const std::string& t,

70
src/graphics/render_geometry.cpp
View File

@@ -263,41 +263,41 @@ void IrrDriver::renderSolidFirstPass()
if (UserConfigParams::m_azdo)
{
multidraw1stPass<MeshShader::InstancedObjectPass1Shader, MAT_DEFAULT, video::EVT_STANDARD, InstanceTypeSingleTex>();
multidraw1stPass<MeshShader::InstancedObjectRefPass1Shader, MAT_ALPHA_REF, video::EVT_STANDARD, InstanceTypeSingleTex>();
multidraw1stPass<MeshShader::InstancedObjectPass1Shader, MAT_SPHEREMAP, video::EVT_STANDARD, InstanceTypeSingleTex>();
multidraw1stPass<MeshShader::InstancedObjectRefPass1Shader, MAT_UNLIT, video::EVT_STANDARD, InstanceTypeSingleTex>();
multidraw1stPass<MeshShader::InstancedGrassPass1Shader, MAT_GRASS, video::EVT_STANDARD, InstanceTypeSingleTex>(windDir);
multidraw1stPass<MeshShader::InstancedObjectPass1Shader, MAT_DEFAULT, video::EVT_STANDARD, InstanceTypeDualTex>();
multidraw1stPass<MeshShader::InstancedObjectRefPass1Shader, MAT_ALPHA_REF, video::EVT_STANDARD, InstanceTypeDualTex>();
multidraw1stPass<MeshShader::InstancedObjectPass1Shader, MAT_SPHEREMAP, video::EVT_STANDARD, InstanceTypeDualTex>();
multidraw1stPass<MeshShader::InstancedObjectRefPass1Shader, MAT_UNLIT, video::EVT_STANDARD, InstanceTypeDualTex>();
multidraw1stPass<MeshShader::InstancedGrassPass1Shader, MAT_GRASS, video::EVT_STANDARD, InstanceTypeDualTex>(windDir);
multidraw1stPass<MeshShader::InstancedNormalMapShader, MAT_NORMAL_MAP, video::EVT_TANGENTS, InstanceTypeDualTex>();
multidraw1stPass<MeshShader::InstancedObjectPass1Shader, MAT_DETAIL, video::EVT_2TCOORDS, InstanceTypeDualTex>();
multidraw1stPass<MeshShader::InstancedNormalMapShader, MAT_NORMAL_MAP, video::EVT_TANGENTS, InstanceTypeThreeTex>();
multidraw1stPass<MeshShader::InstancedObjectPass1Shader, MAT_DETAIL, video::EVT_2TCOORDS, InstanceTypeThreeTex>();
}
else if (irr_driver->hasARB_draw_indirect())
{
// Default
renderInstancedMeshes1stPass<MeshShader::InstancedObjectPass1Shader, MAT_DEFAULT, video::EVT_STANDARD, InstanceTypeSingleTex>(
TexUnits(TexUnit(0, true)), ListInstancedMatDefault::getInstance()->SolidPass);
renderInstancedMeshes1stPass<MeshShader::InstancedObjectPass1Shader, MAT_DEFAULT, video::EVT_STANDARD, InstanceTypeDualTex>(
TexUnits(TexUnit(0, true), TexUnit(1, false)), ListInstancedMatDefault::getInstance()->SolidPass);
// Alpha ref
renderInstancedMeshes1stPass<MeshShader::InstancedObjectRefPass1Shader, MAT_ALPHA_REF, video::EVT_STANDARD, InstanceTypeSingleTex>(
TexUnits(TexUnit(0, true)), ListInstancedMatAlphaRef::getInstance()->SolidPass);
renderInstancedMeshes1stPass<MeshShader::InstancedObjectRefPass1Shader, MAT_ALPHA_REF, video::EVT_STANDARD, InstanceTypeDualTex>(
TexUnits(TexUnit(0, true), TexUnit(1, false)), ListInstancedMatAlphaRef::getInstance()->SolidPass);
// Unlit
renderInstancedMeshes1stPass<MeshShader::InstancedObjectPass1Shader, MAT_UNLIT, video::EVT_STANDARD, InstanceTypeSingleTex>(
TexUnits(TexUnit(0, true)), ListInstancedMatUnlit::getInstance()->SolidPass);
renderInstancedMeshes1stPass<MeshShader::InstancedObjectPass1Shader, MAT_UNLIT, video::EVT_STANDARD, InstanceTypeDualTex>(
TexUnits(TexUnit(0, true), TexUnit(1, false)), ListInstancedMatUnlit::getInstance()->SolidPass);
// Spheremap
renderInstancedMeshes1stPass<MeshShader::InstancedObjectPass1Shader, MAT_SPHEREMAP, video::EVT_STANDARD, InstanceTypeSingleTex>(
TexUnits(TexUnit(0, true)), ListInstancedMatSphereMap::getInstance()->SolidPass);
renderInstancedMeshes1stPass<MeshShader::InstancedObjectPass1Shader, MAT_SPHEREMAP, video::EVT_STANDARD, InstanceTypeDualTex>(
TexUnits(TexUnit(0, true), TexUnit(1, false)), ListInstancedMatSphereMap::getInstance()->SolidPass);
// Grass
renderInstancedMeshes1stPass<MeshShader::InstancedGrassPass1Shader, MAT_GRASS, video::EVT_STANDARD, InstanceTypeSingleTex>(
renderInstancedMeshes1stPass<MeshShader::InstancedGrassPass1Shader, MAT_GRASS, video::EVT_STANDARD, InstanceTypeDualTex>(
TexUnits(TexUnit(0, true)), ListInstancedMatGrass::getInstance()->SolidPass, windDir);
// Detail
renderInstancedMeshes1stPass<MeshShader::InstancedObjectPass1Shader, MAT_DETAIL, video::EVT_2TCOORDS, InstanceTypeDualTex>(
TexUnits(TexUnit(0, true)), ListInstancedMatDetails::getInstance()->SolidPass);
renderInstancedMeshes1stPass<MeshShader::InstancedObjectPass1Shader, MAT_DETAIL, video::EVT_2TCOORDS, InstanceTypeThreeTex>(
TexUnits(TexUnit(0, true), TexUnit(1, false)), ListInstancedMatDetails::getInstance()->SolidPass);
// Normal Map
renderInstancedMeshes1stPass<MeshShader::InstancedNormalMapShader, MAT_NORMAL_MAP, video::EVT_TANGENTS, InstanceTypeDualTex>(
TexUnits(TexUnit(1, false), TexUnit(0, true)), ListInstancedMatNormalMap::getInstance()->SolidPass);
renderInstancedMeshes1stPass<MeshShader::InstancedNormalMapShader, MAT_NORMAL_MAP, video::EVT_TANGENTS, InstanceTypeThreeTex>(
TexUnits(TexUnit(2, false), TexUnit(1, false)), ListInstancedMatNormalMap::getInstance()->SolidPass);
}
}
}
@@ -443,42 +443,42 @@ void IrrDriver::renderSolidSecondPass()
if (UserConfigParams::m_azdo)
{
multidraw2ndPass<MeshShader::InstancedObjectPass2Shader, MAT_DEFAULT, video::EVT_STANDARD, InstanceTypeSingleTex>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
multidraw2ndPass<MeshShader::InstancedObjectRefPass2Shader, MAT_ALPHA_REF, video::EVT_STANDARD, InstanceTypeSingleTex>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
multidraw2ndPass<MeshShader::InstancedSphereMapShader, MAT_SPHEREMAP, video::EVT_STANDARD, InstanceTypeSingleTex>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
multidraw2ndPass<MeshShader::InstancedObjectUnlitShader, MAT_UNLIT, video::EVT_STANDARD, InstanceTypeSingleTex>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
multidraw2ndPass<MeshShader::InstancedObjectPass2Shader, MAT_DEFAULT, video::EVT_STANDARD, InstanceTypeDualTex>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
multidraw2ndPass<MeshShader::InstancedObjectRefPass2Shader, MAT_ALPHA_REF, video::EVT_STANDARD, InstanceTypeDualTex>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
multidraw2ndPass<MeshShader::InstancedSphereMapShader, MAT_SPHEREMAP, video::EVT_STANDARD, InstanceTypeDualTex>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
multidraw2ndPass<MeshShader::InstancedObjectUnlitShader, MAT_UNLIT, video::EVT_STANDARD, InstanceTypeDualTex>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
SunLightProvider * const cb = (SunLightProvider *)irr_driver->getCallback(ES_SUNLIGHT);
multidraw2ndPass<MeshShader::InstancedGrassPass2Shader, MAT_GRASS, video::EVT_STANDARD, InstanceTypeSingleTex>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, DepthHandle, 0), windDir, cb->getPosition());
multidraw2ndPass<MeshShader::InstancedGrassPass2Shader, MAT_GRASS, video::EVT_STANDARD, InstanceTypeDualTex>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, DepthHandle, 0), windDir, cb->getPosition());
multidraw2ndPass<MeshShader::InstancedObjectPass2Shader, MAT_NORMAL_MAP, video::EVT_TANGENTS, InstanceTypeDualTex>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
multidraw2ndPass<MeshShader::InstancedDetailledObjectPass2Shader, MAT_DETAIL, video::EVT_2TCOORDS, InstanceTypeDualTex>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0));
multidraw2ndPass<MeshShader::InstancedObjectPass2Shader, MAT_NORMAL_MAP, video::EVT_TANGENTS, InstanceTypeThreeTex>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0));
multidraw2ndPass<MeshShader::InstancedDetailledObjectPass2Shader, MAT_DETAIL, video::EVT_2TCOORDS, InstanceTypeThreeTex>(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, 0, 0));
}
else if (irr_driver->hasARB_draw_indirect())
{
// Default
renderInstancedMeshes2ndPass<MeshShader::InstancedObjectPass2Shader, MAT_DEFAULT, video::EVT_STANDARD, InstanceTypeSingleTex>(
renderInstancedMeshes2ndPass<MeshShader::InstancedObjectPass2Shader, MAT_DEFAULT, video::EVT_STANDARD, InstanceTypeDualTex>(
TexUnits(TexUnit(0, true)), DiffSpecSSAOTex, ListInstancedMatDefault::getInstance()->SolidPass);
// Alpha ref
renderInstancedMeshes2ndPass<MeshShader::InstancedObjectRefPass2Shader, MAT_ALPHA_REF, video::EVT_STANDARD, InstanceTypeSingleTex>(
renderInstancedMeshes2ndPass<MeshShader::InstancedObjectRefPass2Shader, MAT_ALPHA_REF, video::EVT_STANDARD, InstanceTypeDualTex>(
TexUnits(TexUnit(0, true)), DiffSpecSSAOTex, ListInstancedMatAlphaRef::getInstance()->SolidPass);
// Unlit
renderInstancedMeshes2ndPass<MeshShader::InstancedObjectUnlitShader, MAT_UNLIT, video::EVT_STANDARD, InstanceTypeSingleTex>(
renderInstancedMeshes2ndPass<MeshShader::InstancedObjectUnlitShader, MAT_UNLIT, video::EVT_STANDARD, InstanceTypeDualTex>(
TexUnits(TexUnit(0, true)), DiffSpecSSAOTex, ListInstancedMatUnlit::getInstance()->SolidPass);
// Spheremap
renderInstancedMeshes2ndPass<MeshShader::InstancedSphereMapShader, MAT_SPHEREMAP, video::EVT_STANDARD, InstanceTypeSingleTex>(
renderInstancedMeshes2ndPass<MeshShader::InstancedSphereMapShader, MAT_SPHEREMAP, video::EVT_STANDARD, InstanceTypeDualTex>(
TexUnits(TexUnit(0, true)), DiffSpecSSAOTex, ListInstancedMatSphereMap::getInstance()->SolidPass);
// Grass
SunLightProvider * const cb = (SunLightProvider *)irr_driver->getCallback(ES_SUNLIGHT);
DiffSpecSSAOTex.push_back(irr_driver->getDepthStencilTexture());
renderInstancedMeshes2ndPass<MeshShader::InstancedGrassPass2Shader, MAT_GRASS, video::EVT_STANDARD, InstanceTypeSingleTex>(
renderInstancedMeshes2ndPass<MeshShader::InstancedGrassPass2Shader, MAT_GRASS, video::EVT_STANDARD, InstanceTypeDualTex>(
TexUnits(TexUnit(0, true)), DiffSpecSSAOTex, ListInstancedMatGrass::getInstance()->SolidPass, windDir, cb->getPosition());
DiffSpecSSAOTex.pop_back();
// Details
renderInstancedMeshes2ndPass<MeshShader::InstancedDetailledObjectPass2Shader, MAT_DETAIL, video::EVT_2TCOORDS, InstanceTypeDualTex>(
TexUnits(TexUnit(0, true), TexUnit(1, false)), DiffSpecSSAOTex, ListInstancedMatDetails::getInstance()->SolidPass);
renderInstancedMeshes2ndPass<MeshShader::InstancedDetailledObjectPass2Shader, MAT_DETAIL, video::EVT_2TCOORDS, InstanceTypeThreeTex>(
TexUnits(TexUnit(0, true), TexUnit(2, false)), DiffSpecSSAOTex, ListInstancedMatDetails::getInstance()->SolidPass);
// Normal map
renderInstancedMeshes2ndPass<MeshShader::InstancedObjectPass2Shader, MAT_NORMAL_MAP, video::EVT_TANGENTS, InstanceTypeDualTex>(
renderInstancedMeshes2ndPass<MeshShader::InstancedObjectPass2Shader, MAT_NORMAL_MAP, video::EVT_TANGENTS, InstanceTypeThreeTex>(
TexUnits(TexUnit(0, true)), DiffSpecSSAOTex, ListInstancedMatNormalMap::getInstance()->SolidPass);
}
}

6
src/graphics/shaders.cpp
View File

@@ -817,7 +817,7 @@ namespace MeshShader
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/instanced_object_pass1.frag").c_str());
AssignUniforms();
AssignSamplerNames(Program, 0, "tex");
AssignSamplerNames(Program, 0, "tex", 1, "glosstex");
}
InstancedObjectRefPass1Shader::InstancedObjectRefPass1Shader()
@@ -829,7 +829,7 @@ namespace MeshShader
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/instanced_objectref_pass1.frag").c_str());
AssignUniforms();
AssignSamplerNames(Program, 0, "tex");
AssignSamplerNames(Program, 0, "tex", 1, "glosstex");
}
InstancedGrassPass1Shader::InstancedGrassPass1Shader()
@@ -851,7 +851,7 @@ namespace MeshShader
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/encode_normal.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/instanced_normalmap.frag").c_str());
AssignUniforms();
AssignSamplerNames(Program, 0, "normalMap", 1, "DiffuseForAlpha");
AssignSamplerNames(Program, 0, "normalMap", 1, "glossMap");
}
// Solid Lit pass shaders

4
src/graphics/shaders.hpp
View File

@@ -77,13 +77,13 @@ public:
NormalMapShader();
};
class InstancedObjectPass1Shader : public ShaderHelperSingleton<InstancedObjectPass1Shader>, public TextureRead<Trilinear_Anisotropic_Filtered>
class InstancedObjectPass1Shader : public ShaderHelperSingleton<InstancedObjectPass1Shader>, public TextureRead<Trilinear_Anisotropic_Filtered, Trilinear_Anisotropic_Filtered>
{
public:
InstancedObjectPass1Shader();
};
class InstancedObjectRefPass1Shader : public ShaderHelperSingleton<InstancedObjectRefPass1Shader>, public TextureRead<Trilinear_Anisotropic_Filtered>
class InstancedObjectRefPass1Shader : public ShaderHelperSingleton<InstancedObjectRefPass1Shader>, public TextureRead<Trilinear_Anisotropic_Filtered, Trilinear_Anisotropic_Filtered>
{
public:
InstancedObjectRefPass1Shader();

4
src/graphics/stkmesh.cpp
View File

@@ -301,7 +301,7 @@ static void
SetTexture(GLMesh &mesh, unsigned i, bool isSrgb)
{
if (!mesh.textures[i])
mesh.textures[i] = getUnicolorTexture(video::SColor(255, 255, 255, 255));
Log::fatal("STKMesh", "Missing texture");
compressTexture(mesh.textures[i], isSrgb);
if (UserConfigParams::m_azdo)
{
@@ -323,11 +323,13 @@ void InitTextures(GLMesh &mesh, MeshMaterial Mat)
case MAT_SPHEREMAP:
case MAT_UNLIT:
SetTexture(mesh, 0, true);
SetTexture(mesh, 1, false);
break;
case MAT_DETAIL:
case MAT_NORMAL_MAP:
SetTexture(mesh, 0, true);
SetTexture(mesh, 1, false);
SetTexture(mesh, 2, false);
break;
case MAT_SPLATTING:
SetTexture(mesh, 0, true);

47
src/graphics/stkscenemanager.cpp
View File

@@ -66,6 +66,27 @@ void InstanceFiller<InstanceDataDualTex>::add(GLMesh *mesh, scene::ISceneNode *n
Instance.SecondTexture = mesh->TextureHandles[1];
}
template<>
void InstanceFiller<InstanceDataThreeTex>::add(GLMesh *mesh, scene::ISceneNode *node, InstanceDataThreeTex &Instance)
{
const core::matrix4 &mat = node->getAbsoluteTransformation();
const core::vector3df &Origin = mat.getTranslation();
const core::vector3df &Orientation = mat.getRotationDegrees();
const core::vector3df &Scale = mat.getScale();
Instance.Origin.X = Origin.X;
Instance.Origin.Y = Origin.Y;
Instance.Origin.Z = Origin.Z;
Instance.Orientation.X = Orientation.X;
Instance.Orientation.Y = Orientation.Y;
Instance.Orientation.Z = Orientation.Z;
Instance.Scale.X = Scale.X;
Instance.Scale.Y = Scale.Y;
Instance.Scale.Z = Scale.Z;
Instance.Texture = mesh->TextureHandles[0];
Instance.SecondTexture = mesh->TextureHandles[1];
Instance.ThirdTexture = mesh->TextureHandles[2];
}
template<>
void InstanceFiller<GlowInstanceData>::add(GLMesh *mesh, scene::ISceneNode *node, GlowInstanceData &Instance)
{
@@ -522,8 +543,8 @@ void IrrDriver::PrepareDrawCalls(scene::ICameraSceneNode *camnode)
if (!irr_driver->hasARB_draw_indirect())
return;
InstanceDataSingleTex *InstanceBufferSingleTex;
InstanceDataDualTex *InstanceBufferDualTex;
InstanceDataThreeTex *InstanceBufferThreeTex;
InstanceDataSingleTex *ShadowInstanceBuffer;
InstanceDataSingleTex *RSMInstanceBuffer;
GlowInstanceData *GlowInstanceBuffer;
@@ -534,8 +555,8 @@ void IrrDriver::PrepareDrawCalls(scene::ICameraSceneNode *camnode)
if (irr_driver->hasBufferStorageExtension())
{
InstanceBufferSingleTex = (InstanceDataSingleTex*)VAOManager::getInstance()->getInstanceBufferPtr(InstanceTypeSingleTex);
InstanceBufferDualTex = (InstanceDataDualTex*)VAOManager::getInstance()->getInstanceBufferPtr(InstanceTypeDualTex);
InstanceBufferThreeTex = (InstanceDataThreeTex*)VAOManager::getInstance()->getInstanceBufferPtr(InstanceTypeThreeTex);
ShadowInstanceBuffer = (InstanceDataSingleTex*)VAOManager::getInstance()->getInstanceBufferPtr(InstanceTypeShadow);
RSMInstanceBuffer = (InstanceDataSingleTex*)VAOManager::getInstance()->getInstanceBufferPtr(InstanceTypeRSM);
GlowInstanceBuffer = (GlowInstanceData*)VAOManager::getInstance()->getInstanceBufferPtr(InstanceTypeGlow);
@@ -568,8 +589,8 @@ void IrrDriver::PrepareDrawCalls(scene::ICameraSceneNode *camnode)
size_t offset = 0, current_cmd = 0;
if (!irr_driver->hasBufferStorageExtension())
{
glBindBuffer(GL_ARRAY_BUFFER, VAOManager::getInstance()->getInstanceBuffer(InstanceTypeSingleTex));
InstanceBufferSingleTex = (InstanceDataSingleTex*)glMapBufferRange(GL_ARRAY_BUFFER, 0, 10000 * sizeof(InstanceDataDualTex), GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
glBindBuffer(GL_ARRAY_BUFFER, VAOManager::getInstance()->getInstanceBuffer(InstanceTypeDualTex));
InstanceBufferDualTex = (InstanceDataDualTex*)glMapBufferRange(GL_ARRAY_BUFFER, 0, 10000 * sizeof(InstanceDataDualTex), GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, SolidPassCmd::getInstance()->drawindirectcmd);
CmdBuffer = (DrawElementsIndirectCommand*)glMapBufferRange(GL_DRAW_INDIRECT_BUFFER, 0, 10000 * sizeof(DrawElementsIndirectCommand), GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
}
@@ -577,40 +598,40 @@ void IrrDriver::PrepareDrawCalls(scene::ICameraSceneNode *camnode)
// Default Material
SolidPassCmd::getInstance()->Offset[MAT_DEFAULT] = current_cmd;
FillInstances(MeshForSolidPass[MAT_DEFAULT], ListInstancedMatDefault::getInstance()->SolidPass, InstanceBufferSingleTex, CmdBuffer, offset, current_cmd, SolidPoly, playercamculling);
FillInstances(MeshForSolidPass[MAT_DEFAULT], ListInstancedMatDefault::getInstance()->SolidPass, InstanceBufferDualTex, CmdBuffer, offset, current_cmd, SolidPoly, playercamculling);
SolidPassCmd::getInstance()->Size[MAT_DEFAULT] = current_cmd - SolidPassCmd::getInstance()->Offset[MAT_DEFAULT];
// Alpha Ref
SolidPassCmd::getInstance()->Offset[MAT_ALPHA_REF] = current_cmd;
FillInstances(MeshForSolidPass[MAT_ALPHA_REF], ListInstancedMatAlphaRef::getInstance()->SolidPass, InstanceBufferSingleTex, CmdBuffer, offset, current_cmd, SolidPoly, playercamculling);
FillInstances(MeshForSolidPass[MAT_ALPHA_REF], ListInstancedMatAlphaRef::getInstance()->SolidPass, InstanceBufferDualTex, CmdBuffer, offset, current_cmd, SolidPoly, playercamculling);
SolidPassCmd::getInstance()->Size[MAT_ALPHA_REF] = current_cmd - SolidPassCmd::getInstance()->Offset[MAT_ALPHA_REF];
// Unlit
SolidPassCmd::getInstance()->Offset[MAT_UNLIT] = current_cmd;
FillInstances(MeshForSolidPass[MAT_UNLIT], ListInstancedMatUnlit::getInstance()->SolidPass, InstanceBufferSingleTex, CmdBuffer, offset, current_cmd, SolidPoly, playercamculling);
FillInstances(MeshForSolidPass[MAT_UNLIT], ListInstancedMatUnlit::getInstance()->SolidPass, InstanceBufferDualTex, CmdBuffer, offset, current_cmd, SolidPoly, playercamculling);
SolidPassCmd::getInstance()->Size[MAT_UNLIT] = current_cmd - SolidPassCmd::getInstance()->Offset[MAT_UNLIT];
// Spheremap
SolidPassCmd::getInstance()->Offset[MAT_SPHEREMAP] = current_cmd;
FillInstances(MeshForSolidPass[MAT_SPHEREMAP], ListInstancedMatSphereMap::getInstance()->SolidPass, InstanceBufferSingleTex, CmdBuffer, offset, current_cmd, SolidPoly, playercamculling);
FillInstances(MeshForSolidPass[MAT_SPHEREMAP], ListInstancedMatSphereMap::getInstance()->SolidPass, InstanceBufferDualTex, CmdBuffer, offset, current_cmd, SolidPoly, playercamculling);
SolidPassCmd::getInstance()->Size[MAT_SPHEREMAP] = current_cmd - SolidPassCmd::getInstance()->Offset[MAT_SPHEREMAP];
// Grass
SolidPassCmd::getInstance()->Offset[MAT_GRASS] = current_cmd;
FillInstances(MeshForSolidPass[MAT_GRASS], ListInstancedMatGrass::getInstance()->SolidPass, InstanceBufferSingleTex, CmdBuffer, offset, current_cmd, SolidPoly, playercamculling);
FillInstances(MeshForSolidPass[MAT_GRASS], ListInstancedMatGrass::getInstance()->SolidPass, InstanceBufferDualTex, CmdBuffer, offset, current_cmd, SolidPoly, playercamculling);
SolidPassCmd::getInstance()->Size[MAT_GRASS] = current_cmd - SolidPassCmd::getInstance()->Offset[MAT_GRASS];
if (!irr_driver->hasBufferStorageExtension())
{
glUnmapBuffer(GL_ARRAY_BUFFER);
glBindBuffer(GL_ARRAY_BUFFER, VAOManager::getInstance()->getInstanceBuffer(InstanceTypeDualTex));
InstanceBufferDualTex = (InstanceDataDualTex*)glMapBufferRange(GL_ARRAY_BUFFER, 0, 10000 * sizeof(InstanceDataSingleTex), GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
glBindBuffer(GL_ARRAY_BUFFER, VAOManager::getInstance()->getInstanceBuffer(InstanceTypeThreeTex));
InstanceBufferThreeTex = (InstanceDataThreeTex*)glMapBufferRange(GL_ARRAY_BUFFER, 0, 10000 * sizeof(InstanceDataSingleTex), GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
}
// Detail
SolidPassCmd::getInstance()->Offset[MAT_DETAIL] = current_cmd;
FillInstances(MeshForSolidPass[MAT_DETAIL], ListInstancedMatDetails::getInstance()->SolidPass, InstanceBufferDualTex, CmdBuffer, offset, current_cmd, SolidPoly, playercamculling);
FillInstances(MeshForSolidPass[MAT_DETAIL], ListInstancedMatDetails::getInstance()->SolidPass, InstanceBufferThreeTex, CmdBuffer, offset, current_cmd, SolidPoly, playercamculling);
SolidPassCmd::getInstance()->Size[MAT_DETAIL] = current_cmd - SolidPassCmd::getInstance()->Offset[MAT_DETAIL];
// Normal Map
SolidPassCmd::getInstance()->Offset[MAT_NORMAL_MAP] = current_cmd;
FillInstances(MeshForSolidPass[MAT_NORMAL_MAP], ListInstancedMatNormalMap::getInstance()->SolidPass, InstanceBufferDualTex, CmdBuffer, offset, current_cmd, SolidPoly, playercamculling);
FillInstances(MeshForSolidPass[MAT_NORMAL_MAP], ListInstancedMatNormalMap::getInstance()->SolidPass, InstanceBufferThreeTex, CmdBuffer, offset, current_cmd, SolidPoly, playercamculling);
SolidPassCmd::getInstance()->Size[MAT_NORMAL_MAP] = current_cmd - SolidPassCmd::getInstance()->Offset[MAT_NORMAL_MAP];

37
src/graphics/texturemanager.cpp
View File

@@ -1,6 +1,6 @@
#include "texturemanager.hpp"
#include <fstream>
#include <string>
#include <sstream>
#include "../../lib/irrlicht/source/Irrlicht/COpenGLTexture.h"
#include "irr_driver.hpp"
@@ -169,14 +169,31 @@ void saveCompressedTexture(const std::string& compressed_tex)
static unsigned colorcount = 0;
video::ITexture* getUnicolorTexture(video::SColor c)
std::map<int, video::ITexture*> unicolor_cache;
video::ITexture* getUnicolorTexture(const video::SColor &c)
{
video::SColor tmp[4] = {
c, c, c, c
};
video::IImage *img = irr_driver->getVideoDriver()->createImageFromData(video::ECF_A8R8G8B8, core::dimension2d<u32>(2, 2), tmp);
img->grab();
std::string name("color");
name += colorcount++;
return irr_driver->getVideoDriver()->addTexture(name.c_str(), img);
std::map<int, video::ITexture*>::iterator it = unicolor_cache.find(c.color);
if (it != unicolor_cache.end())
{
it->second->grab();
return it->second;
}
else
{
unsigned tmp[4] = {
c.color,
c.color,
c.color,
c.color
};
video::IImage *img = irr_driver->getVideoDriver()->createImageFromData(video::ECF_A8R8G8B8, core::dimension2d<u32>(2, 2), tmp);
img->grab();
std::stringstream name;
name << "color" << c.color;
video::ITexture* tex = irr_driver->getVideoDriver()->addTexture(name.str().c_str(), img);
unicolor_cache[c.color] = tex;
img->drop();
return tex;
}
}

25
src/graphics/vaomanager.cpp
View File

@@ -220,6 +220,21 @@ void VAOInstanceUtil<InstanceDataDualTex>::SetVertexAttrib()
glVertexAttribDivisor(11, 1);
}
template<>
void VAOInstanceUtil<InstanceDataThreeTex>::SetVertexAttrib()
{
SetVertexAttrib_impl();
glEnableVertexAttribArray(10);
glVertexAttribIPointer(10, 2, GL_UNSIGNED_INT, sizeof(InstanceDataThreeTex), (GLvoid*)(9 * sizeof(float)));
glVertexAttribDivisor(10, 1);
glEnableVertexAttribArray(11);
glVertexAttribIPointer(11, 2, GL_UNSIGNED_INT, sizeof(InstanceDataThreeTex), (GLvoid*)(9 * sizeof(float) + 2 * sizeof(unsigned)));
glVertexAttribDivisor(11, 1);
glEnableVertexAttribArray(13);
glVertexAttribIPointer(13, 2, GL_UNSIGNED_INT, sizeof(InstanceDataThreeTex), (GLvoid*)(9 * sizeof(float) + 4 * sizeof(unsigned)));
glVertexAttribDivisor(13, 1);
}
template<>
void VAOInstanceUtil<GlowInstanceData>::SetVertexAttrib()
{
@@ -241,15 +256,15 @@ void VAOManager::regenerateInstancedVAO()
if (!vbo[tp] || !ibo[tp])
continue;
GLuint vao = createVAO(vbo[tp], ibo[tp], tp);
glBindBuffer(GL_ARRAY_BUFFER, instance_vbo[InstanceTypeSingleTex]);
VAOInstanceUtil<InstanceDataSingleTex>::SetVertexAttrib();
InstanceVAO[std::pair<video::E_VERTEX_TYPE, InstanceType>(tp, InstanceTypeSingleTex)] = vao;
vao = createVAO(vbo[tp], ibo[tp], tp);
glBindBuffer(GL_ARRAY_BUFFER, instance_vbo[InstanceTypeDualTex]);
VAOInstanceUtil<InstanceDataDualTex>::SetVertexAttrib();
InstanceVAO[std::pair<video::E_VERTEX_TYPE, InstanceType>(tp, InstanceTypeDualTex)] = vao;
vao = createVAO(vbo[tp], ibo[tp], tp);
glBindBuffer(GL_ARRAY_BUFFER, instance_vbo[InstanceTypeThreeTex]);
VAOInstanceUtil<InstanceDataThreeTex>::SetVertexAttrib();
InstanceVAO[std::pair<video::E_VERTEX_TYPE, InstanceType>(tp, InstanceTypeThreeTex)] = vao;
vao = createVAO(vbo[tp], ibo[tp], tp);
glBindBuffer(GL_ARRAY_BUFFER, instance_vbo[InstanceTypeShadow]);
VAOInstanceUtil<InstanceDataSingleTex>::SetVertexAttrib();

30
src/graphics/vaomanager.hpp
View File

@@ -10,8 +10,8 @@
enum InstanceType
{
InstanceTypeSingleTex,
InstanceTypeDualTex,
InstanceTypeThreeTex,
InstanceTypeShadow,
InstanceTypeRSM,
InstanceTypeGlow,
@@ -76,6 +76,34 @@ struct InstanceDataDualTex
} __attribute__((packed));
#endif
struct InstanceDataThreeTex
{
struct
{
float X;
float Y;
float Z;
} Origin;
struct
{
float X;
float Y;
float Z;
} Orientation;
struct
{
float X;
float Y;
float Z;
} Scale;
uint64_t Texture;
uint64_t SecondTexture;
uint64_t ThirdTexture;
#ifdef WIN32
};
#else
} __attribute__((packed));
#endif
struct GlowInstanceData
{

3
src/tracks/quad_graph.cpp
View File

@@ -37,6 +37,7 @@
#include "tracks/check_manager.hpp"
#include "tracks/quad_set.hpp"
#include "tracks/track.hpp"
#include "graphics/glwrap.hpp"
const int QuadGraph::UNKNOWN_SECTOR = -1;
QuadGraph *QuadGraph::m_quad_graph = NULL;
@@ -411,6 +412,8 @@ void QuadGraph::createMesh(bool show_invisible,
m.Lighting = false;
if(enable_transparency)
m.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
m.setTexture(0, getUnicolorTexture(SColor(255, 255, 255, 255)));
m.setTexture(1, getUnicolorTexture(SColor(0, 0, 0, 0)));
m_mesh = irr_driver->createQuadMesh(&m);
m_mesh_buffer = m_mesh->getMeshBuffer(0);
assert(m_mesh_buffer->getVertexType()==video::EVT_STANDARD);