copy {
from "${projRoot}/builtin" into "${assetsFolder}/builtin"
}
- /*copy {
- // ToDo: fix Minetest shaders that currently don't work with OpenGL ES
+ copy {
from "${projRoot}/client/shaders" into "${assetsFolder}/client/shaders"
- }*/
+ }
copy {
from "../native/deps/Android/Irrlicht/shaders" into "${assetsFolder}/client/shaders/Irrlicht"
}
"box[8,0;3.75,4.5;#999999]"
local video_driver = core.settings:get("video_driver")
- local shaders_supported = video_driver == "opengl"
- local shaders_enabled = false
- if shaders_supported then
- shaders_enabled = core.settings:get_bool("enable_shaders")
+ local shaders_enabled = core.settings:get_bool("enable_shaders")
+ if video_driver == "opengl" then
tab_string = tab_string ..
"checkbox[8.25,0;cb_shaders;" .. fgettext("Shaders") .. ";"
.. tostring(shaders_enabled) .. "]"
+ elseif video_driver == "ogles2" then
+ tab_string = tab_string ..
+ "checkbox[8.25,0;cb_shaders;" .. fgettext("Shaders (experimental)") .. ";"
+ .. tostring(shaders_enabled) .. "]"
else
core.settings:set_bool("enable_shaders", false)
+ shaders_enabled = false
tab_string = tab_string ..
"label[8.38,0.2;" .. core.colorize("#888888",
fgettext("Shaders (unavailable)")) .. "]"
# The rendering back-end for Irrlicht.
# A restart is required after changing this.
# Note: On Android, stick with OGLES1 if unsure! App may fail to start otherwise.
-# On other platforms, OpenGL is recommended, and it’s the only driver with
-# shader support currently.
+# On other platforms, OpenGL is recommended.
+# Shaders are supported by OpenGL (desktop only) and OGLES2 (experimental)
video_driver (Video driver) enum opengl null,software,burningsvideo,direct3d8,direct3d9,opengl,ogles1,ogles2
# Radius of cloud area stated in number of 64 node cloud squares.
#define rightImage normalTexture
#define maskImage textureFlags
+varying mediump vec2 varTexCoord;
+
void main(void)
{
- vec2 uv = gl_TexCoord[0].st;
+ vec2 uv = varTexCoord.st;
vec4 left = texture2D(leftImage, uv).rgba;
vec4 right = texture2D(rightImage, uv).rgba;
vec4 mask = texture2D(maskImage, uv).rgba;
+varying mediump vec2 varTexCoord;
+
void main(void)
{
- gl_TexCoord[0] = gl_MultiTexCoord0;
- gl_Position = gl_Vertex;
- gl_FrontColor = gl_BackColor = gl_Color;
+ varTexCoord = inTexCoord0;
+ gl_Position = inVertexPosition;
}
+varying lowp vec4 varColor;
+
void main(void)
{
- gl_FragColor = gl_Color;
+ gl_FragColor = varColor;
}
-uniform mat4 mWorldViewProj;
+varying lowp vec4 varColor;
void main(void)
{
- gl_TexCoord[0] = gl_MultiTexCoord0;
- gl_Position = mWorldViewProj * gl_Vertex;
-
- gl_FrontColor = gl_BackColor = gl_Color;
+ gl_Position = mWorldViewProj * inVertexPosition;
+ varColor = inVertexColor;
}
uniform sampler2D normalTexture;
uniform vec3 yawVec;
+varying lowp vec4 varColor;
+varying mediump vec2 varTexCoord;
+
void main (void)
{
- vec2 uv = gl_TexCoord[0].st;
+ vec2 uv = varTexCoord.st;
//texture sampling rate
const float step = 1.0 / 256.0;
vec3 color = (1.1 * diffuse + 0.05 * height + 0.5 * specular) * base.rgb;
vec4 col = vec4(color.rgb, base.a);
- col *= gl_Color;
+ col *= varColor;
gl_FragColor = vec4(col.rgb, base.a);
}
-uniform mat4 mWorldViewProj;
uniform mat4 mWorld;
+varying lowp vec4 varColor;
+varying mediump vec2 varTexCoord;
+
void main(void)
{
- gl_TexCoord[0] = gl_MultiTexCoord0;
- gl_Position = mWorldViewProj * gl_Vertex;
- gl_FrontColor = gl_BackColor = gl_Color;
+ varTexCoord = inTexCoord0.st;
+ gl_Position = mWorldViewProj * inVertexPosition;
+ varColor = inVertexColor;
}
// cameraOffset + worldPosition (for large coordinates the limits of float
// precision must be considered).
varying vec3 worldPosition;
-
+varying lowp vec4 varColor;
+varying mediump vec2 varTexCoord;
varying vec3 eyeVec;
const float fogStart = FOG_START;
-const float fogShadingParameter = 1 / ( 1 - fogStart);
+const float fogShadingParameter = 1.0 / ( 1.0 - fogStart);
#ifdef ENABLE_TONE_MAPPING
void main(void)
{
vec3 color;
- vec2 uv = gl_TexCoord[0].st;
+ vec2 uv = varTexCoord.st;
vec4 base = texture2D(baseTexture, uv).rgba;
-
#ifdef USE_DISCARD
// If alpha is zero, we can just discard the pixel. This fixes transparency
- // on GPUs like GC7000L, where GL_ALPHA_TEST is not implemented in mesa.
+ // on GPUs like GC7000L, where GL_ALPHA_TEST is not implemented in mesa,
+ // and also on GLES 2, where GL_ALPHA_TEST is missing entirely.
if (base.a == 0.0) {
discard;
}
color = base.rgb;
- vec4 col = vec4(color.rgb * gl_Color.rgb, 1.0);
+ vec4 col = vec4(color.rgb * varColor.rgb, 1.0);
#ifdef ENABLE_TONE_MAPPING
col = applyToneMapping(col);
-uniform mat4 mWorldViewProj;
uniform mat4 mWorld;
// Color of the light emitted by the sun.
// cameraOffset + worldPosition (for large coordinates the limits of float
// precision must be considered).
varying vec3 worldPosition;
-
+varying lowp vec4 varColor;
+varying mediump vec2 varTexCoord;
varying vec3 eyeVec;
// Color of the light emitted by the light sources.
void main(void)
{
- gl_TexCoord[0] = gl_MultiTexCoord0;
+ varTexCoord = inTexCoord0.st;
float disp_x;
float disp_z;
// OpenGL < 4.3 does not support continued preprocessor lines
#if (MATERIAL_TYPE == TILE_MATERIAL_WAVING_LEAVES && ENABLE_WAVING_LEAVES) || (MATERIAL_TYPE == TILE_MATERIAL_WAVING_PLANTS && ENABLE_WAVING_PLANTS)
- vec4 pos2 = mWorld * gl_Vertex;
+ vec4 pos2 = mWorld * inVertexPosition;
float tOffset = (pos2.x + pos2.y) * 0.001 + pos2.z * 0.002;
disp_x = (smoothTriangleWave(animationTimer * 23.0 + tOffset) +
smoothTriangleWave(animationTimer * 11.0 + tOffset)) * 0.4;
smoothTriangleWave(animationTimer * 13.0 + tOffset)) * 0.5;
#endif
- worldPosition = (mWorld * gl_Vertex).xyz;
+ worldPosition = (mWorld * inVertexPosition).xyz;
// OpenGL < 4.3 does not support continued preprocessor lines
#if (MATERIAL_TYPE == TILE_MATERIAL_WAVING_LIQUID_TRANSPARENT || MATERIAL_TYPE == TILE_MATERIAL_WAVING_LIQUID_OPAQUE || MATERIAL_TYPE == TILE_MATERIAL_WAVING_LIQUID_BASIC) && ENABLE_WAVING_WATER
// Generate waves with Perlin-type noise.
// The constants are calibrated such that they roughly
// correspond to the old sine waves.
- vec4 pos = gl_Vertex;
+ vec4 pos = inVertexPosition;
vec3 wavePos = worldPosition + cameraOffset;
// The waves are slightly compressed along the z-axis to get
// wave-fronts along the x-axis.
- wavePos.x /= WATER_WAVE_LENGTH * 3;
- wavePos.z /= WATER_WAVE_LENGTH * 2;
- wavePos.z += animationTimer * WATER_WAVE_SPEED * 10;
- pos.y += (snoise(wavePos) - 1) * WATER_WAVE_HEIGHT * 5;
+ wavePos.x /= WATER_WAVE_LENGTH * 3.0;
+ wavePos.z /= WATER_WAVE_LENGTH * 2.0;
+ wavePos.z += animationTimer * WATER_WAVE_SPEED * 10.0;
+ pos.y += (snoise(wavePos) - 1.0) * WATER_WAVE_HEIGHT * 5.0;
gl_Position = mWorldViewProj * pos;
#elif MATERIAL_TYPE == TILE_MATERIAL_WAVING_LEAVES && ENABLE_WAVING_LEAVES
- vec4 pos = gl_Vertex;
+ vec4 pos = inVertexPosition;
pos.x += disp_x;
pos.y += disp_z * 0.1;
pos.z += disp_z;
gl_Position = mWorldViewProj * pos;
#elif MATERIAL_TYPE == TILE_MATERIAL_WAVING_PLANTS && ENABLE_WAVING_PLANTS
- vec4 pos = gl_Vertex;
- if (gl_TexCoord[0].y < 0.05) {
+ vec4 pos = inVertexPosition;
+ if (varTexCoord.y < 0.05) {
pos.x += disp_x;
pos.z += disp_z;
}
gl_Position = mWorldViewProj * pos;
#else
- gl_Position = mWorldViewProj * gl_Vertex;
+ gl_Position = mWorldViewProj * inVertexPosition;
#endif
vPosition = gl_Position.xyz;
- eyeVec = -(gl_ModelViewMatrix * gl_Vertex).xyz;
+ eyeVec = -(mWorldView * inVertexPosition).xyz;
// Calculate color.
// Red, green and blue components are pre-multiplied with
// The pre-baked colors are halved to prevent overflow.
vec4 color;
// The alpha gives the ratio of sunlight in the incoming light.
- float nightRatio = 1 - gl_Color.a;
- color.rgb = gl_Color.rgb * (gl_Color.a * dayLight.rgb +
- nightRatio * artificialLight.rgb) * 2;
- color.a = 1;
+ float nightRatio = 1.0 - inVertexColor.a;
+ color.rgb = inVertexColor.rgb * (inVertexColor.a * dayLight.rgb +
+ nightRatio * artificialLight.rgb) * 2.0;
+ color.a = 1.0;
// Emphase blue a bit in darker places
// See C++ implementation in mapblock_mesh.cpp final_color_blend()
- float brightness = (color.r + color.g + color.b) / 3;
+ float brightness = (color.r + color.g + color.b) / 3.0;
color.b += max(0.0, 0.021 - abs(0.2 * brightness - 0.021) +
0.07 * brightness);
- gl_FrontColor = gl_BackColor = clamp(color, 0.0, 1.0);
+ varColor = clamp(color, 0.0, 1.0);
}
varying vec3 vNormal;
varying vec3 vPosition;
varying vec3 worldPosition;
+varying lowp vec4 varColor;
+varying mediump vec2 varTexCoord;
varying vec3 eyeVec;
varying float vIDiff;
const float e = 2.718281828459;
const float BS = 10.0;
const float fogStart = FOG_START;
-const float fogShadingParameter = 1 / ( 1 - fogStart);
+const float fogShadingParameter = 1.0 / (1.0 - fogStart);
#ifdef ENABLE_TONE_MAPPING
void main(void)
{
vec3 color;
- vec2 uv = gl_TexCoord[0].st;
+ vec2 uv = varTexCoord.st;
vec4 base = texture2D(baseTexture, uv).rgba;
#ifdef USE_DISCARD
// If alpha is zero, we can just discard the pixel. This fixes transparency
- // on GPUs like GC7000L, where GL_ALPHA_TEST is not implemented in mesa.
+ // on GPUs like GC7000L, where GL_ALPHA_TEST is not implemented in mesa,
+ // and also on GLES 2, where GL_ALPHA_TEST is missing entirely.
if (base.a == 0.0) {
discard;
}
vec4 col = vec4(color.rgb, base.a);
- col.rgb *= gl_Color.rgb;
+ col.rgb *= varColor.rgb;
col.rgb *= emissiveColor.rgb * vIDiff;
-uniform mat4 mWorldViewProj;
uniform mat4 mWorld;
uniform vec3 eyePosition;
varying vec3 vNormal;
varying vec3 vPosition;
varying vec3 worldPosition;
+varying lowp vec4 varColor;
+varying mediump vec2 varTexCoord;
varying vec3 eyeVec;
varying float vIDiff;
{
vec3 v = normal * normal;
- if (normal.y < 0)
- return dot(v, vec3(0.670820f, 0.447213f, 0.836660f));
+ if (normal.y < 0.0)
+ return dot(v, vec3(0.670820, 0.447213, 0.836660));
- return dot(v, vec3(0.670820f, 1.000000f, 0.836660f));
+ return dot(v, vec3(0.670820, 1.000000, 0.836660));
}
void main(void)
{
- gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
- gl_Position = mWorldViewProj * gl_Vertex;
+ varTexCoord = (mTexture * inTexCoord0).st;
+ gl_Position = mWorldViewProj * inVertexPosition;
vPosition = gl_Position.xyz;
- vNormal = gl_Normal;
- worldPosition = (mWorld * gl_Vertex).xyz;
- eyeVec = -(gl_ModelViewMatrix * gl_Vertex).xyz;
+ vNormal = inVertexNormal;
+ worldPosition = (mWorld * inVertexPosition).xyz;
+ eyeVec = -(mWorldView * inVertexPosition).xyz;
#if (MATERIAL_TYPE == TILE_MATERIAL_PLAIN) || (MATERIAL_TYPE == TILE_MATERIAL_PLAIN_ALPHA)
vIDiff = 1.0;
#else
// This is intentional comparison with zero without any margin.
// If normal is not equal to zero exactly, then we assume it's a valid, just not normalized vector
- vIDiff = length(gl_Normal) == 0.0
+ vIDiff = length(inVertexNormal) == 0.0
? 1.0
- : directional_ambient(normalize(gl_Normal));
+ : directional_ambient(normalize(inVertexNormal));
#endif
- gl_FrontColor = gl_BackColor = gl_Color;
+ varColor = inVertexColor;
}
uniform sampler2D baseTexture;
+varying lowp vec4 varColor;
+varying mediump vec2 varTexCoord;
+
void main(void)
{
- vec2 uv = gl_TexCoord[0].st;
+ vec2 uv = varTexCoord.st;
vec4 color = texture2D(baseTexture, uv);
- color.rgb *= gl_Color.rgb;
+ color.rgb *= varColor.rgb;
gl_FragColor = color;
}
-uniform mat4 mWorldViewProj;
+varying lowp vec4 varColor;
+varying mediump vec2 varTexCoord;
void main(void)
{
- gl_TexCoord[0] = gl_MultiTexCoord0;
- gl_Position = mWorldViewProj * gl_Vertex;
+ varTexCoord = inTexCoord0.st;
+ gl_Position = mWorldViewProj * inVertexPosition;
- gl_FrontColor = gl_BackColor = gl_Color;
+ varColor = inVertexColor;
}
description = "Water Source".."\n"..
"Drowning damage: 1",
drawtype = "liquid",
+ waving = 3,
tiles = {"default_water.png"},
special_tiles = {
{name = "default_water.png", backface_culling = false},
description = "Flowing Water".."\n"..
"Drowning damage: 1",
drawtype = "flowingliquid",
+ waving = 3,
tiles = {"default_water_flowing.png"},
special_tiles = {
{name = "default_water_flowing.png", backface_culling = false},
description = "River Water Source".."\n"..
"Drowning damage: 1",
drawtype = "liquid",
+ waving = 3,
tiles = { "default_river_water.png" },
special_tiles = {
{name = "default_river_water.png", backface_culling = false},
description = "Flowing River Water".."\n"..
"Drowning damage: 1",
drawtype = "flowingliquid",
+ waving = 3,
tiles = {"default_river_water_flowing.png"},
special_tiles = {
{name = "default_river_water_flowing.png", backface_culling = false},
#include "log.h"
#include "gamedef.h"
#include "client/tile.h"
+#include "config.h"
#if ENABLE_GLES
#ifdef _IRR_COMPILE_WITH_OGLES1_
{
CachedVertexShaderSetting<float, 16> m_world_view_proj;
CachedVertexShaderSetting<float, 16> m_world;
+#if ENABLE_GLES
+ // Modelview matrix
+ CachedVertexShaderSetting<float, 16> m_world_view;
+ // Texture matrix
+ CachedVertexShaderSetting<float, 16> m_texture;
+ // Normal matrix
+ CachedVertexShaderSetting<float, 9> m_normal;
+#endif
public:
MainShaderConstantSetter() :
- m_world_view_proj("mWorldViewProj"),
- m_world("mWorld")
+ m_world_view_proj("mWorldViewProj")
+ , m_world("mWorld")
+#if ENABLE_GLES
+ , m_world_view("mWorldView")
+ , m_texture("mTexture")
+ , m_normal("mNormal")
+#endif
{}
~MainShaderConstantSetter() = default;
video::IVideoDriver *driver = services->getVideoDriver();
sanity_check(driver);
+ // Set world matrix
+ core::matrix4 world = driver->getTransform(video::ETS_WORLD);
+ if (is_highlevel)
+ m_world.set(*reinterpret_cast<float(*)[16]>(world.pointer()), services);
+ else
+ services->setVertexShaderConstant(world.pointer(), 4, 4);
+
// Set clip matrix
+ core::matrix4 worldView;
+ worldView = driver->getTransform(video::ETS_VIEW);
+ worldView *= world;
core::matrix4 worldViewProj;
worldViewProj = driver->getTransform(video::ETS_PROJECTION);
- worldViewProj *= driver->getTransform(video::ETS_VIEW);
- worldViewProj *= driver->getTransform(video::ETS_WORLD);
+ worldViewProj *= worldView;
if (is_highlevel)
m_world_view_proj.set(*reinterpret_cast<float(*)[16]>(worldViewProj.pointer()), services);
else
services->setVertexShaderConstant(worldViewProj.pointer(), 0, 4);
- // Set world matrix
- core::matrix4 world = driver->getTransform(video::ETS_WORLD);
- if (is_highlevel)
- m_world.set(*reinterpret_cast<float(*)[16]>(world.pointer()), services);
- else
- services->setVertexShaderConstant(world.pointer(), 4, 4);
-
+#if ENABLE_GLES
+ if (is_highlevel) {
+ core::matrix4 texture = driver->getTransform(video::ETS_TEXTURE_0);
+ m_world_view.set(*reinterpret_cast<float(*)[16]>(worldView.pointer()), services);
+ m_texture.set(*reinterpret_cast<float(*)[16]>(texture.pointer()), services);
+
+ core::matrix4 normal;
+ worldView.getTransposed(normal);
+ sanity_check(normal.makeInverse());
+ float m[9] = {
+ normal[0], normal[1], normal[2],
+ normal[4], normal[5], normal[6],
+ normal[8], normal[9], normal[10],
+ };
+ m_normal.set(m, services);
+ }
+#endif
}
};
return shaderinfo;
// Create shaders header
- std::string shaders_header = "#version 120\n";
-
+ bool use_gles = false;
+#if ENABLE_GLES
+ use_gles = driver->getDriverType() == video::EDT_OGLES2;
+#endif
+ std::string shaders_header, vertex_header, pixel_header; // geometry shaders aren’t supported in GLES<3
+ if (use_gles) {
+ shaders_header =
+ "#version 100\n"
+ ;
+ vertex_header = R"(
+ uniform highp mat4 mWorldView;
+ uniform highp mat4 mWorldViewProj;
+ uniform mediump mat4 mTexture;
+ uniform mediump mat3 mNormal;
+
+ attribute highp vec4 inVertexPosition;
+ attribute lowp vec4 inVertexColor;
+ attribute mediump vec4 inTexCoord0;
+ attribute mediump vec3 inVertexNormal;
+ attribute mediump vec4 inVertexTangent;
+ attribute mediump vec4 inVertexBinormal;
+ )";
+ pixel_header = R"(
+ precision mediump float;
+ )";
+ } else {
+ shaders_header = R"(
+ #version 120
+ #define lowp
+ #define mediump
+ #define highp
+ )";
+ vertex_header = R"(
+ #define mWorldView gl_ModelViewMatrix
+ #define mWorldViewProj gl_ModelViewProjectionMatrix
+ #define mTexture (gl_TextureMatrix[0])
+ #define mNormal gl_NormalMatrix
+
+ #define inVertexPosition gl_Vertex
+ #define inVertexColor gl_Color
+ #define inTexCoord0 gl_MultiTexCoord0
+ #define inVertexNormal gl_Normal
+ #define inVertexTangent gl_MultiTexCoord1
+ #define inVertexBinormal gl_MultiTexCoord2
+ )";
+ }
+
+ bool use_discard = use_gles;
#ifdef __unix__
// For renderers that should use discard instead of GL_ALPHA_TEST
const char* gl_renderer = (const char*)glGetString(GL_RENDERER);
- if (strstr(gl_renderer, "GC7000")) {
- shaders_header += "#define USE_DISCARD\n";
- }
+ if (strstr(gl_renderer, "GC7000"))
+ use_discard = true;
#endif
+ if (use_discard && shaderinfo.base_material != video::EMT_SOLID)
+ shaders_header += "#define USE_DISCARD\n";
static const char* drawTypes[] = {
"NDT_NORMAL",
shaders_header += "#define ";
shaders_header += drawTypes[i];
shaders_header += " ";
- shaders_header += itos(i);
+ shaders_header += std::to_string(i);
shaders_header += "\n";
}
shaders_header += "#define ";
shaders_header += materialTypes[i];
shaders_header += " ";
- shaders_header += itos(i);
+ shaders_header += std::to_string(i);
shaders_header += "\n";
}
shaders_header += "#define MATERIAL_TYPE ";
- shaders_header += itos(material_type);
+ shaders_header += std::to_string(material_type);
shaders_header += "\n";
shaders_header += "#define DRAW_TYPE ";
- shaders_header += itos(drawtype);
+ shaders_header += std::to_string(drawtype);
shaders_header += "\n";
if (g_settings->getBool("enable_waving_water")){
shaders_header += "#define ENABLE_WAVING_WATER 1\n";
shaders_header += "#define WATER_WAVE_HEIGHT ";
- shaders_header += ftos(g_settings->getFloat("water_wave_height"));
+ shaders_header += std::to_string(g_settings->getFloat("water_wave_height"));
shaders_header += "\n";
shaders_header += "#define WATER_WAVE_LENGTH ";
- shaders_header += ftos(g_settings->getFloat("water_wave_length"));
+ shaders_header += std::to_string(g_settings->getFloat("water_wave_length"));
shaders_header += "\n";
shaders_header += "#define WATER_WAVE_SPEED ";
- shaders_header += ftos(g_settings->getFloat("water_wave_speed"));
+ shaders_header += std::to_string(g_settings->getFloat("water_wave_speed"));
shaders_header += "\n";
} else{
shaders_header += "#define ENABLE_WAVING_WATER 0\n";
shaders_header += "#define ENABLE_TONE_MAPPING\n";
shaders_header += "#define FOG_START ";
- shaders_header += ftos(rangelim(g_settings->getFloat("fog_start"), 0.0f, 0.99f));
+ shaders_header += std::to_string(rangelim(g_settings->getFloat("fog_start"), 0.0f, 0.99f));
shaders_header += "\n";
// Call addHighLevelShaderMaterial() or addShaderMaterial()
const c8* pixel_program_ptr = 0;
const c8* geometry_program_ptr = 0;
if (!vertex_program.empty()) {
- vertex_program = shaders_header + vertex_program;
+ vertex_program = shaders_header + vertex_header + vertex_program;
vertex_program_ptr = vertex_program.c_str();
}
if (!pixel_program.empty()) {
- pixel_program = shaders_header + pixel_program;
+ pixel_program = shaders_header + pixel_header + pixel_program;
pixel_program_ptr = pixel_program.c_str();
}
if (!geometry_program.empty()) {
geometry_program = "";
is_highlevel = false;
- if(enable_shaders){
- // Look for high level shaders
- if(drivertype == video::EDT_DIRECT3D9){
- // Direct3D 9: HLSL
- // (All shaders in one file)
- vertex_program = sourcecache->getOrLoad(name, "d3d9.hlsl");
- pixel_program = vertex_program;
- geometry_program = vertex_program;
- }
- else if(drivertype == video::EDT_OPENGL){
- // OpenGL: GLSL
- vertex_program = sourcecache->getOrLoad(name, "opengl_vertex.glsl");
- pixel_program = sourcecache->getOrLoad(name, "opengl_fragment.glsl");
- geometry_program = sourcecache->getOrLoad(name, "opengl_geometry.glsl");
- }
- if (!vertex_program.empty() || !pixel_program.empty() || !geometry_program.empty()){
- is_highlevel = true;
- return;
- }
- }
+ if (!enable_shaders)
+ return;
+
+ // Look for high level shaders
+ switch (drivertype) {
+ case video::EDT_DIRECT3D9:
+ // Direct3D 9: HLSL
+ // (All shaders in one file)
+ vertex_program = sourcecache->getOrLoad(name, "d3d9.hlsl");
+ pixel_program = vertex_program;
+ geometry_program = vertex_program;
+ break;
+
+ case video::EDT_OPENGL:
+#if ENABLE_GLES
+ case video::EDT_OGLES2:
+#endif
+ // OpenGL: GLSL
+ vertex_program = sourcecache->getOrLoad(name, "opengl_vertex.glsl");
+ pixel_program = sourcecache->getOrLoad(name, "opengl_fragment.glsl");
+ geometry_program = sourcecache->getOrLoad(name, "opengl_geometry.glsl");
+ break;
+ default:
+ // e.g. OpenGL ES 1 (with no shader support)
+ break;
+ }
+ if (!vertex_program.empty() || !pixel_program.empty() || !geometry_program.empty()){
+ is_highlevel = true;
+ return;
+ }
}
void dumpShaderProgram(std::ostream &output_stream,
projects / minetest.git / commitdiff