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

Remove features in SP that give no performance boost at all

Browse Source 
gl_Layer in vertex shader, bindless and array textures
This commit is contained in:
Benau 2018-01-13 14:49:33 +08:00
parent 503455d02f
commit 24308ced03
24 changed files with 100 additions and 997 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
data/shaders/sp_grass_pass.vert
View File

@ -21,37 +21,12 @@ layout(location = 9) in vec4 i_rotation;
layout(location = 10) in vec4 i_scale; layout(location = 10) in vec4 i_scale;
layout(location = 12) in ivec2 i_misc_data; layout(location = 12) in ivec2 i_misc_data;
#if defined(Use_Bindless_Texture)
layout(location = 13) in uvec4 i_bindless_texture_0;
layout(location = 14) in uvec4 i_bindless_texture_1;
layout(location = 15) in uvec4 i_bindless_texture_2;
#elif defined(Use_Array_Texture)
layout(location = 13) in uvec4 i_array_texture_0;
layout(location = 14) in uvec2 i_array_texture_1;
#endif
#stk_include "utils/get_world_location.vert" #stk_include "utils/get_world_location.vert"
out vec3 normal; out vec3 normal;
out vec2 uv; out vec2 uv;
flat out float hue_change; flat out float hue_change;
#if defined(Use_Bindless_Texture)
flat out sampler2D tex_layer_0;
flat out sampler2D tex_layer_1;
flat out sampler2D tex_layer_2;
flat out sampler2D tex_layer_3;
flat out sampler2D tex_layer_4;
flat out sampler2D tex_layer_5;
#elif defined(Use_Array_Texture)
flat out float array_0;
flat out float array_1;
flat out float array_2;
flat out float array_3;
flat out float array_4;
flat out float array_5;
#endif
void main() void main()
{ {
@ -60,22 +35,6 @@ void main()
vec4 i_rotation = convert10BitVector(i_rotation_orig); vec4 i_rotation = convert10BitVector(i_rotation_orig);
#endif #endif
#if defined(Use_Bindless_Texture)
tex_layer_0 = sampler2D(i_bindless_texture_0.xy);
tex_layer_1 = sampler2D(i_bindless_texture_0.zw);
tex_layer_2 = sampler2D(i_bindless_texture_1.xy);
tex_layer_3 = sampler2D(i_bindless_texture_1.zw);
tex_layer_4 = sampler2D(i_bindless_texture_2.xy);
tex_layer_5 = sampler2D(i_bindless_texture_2.zw);
#elif defined(Use_Array_Texture)
array_0 = float(i_array_texture_0.x);
array_1 = float(i_array_texture_0.y);
array_2 = float(i_array_texture_0.z);
array_3 = float(i_array_texture_0.w);
array_4 = float(i_array_texture_1.x);
array_5 = float(i_array_texture_1.y);
#endif
vec3 test = sin(wind_direction * (i_position.y * 0.1)); vec3 test = sin(wind_direction * (i_position.y * 0.1));
test += cos(wind_direction) * 0.7; test += cos(wind_direction) * 0.7;

45
data/shaders/sp_grass_shadow.vert
View File

@ -14,35 +14,10 @@ layout(location = 9) in vec4 i_rotation;
layout(location = 10) in vec4 i_scale; layout(location = 10) in vec4 i_scale;
#if defined(Use_Bindless_Texture)
layout(location = 13) in uvec4 i_bindless_texture_0;
layout(location = 14) in uvec4 i_bindless_texture_1;
layout(location = 15) in uvec4 i_bindless_texture_2;
#elif defined(Use_Array_Texture)
layout(location = 13) in uvec4 i_array_texture_0;
layout(location = 14) in uvec2 i_array_texture_1;
#endif
#stk_include "utils/get_world_location.vert" #stk_include "utils/get_world_location.vert"
out vec2 uv; out vec2 uv;
#if defined(Use_Bindless_Texture)
flat out sampler2D tex_layer_0;
flat out sampler2D tex_layer_1;
flat out sampler2D tex_layer_2;
flat out sampler2D tex_layer_3;
flat out sampler2D tex_layer_4;
flat out sampler2D tex_layer_5;
#elif defined(Use_Array_Texture)
flat out float array_0;
flat out float array_1;
flat out float array_2;
flat out float array_3;
flat out float array_4;
flat out float array_5;
#endif
void main() void main()
{ {
@ -50,26 +25,6 @@ void main()
vec4 i_rotation = convert10BitVector(i_rotation_orig); vec4 i_rotation = convert10BitVector(i_rotation_orig);
#endif #endif
#if defined(Use_Bindless_Texture)
tex_layer_0 = sampler2D(i_bindless_texture_0.xy);
tex_layer_1 = sampler2D(i_bindless_texture_0.zw);
tex_layer_2 = sampler2D(i_bindless_texture_1.xy);
tex_layer_3 = sampler2D(i_bindless_texture_1.zw);
tex_layer_4 = sampler2D(i_bindless_texture_2.xy);
tex_layer_5 = sampler2D(i_bindless_texture_2.zw);
#elif defined(Use_Array_Texture)
array_0 = float(i_array_texture_0.x);
array_1 = float(i_array_texture_0.y);
array_2 = float(i_array_texture_0.z);
array_3 = float(i_array_texture_0.w);
array_4 = float(i_array_texture_1.x);
array_5 = float(i_array_texture_1.y);
#endif
#ifdef VSLayer
gl_Layer = layer;
#endif
vec3 test = sin(wind_direction * (i_position.y * 0.1)); vec3 test = sin(wind_direction * (i_position.y * 0.1));
test += cos(wind_direction) * 0.7; test += cos(wind_direction) * 0.7;

41
data/shaders/sp_pass.vert
View File

@ -28,15 +28,6 @@ layout(location = 10) in vec4 i_scale;
layout(location = 11) in vec2 i_texture_trans; layout(location = 11) in vec2 i_texture_trans;
layout(location = 12) in ivec2 i_misc_data; layout(location = 12) in ivec2 i_misc_data;
#if defined(Use_Bindless_Texture)
layout(location = 13) in uvec4 i_bindless_texture_0;
layout(location = 14) in uvec4 i_bindless_texture_1;
layout(location = 15) in uvec4 i_bindless_texture_2;
#elif defined(Use_Array_Texture)
layout(location = 13) in uvec4 i_array_texture_0;
layout(location = 14) in uvec2 i_array_texture_1;
#endif
#stk_include "utils/get_world_location.vert" #stk_include "utils/get_world_location.vert"
out vec3 tangent; out vec3 tangent;
@ -48,22 +39,6 @@ out vec4 color;
out float camdist; out float camdist;
flat out float hue_change; flat out float hue_change;
#if defined(Use_Bindless_Texture)
flat out sampler2D tex_layer_0;
flat out sampler2D tex_layer_1;
flat out sampler2D tex_layer_2;
flat out sampler2D tex_layer_3;
flat out sampler2D tex_layer_4;
flat out sampler2D tex_layer_5;
#elif defined(Use_Array_Texture)
flat out float array_0;
flat out float array_1;
flat out float array_2;
flat out float array_3;
flat out float array_4;
flat out float array_5;
#endif
void main() void main()
{ {
@ -73,22 +48,6 @@ void main()
vec4 i_rotation = convert10BitVector(i_rotation_orig); vec4 i_rotation = convert10BitVector(i_rotation_orig);
#endif #endif
#if defined(Use_Bindless_Texture)
tex_layer_0 = sampler2D(i_bindless_texture_0.xy);
tex_layer_1 = sampler2D(i_bindless_texture_0.zw);
tex_layer_2 = sampler2D(i_bindless_texture_1.xy);
tex_layer_3 = sampler2D(i_bindless_texture_1.zw);
tex_layer_4 = sampler2D(i_bindless_texture_2.xy);
tex_layer_5 = sampler2D(i_bindless_texture_2.zw);
#elif defined(Use_Array_Texture)
array_0 = float(i_array_texture_0.x);
array_1 = float(i_array_texture_0.y);
array_2 = float(i_array_texture_0.z);
array_3 = float(i_array_texture_0.w);
array_4 = float(i_array_texture_1.x);
array_5 = float(i_array_texture_1.y);
#endif
vec4 quaternion = normalize(vec4(i_rotation.xyz, i_scale.w)); vec4 quaternion = normalize(vec4(i_rotation.xyz, i_scale.w));
vec4 world_position = getWorldPosition(i_origin, quaternion, i_scale.xyz, vec4 world_position = getWorldPosition(i_origin, quaternion, i_scale.xyz,
i_position); i_position);

45
data/shaders/sp_shadow.vert
View File

@ -12,35 +12,10 @@ layout(location = 9) in vec4 i_rotation;
layout(location = 10) in vec4 i_scale; layout(location = 10) in vec4 i_scale;
#if defined(Use_Bindless_Texture)
layout(location = 13) in uvec4 i_bindless_texture_0;
layout(location = 14) in uvec4 i_bindless_texture_1;
layout(location = 15) in uvec4 i_bindless_texture_2;
#elif defined(Use_Array_Texture)
layout(location = 13) in uvec4 i_array_texture_0;
layout(location = 14) in uvec2 i_array_texture_1;
#endif
#stk_include "utils/get_world_location.vert" #stk_include "utils/get_world_location.vert"
out vec2 uv; out vec2 uv;
#if defined(Use_Bindless_Texture)
flat out sampler2D tex_layer_0;
flat out sampler2D tex_layer_1;
flat out sampler2D tex_layer_2;
flat out sampler2D tex_layer_3;
flat out sampler2D tex_layer_4;
flat out sampler2D tex_layer_5;
#elif defined(Use_Array_Texture)
flat out float array_0;
flat out float array_1;
flat out float array_2;
flat out float array_3;
flat out float array_4;
flat out float array_5;
#endif
void main() void main()
{ {
@ -48,26 +23,6 @@ void main()
vec4 i_rotation = convert10BitVector(i_rotation_orig); vec4 i_rotation = convert10BitVector(i_rotation_orig);
#endif #endif
#if defined(Use_Bindless_Texture)
tex_layer_0 = sampler2D(i_bindless_texture_0.xy);
tex_layer_1 = sampler2D(i_bindless_texture_0.zw);
tex_layer_2 = sampler2D(i_bindless_texture_1.xy);
tex_layer_3 = sampler2D(i_bindless_texture_1.zw);
tex_layer_4 = sampler2D(i_bindless_texture_2.xy);
tex_layer_5 = sampler2D(i_bindless_texture_2.zw);
#elif defined(Use_Array_Texture)
array_0 = float(i_array_texture_0.x);
array_1 = float(i_array_texture_0.y);
array_2 = float(i_array_texture_0.z);
array_3 = float(i_array_texture_0.w);
array_4 = float(i_array_texture_1.x);
array_5 = float(i_array_texture_1.y);
#endif
#ifdef VSLayer
gl_Layer = layer;
#endif
vec4 quaternion = normalize(vec4(i_rotation.xyz, i_scale.w)); vec4 quaternion = normalize(vec4(i_rotation.xyz, i_scale.w));
vec4 world_position = getWorldPosition(i_origin, quaternion, i_scale.xyz, vec4 world_position = getWorldPosition(i_origin, quaternion, i_scale.xyz,
i_position); i_position);

41
data/shaders/sp_skinning.vert
View File

@ -35,15 +35,6 @@ layout(location = 10) in vec4 i_scale;
layout(location = 11) in vec2 i_texture_trans; layout(location = 11) in vec2 i_texture_trans;
layout(location = 12) in ivec2 i_misc_data; layout(location = 12) in ivec2 i_misc_data;
#if defined(Use_Bindless_Texture)
layout(location = 13) in uvec4 i_bindless_texture_0;
layout(location = 14) in uvec4 i_bindless_texture_1;
layout(location = 15) in uvec4 i_bindless_texture_2;
#elif defined(Use_Array_Texture)
layout(location = 13) in uvec4 i_array_texture_0;
layout(location = 14) in uvec2 i_array_texture_1;
#endif
#stk_include "utils/get_world_location.vert" #stk_include "utils/get_world_location.vert"
out vec3 tangent; out vec3 tangent;
@ -55,22 +46,6 @@ out vec4 color;
out float camdist; out float camdist;
flat out float hue_change; flat out float hue_change;
#if defined(Use_Bindless_Texture)
flat out sampler2D tex_layer_0;
flat out sampler2D tex_layer_1;
flat out sampler2D tex_layer_2;
flat out sampler2D tex_layer_3;
flat out sampler2D tex_layer_4;
flat out sampler2D tex_layer_5;
#elif defined(Use_Array_Texture)
flat out float array_0;
flat out float array_1;
flat out float array_2;
flat out float array_3;
flat out float array_4;
flat out float array_5;
#endif
void main() void main()
{ {
@ -80,22 +55,6 @@ void main()
vec4 i_rotation = convert10BitVector(i_rotation_orig); vec4 i_rotation = convert10BitVector(i_rotation_orig);
#endif #endif
#if defined(Use_Bindless_Texture)
tex_layer_0 = sampler2D(i_bindless_texture_0.xy);
tex_layer_1 = sampler2D(i_bindless_texture_0.zw);
tex_layer_2 = sampler2D(i_bindless_texture_1.xy);
tex_layer_3 = sampler2D(i_bindless_texture_1.zw);
tex_layer_4 = sampler2D(i_bindless_texture_2.xy);
tex_layer_5 = sampler2D(i_bindless_texture_2.zw);
#elif defined(Use_Array_Texture)
array_0 = float(i_array_texture_0.x);
array_1 = float(i_array_texture_0.y);
array_2 = float(i_array_texture_0.z);
array_3 = float(i_array_texture_0.w);
array_4 = float(i_array_texture_1.x);
array_5 = float(i_array_texture_1.y);
#endif
vec4 idle_position = vec4(i_position, 1.0); vec4 idle_position = vec4(i_position, 1.0);
vec4 idle_normal = vec4(i_normal.xyz, 0.0); vec4 idle_normal = vec4(i_normal.xyz, 0.0);
vec4 idle_tangent = vec4(i_tangent.xyz, 0.0); vec4 idle_tangent = vec4(i_tangent.xyz, 0.0);

46
data/shaders/sp_skinning_shadow.vert
View File

@ -6,7 +6,6 @@ uniform sampler2D skinning_tex;
uniform samplerBuffer skinning_tex; uniform samplerBuffer skinning_tex;
#endif #endif
layout(location = 0) in vec3 i_position; layout(location = 0) in vec3 i_position;
layout(location = 3) in vec2 i_uv; layout(location = 3) in vec2 i_uv;
layout(location = 6) in ivec4 i_joint; layout(location = 6) in ivec4 i_joint;
@ -22,35 +21,10 @@ layout(location = 9) in vec4 i_rotation;
layout(location = 10) in vec4 i_scale; layout(location = 10) in vec4 i_scale;
layout(location = 12) in ivec2 i_misc_data; layout(location = 12) in ivec2 i_misc_data;
#if defined(Use_Bindless_Texture)
layout(location = 13) in uvec4 i_bindless_texture_0;
layout(location = 14) in uvec4 i_bindless_texture_1;
layout(location = 15) in uvec4 i_bindless_texture_2;
#elif defined(Use_Array_Texture)
layout(location = 13) in uvec4 i_array_texture_0;
layout(location = 14) in uvec2 i_array_texture_1;
#endif
#stk_include "utils/get_world_location.vert" #stk_include "utils/get_world_location.vert"
out vec2 uv; out vec2 uv;
#if defined(Use_Bindless_Texture)
flat out sampler2D tex_layer_0;
flat out sampler2D tex_layer_1;
flat out sampler2D tex_layer_2;
flat out sampler2D tex_layer_3;
flat out sampler2D tex_layer_4;
flat out sampler2D tex_layer_5;
#elif defined(Use_Array_Texture)
flat out float array_0;
flat out float array_1;
flat out float array_2;
flat out float array_3;
flat out float array_4;
flat out float array_5;
#endif
void main() void main()
{ {
@ -58,26 +32,6 @@ void main()
vec4 i_rotation = convert10BitVector(i_rotation_orig); vec4 i_rotation = convert10BitVector(i_rotation_orig);
#endif #endif
#if defined(Use_Bindless_Texture)
tex_layer_0 = sampler2D(i_bindless_texture_0.xy);
tex_layer_1 = sampler2D(i_bindless_texture_0.zw);
tex_layer_2 = sampler2D(i_bindless_texture_1.xy);
tex_layer_3 = sampler2D(i_bindless_texture_1.zw);
tex_layer_4 = sampler2D(i_bindless_texture_2.xy);
tex_layer_5 = sampler2D(i_bindless_texture_2.zw);
#elif defined(Use_Array_Texture)
array_0 = float(i_array_texture_0.x);
array_1 = float(i_array_texture_0.y);
array_2 = float(i_array_texture_0.z);
array_3 = float(i_array_texture_0.w);
array_4 = float(i_array_texture_1.x);
array_5 = float(i_array_texture_1.y);
#endif
#ifdef VSLayer
gl_Layer = layer;
#endif
vec4 idle_position = vec4(i_position, 1.0); vec4 idle_position = vec4(i_position, 1.0);
vec4 skinned_position = vec4(0.0); vec4 skinned_position = vec4(0.0);
int skinning_offset = i_misc_data.x; int skinning_offset = i_misc_data.x;

28
data/shaders/utils/getLightFactor.frag
View File

@ -1,28 +0,0 @@
#ifdef Use_Bindless_Texture
layout(bindless_sampler) uniform sampler2D DiffuseMap;
layout(bindless_sampler) uniform sampler2D SpecularMap;
layout(bindless_sampler) uniform sampler2D SSAO;
#else
uniform sampler2D DiffuseMap;
uniform sampler2D SpecularMap;
uniform sampler2D SSAO;
#endif
vec3 getLightFactor(vec3 diffuseMatColor, vec3 specularMatColor, float specMapValue, float emitMapValue)
{
#if defined(Advanced_Lighting_Enabled)
vec2 tc = gl_FragCoord.xy / u_screen;
vec3 DiffuseComponent = texture(DiffuseMap, tc).xyz;
vec3 SpecularComponent = texture(SpecularMap, tc).xyz;
float ao = texture(SSAO, tc).x;
vec3 tmp = diffuseMatColor * DiffuseComponent * (1. - specMapValue) + specularMatColor * SpecularComponent * specMapValue;
vec3 emitCol = diffuseMatColor.xyz * diffuseMatColor.xyz * diffuseMatColor.xyz * 15.;
return tmp * ao + (emitMapValue * emitCol);
#else
#if !defined(sRGB_Framebuffer_Usable)
return diffuseMatColor * 0.73; // 0.5 ^ (1. / 2.2)
#else
return diffuseMatColor * 0.5;
#endif
#endif
}

41
data/shaders/utils/sp_texture_sampling.frag
View File

@ -1,78 +1,37 @@
// Wrapper to allow easy sampling for material texture slots // Wrapper to allow easy sampling for material texture slots
#if defined(Use_Array_Texture)
flat in float array_0;
flat in float array_1;
flat in float array_2;
flat in float array_3;
flat in float array_4;
flat in float array_5;
uniform sampler2DArray tex_array;
#elif defined(Use_Bindless_Texture)
flat in sampler2D tex_layer_0;
flat in sampler2D tex_layer_1;
flat in sampler2D tex_layer_2;
flat in sampler2D tex_layer_3;
flat in sampler2D tex_layer_4;
flat in sampler2D tex_layer_5;
#else
uniform sampler2D tex_layer_0; uniform sampler2D tex_layer_0;
uniform sampler2D tex_layer_1; uniform sampler2D tex_layer_1;
uniform sampler2D tex_layer_2; uniform sampler2D tex_layer_2;
uniform sampler2D tex_layer_3; uniform sampler2D tex_layer_3;
uniform sampler2D tex_layer_4; uniform sampler2D tex_layer_4;
uniform sampler2D tex_layer_5; uniform sampler2D tex_layer_5;
#endif
vec4 sampleTextureSlot0(vec2 uv) vec4 sampleTextureSlot0(vec2 uv)
{ {
#ifdef Use_Array_Texture
return texture(tex_array, vec3(uv, array_0));
#else
return texture(tex_layer_0, uv); return texture(tex_layer_0, uv);
#endif
} }
vec4 sampleTextureSlot1(vec2 uv) vec4 sampleTextureSlot1(vec2 uv)
{ {
#ifdef Use_Array_Texture
return texture(tex_array, vec3(uv, array_1));
#else
return texture(tex_layer_1, uv); return texture(tex_layer_1, uv);
#endif
} }
vec4 sampleTextureSlot2(vec2 uv) vec4 sampleTextureSlot2(vec2 uv)
{ {
#ifdef Use_Array_Texture
return texture(tex_array, vec3(uv, array_2));
#else
return texture(tex_layer_2, uv); return texture(tex_layer_2, uv);
#endif
} }
vec4 sampleTextureSlot3(vec2 uv) vec4 sampleTextureSlot3(vec2 uv)
{ {
#ifdef Use_Array_Texture
return texture(tex_array, vec3(uv, array_3));
#else
return texture(tex_layer_3, uv); return texture(tex_layer_3, uv);
#endif
} }
vec4 sampleTextureSlot4(vec2 uv) vec4 sampleTextureSlot4(vec2 uv)
{ {
#ifdef Use_Array_Texture
return texture(tex_array, vec3(uv, array_4));
#else
return texture(tex_layer_4, uv); return texture(tex_layer_4, uv);
#endif
} }
vec4 sampleTextureSlot5(vec2 uv) vec4 sampleTextureSlot5(vec2 uv)
{ {
#ifdef Use_Array_Texture
return texture(tex_array, vec3(uv, array_5));
#else
return texture(tex_layer_5, uv); return texture(tex_layer_5, uv);
#endif
} }

27
src/graphics/central_settings.cpp
View File

@ -39,7 +39,6 @@ void CentralVideoSettings::init()
hasArraysOfArrays = false; hasArraysOfArrays = false;
hasTextureStorage = false; hasTextureStorage = false;
hasTextureView = false; hasTextureView = false;
hasBindlessTexture = false;
hasAtomics = false; hasAtomics = false;
hasSSBO = false; hasSSBO = false;
hasImageLoadStore = false; hasImageLoadStore = false;
@ -96,16 +95,6 @@ void CentralVideoSettings::init()
} }
#if !defined(USE_GLES2) #if !defined(USE_GLES2)
if (hasGLExtension("GL_AMD_vertex_shader_layer"))
{
m_vs_layer_extension = "GL_AMD_vertex_shader_layer";
Log::info("GLDriver", "AMD Vertex Shader Layer Present");
}
if (hasGLExtension("GL_ARB_shader_viewport_layer_array"))
{
m_vs_layer_extension = "GL_ARB_shader_viewport_layer_array";
Log::info("GLDriver", "ARB Shader Viewport Layer Array Present");
}
if (!GraphicsRestrictions::isDisabled(GraphicsRestrictions::GR_BUFFER_STORAGE) && if (!GraphicsRestrictions::isDisabled(GraphicsRestrictions::GR_BUFFER_STORAGE) &&
hasGLExtension("GL_ARB_buffer_storage") ) hasGLExtension("GL_ARB_buffer_storage") )
{ {
@ -317,10 +306,6 @@ bool CentralVideoSettings::isEXTTextureCompressionS3TCUsable() const
return hasTextureCompression; return hasTextureCompression;
} }
bool CentralVideoSettings::supportsGLLayerInVertexShader() const
{
return !m_vs_layer_extension.empty();
}
bool CentralVideoSettings::isARBBufferStorageUsable() const bool CentralVideoSettings::isARBBufferStorageUsable() const
{ {
@ -347,11 +332,6 @@ bool CentralVideoSettings::isARBTextureViewUsable() const
return hasTextureView; return hasTextureView;
} }
bool CentralVideoSettings::isARBBindlessTextureUsable() const
{
return false;
}
bool CentralVideoSettings::isARBShaderAtomicCountersUsable() const bool CentralVideoSettings::isARBShaderAtomicCountersUsable() const
{ {
return hasAtomics; return hasAtomics;
@ -442,11 +422,4 @@ bool CentralVideoSettings::isARBInstancedArraysUsable() const
(m_gl_major_version > 3 || (m_gl_major_version == 3 && m_gl_minor_version >= 2)); (m_gl_major_version > 3 || (m_gl_major_version == 3 && m_gl_minor_version >= 2));
} }
bool CentralVideoSettings::useArrayTextures() const
{
return false;
//return (UserConfigParams::m_high_definition_textures & 0x01) == 0 &&
// UserConfigParams::m_max_texture_size <= 256;
}
#endif // !SERVER_ONLY #endif // !SERVER_ONLY

8
src/graphics/central_settings.hpp
View File

@ -27,13 +27,11 @@ private:
bool m_glsl; bool m_glsl;
int m_gl_major_version, m_gl_minor_version; int m_gl_major_version, m_gl_minor_version;
std::string m_vs_layer_extension;
bool hasBufferStorage; bool hasBufferStorage;
bool hasComputeShaders; bool hasComputeShaders;
bool hasArraysOfArrays; bool hasArraysOfArrays;
bool hasTextureStorage; bool hasTextureStorage;
bool hasTextureView; bool hasTextureView;
bool hasBindlessTexture;
bool hasUBO; bool hasUBO;
bool hasExplicitAttribLocation; bool hasExplicitAttribLocation;
bool hasGS; bool hasGS;
@ -72,7 +70,6 @@ public:
bool isARBTextureStorageUsable() const; bool isARBTextureStorageUsable() const;
bool isARBComputeShaderUsable() const; bool isARBComputeShaderUsable() const;
bool isARBArraysOfArraysUsable() const; bool isARBArraysOfArraysUsable() const;
bool isARBBindlessTextureUsable() const;
bool isARBBufferStorageUsable() const; bool isARBBufferStorageUsable() const;
bool isARBShaderAtomicCountersUsable() const; bool isARBShaderAtomicCountersUsable() const;
bool isARBShaderStorageBufferObjectUsable() const; bool isARBShaderStorageBufferObjectUsable() const;
@ -83,11 +80,8 @@ public:
bool isARBPixelBufferObjectUsable() const; bool isARBPixelBufferObjectUsable() const;
bool isARBSamplerObjectsUsable() const; bool isARBSamplerObjectsUsable() const;
bool isARBVertexType2101010RevUsable() const; bool isARBVertexType2101010RevUsable() const;
bool useArrayTextures() const;
bool isARBInstancedArraysUsable() const; bool isARBInstancedArraysUsable() const;
const std::string& getVSLayerExtension() const { return m_vs_layer_extension; }
#if defined(USE_GLES2) #if defined(USE_GLES2)
bool isEXTTextureFormatBGRA8888Usable() const; bool isEXTTextureFormatBGRA8888Usable() const;
bool isEXTColorBufferFloatUsable() const; bool isEXTColorBufferFloatUsable() const;
@ -98,8 +92,6 @@ public:
bool supportsHardwareSkinning() const; bool supportsHardwareSkinning() const;
bool supportsTextureCompression() const; bool supportsTextureCompression() const;
bool supportsGLLayerInVertexShader() const;
// "Macro" around feature support and user config // "Macro" around feature support and user config
bool isShadowEnabled() const; bool isShadowEnabled() const;
bool isTextureCompressionEnabled() const; bool isTextureCompressionEnabled() const;

65
src/graphics/frame_buffer_layer.cpp
View File

@ -28,37 +28,19 @@ FrameBufferLayer::FrameBufferLayer(const std::vector<GLuint> &rtts, unsigned w,
m_width = w; m_width = w;
m_height = h; m_height = h;
// When vertex shader gl_layer issupported, only 1 fbo will be created m_fbo_layer.resize(layer_count);
#ifndef USE_GLES2 glGenFramebuffers(layer_count, m_fbo_layer.data());
if (CVS->supportsGLLayerInVertexShader()) for (unsigned layer = 0; layer < layer_count; layer++)
{ {
glGenFramebuffers(1, &m_fbo); glBindFramebuffer(GL_FRAMEBUFFER, m_fbo_layer[layer]);
glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
for (unsigned i = 0; i < rtts.size(); i++) for (unsigned i = 0; i < rtts.size(); i++)
{ {
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, glFramebufferTextureLayer(GL_FRAMEBUFFER,
rtts[i], 0); GL_COLOR_ATTACHMENT0 + i, rtts[i], 0, layer);
} }
assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) ==
GL_FRAMEBUFFER_COMPLETE_EXT); GL_FRAMEBUFFER_COMPLETE_EXT);
} }
else
#endif
{
m_fbo_layer.resize(layer_count);
glGenFramebuffers(layer_count, m_fbo_layer.data());
for (unsigned layer = 0; layer < layer_count; layer++)
{
glBindFramebuffer(GL_FRAMEBUFFER, m_fbo_layer[layer]);
for (unsigned i = 0; i < rtts.size(); i++)
{
glFramebufferTextureLayer(GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0 + i, rtts[i], 0, layer);
}
assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) ==
GL_FRAMEBUFFER_COMPLETE_EXT);
}
}
} // FrameBufferLayer } // FrameBufferLayer
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@ -72,40 +54,21 @@ FrameBufferLayer::FrameBufferLayer(const std::vector<GLuint> &rtts,
m_width = w; m_width = w;
m_height = h; m_height = h;
#ifndef USE_GLES2 m_fbo_layer.resize(layer_count);
if (CVS->supportsGLLayerInVertexShader()) glGenFramebuffers(layer_count, m_fbo_layer.data());
for (unsigned layer = 0; layer < layer_count; layer++)
{ {
glGenFramebuffers(1, &m_fbo); glBindFramebuffer(GL_FRAMEBUFFER, m_fbo_layer[layer]);
glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
for (unsigned i = 0; i < rtts.size(); i++) for (unsigned i = 0; i < rtts.size(); i++)
{ {
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, glFramebufferTextureLayer(GL_FRAMEBUFFER,
rtts[i], 0); GL_COLOR_ATTACHMENT0 + i, rtts[i], 0, layer);
} }
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, glFramebufferTextureLayer(GL_FRAMEBUFFER,
depth_stencil, 0); GL_DEPTH_STENCIL_ATTACHMENT, depth_stencil, 0, layer);
assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) ==
GL_FRAMEBUFFER_COMPLETE_EXT); GL_FRAMEBUFFER_COMPLETE_EXT);
} }
else
#endif
{
m_fbo_layer.resize(layer_count);
glGenFramebuffers(layer_count, m_fbo_layer.data());
for (unsigned layer = 0; layer < layer_count; layer++)
{
glBindFramebuffer(GL_FRAMEBUFFER, m_fbo_layer[layer]);
for (unsigned i = 0; i < rtts.size(); i++)
{
glFramebufferTextureLayer(GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0 + i, rtts[i], 0, layer);
}
glFramebufferTextureLayer(GL_FRAMEBUFFER,
GL_DEPTH_STENCIL_ATTACHMENT, depth_stencil, 0, layer);
assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) ==
GL_FRAMEBUFFER_COMPLETE_EXT);
}
}
} // FrameBufferLayer } // FrameBufferLayer
#endif #endif

20
src/graphics/shader_based_renderer.cpp
View File

@ -182,28 +182,18 @@ void ShaderBasedRenderer::renderShadows()
glCullFace(GL_BACK); glCullFace(GL_BACK);
glEnable(GL_CULL_FACE); glEnable(GL_CULL_FACE);
glEnable(GL_POLYGON_OFFSET_FILL); glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(1.5, 50.); glPolygonOffset(1.5f, 50.0f);
if (CVS->supportsGLLayerInVertexShader()) glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
{
m_rtts->getShadowFrameBuffer().bindDepthOnly();
glClearColor(1., 1., 1., 1.);
glClear(GL_DEPTH_BUFFER_BIT);
glClearColor(0., 0., 0., 0.);
}
for (unsigned cascade = 0; cascade < 4; cascade++) for (unsigned cascade = 0; cascade < 4; cascade++)
{ {
if (!CVS->supportsGLLayerInVertexShader()) m_rtts->getShadowFrameBuffer().bindLayerDepthOnly(cascade);
{ glClear(GL_DEPTH_BUFFER_BIT);
m_rtts->getShadowFrameBuffer().bindLayerDepthOnly(cascade);
glClearColor(1., 1., 1., 1.);
glClear(GL_DEPTH_BUFFER_BIT);
glClearColor(0., 0., 0., 0.);
}
SP::sp_cur_shadow_cascade = cascade; SP::sp_cur_shadow_cascade = cascade;
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SHADOWS_CASCADE0 + cascade)); ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SHADOWS_CASCADE0 + cascade));
SP::draw(SP::RP_SHADOW, (SP::DrawCallType)(SP::DCT_SHADOW1 + cascade)); SP::draw(SP::RP_SHADOW, (SP::DrawCallType)(SP::DCT_SHADOW1 + cascade));
} }
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glDisable(GL_POLYGON_OFFSET_FILL); glDisable(GL_POLYGON_OFFSET_FILL);
PROFILER_POP_CPU_MARKER(); PROFILER_POP_CPU_MARKER();
} }

16
src/graphics/shader_files_manager.cpp
View File

@ -142,9 +142,6 @@ GLuint ShaderFilesManager::loadShader(const std::string &file, unsigned type)
} }
#endif #endif
if (CVS->supportsGLLayerInVertexShader())
code << "#extension " << CVS->getVSLayerExtension() << " : enable\n";
if (CVS->isARBExplicitAttribLocationUsable()) if (CVS->isARBExplicitAttribLocationUsable())
{ {
#if !defined(USE_GLES2) #if !defined(USE_GLES2)
@ -153,17 +150,6 @@ GLuint ShaderFilesManager::loadShader(const std::string &file, unsigned type)
code << "#define Explicit_Attrib_Location_Usable\n"; code << "#define Explicit_Attrib_Location_Usable\n";
} }
if (CVS->useArrayTextures())
{
code << "#define Use_Array_Texture\n";
}
else if (CVS->isARBBindlessTextureUsable())
{
code << "#extension GL_ARB_bindless_texture : enable\n";
code << "#extension GL_NV_gpu_shader5 : require\n";
code << "#define Use_Bindless_Texture\n";
}
if (GraphicsRestrictions::isDisabled if (GraphicsRestrictions::isDisabled
(GraphicsRestrictions::GR_CORRECT_10BIT_NORMALIZATION)) (GraphicsRestrictions::GR_CORRECT_10BIT_NORMALIZATION))
{ {
@ -173,8 +159,6 @@ GLuint ShaderFilesManager::loadShader(const std::string &file, unsigned type)
code << "//" << file << "\n"; code << "//" << file << "\n";
if (!CVS->isARBUniformBufferObjectUsable()) if (!CVS->isARBUniformBufferObjectUsable())
code << "#define UBO_DISABLED\n"; code << "#define UBO_DISABLED\n";
if (CVS->supportsGLLayerInVertexShader())
code << "#define VSLayer\n";
if (CVS->needsVertexIdWorkaround()) if (CVS->needsVertexIdWorkaround())
code << "#define Needs_Vertex_Id_Workaround\n"; code << "#define Needs_Vertex_Id_Workaround\n";
if (CVS->isDefferedEnabled()) if (CVS->isDefferedEnabled())

47
src/graphics/sp/sp_base.cpp
View File

@ -89,7 +89,8 @@ std::unordered_set<SPMeshBuffer*> g_instances;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
std::array<GLuint, ST_COUNT> g_samplers; std::array<GLuint, ST_COUNT> g_samplers;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
std::vector<GLuint> sp_prefilled_tex (2); // Check sp_shader.cpp for the name
std::array<GLuint, 1> sp_prefilled_tex;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
std::vector<float> g_bounding_boxes; std::vector<float> g_bounding_boxes;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@ -313,7 +314,7 @@ void initSkinning()
#endif #endif
resizeSkinning(stk_config->m_max_skinning_bones); resizeSkinning(stk_config->m_max_skinning_bones);
sp_prefilled_tex[1] = g_skinning_tex; sp_prefilled_tex[0] = g_skinning_tex;
} // initSkinning } // initSkinning
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@ -1292,17 +1293,9 @@ void addObject(SPMeshNode* node)
if (dc_type == 0) if (dc_type == 0)
{ {
auto& ret = g_draw_calls[DCT_TRANSPARENT][shader]; auto& ret = g_draw_calls[DCT_TRANSPARENT][shader];
if (CVS->isARBBindlessTextureUsable() || for (auto& p : mb->getTextureCompare())
CVS->useArrayTextures())
{ {
ret[""].insert(mb); ret[p.first].insert(mb);
}
else
{
for (auto& p : mb->getTextureCompare())
{
ret[p.first].insert(mb);
}
} }
mb->addInstanceData(id, DCT_TRANSPARENT); mb->addInstanceData(id, DCT_TRANSPARENT);
} }
@ -1316,9 +1309,7 @@ void addObject(SPMeshNode* node)
// Check if shader for render pass uses mesh samplers // Check if shader for render pass uses mesh samplers
const RenderPass check_pass = const RenderPass check_pass =
dc_type == DCT_NORMAL ? RP_1ST : RP_SHADOW; dc_type == DCT_NORMAL ? RP_1ST : RP_SHADOW;
const bool sampler_less = shader->samplerLess(check_pass) || const bool sampler_less = shader->samplerLess(check_pass);
CVS->isARBBindlessTextureUsable() ||
CVS->useArrayTextures();
auto& ret = g_draw_calls[dc_type][shader]; auto& ret = g_draw_calls[dc_type][shader];
if (sampler_less) if (sampler_less)
{ {
@ -1443,17 +1434,9 @@ void handleDynamicDrawCall()
if (dc_type == 0) if (dc_type == 0)
{ {
auto& ret = g_draw_calls[DCT_TRANSPARENT][shader]; auto& ret = g_draw_calls[DCT_TRANSPARENT][shader];
if (CVS->isARBBindlessTextureUsable() || for (auto& p : dydc->getTextureCompare())
CVS->useArrayTextures())
{ {
ret[""].insert(dydc); ret[p.first].insert(dydc);
}
else
{
for (auto& p : dydc->getTextureCompare())
{
ret[p.first].insert(dydc);
}
} }
} }
else else
@ -1466,9 +1449,7 @@ void handleDynamicDrawCall()
// Check if shader for render pass uses mesh samplers // Check if shader for render pass uses mesh samplers
const RenderPass check_pass = const RenderPass check_pass =
dc_type == DCT_NORMAL ? RP_1ST : RP_SHADOW; dc_type == DCT_NORMAL ? RP_1ST : RP_SHADOW;
const bool sampler_less = shader->samplerLess(check_pass) || const bool sampler_less = shader->samplerLess(check_pass);
CVS->isARBBindlessTextureUsable() ||
CVS->useArrayTextures();
auto& ret = g_draw_calls[dc_type][shader]; auto& ret = g_draw_calls[dc_type][shader];
if (sampler_less) if (sampler_less)
{ {
@ -1724,20 +1705,14 @@ void draw(RenderPass rp, DrawCallType dct)
p.first->bindPrefilledTextures(rp); p.first->bindPrefilledTextures(rp);
for (unsigned j = 0; j < p.second.size(); j++) for (unsigned j = 0; j < p.second.size(); j++)
{ {
if (!(CVS->isARBBindlessTextureUsable() || p.first->bindTextures(p.second[j].first, rp);
CVS->useArrayTextures()))
{
p.first->bindTextures(p.second[j].first, rp);
}
for (unsigned k = 0; k < p.second[j].second.size(); k++) for (unsigned k = 0; k < p.second[j].second.size(); k++)
{ {
static std::vector<SPUniformAssigner*> draw_call_uniforms; static std::vector<SPUniformAssigner*> draw_call_uniforms;
p.first->setUniformsPerObject(static_cast<SPPerObjectUniform*> p.first->setUniformsPerObject(static_cast<SPPerObjectUniform*>
(p.second[j].second[k].first), &draw_call_uniforms, rp); (p.second[j].second[k].first), &draw_call_uniforms, rp);
p.second[j].second[k].first->draw(dct, p.second[j].second[k].first->draw(dct,
p.second[j].second[k].second/*material_id*/, p.second[j].second[k].second/*material_id*/);
CVS->isARBBindlessTextureUsable() ||
CVS->useArrayTextures());
for (SPUniformAssigner* ua : draw_call_uniforms) for (SPUniformAssigner* ua : draw_call_uniforms)
{ {
ua->reset(); ua->reset();

2
src/graphics/sp/sp_base.hpp
View File

@ -87,7 +87,7 @@ class SPMeshBuffer;
extern GLuint sp_mat_ubo[MAX_PLAYER_COUNT][3]; extern GLuint sp_mat_ubo[MAX_PLAYER_COUNT][3];
extern GLuint sp_fog_ubo; extern GLuint sp_fog_ubo;
extern bool sp_first_frame; extern bool sp_first_frame;
extern std::vector<GLuint> sp_prefilled_tex; extern std::array<GLuint, 1> sp_prefilled_tex;
extern unsigned sp_solid_poly_count; extern unsigned sp_solid_poly_count;
extern unsigned sp_shadow_poly_count; extern unsigned sp_shadow_poly_count;
extern int sp_cur_shadow_cascade; extern int sp_cur_shadow_cascade;

62
src/graphics/sp/sp_dynamic_draw_call.cpp
View File

@ -54,8 +54,7 @@ SPDynamicDrawCall::SPDynamicDrawCall(scene::E_PRIMITIVE_TYPE pt,
glBufferData(GL_ARRAY_BUFFER, 4 * 48, NULL, GL_DYNAMIC_DRAW); glBufferData(GL_ARRAY_BUFFER, 4 * 48, NULL, GL_DYNAMIC_DRAW);
glGenBuffers(1, &m_ibo); glGenBuffers(1, &m_ibo);
glBindBuffer(GL_ARRAY_BUFFER, m_ibo); glBindBuffer(GL_ARRAY_BUFFER, m_ibo);
glBufferData(GL_ARRAY_BUFFER, 32 + 48/*Max textures handles*/, NULL, glBufferData(GL_ARRAY_BUFFER, 32, NULL, GL_DYNAMIC_DRAW);
GL_DYNAMIC_DRAW);
SPInstancedData id = SPInstancedData(m_trans, 0.0f, 0.0f, 0.0f, 0); SPInstancedData id = SPInstancedData(m_trans, 0.0f, 0.0f, 0.0f, 0);
glBufferSubData(GL_ARRAY_BUFFER, 0, 32, &id); glBufferSubData(GL_ARRAY_BUFFER, 0, 32, &id);
SPTextureManager::get()->increaseGLCommandFunctionCount(1); SPTextureManager::get()->increaseGLCommandFunctionCount(1);
@ -119,53 +118,27 @@ SPDynamicDrawCall::SPDynamicDrawCall(scene::E_PRIMITIVE_TYPE pt,
glBindBuffer(GL_ARRAY_BUFFER, m_ibo); glBindBuffer(GL_ARRAY_BUFFER, m_ibo);
// Origin // Origin
glEnableVertexAttribArray(8); glEnableVertexAttribArray(8);
glVertexAttribPointer(8, 3, GL_FLOAT, GL_FALSE, 32 + 48, (void*)0); glVertexAttribPointer(8, 3, GL_FLOAT, GL_FALSE, 32, (void*)0);
glVertexAttribDivisorARB(8, 1); glVertexAttribDivisorARB(8, 1);
// Rotation (quaternion .xyz) // Rotation (quaternion .xyz)
glEnableVertexAttribArray(9); glEnableVertexAttribArray(9);
glVertexAttribPointer(9, 4, GL_INT_2_10_10_10_REV, glVertexAttribPointer(9, 4, GL_INT_2_10_10_10_REV,
GraphicsRestrictions::isDisabled GraphicsRestrictions::isDisabled
(GraphicsRestrictions::GR_CORRECT_10BIT_NORMALIZATION) ? (GraphicsRestrictions::GR_CORRECT_10BIT_NORMALIZATION) ?
GL_FALSE : GL_TRUE, 32 + 48, (void*)12); GL_FALSE : GL_TRUE, 32, (void*)12);
glVertexAttribDivisorARB(9, 1); glVertexAttribDivisorARB(9, 1);
// Scale (3 half floats and .w for quaternion .w) // Scale (3 half floats and .w for quaternion .w)
glEnableVertexAttribArray(10); glEnableVertexAttribArray(10);
glVertexAttribPointer(10, 4, GL_HALF_FLOAT, GL_FALSE, 32 + 48, (void*)16); glVertexAttribPointer(10, 4, GL_HALF_FLOAT, GL_FALSE, 32, (void*)16);
glVertexAttribDivisorARB(10, 1); glVertexAttribDivisorARB(10, 1);
// Texture translation // Texture translation
glEnableVertexAttribArray(11); glEnableVertexAttribArray(11);
glVertexAttribPointer(11, 2, GL_HALF_FLOAT, GL_FALSE, 32 + 48, (void*)24); glVertexAttribPointer(11, 2, GL_HALF_FLOAT, GL_FALSE, 32, (void*)24);
glVertexAttribDivisorARB(11, 1); glVertexAttribDivisorARB(11, 1);
// Misc data (skinning offset and hue change) // Misc data (skinning offset and hue change)
glEnableVertexAttribArray(12); glEnableVertexAttribArray(12);
glVertexAttribIPointer(12, 2, GL_SHORT, 32 + 48, (void*)28); glVertexAttribIPointer(12, 2, GL_SHORT, 32, (void*)28);
glVertexAttribDivisorARB(12, 1); glVertexAttribDivisorARB(12, 1);
if (CVS->useArrayTextures())
{
// uvec4 + uvec2 for 6 texture array indices
glEnableVertexAttribArray(13);
glVertexAttribIPointer(13, 4, GL_UNSIGNED_SHORT, 32 + 48, (void*)32);
glVertexAttribDivisorARB(13, 1);
glEnableVertexAttribArray(14);
glVertexAttribIPointer(14, 2, GL_UNSIGNED_SHORT, 32 + 48, (void*)40);
glVertexAttribDivisorARB(14, 1);
glDisableVertexAttribArray(15);
}
else if (CVS->isARBBindlessTextureUsable())
{
// 3 * 2 uvec2 for bindless samplers
glEnableVertexAttribArray(13);
glVertexAttribIPointer(13, 4, GL_UNSIGNED_INT, 32 + 48, (void*)32);
glVertexAttribDivisorARB(13, 1);
glEnableVertexAttribArray(14);
glVertexAttribIPointer(14, 4, GL_UNSIGNED_INT, 32 + 48, (void*)48);
glVertexAttribDivisorARB(14, 1);
glEnableVertexAttribArray(15);
glVertexAttribIPointer(15, 4, GL_UNSIGNED_INT, 32 + 48, (void*)64);
glVertexAttribDivisorARB(15, 1);
}
glBindVertexArray(0); glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
#endif #endif
@ -185,29 +158,6 @@ bool SPDynamicDrawCall::initTextureDyDc()
} }
} }
} }
if (!(CVS->useArrayTextures() || CVS->isARBBindlessTextureUsable()))
{
return true;
}
glBindBuffer(GL_ARRAY_BUFFER, m_ibo);
if (CVS->useArrayTextures())
{
for (unsigned i = 0; i < 6; i++)
{
uint16_t array_index = (uint16_t)
m_textures[0][i]->getTextureArrayIndex();
glBufferSubData(GL_ARRAY_BUFFER, 32 + (i * 2), 2, &array_index);
}
}
else
{
for (unsigned i = 0; i < 6; i++)
{
glBufferSubData(GL_ARRAY_BUFFER, 32 + (i * 8), 8,
m_textures[0][i]->getTextureHandlePointer());
}
}
glBindBuffer(GL_ARRAY_BUFFER, 0);
#endif #endif
return true; return true;
} // initTextureDyDc } // initTextureDyDc

6
src/graphics/sp/sp_dynamic_draw_call.hpp
View File

@ -70,8 +70,8 @@ public:
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
~SPDynamicDrawCall() {} ~SPDynamicDrawCall() {}
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
virtual void draw(DrawCallType dct = DCT_NORMAL, int material_id = -1, virtual void draw(DrawCallType dct = DCT_NORMAL,
bool bindless_texture = false) const int material_id = -1) const
{ {
#ifndef SERVER_ONLY #ifndef SERVER_ONLY
glBindVertexArray(m_vao[0]); glBindVertexArray(m_vao[0]);
@ -92,7 +92,7 @@ public:
SPInstancedData id = SPInstancedData(getAbsoluteTransformation(), SPInstancedData id = SPInstancedData(getAbsoluteTransformation(),
m_texture_trans.X, m_texture_trans.Y, 0.0f, 0); m_texture_trans.X, m_texture_trans.Y, 0.0f, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_ibo); glBindBuffer(GL_ARRAY_BUFFER, m_ibo);
glBufferSubData(GL_ARRAY_BUFFER, 0, 32, &id); glBufferSubData(GL_ARRAY_BUFFER, 0, 32, id.getData());
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
} }
if (m_update_offset >= 0 && !m_vertices.empty()) if (m_update_offset >= 0 && !m_vertices.empty())

78
src/graphics/sp/sp_mesh_buffer.cpp
View File

@ -98,48 +98,6 @@ bool SPMeshBuffer::initTexture()
} }
} }
} }
if (!(CVS->useArrayTextures() || CVS->isARBBindlessTextureUsable()))
{
return true;
}
glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
std::set<uint16_t> used_vertices;
for (unsigned int j = 0; j < getIndexCount(); j += 3)
{
for (unsigned int k = 0; k < 3; k++)
{
const uint16_t vertex_id = m_indices[j + k];
auto ret = used_vertices.find(vertex_id);
if (ret == used_vertices.end())
{
used_vertices.insert(vertex_id);
std::array<std::shared_ptr<SPTexture>, 6> textures =
getSPTextures(j);
if (CVS->useArrayTextures())
{
for (unsigned i = 0; i < 6; i++)
{
uint16_t array_index = (uint16_t)
textures[i]->getTextureArrayIndex();
glBufferSubData(GL_ARRAY_BUFFER,
(vertex_id * m_pitch) + (m_pitch - 12) + (i * 2),
2, &array_index);
}
}
else
{
for (unsigned i = 0; i < 6; i++)
{
glBufferSubData(GL_ARRAY_BUFFER,
(vertex_id * m_pitch) + (m_pitch - 48) + (i * 8),
8, textures[i]->getTextureHandlePointer());
}
}
}
}
}
assert(used_vertices.size() == m_vertices.size());
glBindBuffer(GL_ARRAY_BUFFER, 0);
#endif #endif
return true; return true;
} // initTexture } // initTexture
@ -176,8 +134,7 @@ void SPMeshBuffer::uploadGLMesh()
std::get<2>(m_stk_material[0])->getShaderName() == "normalmap" && std::get<2>(m_stk_material[0])->getShaderName() == "normalmap" &&
CVS->isDefferedEnabled(); CVS->isDefferedEnabled();
const unsigned pitch = 48 - (use_tangents ? 0 : 4) - (use_2_uv ? 0 : 4) - const unsigned pitch = 48 - (use_tangents ? 0 : 4) - (use_2_uv ? 0 : 4) -
(m_skinned ? 0 : 16) + (CVS->useArrayTextures() ? 12 : (m_skinned ? 0 : 16);
CVS->isARBBindlessTextureUsable() ? 48 : 0);
m_pitch = pitch; m_pitch = pitch;
if (m_vbo != 0) if (m_vbo != 0)
@ -373,36 +330,9 @@ void SPMeshBuffer::recreateVAO(unsigned i)
glDisableVertexAttribArray(6); glDisableVertexAttribArray(6);
glDisableVertexAttribArray(7); glDisableVertexAttribArray(7);
} }
glDisableVertexAttribArray(13);
if (CVS->useArrayTextures()) glDisableVertexAttribArray(14);
{ glDisableVertexAttribArray(15);
// uvec4 + uvec2 for 6 texture array indices
glEnableVertexAttribArray(13);
glVertexAttribIPointer(13, 4, GL_UNSIGNED_SHORT, pitch, (void*)offset);
offset += 8;
glEnableVertexAttribArray(14);
glVertexAttribIPointer(14, 2, GL_UNSIGNED_SHORT, pitch, (void*)offset);
offset += 4;
glDisableVertexAttribArray(15);
}
else if (CVS->isARBBindlessTextureUsable())
{
// 3 * 2 uvec2 for bindless samplers
glEnableVertexAttribArray(13);
glVertexAttribIPointer(13, 4, GL_UNSIGNED_INT, pitch, (void*)offset);
offset += 16;
glEnableVertexAttribArray(14);
glVertexAttribIPointer(14, 4, GL_UNSIGNED_INT, pitch, (void*)offset);
offset += 16;
glEnableVertexAttribArray(15);
glVertexAttribIPointer(15, 4, GL_UNSIGNED_INT, pitch, (void*)offset);
}
else
{
glDisableVertexAttribArray(13);
glDisableVertexAttribArray(14);
glDisableVertexAttribArray(15);
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo);
glBindBuffer(GL_ARRAY_BUFFER, m_ins_array[i]); glBindBuffer(GL_ARRAY_BUFFER, m_ins_array[i]);

26
src/graphics/sp/sp_mesh_buffer.hpp
View File

@ -109,31 +109,15 @@ public:
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
~SPMeshBuffer(); ~SPMeshBuffer();
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
virtual void draw(DrawCallType dct = DCT_NORMAL, int material_id = -1, virtual void draw(DrawCallType dct = DCT_NORMAL, int material_id = -1) const
bool bindless_texture = false) const
{ {
#ifndef SERVER_ONLY #ifndef SERVER_ONLY
glBindVertexArray(m_vao[dct]); glBindVertexArray(m_vao[dct]);
if (material_id == -1 || bindless_texture) if (material_id == -1)
{ {
/*if (bindless_texture) // Draw whole mesh buffer, usually in shadow pass
// Only nvidia gpu allow texture with non-dynamically-uniform glDrawElementsInstanced(GL_TRIANGLES, getIndexCount(),
// handles (texture handles that aren't constant within a same draw) GL_UNSIGNED_SHORT, 0, (unsigned)m_ins_dat[dct].size());
{
for (unsigned i = 0; i < m_stk_material.size(); i++)
{
glDrawElementsInstanced(GL_TRIANGLES,
std::get<1>(m_stk_material[i]),
GL_UNSIGNED_SHORT,
(void*)(std::get<0>(m_stk_material[i]) << 1),
(unsigned)m_ins_dat[dct].size());
}
}
else*/
{
glDrawElementsInstanced(GL_TRIANGLES, getIndexCount(),
GL_UNSIGNED_SHORT, 0, (unsigned)m_ins_dat[dct].size());
}
} }
else else
{ {

5
src/graphics/sp/sp_shader.cpp
View File

@ -30,11 +30,10 @@ namespace SP
std::unordered_map<std::string, std::pair<unsigned, SamplerType> > std::unordered_map<std::string, std::pair<unsigned, SamplerType> >
g_prefilled_names = g_prefilled_names =
{ {
{ "tex_array", { 0, ST_TRILINEAR } }
#ifdef USE_GLES2 #ifdef USE_GLES2
,{ "skinning_tex", { 1, ST_NEAREST_CLAMPED } } { "skinning_tex", { 0, ST_NEAREST_CLAMPED } }
#else #else
,{ "skinning_tex", { 1, ST_TEXTURE_BUFFER } } { "skinning_tex", { 0, ST_TEXTURE_BUFFER } }
#endif #endif
}; };

247
src/graphics/sp/sp_texture.cpp
View File

@ -53,15 +53,11 @@ namespace SP
{ {
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
SPTexture::SPTexture(const std::string& path, Material* m, bool undo_srgb, SPTexture::SPTexture(const std::string& path, Material* m, bool undo_srgb,
int ta_idx, const std::string& container_id) const std::string& container_id)
: m_path(path), m_texture_array_idx(ta_idx), m_width(0), m_height(0), : m_path(path), m_width(0), m_height(0), m_material(m),
m_material(m), m_undo_srgb(undo_srgb) m_undo_srgb(undo_srgb)
{ {
#ifndef SERVER_ONLY #ifndef SERVER_ONLY
if (CVS->useArrayTextures())
{
return;
}
glGenTextures(1, &m_texture_name); glGenTextures(1, &m_texture_name);
createWhite(false/*private_init*/); createWhite(false/*private_init*/);
@ -89,18 +85,10 @@ SPTexture::SPTexture(const std::string& path, Material* m, bool undo_srgb,
} // SPTexture } // SPTexture
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
SPTexture::SPTexture(bool white, int ta_idx) SPTexture::SPTexture(bool white)
: m_texture_array_idx(ta_idx), m_width(0), m_height(0), : m_width(0), m_height(0), m_undo_srgb(false)
m_undo_srgb(false)
{ {
#ifndef SERVER_ONLY #ifndef SERVER_ONLY
if (CVS->useArrayTextures())
{
m_width.store(irr_driver->getVideoDriver()->getDriverAttributes()
.getAttributeAsDimension2d("MAX_TEXTURE_SIZE").Width);
m_height.store(m_width.load());
return;
}
glGenTextures(1, &m_texture_name); glGenTextures(1, &m_texture_name);
if (white) if (white)
{ {
@ -110,7 +98,6 @@ SPTexture::SPTexture(bool white, int ta_idx)
{ {
createTransparent(); createTransparent();
} }
addTextureHandle();
#endif #endif
} // SPTexture } // SPTexture
@ -118,12 +105,6 @@ SPTexture::SPTexture(bool white, int ta_idx)
SPTexture::~SPTexture() SPTexture::~SPTexture()
{ {
#ifndef SERVER_ONLY #ifndef SERVER_ONLY
#if !(defined(SERVER_ONLY) || defined(USE_GLES2))
if (m_texture_handle != 0 && CVS->isARBBindlessTextureUsable())
{
glMakeTextureHandleNonResidentARB(m_texture_handle);
}
#endif
if (m_texture_name != 0) if (m_texture_name != 0)
{ {
glDeleteTextures(1, &m_texture_name); glDeleteTextures(1, &m_texture_name);
@ -131,19 +112,6 @@ SPTexture::~SPTexture()
#endif #endif
} // ~SPTexture } // ~SPTexture
// ----------------------------------------------------------------------------
void SPTexture::addTextureHandle()
{
#if !(defined(SERVER_ONLY) || defined(USE_GLES2))
if (CVS->isARBBindlessTextureUsable())
{
m_texture_handle = glGetTextureSamplerHandleARB(m_texture_name,
getSampler(ST_TRILINEAR));
glMakeTextureHandleResidentARB(m_texture_handle);
}
#endif
} // addTextureHandle
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
std::shared_ptr<video::IImage> SPTexture::getImageFromPath std::shared_ptr<video::IImage> SPTexture::getImageFromPath
(const std::string& path) const (const std::string& path) const
@ -192,11 +160,11 @@ std::shared_ptr<video::IImage> SPTexture::getTextureImage() const
const core::dimension2du& max_size = irr_driver->getVideoDriver() const core::dimension2du& max_size = irr_driver->getVideoDriver()
->getDriverAttributes().getAttributeAsDimension2d("MAX_TEXTURE_SIZE"); ->getDriverAttributes().getAttributeAsDimension2d("MAX_TEXTURE_SIZE");
if (tex_size.Width > max_size.Width || CVS->useArrayTextures()) if (tex_size.Width > max_size.Width)
{ {
tex_size.Width = max_size.Width; tex_size.Width = max_size.Width;
} }
if (tex_size.Height > max_size.Height || CVS->useArrayTextures()) if (tex_size.Height > max_size.Height)
{ {
tex_size.Height = max_size.Height; tex_size.Height = max_size.Height;
} }
@ -254,7 +222,7 @@ bool SPTexture::compressedTexImage2d(std::shared_ptr<video::IImage> texture,
#ifndef SERVER_ONLY #ifndef SERVER_ONLY
unsigned format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; unsigned format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
#ifndef USE_GLES2 #ifndef USE_GLES2
if (m_undo_srgb && !CVS->useArrayTextures()) if (m_undo_srgb)
{ {
format = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT; format = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
} }
@ -273,96 +241,12 @@ bool SPTexture::compressedTexImage2d(std::shared_ptr<video::IImage> texture,
compressed += cur_mipmap_size; compressed += cur_mipmap_size;
} }
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
addTextureHandle();
m_width.store(mipmap_sizes[0].first.Width); m_width.store(mipmap_sizes[0].first.Width);
m_height.store(mipmap_sizes[0].first.Height); m_height.store(mipmap_sizes[0].first.Height);
#endif #endif
return true; return true;
} // compressedTexImage2d } // compressedTexImage2d
// ----------------------------------------------------------------------------
bool SPTexture::compressedTexImage3d(std::shared_ptr<video::IImage> texture,
const std::vector<std::pair
<core::dimension2du, unsigned> >&
mipmap_sizes)
{
#ifndef SERVER_ONLY
assert(m_texture_array_idx != -1);
glBindTexture(GL_TEXTURE_2D_ARRAY,
SPTextureManager::get()->getTextureArrayName());
uint8_t* compressed = (uint8_t*)texture->lock();
unsigned cur_mipmap_size = 0;
for (unsigned i = 0; i < mipmap_sizes.size(); i++)
{
cur_mipmap_size = mipmap_sizes[i].second;
glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, i,
0, 0, m_texture_array_idx,
mipmap_sizes[i].first.Width, mipmap_sizes[i].first.Height, 1,
GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, cur_mipmap_size, compressed);
compressed += cur_mipmap_size;
}
glBindTexture(GL_TEXTURE_2D_ARRAY, 0);
m_width.store(mipmap_sizes[0].first.Width);
m_height.store(mipmap_sizes[0].first.Height);
#endif
return true;
} // compressedTexImage3d
// ----------------------------------------------------------------------------
bool SPTexture::texImage3d(std::shared_ptr<video::IImage> texture,
std::shared_ptr<video::IImage> mipmaps)
{
#ifndef SERVER_ONLY
assert(m_texture_array_idx != -1);
if (texture)
{
#ifdef USE_GLES2
unsigned upload_format = GL_RGBA;
#else
unsigned upload_format = GL_BGRA;
#endif
glBindTexture(GL_TEXTURE_2D_ARRAY,
SPTextureManager::get()->getTextureArrayName());
glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, m_texture_array_idx,
texture->getDimension().Width, texture->getDimension().Height,
1, upload_format, GL_UNSIGNED_BYTE, texture->lock());
assert(mipmaps);
std::vector<std::pair<core::dimension2du, unsigned> >
mipmap_sizes;
unsigned width = texture->getDimension().Width;
unsigned height = texture->getDimension().Height;
mipmap_sizes.emplace_back(core::dimension2du(width, height),
width * height * 4);
while (true)
{
width = width < 2 ? 1 : width >> 1;
height = height < 2 ? 1 : height >> 1;
mipmap_sizes.emplace_back
(core::dimension2du(width, height), width * height * 4);
if (width == 1 && height == 1)
{
break;
}
}
uint8_t* ptr = (uint8_t*)mipmaps->lock();
for (unsigned i = 1; i < mipmap_sizes.size(); i++)
{
glTexSubImage3D(GL_TEXTURE_2D_ARRAY, i, 0, 0, m_texture_array_idx,
mipmap_sizes[i].first.Width, mipmap_sizes[i].first.Height,
1, upload_format, GL_UNSIGNED_BYTE, ptr);
ptr += mipmap_sizes[i].second;
}
glBindTexture(GL_TEXTURE_2D_ARRAY, 0);
}
m_width.store(irr_driver->getVideoDriver()->getDriverAttributes()
.getAttributeAsDimension2d("MAX_TEXTURE_SIZE").Width);
m_height.store(m_width.load());
#endif
return true;
} // texImage3d
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
bool SPTexture::texImage2d(std::shared_ptr<video::IImage> texture, bool SPTexture::texImage2d(std::shared_ptr<video::IImage> texture,
std::shared_ptr<video::IImage> mipmaps) std::shared_ptr<video::IImage> mipmaps)
@ -415,7 +299,6 @@ bool SPTexture::texImage2d(std::shared_ptr<video::IImage> texture,
} }
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
} }
addTextureHandle();
if (texture) if (texture)
{ {
m_width.store(texture->getDimension().Width); m_width.store(texture->getDimension().Width);
@ -565,29 +448,45 @@ bool SPTexture::threadedLoad()
applyMask(image.get(), mask.get()); applyMask(image.get(), mask.get());
} }
std::shared_ptr<video::IImage> mipmaps; std::shared_ptr<video::IImage> mipmaps;
if (CVS->useArrayTextures())
if (!m_cache_directory.empty() &&
CVS->isTextureCompressionEnabled() && image &&
image->getDimension().Width >= 4 &&
image->getDimension().Height >= 4)
{ {
if (CVS->isTextureCompressionEnabled()) auto r = compressTexture(image);
SPTextureManager::get()->increaseGLCommandFunctionCount(1);
SPTextureManager::get()->addGLCommandFunction(
[this, image, r]()->bool
{ return compressedTexImage2d(image, r); });
if (!cache_loc.empty())
{ {
auto r = compressTexture(image); SPTextureManager::get()->addThreadedFunction(
SPTextureManager::get()->increaseGLCommandFunctionCount(1); [this, image, r, cache_loc]()->bool
SPTextureManager::get()->addGLCommandFunction( {
[this, image, r]()->bool return saveCompressedTexture(image, r, cache_loc);
{ return compressedTexImage3d(image, r); }); });
} }
else }
else
{
#ifndef USE_GLES2
if (UserConfigParams::m_hq_mipmap && image &&
image->getDimension().Width > 1 &&
image->getDimension().Height > 1)
{ {
std::vector<std::pair<core::dimension2du, unsigned> > std::vector<std::pair<core::dimension2du, unsigned> >
mipmap_sizes; mipmap_sizes;
unsigned width = image->getDimension().Width; unsigned width = image->getDimension().Width;
unsigned height = image->getDimension().Height; unsigned height = image->getDimension().Height;
mipmap_sizes.emplace_back(core::dimension2du(width, height), 0); mipmap_sizes.emplace_back(core::dimension2du(width, height),
0);
while (true) while (true)
{ {
width = width < 2 ? 1 : width >> 1; width = width < 2 ? 1 : width >> 1;
height = height < 2 ? 1 : height >> 1; height = height < 2 ? 1 : height >> 1;
mipmap_sizes.emplace_back(core::dimension2du(width, height), mipmap_sizes.emplace_back
0); (core::dimension2du(width, height), 0);
if (width == 1 && height == 1) if (width == 1 && height == 1)
{ {
break; break;
@ -595,71 +494,16 @@ bool SPTexture::threadedLoad()
} }
mipmaps.reset(irr_driver->getVideoDriver()->createImage mipmaps.reset(irr_driver->getVideoDriver()->createImage
(video::ECF_A8R8G8B8, mipmap_sizes[0].first)); (video::ECF_A8R8G8B8, mipmap_sizes[0].first));
generateQuickMipmap(image, mipmap_sizes, generateHQMipmap(image->lock(), mipmap_sizes,
(uint8_t*)mipmaps->lock()); (uint8_t*)mipmaps->lock());
SPTextureManager::get()->increaseGLCommandFunctionCount(1);
SPTextureManager::get()->addGLCommandFunction(
[this, image, mipmaps]()->bool
{ return texImage3d(image, mipmaps); });
} }
}
else
{
if (!m_cache_directory.empty() &&
CVS->isTextureCompressionEnabled() && image &&
image->getDimension().Width >= 4 &&
image->getDimension().Height >= 4)
{
auto r = compressTexture(image);
SPTextureManager::get()->increaseGLCommandFunctionCount(1);
SPTextureManager::get()->addGLCommandFunction(
[this, image, r]()->bool
{ return compressedTexImage2d(image, r); });
if (!cache_loc.empty())
{
SPTextureManager::get()->addThreadedFunction(
[this, image, r, cache_loc]()->bool
{
return saveCompressedTexture(image, r, cache_loc);
});
}
}
else
{
#ifndef USE_GLES2
if (UserConfigParams::m_hq_mipmap && image &&
image->getDimension().Width > 1 &&
image->getDimension().Height > 1)
{
std::vector<std::pair<core::dimension2du, unsigned> >
mipmap_sizes;
unsigned width = image->getDimension().Width;
unsigned height = image->getDimension().Height;
mipmap_sizes.emplace_back(core::dimension2du(width, height),
0);
while (true)
{
width = width < 2 ? 1 : width >> 1;
height = height < 2 ? 1 : height >> 1;
mipmap_sizes.emplace_back
(core::dimension2du(width, height), 0);
if (width == 1 && height == 1)
{
break;
}
}
mipmaps.reset(irr_driver->getVideoDriver()->createImage
(video::ECF_A8R8G8B8, mipmap_sizes[0].first));
generateHQMipmap(image->lock(), mipmap_sizes,
(uint8_t*)mipmaps->lock());
}
#endif #endif
SPTextureManager::get()->increaseGLCommandFunctionCount(1); SPTextureManager::get()->increaseGLCommandFunctionCount(1);
SPTextureManager::get()->addGLCommandFunction( SPTextureManager::get()->addGLCommandFunction(
[this, image, mipmaps]()->bool [this, image, mipmaps]()->bool
{ return texImage2d(image, mipmaps); }); { return texImage2d(image, mipmaps); });
}
} }
#endif #endif
return true; return true;
} // threadedLoad } // threadedLoad
@ -798,12 +642,6 @@ void SPTexture::applyMask(video::IImage* texture, video::IImage* mask)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
bool SPTexture::initialized() const bool SPTexture::initialized() const
{ {
#ifndef SERVER_ONLY
if (CVS->isARBBindlessTextureUsable())
{
return m_texture_handle != 0;
}
#endif
return m_width.load() != 0 && m_height.load() != 0; return m_width.load() != 0 && m_height.load() != 0;
} // initialized } // initialized
@ -931,9 +769,8 @@ std::vector<std::pair<core::dimension2du, unsigned> >
break; break;
} }
} }
// For array textures all textures need to have a same internal format
const unsigned tc_flag = squish::kDxt5 | stk_config->m_tc_quality; const unsigned tc_flag = squish::kDxt5 | stk_config->m_tc_quality;
// | (m_undo_srgb && CVS->useArrayTextures() ? squish::kToLinear : 0);
const unsigned compressed_size = squish::GetStorageRequirements( const unsigned compressed_size = squish::GetStorageRequirements(
mipmap_sizes[0].first.Width, mipmap_sizes[0].first.Height, mipmap_sizes[0].first.Width, mipmap_sizes[0].first.Height,
tc_flag); tc_flag);

30
src/graphics/sp/sp_texture.hpp
View File

@ -48,16 +48,12 @@ private:
std::string m_cache_directory; std::string m_cache_directory;
int m_texture_array_idx;
GLuint m_texture_name = 0; GLuint m_texture_name = 0;
std::atomic_uint m_width; std::atomic_uint m_width;
std::atomic_uint m_height; std::atomic_uint m_height;
uint64_t m_texture_handle = 0;
Material* m_material; Material* m_material;
const bool m_undo_srgb; const bool m_undo_srgb;
@ -141,22 +137,15 @@ private:
#endif #endif
} }
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
SPTexture(bool white, int ta_idx); SPTexture(bool white);
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
bool texImage2d(std::shared_ptr<video::IImage> texture, bool texImage2d(std::shared_ptr<video::IImage> texture,
std::shared_ptr<video::IImage> mipmaps); std::shared_ptr<video::IImage> mipmaps);
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
bool texImage3d(std::shared_ptr<video::IImage> texture,
std::shared_ptr<video::IImage> mipmaps);
// ------------------------------------------------------------------------
bool compressedTexImage2d(std::shared_ptr<video::IImage> texture, bool compressedTexImage2d(std::shared_ptr<video::IImage> texture,
const std::vector<std::pair<core::dimension2du, const std::vector<std::pair<core::dimension2du,
unsigned> >& mipmap_sizes); unsigned> >& mipmap_sizes);
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
bool compressedTexImage3d(std::shared_ptr<video::IImage> texture,
const std::vector<std::pair<core::dimension2du,
unsigned> >& mipmap_sizes);
// ------------------------------------------------------------------------
bool saveCompressedTexture(std::shared_ptr<video::IImage> texture, bool saveCompressedTexture(std::shared_ptr<video::IImage> texture,
const std::vector<std::pair<core::dimension2du, const std::vector<std::pair<core::dimension2du,
unsigned> >& sizes, unsigned> >& sizes,
@ -174,19 +163,19 @@ public:
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
static std::shared_ptr<SPTexture> getWhiteTexture() static std::shared_ptr<SPTexture> getWhiteTexture()
{ {
SPTexture* tex = new SPTexture(true/*white*/, 0); SPTexture* tex = new SPTexture(true/*white*/);
tex->m_path = "unicolor_white"; tex->m_path = "unicolor_white";
return std::shared_ptr<SPTexture>(tex); return std::shared_ptr<SPTexture>(tex);
} }
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
static std::shared_ptr<SPTexture> getTransparentTexture() static std::shared_ptr<SPTexture> getTransparentTexture()
{ {
SPTexture* tex = new SPTexture(false/*white*/, 1); SPTexture* tex = new SPTexture(false/*white*/);
return std::shared_ptr<SPTexture>(tex); return std::shared_ptr<SPTexture>(tex);
} }
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
SPTexture(const std::string& path, Material* m, bool undo_srgb, SPTexture(const std::string& path, Material* m, bool undo_srgb,
int ta_idx, const std::string& container_id); const std::string& container_id);
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
~SPTexture(); ~SPTexture();
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
@ -196,14 +185,6 @@ public:
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
GLuint getOpenGLTextureName() const { return m_texture_name; } GLuint getOpenGLTextureName() const { return m_texture_name; }
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
uint64_t getTextureHandle() const { return m_texture_handle; }
// ------------------------------------------------------------------------
const uint64_t* getTextureHandlePointer() const
{
assert(m_texture_handle != 0);
return &m_texture_handle;
}
// ------------------------------------------------------------------------
bool initialized() const; bool initialized() const;
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
unsigned getWidth() const { return m_width.load(); } unsigned getWidth() const { return m_width.load(); }
@ -211,8 +192,7 @@ public:
unsigned getHeight() const { return m_height.load(); } unsigned getHeight() const { return m_height.load(); }
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
bool threadedLoad(); bool threadedLoad();
// ------------------------------------------------------------------------
int getTextureArrayIndex() const { return m_texture_array_idx; }
}; };

109
src/graphics/sp/sp_texture_manager.cpp
View File

@ -27,11 +27,6 @@
#include <string> #include <string>
const int MAX_TA = 256;
#ifndef USE_GLES2
#include <squish.h>
#endif
namespace SP namespace SP
{ {
SPTextureManager* SPTextureManager::m_sptm = NULL; SPTextureManager* SPTextureManager::m_sptm = NULL;
@ -76,17 +71,6 @@ SPTextureManager::SPTextureManager()
} }
}); });
} }
if (CVS->useArrayTextures())
{
Log::info("SPTextureManager", "Enable array textures, size %d",
irr_driver->getVideoDriver()->getDriverAttributes()
.getAttributeAsDimension2d("MAX_TEXTURE_SIZE").Width);
glGenTextures(1, &m_all_textures_array);
sp_prefilled_tex[0] = m_all_textures_array;
initTextureArray();
}
m_textures["unicolor_white"] = SPTexture::getWhiteTexture(); m_textures["unicolor_white"] = SPTexture::getWhiteTexture();
m_textures[""] = SPTexture::getTransparentTexture(); m_textures[""] = SPTexture::getTransparentTexture();
} // SPTextureManager } // SPTextureManager
@ -104,81 +88,8 @@ SPTextureManager::~SPTextureManager()
t.join(); t.join();
} }
m_threaded_load_obj.clear(); m_threaded_load_obj.clear();
if (m_all_textures_array != 0)
{
glDeleteTextures(1, &m_all_textures_array);
}
} // ~SPTextureManager } // ~SPTextureManager
// ----------------------------------------------------------------------------
void SPTextureManager::initTextureArray()
{
#ifdef USE_GLES2
unsigned upload_format = GL_RGBA;
#else
unsigned upload_format = GL_BGRA;
#endif
const unsigned size = irr_driver->getVideoDriver()->getDriverAttributes()
.getAttributeAsDimension2d("MAX_TEXTURE_SIZE").Width;
std::vector<unsigned> white, transparent;
white.resize(size * size, -1);
transparent.resize(size * size, 0);
glBindTexture(GL_TEXTURE_2D_ARRAY, m_all_textures_array);
#if !(defined(SERVER_ONLY) || defined(USE_GLES2))
if (CVS->isTextureCompressionEnabled())
{
std::vector<std::pair<core::dimension2du, unsigned> > mipmap_sizes;
unsigned width = size;
unsigned height = size;
mipmap_sizes.emplace_back(core::dimension2du(width, height),
squish::GetStorageRequirements(width, height, squish::kDxt5));
while (true)
{
width = width < 2 ? 1 : width >> 1;
height = height < 2 ? 1 : height >> 1;
mipmap_sizes.emplace_back(core::dimension2du(width, height),
squish::GetStorageRequirements(width, height, squish::kDxt5));
if (width == 1 && height == 1)
{
break;
}
}
unsigned cur_mipmap_size = 0;
for (unsigned i = 0; i < mipmap_sizes.size(); i++)
{
cur_mipmap_size = mipmap_sizes[i].second;
glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, i,
GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
mipmap_sizes[i].first.Width, mipmap_sizes[i].first.Height,
MAX_TA, 0, cur_mipmap_size * MAX_TA, NULL);
glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, i,
0, 0, 0,
mipmap_sizes[i].first.Width, mipmap_sizes[i].first.Height, 1,
GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, cur_mipmap_size,
white.data());
glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, i,
0, 0, 1,
mipmap_sizes[i].first.Width, mipmap_sizes[i].first.Height, 1,
GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, cur_mipmap_size,
transparent.data());
}
}
else
#endif
{
glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA,
size, size, MAX_TA, 0, upload_format, GL_UNSIGNED_BYTE, NULL);
glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0,
size, size, 1, upload_format, GL_UNSIGNED_BYTE,
white.data());
glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 1,
size, size, 1, upload_format, GL_UNSIGNED_BYTE,
transparent.data());
glGenerateMipmap(GL_TEXTURE_2D_ARRAY);
}
glBindTexture(GL_TEXTURE_2D_ARRAY, 0);
} // initTextureArray
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
void SPTextureManager::checkForGLCommand(bool before_scene) void SPTextureManager::checkForGLCommand(bool before_scene)
{ {
@ -234,21 +145,8 @@ std::shared_ptr<SPTexture> SPTextureManager::getTexture(const std::string& p,
{ {
return ret->second; return ret->second;
} }
int ta_idx = -1;
if (CVS->useArrayTextures())
{
ta_idx = getTextureArrayIndex();
if (ta_idx > MAX_TA)
{
Log::error("SPTextureManager", "Too many textures");
// Give user a transparent texture
return m_textures.at("");
}
}
std::shared_ptr<SPTexture> t = std::shared_ptr<SPTexture> t =
std::make_shared<SPTexture>(p, m, undo_srgb, ta_idx, cid); std::make_shared<SPTexture>(p, m, undo_srgb, cid);
addThreadedFunction(std::bind(&SPTexture::threadedLoad, t)); addThreadedFunction(std::bind(&SPTexture::threadedLoad, t));
m_textures[p] = t; m_textures[p] = t;
return t; return t;
@ -261,11 +159,6 @@ void SPTextureManager::removeUnusedTextures()
{ {
if (it->second.use_count() == 1) if (it->second.use_count() == 1)
{ {
int ta_idx = it->second->getTextureArrayIndex();
if (ta_idx != -1)
{
m_freed_texture_array_idx.push_back(ta_idx);
}
it = m_textures.erase(it); it = m_textures.erase(it);
} }
else else

21
src/graphics/sp/sp_texture_manager.hpp
View File

@ -47,8 +47,6 @@ class SPTextureManager : public NoCopy
private: private:
static SPTextureManager* m_sptm; static SPTextureManager* m_sptm;
GLuint m_all_textures_array = 0;
std::unordered_map<std::string, std::shared_ptr<SPTexture> > m_textures; std::unordered_map<std::string, std::shared_ptr<SPTexture> > m_textures;
std::atomic_uint m_max_threaded_load_obj; std::atomic_uint m_max_threaded_load_obj;
@ -65,11 +63,6 @@ private:
std::list<std::thread> m_threaded_load_obj; std::list<std::thread> m_threaded_load_obj;
std::list<int> m_freed_texture_array_idx;
// ------------------------------------------------------------------------
void initTextureArray();
public: public:
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
static SPTextureManager* get() static SPTextureManager* get()
@ -118,19 +111,7 @@ public:
int dumpTextureUsage(); int dumpTextureUsage();
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
void dumpAllTexture(); void dumpAllTexture();
// ------------------------------------------------------------------------
int getTextureArrayIndex()
{
if (!m_freed_texture_array_idx.empty())
{
int ret = m_freed_texture_array_idx.front();
m_freed_texture_array_idx.pop_front();
return ret;
}
return (int)m_textures.size();
}
// ------------------------------------------------------------------------
GLuint getTextureArrayName() const { return m_all_textures_array; }
}; };
} }