ENABLE_GLES predates forking Irrlicht. Its primary use was to distinguish Irrlicht-ogles from upstream version as Minetest could be compiled with either.
That's not necessary anymore and gets in the way sometimes.
ENABLE_CURL=ON - Build with cURL; Enables use of online mod repo, public serverlist and remote media fetching via http
ENABLE_CURSES=ON - Build with (n)curses; Enables a server side terminal (command line option: --terminal)
ENABLE_GETTEXT=ON - Build with Gettext; Allows using translations
- ENABLE_GLES=OFF - Enable extra support code for OpenGL ES (requires support by IrrlichtMt)
ENABLE_LEVELDB=ON - Build with LevelDB; Enables use of LevelDB map backend
ENABLE_POSTGRESQL=ON - Build with libpq; Enables use of PostgreSQL map backend (PostgreSQL 9.5 or greater recommended)
ENABLE_REDIS=ON - Build with libhiredis; Enables use of Redis map backend
LOCAL_CFLAGS += \
-DJSONCPP_NO_LOCALE_SUPPORT \
-DHAVE_TOUCHSCREENGUI \
- -DENABLE_GLES=1 \
-DUSE_CURL=1 \
-DUSE_SOUND=1 \
-DUSE_LEVELDB=0 \
[**Camera]
-# Camera 'near clipping plane' distance in nodes, between 0 and 0.25
-# Only works on GLES platforms. Most users will not need to change this.
-# Increasing can reduce artifacting on weaker GPUs.
-# 0.1 = Default, 0.25 = Good value for weaker tablets.
-near_plane (Near plane) float 0.1 0 0.25
-
# Field of view in degrees.
fov (Field of view) int 72 45 160
endif()
endif()
-# TODO: this should be removed one day, we can enable it unconditionally
-option(ENABLE_GLES "Enable extra support code for OpenGL ES" FALSE)
-mark_as_advanced(ENABLE_GLES)
-
option(ENABLE_TOUCH "Enable Touchscreen support" FALSE)
if(ENABLE_TOUCH)
add_definitions(-DHAVE_TOUCHSCREENGUI)
{
f32 viewing_range = g_settings->getFloat("viewing_range");
- // Ignore near_plane setting on all other platforms to prevent abuse
-#if ENABLE_GLES
- m_cameranode->setNearValue(rangelim(
- g_settings->getFloat("near_plane"), 0.0f, 0.25f) * BS);
-#else
m_cameranode->setNearValue(0.1f * BS);
-#endif
m_draw_control.wanted_range = std::fmin(adjustDist(viewing_range, getFovMax()), 4000);
if (m_draw_control.range_all) {
(u32)destrect.getHeight()));
imageScaleNNAA(srcimg, srcrect, destimg);
-#if ENABLE_GLES
// Some platforms are picky about textures being powers of 2, so expand
// the image dimensions to the next power of 2, if necessary.
if (!driver->queryFeature(video::EVDF_TEXTURE_NPOT)) {
destimg->drop();
destimg = po2img;
}
-#endif
// Convert the scaled image back into a texture.
scaled = driver->addTexture(scalename, destimg);
#include "render/factory.h"
#include "inputhandler.h"
#include "gettext.h"
+#include "filesys.h"
#include "../gui/guiSkin.h"
#if !defined(_WIN32) && !defined(__APPLE__) && !defined(__ANDROID__) && \
#include <winuser.h>
#endif
-#if ENABLE_GLES
-#include "filesys.h"
-#endif
-
RenderingEngine *RenderingEngine::s_singleton = nullptr;
const float RenderingEngine::BASE_BLOOM_STRENGTH = 1.0f;
#ifdef __ANDROID__
params.PrivateData = porting::app_global;
#endif
-#if ENABLE_GLES
// there is no standardized path for these on desktop
std::string rel_path = std::string("client") + DIR_DELIM
+ "shaders" + DIR_DELIM + "Irrlicht";
params.OGLES2ShaderPath = (porting::path_share + DIR_DELIM + rel_path + DIR_DELIM).c_str();
-#endif
m_device = createDeviceEx(params);
driver = m_device->getVideoDriver();
const video::SExposedVideoData exposedData = driver->getExposedVideoData();
switch (driver->getDriverType()) {
-#if ENABLE_GLES
case video::EDT_OGLES1:
case video::EDT_OGLES2:
-#endif
case video::EDT_OPENGL:
hWnd = reinterpret_cast<HWND>(exposedData.OpenGLWin32.HWnd);
break;
CachedVertexShaderSetting<f32> m_perspective_zbias_vertex;
CachedPixelShaderSetting<f32> m_perspective_zbias_pixel;
-#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_perspective_bias1_pixel("xyPerspectiveBias1")
, m_perspective_zbias_vertex("zPerspectiveBias")
, m_perspective_zbias_pixel("zPerspectiveBias")
-#if ENABLE_GLES
, m_world_view("mWorldView")
, m_texture("mTexture")
, m_normal("mNormal")
-#endif
{}
~MainShaderConstantSetter() = default;
worldViewProj *= worldView;
m_world_view_proj.set(*reinterpret_cast<float(*)[16]>(worldViewProj.pointer()), services);
-#if ENABLE_GLES
- 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
+ if (driver->getDriverType() == video::EDT_OGLES2) {
+ 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);
+ }
// Set uniforms for Shadow shader
if (ShadowRenderer *shadow = RenderingEngine::get_shadow_renderer()) {
video::IGPUProgrammingServices *gpu = driver->getGPUProgrammingServices();
// Create shaders header
- bool use_gles = false;
-#if ENABLE_GLES
- use_gles = driver->getDriverType() == video::EDT_OGLES2;
-#endif
+ bool use_gles = driver->getDriverType() == video::EDT_OGLES2;
std::stringstream shaders_header;
shaders_header
<< std::noboolalpha
#include <algorithm>
#include <ICameraSceneNode.h>
+#include <IVideoDriver.h>
#include "util/string.h"
#include "util/container.h"
#include "util/thread.h"
video::ITexture *tex = NULL;
if (img != NULL) {
-#if ENABLE_GLES
img = Align2Npot2(img, driver);
-#endif
// Create texture from resulting image
tex = driver->addTexture(name.c_str(), img);
guiScalingCache(io::path(name.c_str()), driver, img);
// shouldn't really need to be done, but can't hurt
std::set<std::string> source_image_names;
video::IImage *img = generateImage(ti.name, source_image_names);
-#if ENABLE_GLES
img = Align2Npot2(img, driver);
-#endif
// Create texture from resulting image
video::ITexture *t = NULL;
if (img) {
return baseimg;
}
-#if ENABLE_GLES
-
/**
* Check and align image to npot2 if required by hardware
* @param image image to check for npot2 alignment
return targetimage;
}
-#endif
-
static std::string unescape_string(const std::string &str, const char esc = '\\')
{
std::string out;
#include "util/numeric.h"
#include "config.h"
-#if ENABLE_GLES
-#include <IVideoDriver.h>
-#endif
-
class IGameDef;
struct TileSpec;
struct TileDef;
+namespace irr { namespace video { class IVideoDriver; } }
+
typedef std::vector<video::SColor> Palette;
/*
IWritableTextureSource *createTextureSource();
-#if ENABLE_GLES
video::IImage *Align2Npot2(video::IImage *image, video::IVideoDriver *driver);
-#endif
enum MaterialType{
TILE_MATERIAL_BASIC,
#cmakedefine01 USE_SPATIAL
#cmakedefine01 USE_SYSTEM_GMP
#cmakedefine01 USE_REDIS
-#cmakedefine01 ENABLE_GLES
#cmakedefine01 HAVE_ENDIAN_H
#cmakedefine01 CURSES_HAVE_CURSES_H
#cmakedefine01 CURSES_HAVE_NCURSES_H
settings->setDefault("fps_max_unfocused", "20");
settings->setDefault("viewing_range", "190");
settings->setDefault("client_mesh_chunk", "1");
-#if ENABLE_GLES
- settings->setDefault("near_plane", "0.1");
-#endif
settings->setDefault("screen_w", "1024");
settings->setDefault("screen_h", "600");
settings->setDefault("autosave_screensize", "true");
#include "client/fontengine.h"
#include "client/guiscalingfilter.h"
#include "irrlicht_changes/static_text.h"
-
-#if ENABLE_GLES
#include "client/tile.h"
-#endif
/******************************************************************************/
/******************************************************************************/
MenuTextureSource::~MenuTextureSource()
{
- for (const std::string &texture_to_delete : m_to_delete) {
- const char *tname = texture_to_delete.c_str();
- video::ITexture *texture = m_driver->getTexture(tname);
- m_driver->removeTexture(texture);
+ u32 before = m_driver->getTextureCount();
+
+ for (const auto &it: m_to_delete) {
+ m_driver->removeTexture(it);
}
+ m_to_delete.clear();
+
+ infostream << "~MenuTextureSource() before cleanup: "<< before
+ << " after: " << m_driver->getTextureCount() << std::endl;
}
/******************************************************************************/
if (name.empty())
return NULL;
-#if ENABLE_GLES
+ // return if already loaded
video::ITexture *retval = m_driver->findTexture(name.c_str());
if (retval)
return retval;
image = Align2Npot2(image, m_driver);
retval = m_driver->addTexture(name.c_str(), image);
- m_to_delete.insert(name);
image->drop();
+
+ if (retval)
+ m_to_delete.push_back(retval);
return retval;
-#else
- return m_driver->getTexture(name.c_str());
-#endif
}
/******************************************************************************/
private:
/** driver to get textures from */
video::IVideoDriver *m_driver = nullptr;
- /** set of texture names to delete */
- std::set<std::string> m_to_delete;
+ /** set of textures to delete */
+ std::vector<video::ITexture*> m_to_delete;
};
/** GUIEngine specific implementation of OnDemandSoundFetcher */
projects / minetest.git / commitdiff