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

Merged master

Browse Source
This commit is contained in:
Sachith Hasaranga Seneviratne 2014-08-01 18:40:05 +05:30
commit c3a774fcc9
146 changed files with 2227 additions and 1520 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@ -6,12 +6,15 @@ build-win/
cmake_build/
dependencies/
CMakeFiles/
stk-editor/
.config/
supertuxkart-64
data/editor
data/karts
data/library
data/models
data/music
data/sfx
data/textures

19
.travis.yml
View File

@ -15,17 +15,26 @@ before_install:
- sudo apt-get update -qq
# Install dependencies
- sudo apt-get install build-essential cmake libogg-dev libvorbis-dev libopenal-dev libxxf86vm-dev libcurl4-openssl-dev libfribidi-dev libbluetooth-dev
# Install mesa from an other repo (a newer version is required)
- sudo apt-add-repository "deb http://archive.ubuntu.com/ubuntu quantal main restricted"
# Install mesa from an other repo (a newer version is required). Quantal is not supported anymore, saucy is only supported till July 2014,
# so we try to use trusty (precise which is what traiv uses a too old mesa version which doesn't link)
- sudo apt-add-repository "deb http://archive.ubuntu.com/ubuntu trusty main restricted"
- sudo apt-key adv --recv-keys --keyserver keyserver.ubuntu.com 3B4FE6ACC0B21F32
- sudo apt-get update -qq
- sudo apt-get install libgl1-mesa-dev libglu1-mesa-dev
script:
# Build commands
- mkdir build
- cd build
# First a debug build:
- mkdir build-debug
- cd build-debug
- cmake .. -DCMAKE_BUILD_TYPE=Debug -DCHECK_ASSETS=off
- make VERBOSE=1 -j 4
# Then a release build:
- cd ..
- mkdir build-release
- cd build-release
- cmake .. -DCMAKE_BUILD_TYPE=Release -DCHECK_ASSETS=off
- make VERBOSE=1 -j 4
notifications:
irc:
channels:

41
CMakeLists.txt
View File

@ -17,7 +17,6 @@ option(CHECK_ASSETS "Check if assets are installed in ../stk-assets" ON)
if(UNIX)
option(USE_CPP2011 "Activate C++ 2011 mode (GCC only)" OFF)
option(USE_XRANDR "Use xrandr instead of vidmode" OFF)
endif()
if(MSVC)
# Normally hide the option to build wiiuse on VS, since it depends
@ -29,6 +28,10 @@ else()
set(WIIUSE_BUILD ON)
endif()
if(UNIX AND NOT APPLE)
option(USE_XRANDR "Use xrandr instead of vidmode" ON)
endif()
set(STK_SOURCE_DIR "src")
set(STK_DATA_DIR "${PROJECT_SOURCE_DIR}/data")
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin")
@ -123,10 +126,6 @@ if(USE_FRIBIDI)
endif()
endif()
# Xrandr
if(UNIX AND USE_XRANDR)
find_package(Xrandr REQUIRED)
endif()
if(UNIX)
# if(USE_CPP2011)
@ -139,13 +138,14 @@ find_package(OpenGL REQUIRED)
include_directories(${OPENGL_INCLUDE_DIR})
if(UNIX AND NOT APPLE)
find_library(IRRLICHT_XF86VM_LIBRARY Xxf86vm)
mark_as_advanced(IRRLICHT_XF86VM_LIBRARY)
else()
set(IRRLICHT_XF86VM_LIBRARY "")
if(USE_XRANDR)
find_package(Xrandr REQUIRED)
else()
find_library(IRRLICHT_XF86VM_LIBRARY Xxf86vm)
mark_as_advanced(IRRLICHT_XF86VM_LIBRARY)
endif()
endif()
# Set some compiler options
if(UNIX)
@ -158,12 +158,12 @@ if(WIN32)
# And shut up about unsafe stuff
add_definitions(-D_CRT_SECURE_NO_WARNINGS)
# VS will automatically add NDEBUG for release mode, but only _DEBUG in debug mode.
# Since STK uses DEBUG, this is added for debug compilation only:
# VS will automatically add NDEBUG for release mode, but only _DEBUG in debug mode.
# Since STK uses DEBUG, this is added for debug compilation only:
set_property(DIRECTORY PROPERTY COMPILE_DEFINITIONS_DEBUG DEBUG)
else()
# All non VS generators used create only a single compile mode, so
# compile flags can be simplye be added
# compile flags can be simplye be added
if(CMAKE_BUILD_TYPE MATCHES Debug)
add_definitions(-DDEBUG)
else()
@ -251,10 +251,16 @@ target_link_libraries(supertuxkart
angelscript
${CURL_LIBRARIES}
${OGGVORBIS_LIBRARIES}
${IRRLICHT_XF86VM_LIBRARY}
${OPENAL_LIBRARY}
${OPENGL_LIBRARIES})
if(UNIX AND NOT APPLE)
if(USE_XRANDR)
target_link_libraries(supertuxkart ${XRANDR_LIBRARIES})
else()
target_link_libraries(supertuxkart ${IRRLICHT_XF86VM_LIBRARY})
endif()
endif()
if(APPLE)
# In theory it would be cleaner to let CMake detect the right dependencies. In practice, this means that if a OSX user has
@ -290,11 +296,6 @@ if(USE_WIIUSE)
endif()
# Xrandr
if(UNIX AND USE_XRANDR)
target_link_libraries(supertuxkart ${XRANDR_LIBRARIES})
endif()
if(MSVC)
target_link_libraries(supertuxkart iphlpapi.lib)
add_custom_command(TARGET supertuxkart POST_BUILD

44
data/gui/custom_video_settings.stkgui
View File

@ -70,27 +70,11 @@
</div>
</div>
<spacer height="20" width="10" />
<div layout="horizontal-row" width="100%" proportion="1">
<div layout="horizontal-row" proportion="1" height="fit">
<checkbox id="motionblur"/>
<spacer width="10" height="10"/>
<label text="Motion blur" I18N="Video settings"/>
</div>
<spacer height="4" width="10" />
<div layout="horizontal-row" proportion="1" height="fit">
<checkbox id="texture_compression"/>
<spacer width="10" height="10"/>
<label text="Texture compression" I18N="Video settings"/>
</div>
</div>
<spacer height="4" width="10" />
<div layout="horizontal-row" width="100%" proportion="1">
<spacer width="70" height="10"/>
<div layout="horizontal-row" proportion="1" height="fit">
<checkbox id="glow"/>
<spacer width="10" height="10"/>
@ -105,7 +89,27 @@
<label text="Anti-aliasing" I18N="Video settings"/>
</div>
</div>
<spacer height="4" width="10" />
<div layout="horizontal-row" width="100%" proportion="1">
<spacer width="70" height="10"/>
<div layout="horizontal-row" proportion="1" height="fit">
<checkbox id="motionblur"/>
<spacer width="10" height="10"/>
<label text="Motion blur" I18N="Video settings"/>
</div>
<spacer height="4" width="10" />
<div layout="horizontal-row" proportion="1" height="fit">
<checkbox id="dof"/>
<spacer width="10" height="10"/>
<label text="Depth of field" I18N="Video settings"/>
</div>
</div>
<spacer height="4" width="10" />
<div layout="horizontal-row" width="100%" proportion="1">
@ -136,9 +140,9 @@
<spacer height="4" width="10" />
<div layout="horizontal-row" proportion="1" height="fit">
<checkbox id="dof"/>
<checkbox id="texture_compression"/>
<spacer width="10" height="10"/>
<label text="Depth of field" I18N="Video settings"/>
<label text="Texture compression" I18N="Video settings"/>
</div>
</div>

1
data/shaders/grass_pass2.frag
View File

@ -3,6 +3,7 @@ uniform mat4 ViewMatrix;
uniform mat4 ProjectionMatrix;
uniform mat4 InverseViewMatrix;
uniform mat4 InverseProjectionMatrix;
uniform vec2 screen;
#else
layout (std140) uniform MatrixesData
{

1
data/shaders/instanciedgrassshadow.vert
View File

@ -17,6 +17,7 @@ layout(location = 8) in vec3 Orientation;
layout(location = 9) in vec3 Scale;
#else
in vec3 Position;
in vec4 Color;
in vec2 Texcoord;
in vec3 Origin;

2
data/shaders/rh.frag
View File

@ -60,7 +60,7 @@ void main(void)
vec2 uv = RHuv + offset * 0.01;
// Get world position and normal from the RSM sample
float depth = texture2D(dtex, uv).z;
float depth = texture(dtex, uv).z;
vec4 RSMPos = inverse(RSMMatrix) * (2. * vec4(uv, depth, 1.) - 1.);
RSMPos /= RSMPos.w;
vec3 RSMAlbedo = texture(ctex, uv).xyz;

8
data/shaders/rsm.vert
View File

@ -8,11 +8,17 @@ uniform mat4 TextureMatrix =
0., 0., 1., 0.,
0., 0., 0., 1.);
#if __VERSION__ >= 330
layout(location = 0) in vec3 Position;
layout(location = 1) in vec3 Normal;
layout(location = 2) in vec4 Color;
layout(location = 3) in vec2 Texcoord;
#else
in vec3 Position;
in vec3 Normal;
in vec4 Color;
in vec2 Texcoord;
#endif
out vec3 nor;
out vec2 uv;

5
data/shaders/shadow.vert
View File

@ -9,8 +9,13 @@ layout (std140) uniform MatrixesData
uniform mat4 ModelMatrix;
#if __VERSION__ >= 330
layout(location = 0) in vec3 Position;
layout(location = 3) in vec2 Texcoord;
#else
in vec3 Position;
in vec2 Texcoord;
#endif
#ifdef VSLayer
out vec2 uv;

6
data/shaders/shadow_grass.vert
View File

@ -10,9 +10,15 @@ layout (std140) uniform MatrixesData
uniform mat4 ModelMatrix;
uniform vec3 windDir;
#if __VERSION__ >= 330
layout(location = 0) in vec3 Position;
layout(location = 2) in vec4 Color;
layout(location = 3) in vec2 Texcoord;
#else
in vec3 Position;
in vec4 Color;
in vec2 Texcoord;
#endif
#ifdef VSLayer
out vec2 uv;

2
data/shaders/ssao.frag
View File

@ -26,7 +26,7 @@ out float AO;
const float sigma = 1.;
const float tau = 7.;
const float beta = 0.001;
const float beta = 0.002;
const float epsilon = .00001;
const float radius = 1.;
const float k = 1.5;

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

@ -1,8 +1,14 @@
uniform sampler2D DiffuseMap;
uniform sampler2D SpecularMap;
uniform sampler2D SSAO;
uniform vec3 ambient;
#ifdef UBO_DISABLED
uniform mat4 ViewMatrix;
uniform mat4 ProjectionMatrix;
uniform mat4 InverseViewMatrix;
uniform mat4 InverseProjectionMatrix;
uniform vec2 screen;
#else
layout (std140) uniform MatrixesData
{
mat4 ViewMatrix;
@ -12,6 +18,7 @@ layout (std140) uniform MatrixesData
mat4 ShadowViewProjMatrixes[4];
vec2 screen;
};
#endif
vec3 getLightFactor(float specMapValue)
{
@ -19,6 +26,6 @@ vec3 getLightFactor(float specMapValue)
vec3 DiffuseComponent = texture(DiffuseMap, tc).xyz;
vec3 SpecularComponent = texture(SpecularMap, tc).xyz;
float ao = texture(SSAO, tc).x;
vec3 tmp = ao * ambient + DiffuseComponent + SpecularComponent * specMapValue;
vec3 tmp = DiffuseComponent + SpecularComponent * specMapValue;
return tmp * ao;
}

244
lib/irrlicht/source/Irrlicht/CIrrDeviceLinux.cpp
View File

@ -1,4 +1,5 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// Copyright (C) 2014 Dawid Gan
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
@ -48,6 +49,9 @@
#endif // _IRR_COMPILE_WITH_JOYSTICK_EVENTS_
#define XRANDR_ROTATION_LEFT (1 << 1)
#define XRANDR_ROTATION_RIGHT (1 << 3)
namespace irr
{
namespace video
@ -234,7 +238,7 @@ bool CIrrDeviceLinux::switchToFullscreen(bool reset)
return true;
if (reset)
{
#ifdef _IRR_LINUX_X11_VIDMODE_
#ifdef _IRR_LINUX_X11_VIDMODE_
if (UseXVidMode && CreationParams.Fullscreen)
{
XF86VidModeSwitchToMode(display, screennr, &oldVideoMode);
@ -244,9 +248,20 @@ bool CIrrDeviceLinux::switchToFullscreen(bool reset)
#ifdef _IRR_LINUX_X11_RANDR_
if (UseXRandR && CreationParams.Fullscreen)
{
XRRScreenConfiguration *config=XRRGetScreenInfo(display,DefaultRootWindow(display));
XRRSetScreenConfig(display,config,DefaultRootWindow(display),oldRandrMode,oldRandrRotation,CurrentTime);
XRRFreeScreenConfigInfo(config);
XRRScreenResources* res = XRRGetScreenResources(display, DefaultRootWindow(display));
XRROutputInfo* output = XRRGetOutputInfo(display, res, output_id);
XRRCrtcInfo* crtc = XRRGetCrtcInfo(display, res, output->crtc);
Status s = XRRSetCrtcConfig(display, res, output->crtc, CurrentTime,
crtc->x, crtc->y, old_mode,
crtc->rotation, &output_id, 1);
XRRFreeOutputInfo(output);
XRRFreeCrtcInfo(crtc);
XRRFreeScreenResources(res);
if (s != Success)
return false;
}
#endif
return true;
@ -319,30 +334,86 @@ bool CIrrDeviceLinux::switchToFullscreen(bool reset)
#ifdef _IRR_LINUX_X11_RANDR_
if (XRRQueryExtension(display, &eventbase, &errorbase))
{
s32 modeCount;
XRRScreenConfiguration *config=XRRGetScreenInfo(display,DefaultRootWindow(display));
XRRScreenSize *modes=XRRConfigSizes(config,&modeCount);
for (s32 i = 0; i<modeCount; ++i)
{
if (bestMode==-1 && (u32)modes[i].width >= Width && (u32)modes[i].height >= Height)
bestMode = i;
else if (bestMode!=-1 &&
(u32)modes[i].width >= Width &&
(u32)modes[i].height >= Height &&
modes[i].width <= modes[bestMode].width &&
modes[i].height <= modes[bestMode].height)
bestMode = i;
}
if (bestMode != -1)
{
os::Printer::log("Starting randr fullscreen mode...", ELL_INFORMATION);
os::Printer::log("width: ", core::stringc(modes[bestMode].width).c_str(), ELL_INFORMATION);
os::Printer::log("height: ", core::stringc(modes[bestMode].height).c_str(), ELL_INFORMATION);
XRRScreenResources* res = XRRGetScreenResources(display, DefaultRootWindow(display));
XRRSetScreenConfig(display,config,DefaultRootWindow(display),bestMode,oldRandrRotation,CurrentTime);
UseXRandR=true;
if (!res)
{
CreationParams.Fullscreen = false;
return CreationParams.Fullscreen;
}
XRRFreeScreenConfigInfo(config);
XRROutputInfo* output = XRRGetOutputInfo(display, res, output_id);
XRRCrtcInfo* crtc = XRRGetCrtcInfo(display, res, output->crtc);
float refresh_rate, refresh_rate_new;
for (int i = 0; i < res->nmode; i++)
{
const XRRModeInfo* mode = &res->modes[i];
unsigned int w, h;
if (crtc->rotation & (XRANDR_ROTATION_LEFT|XRANDR_ROTATION_RIGHT))
{
w = mode->height;
h = mode->width;
}
else
{
w = mode->width;
h = mode->height;
}
if (bestMode == -1 && w == Width && h == Height)
{
for (int j = 0; j < output->nmode; j++)
{
if (mode->id == output->modes[j])
{
bestMode = j;
refresh_rate = (mode->dotClock * 1000.0) / (mode->hTotal * mode->vTotal);
break;
}
}
}
else if (bestMode != -1 && w == Width && h == Height)
{
refresh_rate_new = (mode->dotClock * 1000.0) / (mode->hTotal * mode->vTotal);
if (refresh_rate_new <= refresh_rate)
break;
for (int j = 0; j < output->nmode; j++)
{
if (mode->id == output->modes[j])
{
bestMode = j;
refresh_rate = refresh_rate_new;
break;
}
}
}
}
// If video mode not found, try to use first available
if (bestMode == -1)
{
bestMode = 0;
}
Status s = XRRSetCrtcConfig(display, res, output->crtc, CurrentTime,
crtc->x, crtc->y, output->modes[bestMode],
crtc->rotation, &output_id, 1);
XRRFreeCrtcInfo(crtc);
XRRFreeOutputInfo(output);
XRRFreeScreenResources(res);
if (s != Success)
{
CreationParams.Fullscreen = false;
return CreationParams.Fullscreen;
}
UseXRandR=true;
}
else
#endif
@ -351,6 +422,7 @@ bool CIrrDeviceLinux::switchToFullscreen(bool reset)
"to switch to fullscreen mode. Running in windowed mode instead.", ELL_WARNING);
CreationParams.Fullscreen = false;
}
return CreationParams.Fullscreen;
}
@ -769,6 +841,17 @@ bool CIrrDeviceLinux::createWindow()
{
if (netWM)
{
// Some window managers don't respect values from XCreateWindow and
// place window in random position. This may cause that fullscreen
// window is showed in wrong screen. It doesn't matter for vidmode
// which displays cloned image in all devices.
#ifdef _IRR_LINUX_X11_RANDR_
XResizeWindow(display, window, Width, Height);
XMoveWindow(display, window, crtc_x, crtc_y);
XRaiseWindow(display, window);
XFlush(display);
#endif
// Workaround for Gnome which sometimes creates window smaller than display
XSizeHints *hints = XAllocSizeHints();
hints->flags=PMinSize;
@ -782,7 +865,8 @@ bool CIrrDeviceLinux::createWindow()
Atom WMStateAtom = XInternAtom(display, "_NET_WM_STATE", true);
Atom WMFullscreenAtom = XInternAtom(display, "_NET_WM_STATE_FULLSCREEN", true);
// Set the fullscreen property
XChangeProperty(display, window, WMStateAtom, XA_ATOM, 32, PropModeReplace, reinterpret_cast<unsigned char *>(& WMFullscreenAtom), 1);
XChangeProperty(display, window, WMStateAtom, XA_ATOM, 32, PropModeReplace,
reinterpret_cast<unsigned char*>(&WMFullscreenAtom), 1);
// Notify the root window
XEvent xev = {0}; // The event should be filled with zeros before setting its attributes
@ -793,7 +877,10 @@ bool CIrrDeviceLinux::createWindow()
xev.xclient.format = 32;
xev.xclient.data.l[0] = 1;
xev.xclient.data.l[1] = WMFullscreenAtom;
XSendEvent(display, DefaultRootWindow(display), false, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
XSendEvent(display, RootWindow(display, visual->screen), false,
SubstructureRedirectMask | SubstructureNotifyMask, &xev);
XFlush(display);
}
else
{
@ -1497,18 +1584,99 @@ video::IVideoModeList* CIrrDeviceLinux::getVideoModeList()
#ifdef _IRR_LINUX_X11_RANDR_
if (XRRQueryExtension(display, &eventbase, &errorbase))
{
int modeCount;
XRRScreenConfiguration *config=XRRGetScreenInfo(display,DefaultRootWindow(display));
oldRandrMode=XRRConfigCurrentConfiguration(config,&oldRandrRotation);
XRRScreenSize *modes=XRRConfigSizes(config,&modeCount);
VideoModeList.setDesktop(defaultDepth, core::dimension2d<u32>(
modes[oldRandrMode].width, modes[oldRandrMode].height));
for (int i = 0; i<modeCount; ++i)
XRRScreenResources* res = XRRGetScreenResources(display, DefaultRootWindow(display));
if (!res)
return &VideoModeList;
XRROutputInfo *output = NULL;
XRRCrtcInfo* crtc = NULL;
crtc_x = crtc_y = -1;
for (int i = 0; i < res->noutput; i++)
{
VideoModeList.addMode(core::dimension2d<u32>(
modes[i].width, modes[i].height), defaultDepth);
output = XRRGetOutputInfo(display, res, res->outputs[i]);
if (!output || !output->crtc || output->connection == RR_Disconnected)
{
XRRFreeOutputInfo(output);
continue;
}
crtc = XRRGetCrtcInfo(display, res, output->crtc);
if (!crtc)
{
XRRFreeCrtcInfo(crtc);
XRRFreeOutputInfo(output);
continue;
}
if (crtc_x == -1 || crtc->x < crtc_x)
{
crtc_x = crtc->x;
crtc_y = crtc->y;
output_id = res->outputs[i];
}
else if (crtc_x == crtc->x && crtc->y < crtc_y)
{
crtc_x = crtc->x;
crtc_y = crtc->y;
output_id = res->outputs[i];
}
XRRFreeCrtcInfo(crtc);
XRRFreeOutputInfo(output);
}
XRRFreeScreenConfigInfo(config);
output = XRRGetOutputInfo(display, res, output_id);
crtc = XRRGetCrtcInfo(display, res, output->crtc);
if (crtc == NULL)
{
XRRFreeCrtcInfo(crtc);
XRRFreeOutputInfo(output);
XRRFreeScreenResources(res);
return &VideoModeList;
}
for (int i = 0; i < res->nmode; i++)
{
const XRRModeInfo* mode = &res->modes[i];
unsigned int w, h;
if (crtc->rotation & (XRANDR_ROTATION_LEFT|XRANDR_ROTATION_RIGHT))
{
w = mode->height;
h = mode->width;
}
else
{
w = mode->width;
h = mode->height;
}
for (int j = 0; j < output->nmode; j++)
{
if (mode->id == output->modes[j])
{
VideoModeList.addMode(core::dimension2d<u32>(
w, h), defaultDepth);
break;
}
}
if (mode->id == crtc->mode)
{
old_mode = crtc->mode;
VideoModeList.setDesktop(defaultDepth,
core::dimension2d<u32>(w, h));
}
}
XRRFreeCrtcInfo(crtc);
XRRFreeOutputInfo(output);
XRRFreeScreenResources(res);
}
else
#endif

6
lib/irrlicht/source/Irrlicht/CIrrDeviceLinux.h
View File

@ -394,8 +394,10 @@ namespace irr
XF86VidModeModeInfo oldVideoMode;
#endif
#ifdef _IRR_LINUX_X11_RANDR_
SizeID oldRandrMode;
Rotation oldRandrRotation;
RROutput output_id;
RRMode old_mode;
int crtc_x;
int crtc_y;
#endif
#ifdef _IRR_COMPILE_WITH_OPENGL_
GLXWindow glxWin;

12
src/addons/addon.cpp
View File

@ -216,3 +216,15 @@ bool Addon::filterByWords(const core::stringw words) const
return false;
} // filterByWords
// ----------------------------------------------------------------------------
/** Deletes the icon file of this addon, and marks it to be re-downloaded (next
* time AddonsManager::downloadIcons() is called.
*/
void Addon::deleteInvalidIconFile()
{
m_icon_ready = false;
std::string icon = file_manager->getAddonsFile("icons/"+m_icon_basename);
file_manager->removeFile(icon);
m_installed = false;
} // redownloadIcon

4
src/addons/addon.hpp
View File

@ -130,6 +130,8 @@ public:
Addon() {};
/** Initialises the object from an XML node. */
Addon(const XMLNode &xml);
void deleteInvalidIconFile();
// ------------------------------------------------------------------------
/** Sets the sort order used in the comparison function. It is static, so
* that each instance can access the sort order. */
@ -164,7 +166,7 @@ public:
const std::string& getIconURL() const { return m_icon_url; }
// ------------------------------------------------------------------------
/** Returns the name of the icon (i.e. the basename of the url). */
const std::string getIconBasename() const { return m_icon_basename; }
const std::string& getIconBasename() const { return m_icon_basename; }
// ------------------------------------------------------------------------
/** Returns the name of the addon. */
const core::stringw& getDescription() const { return m_description; }

2
src/addons/addons_manager.cpp
View File

@ -256,7 +256,7 @@ void AddonsManager::initAddons(const XMLNode *xml)
Log::warn(
"[AddonsManager] Removing '%s' which is not on the server anymore.\n",
m_addons_list.getData()[i].getId().c_str() );
std::string icon = m_addons_list.getData()[i].getIconBasename();
const std::string &icon = m_addons_list.getData()[i].getIconBasename();
std::string icon_file =file_manager->getAddonsFile("icons/"+icon);
if(file_manager->fileExists(icon_file))
{

17
src/config/device_config.cpp
View File

@ -19,6 +19,7 @@
#include <assert.h>
#include "config/device_config.hpp"
#include "utils/log.hpp"
#include <SKeyMap.h>
using namespace irr;
@ -226,7 +227,7 @@ bool DeviceConfig::deserializeAction(irr::io::IrrXMLReader* xml)
// Never hurts to check ;)
if (xml == NULL)
{
fprintf(stderr, "Error: null pointer (DeviceConfig::deserializeAction)\n");
Log::error("DeviceConfig", "Null pointer (DeviceConfig::deserializeAction)");
return false;
}
@ -243,8 +244,8 @@ bool DeviceConfig::deserializeAction(irr::io::IrrXMLReader* xml)
}
if(binding_id==-1)
{
printf("WARNING: DeviceConfig::deserializeAction : action '%s' is unknown\n",
name_string);
Log::warn("DeviceConfig", "DeviceConfig::deserializeAction : action '%s' is unknown.",
name_string);
return false;
}
@ -349,23 +350,15 @@ GamepadConfig::GamepadConfig(irr::io::IrrXMLReader* xml) : DeviceConfig( DEVICE_
{
const char* name_string = xml->getAttributeValue("name");
if(name_string == NULL)
{
printf("ERROR: Unnamed joystick in config file\n");
}
Log::error("DeviceConfig", "Unnamed joystick in config file.");
else
{
m_name = name_string;
}
const char* enabled_string = xml->getAttributeValue("enabled");
if (enabled_string != NULL)
{
m_enabled = (strcmp(enabled_string, "true") == 0);
}
else
{
m_enabled = true;
}
m_plugged = 0;
setDefaultBinds();

4
src/config/user_config.cpp
View File

@ -713,8 +713,8 @@ bool UserConfig::loadConfig()
// add back the code previously there that upgraded the config file to the new
// format instead of overwriting it.
GUIEngine::showMessage( _("Your config file was too old, so it was deleted and a new one will be created."), 10.0f);
printf("Your config file was too old, so it was deleted and a new one will be created.");
GUIEngine::showMessage(_("Your config file was too old, so it was deleted and a new one will be created."), 10.0f);
Log::info("UserConfig", "Your config file was too old, so it was deleted and a new one will be created.");
delete root;
return false;

4
src/graphics/camera.cpp
View File

@ -205,8 +205,8 @@ void Camera::setupCamera()
break;
default:
if(UserConfigParams::logMisc())
fprintf(stderr, "Incorrect number of players: '%d' - assuming 1.\n",
race_manager->getNumLocalPlayers());
Log::warn("Camera", "Incorrect number of players: '%d' - assuming 1.",
race_manager->getNumLocalPlayers());
m_viewport = core::recti(0, 0,
UserConfigParams::m_width,
UserConfigParams::m_height);

8
src/graphics/camera.hpp
View File

@ -25,6 +25,7 @@
#include "utils/no_copy.hpp"
#include "utils/aligned_array.hpp"
#include "utils/leak_check.hpp"
#include "utils/log.hpp"
#include "utils/vec3.hpp"
#include "SColor.h"
@ -155,10 +156,9 @@ private:
m_type = EC_AHEAD_OF_KART;
else
{
fprintf(stderr,
"Invalid camera type '%s' - camera is ignored.\n",
s.c_str());
return false;
Log::warn("Camera", "Invalid camera type '%s' - camera is ignored.",
s.c_str());
return false;
}
node.get("xyz", &m_position);
node.get("distance", &m_distance2);

5
src/graphics/irr_driver.cpp
View File

@ -1931,8 +1931,9 @@ void IrrDriver::update(float dt)
// =================================
if (!m_device->run())
{
GUIEngine::cleanUp();
GUIEngine::deallocate();
// Don't bother cleaning up GUI, has no use and may result in crashes
//GUIEngine::cleanUp();
//GUIEngine::deallocate();
main_loop->abort();
return;
}

2
src/graphics/light.hpp
View File

@ -20,7 +20,7 @@
#define HEADER_LIGHT_HPP
#include <ISceneNode.h>
#include <utils/cpp2011.h>
#include <utils/cpp2011.hpp>
#include <vector>
using namespace irr;

4
src/graphics/material_manager.cpp
View File

@ -239,7 +239,7 @@ bool MaterialManager::pushTempMaterial(const XMLNode *root,
if(!node)
{
// We don't have access to the filename at this stage anymore :(
fprintf(stderr, "Unknown node in material.xml file\n");
Log::warn("MaterialManager", "Unknown node in material.xml file.");
continue;
}
try
@ -249,7 +249,7 @@ bool MaterialManager::pushTempMaterial(const XMLNode *root,
catch(std::exception& e)
{
// The message contains a '%s' for the filename
fprintf(stderr, e.what(), filename.c_str());
Log::warn("MaterialManager", e.what(), filename.c_str());
}
} // for i<xml->getNumNodes)(
return true;

2
src/graphics/particle_emitter.cpp
View File

@ -581,7 +581,7 @@ void ParticleEmitter::setParticleType(const ParticleKind* type)
}
default:
{
fprintf(stderr, "[ParticleEmitter] Unknown shape\n");
Log::error("ParticleEmitter", "Unknown shape");
return;
}
}

7
src/graphics/particle_kind.cpp
View File

@ -23,6 +23,7 @@
#include "io/file_manager.hpp"
#include "io/xml_node.hpp"
#include "utils/constants.hpp"
#include "utils/log.hpp"
#include <stdexcept>
@ -100,7 +101,7 @@ ParticleKind::ParticleKind(const std::string file) : m_min_start_color(255,255,2
}
else
{
fprintf(stderr, "[ParticleKind] <particles> main node has unknown value for attribute 'emitter'\n");
Log::warn("ParticleKind", "<particles> main node has unknown value for attribute 'emitter'.");
m_shape = EMITTER_POINT;
}
@ -254,8 +255,8 @@ Material* ParticleKind::getMaterial() const
}
else
{
fprintf(stderr, "[ParticleKind] WARNING: particle image '%s' does not appear in the list of "
"currently known materials\n", m_material_file.c_str());
Log::warn("ParticleKind", "Particle image '%s' does not appear in the list of "
"currently known materials.", m_material_file.c_str());
return NULL;
}
}

13
src/graphics/render.cpp
View File

@ -141,6 +141,9 @@ void IrrDriver::renderGLSL(float dt)
const core::recti &viewport = camera->getViewport();
if (World::getWorld() && World::getWorld()->getTrack()->hasShadows() && !SphericalHarmonicsTextures.empty())
irr_driver->getSceneManager()->setAmbientLight(SColor(0, 0, 0, 0));
unsigned plc = UpdateLightsInfo(camnode, dt);
computeCameraMatrix(camnode, viewport.LowerRightCorner.X - viewport.UpperLeftCorner.X, viewport.LowerRightCorner.Y - viewport.UpperLeftCorner.Y);
renderScene(camnode, plc, glows, dt, track->hasShadows(), false);
@ -266,10 +269,6 @@ void IrrDriver::renderScene(scene::ICameraSceneNode * const camnode, unsigned po
{
glBindBufferBase(GL_UNIFORM_BUFFER, 0, SharedObject::ViewProjectionMatrixesUBO);
PROFILER_PUSH_CPU_MARKER("- Solid Pass 1", 0xFF, 0x00, 0x00);
renderSolidFirstPass();
PROFILER_POP_CPU_MARKER();
// Shadows
{
PROFILER_PUSH_CPU_MARKER("- Shadow", 0x30, 0x6F, 0x90);
@ -283,6 +282,12 @@ void IrrDriver::renderScene(scene::ICameraSceneNode * const camnode, unsigned po
PROFILER_POP_CPU_MARKER();
}
PROFILER_PUSH_CPU_MARKER("- Solid Pass 1", 0xFF, 0x00, 0x00);
renderSolidFirstPass();
PROFILER_POP_CPU_MARKER();
// Lights
{
PROFILER_PUSH_CPU_MARKER("- Light", 0x00, 0xFF, 0x00);

357
src/graphics/render_geometry.cpp
View File

@ -28,17 +28,88 @@
#include "utils/helpers.hpp"
#include "utils/log.hpp"
#include "utils/profiler.hpp"
#include "utils/tuple.hpp"
#include <algorithm>
namespace RenderGeometry
{
struct TexUnit
{
GLuint m_id;
bool m_premul_alpha;
TexUnit(GLuint id, bool premul_alpha)
{
m_id = id;
m_premul_alpha = premul_alpha;
}
};
template <typename T>
std::vector<TexUnit> TexUnits(T curr) // required on older clang versions
{
std::vector<TexUnit> v;
v.push_back(curr);
return v;
}
template <typename T, typename... R>
std::vector<TexUnit> TexUnits(T curr, R... rest) // required on older clang versions
{
std::vector<TexUnit> v;
v.push_back(curr);
VTexUnits(v, rest...);
return v;
}
template <typename T, typename... R>
void VTexUnits(std::vector<TexUnit>& v, T curr, R... rest) // required on older clang versions
{
v.push_back(curr);
VTexUnits(v, rest...);
}
template <typename T>
void VTexUnits(std::vector<TexUnit>& v, T curr)
{
v.push_back(curr);
}
}
using namespace RenderGeometry;
template<typename Shader, typename...uniforms>
void draw(const GLMesh *mesh, uniforms... Args)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh->PrimitiveType;
GLenum itype = mesh->IndexType;
size_t count = mesh->IndexCount;
Shader::setUniforms(Args...);
glDrawElementsBaseVertex(ptype, count, itype, (GLvoid *)mesh->vaoOffset, mesh->vaoBaseVertex);
}
template<typename T, typename...uniforms>
void draw(const T *Shader, const GLMesh *mesh, uniforms... Args)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh->PrimitiveType;
GLenum itype = mesh->IndexType;
size_t count = mesh->IndexCount;
Shader->setUniforms(Args...);
glDrawElementsBaseVertex(ptype, count, itype, (GLvoid *)mesh->vaoOffset, mesh->vaoBaseVertex);
}
template<unsigned N>
struct unroll_args_instance
{
template<typename T, typename ...TupleTypes, typename ...Args>
static void exec(const T *Shader, const std::tuple<TupleTypes...> &t, Args... args)
static void exec(const T *Shader, const STK::Tuple<TupleTypes...> &t, Args... args)
{
unroll_args_instance<N - 1>::template exec<T>(Shader, t, std::get<N - 1>(t), args...);
unroll_args_instance<N - 1>::template exec<T>(Shader, t, STK::tuple_get<N - 1>(t), args...);
}
};
@ -46,32 +117,57 @@ template<>
struct unroll_args_instance<0>
{
template<typename T, typename ...TupleTypes, typename ...Args>
static void exec(const T *Shader, const std::tuple<TupleTypes...> &t, Args... args)
static void exec(const T *Shader, const STK::Tuple<TupleTypes...> &t, Args... args)
{
draw<T>(Shader, args...);
}
};
template<typename T, typename... TupleType>
void apply_instance(const T *Shader, const std::tuple<TupleType...> &arg)
void apply_instance(const T *Shader, const STK::Tuple<TupleType...> &arg)
{
unroll_args_instance<std::tuple_size<std::tuple<TupleType...> >::value >::template exec<T>(Shader, arg);
unroll_args_instance<sizeof...(TupleType)>::template exec<T>(Shader, arg);
//unroll_args_instance<STK::TupleSize<STK::Tuple<TupleType...> >::value >::template exec<T>(Shader, arg);
}
template<typename Shader, enum E_VERTEX_TYPE VertexType, typename... TupleType>
void renderMeshes1stPass(const std::vector<GLuint> &TexUnits, std::vector<std::tuple<TupleType...> > &meshes)
template<int...List>
struct custom_unroll_args;
template<>
struct custom_unroll_args<>
{
template<typename T, typename ...TupleTypes, typename ...Args>
static void exec(const T *Shader, const STK::Tuple<TupleTypes...> &t, Args... args)
{
draw<T>(Shader, STK::tuple_get<0>(t), args...);
}
};
template<int N, int...List>
struct custom_unroll_args<N, List...>
{
template<typename T, typename ...TupleTypes, typename ...Args>
static void exec(const T *Shader, const STK::Tuple<TupleTypes...> &t, Args... args)
{
custom_unroll_args<List...>::template exec<T>(Shader, t, STK::tuple_get<N>(t), args...);
}
};
template<typename Shader, enum E_VERTEX_TYPE VertexType, int ...List, typename... TupleType>
void renderMeshes1stPass(const std::vector<TexUnit> &TexUnits, std::vector<STK::Tuple<TupleType...> > &meshes)
{
glUseProgram(Shader::getInstance()->Program);
glBindVertexArray(getVAO(VertexType));
for (unsigned i = 0; i < meshes.size(); i++)
{
GLMesh &mesh = *(std::get<0>(meshes[i]));
GLMesh &mesh = *(STK::tuple_get<0>(meshes[i]));
for (unsigned j = 0; j < TexUnits.size(); j++)
{
if (!mesh.textures[j])
mesh.textures[j] = getUnicolorTexture(video::SColor(255, 255, 255, 255));
compressTexture(mesh.textures[j], true);
setTexture(TexUnits[j], getTextureGLuint(mesh.textures[j]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
compressTexture(mesh.textures[j], TexUnits[j].m_premul_alpha);
setTexture(TexUnits[j].m_id, getTextureGLuint(mesh.textures[j]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
}
if (mesh.VAOType != VertexType)
{
@ -80,7 +176,7 @@ void renderMeshes1stPass(const std::vector<GLuint> &TexUnits, std::vector<std::t
#endif
continue;
}
apply_instance(Shader::getInstance(), meshes[i]);
custom_unroll_args<List...>::template exec(Shader::getInstance(), meshes[i]);
}
}
@ -97,11 +193,14 @@ void IrrDriver::renderSolidFirstPass()
glDisable(GL_BLEND);
glEnable(GL_CULL_FACE);
irr_driver->setPhase(SOLID_NORMAL_AND_DEPTH_PASS);
ListDefaultStandardG::Arguments.clear();
ListDefault2TCoordG::Arguments.clear();
ListAlphaRefG::Arguments.clear();
ListNormalG::Arguments.clear();
ListGrassG::Arguments.clear();
ListMatDefault::Arguments.clear();
ListMatAlphaRef::Arguments.clear();
ListMatSphereMap::Arguments.clear();
ListMatDetails::Arguments.clear();
ListMatUnlit::Arguments.clear();
ListMatNormalMap::Arguments.clear();
ListMatGrass::Arguments.clear();
ListMatSplatting::Arguments.clear();
m_scene_manager->drawAll(scene::ESNRP_SOLID);
if (!UserConfigParams::m_dynamic_lights)
@ -109,28 +208,36 @@ void IrrDriver::renderSolidFirstPass()
{
ScopedGPUTimer Timer(getGPUTimer(Q_SOLID_PASS1));
renderMeshes1stPass<MeshShader::ObjectPass1Shader, video::EVT_STANDARD>({ MeshShader::ObjectPass1Shader::getInstance<MeshShader::ObjectPass1Shader>()->TU_tex }, ListDefaultStandardG::Arguments);
renderMeshes1stPass<MeshShader::ObjectPass1Shader, video::EVT_2TCOORDS>({ MeshShader::ObjectPass1Shader::getInstance<MeshShader::ObjectPass1Shader>()->TU_tex }, ListDefault2TCoordG::Arguments);
renderMeshes1stPass<MeshShader::ObjectRefPass1Shader, video::EVT_STANDARD>({ MeshShader::ObjectRefPass1Shader::getInstance<MeshShader::ObjectRefPass1Shader>()->TU_tex }, ListAlphaRefG::Arguments);
renderMeshes1stPass<MeshShader::NormalMapShader, video::EVT_TANGENTS>({ MeshShader::NormalMapShader::getInstance<MeshShader::NormalMapShader>()->TU_glossy, MeshShader::NormalMapShader::getInstance<MeshShader::NormalMapShader>()->TU_normalmap }, ListNormalG::Arguments);
renderMeshes1stPass<MeshShader::GrassPass1Shader, video::EVT_STANDARD>({ MeshShader::GrassPass1Shader::getInstance<MeshShader::GrassPass1Shader>()->TU_tex }, ListGrassG::Arguments);
std::vector<TexUnit> object_pass1_texunits = TexUnits(TexUnit(MeshShader::ObjectPass1Shader::getInstance()->TU_tex, true) );
renderMeshes1stPass<MeshShader::ObjectPass1Shader, video::EVT_STANDARD, 2, 1>(object_pass1_texunits, ListMatDefault::Arguments);
renderMeshes1stPass<MeshShader::ObjectPass1Shader, video::EVT_STANDARD, 2, 1>(object_pass1_texunits, ListMatSphereMap::Arguments);
renderMeshes1stPass<MeshShader::ObjectPass1Shader, video::EVT_STANDARD, 2, 1>(object_pass1_texunits, ListMatUnlit::Arguments);
renderMeshes1stPass<MeshShader::ObjectPass1Shader, video::EVT_2TCOORDS, 2, 1>(object_pass1_texunits, ListMatDetails::Arguments);
renderMeshes1stPass<MeshShader::ObjectPass1Shader, video::EVT_2TCOORDS, 2, 1>(object_pass1_texunits, ListMatSplatting::Arguments);
renderMeshes1stPass<MeshShader::ObjectRefPass1Shader, video::EVT_STANDARD, 3, 2, 1>(TexUnits(TexUnit(MeshShader::ObjectRefPass1Shader::getInstance()->TU_tex, true)), ListMatAlphaRef::Arguments);
renderMeshes1stPass<MeshShader::GrassPass1Shader, video::EVT_STANDARD, 3, 2, 1>(TexUnits(TexUnit(MeshShader::GrassPass1Shader::getInstance()->TU_tex, true)), ListMatGrass::Arguments);
renderMeshes1stPass<MeshShader::NormalMapShader, video::EVT_TANGENTS, 2, 1>(TexUnits(
TexUnit(MeshShader::NormalMapShader::getInstance()->TU_glossy, true),
TexUnit(MeshShader::NormalMapShader::getInstance()->TU_normalmap, false)
), ListMatNormalMap::Arguments);
}
}
template<typename T, enum E_VERTEX_TYPE VertexType, typename... TupleType>
void renderMeshes2ndPass(const T *Shader, const std::vector<GLuint> &TexUnits, std::vector<std::tuple<TupleType...> > &meshes)
template<typename Shader, enum E_VERTEX_TYPE VertexType, int...List, typename... TupleType>
void renderMeshes2ndPass(const std::vector<TexUnit> &TexUnits, std::vector<STK::Tuple<TupleType...> > &meshes)
{
glUseProgram(Shader->Program);
glUseProgram(Shader::getInstance()->Program);
glBindVertexArray(getVAO(VertexType));
for (unsigned i = 0; i < meshes.size(); i++)
{
GLMesh &mesh = *(std::get<0>(meshes[i]));
GLMesh &mesh = *(STK::tuple_get<0>(meshes[i]));
for (unsigned j = 0; j < TexUnits.size(); j++)
{
if (!mesh.textures[j])
mesh.textures[j] = getUnicolorTexture(video::SColor(255, 255, 255, 255));
compressTexture(mesh.textures[j], true);
setTexture(TexUnits[j], getTextureGLuint(mesh.textures[j]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
compressTexture(mesh.textures[j], TexUnits[j].m_premul_alpha);
setTexture(TexUnits[j].m_id, getTextureGLuint(mesh.textures[j]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
if (irr_driver->getLightViz())
{
GLint swizzleMask[] = { GL_ONE, GL_ONE, GL_ONE, GL_ALPHA };
@ -150,7 +257,7 @@ void renderMeshes2ndPass(const T *Shader, const std::vector<GLuint> &TexUnits, s
#endif
continue;
}
apply_instance<T>(Shader, meshes[i]);
custom_unroll_args<List...>::template exec(Shader::getInstance(), meshes[i]);
}
}
@ -176,14 +283,6 @@ void IrrDriver::renderSolidSecondPass()
glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST);
glDisable(GL_BLEND);
ListDefaultStandardSM::Arguments.clear();
ListDefaultTangentSM::Arguments.clear();
ListAlphaRefSM::Arguments.clear();
ListSphereMapSM::Arguments.clear();
ListUnlitSM::Arguments.clear();
ListDetailSM::Arguments.clear();
ListSplattingSM::Arguments.clear();
ListGrassSM::Arguments.clear();
setTexture(0, m_rtts->getRenderTarget(RTT_TMP1), GL_NEAREST, GL_NEAREST);
setTexture(1, m_rtts->getRenderTarget(RTT_TMP2), GL_NEAREST, GL_NEAREST);
setTexture(2, m_rtts->getRenderTarget(RTT_HALF1_R), GL_LINEAR, GL_LINEAR);
@ -193,14 +292,43 @@ void IrrDriver::renderSolidSecondPass()
m_scene_manager->drawAll(scene::ESNRP_SOLID);
renderMeshes2ndPass<MeshShader::ObjectPass2Shader, video::EVT_STANDARD>(MeshShader::ObjectPass2ShaderInstance, { MeshShader::ObjectPass2ShaderInstance->TU_Albedo }, ListDefaultStandardSM::Arguments);
renderMeshes2ndPass<MeshShader::ObjectPass2Shader, video::EVT_TANGENTS>(MeshShader::ObjectPass2ShaderInstance, { MeshShader::ObjectPass2ShaderInstance->TU_Albedo }, ListDefaultTangentSM::Arguments);
renderMeshes2ndPass<MeshShader::ObjectRefPass2Shader, video::EVT_STANDARD>(MeshShader::ObjectRefPass2ShaderInstance, { MeshShader::ObjectRefPass2ShaderInstance->TU_Albedo }, ListAlphaRefSM::Arguments);
renderMeshes2ndPass<MeshShader::SphereMapShader, video::EVT_STANDARD>(MeshShader::SphereMapShaderInstance, { MeshShader::SphereMapShaderInstance->TU_tex }, ListSphereMapSM::Arguments);
renderMeshes2ndPass<MeshShader::ObjectUnlitShader, video::EVT_STANDARD>(MeshShader::ObjectUnlitShaderInstance, { MeshShader::ObjectUnlitShaderInstance->TU_tex }, ListUnlitSM::Arguments);
renderMeshes2ndPass<MeshShader::DetailledObjectPass2Shader, video::EVT_2TCOORDS>(MeshShader::DetailledObjectPass2ShaderInstance, { MeshShader::DetailledObjectPass2ShaderInstance->TU_Albedo, MeshShader::DetailledObjectPass2ShaderInstance->TU_detail }, ListDetailSM::Arguments);
renderMeshes2ndPass<MeshShader::SplattingShader, video::EVT_2TCOORDS>(MeshShader::SplattingShaderInstance, { 8, MeshShader::SplattingShaderInstance->TU_tex_layout, MeshShader::SplattingShaderInstance->TU_tex_detail0, MeshShader::SplattingShaderInstance->TU_tex_detail1, MeshShader::SplattingShaderInstance->TU_tex_detail2, MeshShader::SplattingShaderInstance->TU_tex_detail3 }, ListSplattingSM::Arguments);
renderMeshes2ndPass<MeshShader::GrassPass2Shader, video::EVT_STANDARD>(MeshShader::GrassPass2ShaderInstance, { MeshShader::GrassPass2ShaderInstance->TU_Albedo }, ListGrassSM::Arguments);
renderMeshes2ndPass<MeshShader::ObjectPass2Shader, video::EVT_STANDARD, 3, 1>(TexUnits(
TexUnit(MeshShader::ObjectPass2Shader::getInstance()->TU_Albedo, true)
), ListMatDefault::Arguments);
renderMeshes2ndPass<MeshShader::ObjectRefPass2Shader, video::EVT_STANDARD, 3, 1 >(TexUnits(
TexUnit(MeshShader::ObjectRefPass2Shader::getInstance()->TU_Albedo, true)
), ListMatAlphaRef::Arguments);
renderMeshes2ndPass<MeshShader::SphereMapShader, video::EVT_STANDARD, 2, 1>(TexUnits(
TexUnit(MeshShader::SphereMapShader::getInstance()->TU_tex, true)
), ListMatSphereMap::Arguments);
renderMeshes2ndPass<MeshShader::DetailledObjectPass2Shader, video::EVT_2TCOORDS, 1>(TexUnits(
TexUnit(MeshShader::DetailledObjectPass2Shader::getInstance()->TU_Albedo, true),
TexUnit(MeshShader::DetailledObjectPass2Shader::getInstance()->TU_detail, true)
), ListMatDetails::Arguments);
renderMeshes2ndPass<MeshShader::GrassPass2Shader, video::EVT_STANDARD, 3, 1>(TexUnits(
TexUnit(MeshShader::GrassPass2Shader::getInstance()->TU_Albedo, true)
), ListMatGrass::Arguments);
renderMeshes2ndPass<MeshShader::ObjectUnlitShader, video::EVT_STANDARD, 1>(TexUnits(
TexUnit(MeshShader::ObjectUnlitShader::getInstance()->TU_tex, true)
), ListMatUnlit::Arguments);
renderMeshes2ndPass<MeshShader::SplattingShader, video::EVT_2TCOORDS, 1>(TexUnits(
TexUnit(8, true),
TexUnit(MeshShader::SplattingShader::getInstance()->TU_tex_layout, false),
TexUnit(MeshShader::SplattingShader::getInstance()->TU_tex_detail0, true),
TexUnit(MeshShader::SplattingShader::getInstance()->TU_tex_detail1, true),
TexUnit(MeshShader::SplattingShader::getInstance()->TU_tex_detail2, true),
TexUnit(MeshShader::SplattingShader::getInstance()->TU_tex_detail3, true)
), ListMatSplatting::Arguments);
renderMeshes2ndPass<MeshShader::ObjectPass2Shader, video::EVT_TANGENTS, 3, 1>(TexUnits(
TexUnit(MeshShader::ObjectPass2Shader::getInstance()->TU_Albedo, true)
), ListMatNormalMap::Arguments);
}
}
@ -227,16 +355,24 @@ void IrrDriver::renderTransparent()
if (World::getWorld() && World::getWorld()->isFogEnabled())
{
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
renderMeshes2ndPass<MeshShader::TransparentFogShader, video::EVT_STANDARD>(MeshShader::TransparentFogShaderInstance, { MeshShader::TransparentFogShaderInstance->TU_tex }, ListBlendTransparentFog::Arguments);
renderMeshes2ndPass<MeshShader::TransparentFogShader, video::EVT_STANDARD, 8, 7, 6, 5, 4, 3, 2, 1>(TexUnits(
TexUnit(MeshShader::TransparentFogShader::getInstance()->TU_tex, true)
), ListBlendTransparentFog::Arguments);
glBlendFunc(GL_ONE, GL_ONE);
renderMeshes2ndPass<MeshShader::TransparentFogShader, video::EVT_STANDARD>(MeshShader::TransparentFogShaderInstance, { MeshShader::TransparentFogShaderInstance->TU_tex }, ListAdditiveTransparentFog::Arguments);
renderMeshes2ndPass<MeshShader::TransparentFogShader, video::EVT_STANDARD, 8, 7, 6, 5, 4, 3, 2, 1>(TexUnits(
TexUnit(MeshShader::TransparentFogShader::getInstance()->TU_tex, true)
), ListAdditiveTransparentFog::Arguments);
}
else
{
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
renderMeshes2ndPass<MeshShader::TransparentShader, video::EVT_STANDARD>(MeshShader::TransparentShaderInstance, { MeshShader::TransparentShaderInstance->TU_tex }, ListBlendTransparent::Arguments);
renderMeshes2ndPass<MeshShader::TransparentShader, video::EVT_STANDARD, 2, 1>(TexUnits(
TexUnit(MeshShader::TransparentShader::getInstance()->TU_tex, true)
), ListBlendTransparent::Arguments);
glBlendFunc(GL_ONE, GL_ONE);
renderMeshes2ndPass<MeshShader::TransparentShader, video::EVT_STANDARD>(MeshShader::TransparentShaderInstance, { MeshShader::TransparentShaderInstance->TU_tex }, ListAdditiveTransparent::Arguments);
renderMeshes2ndPass<MeshShader::TransparentShader, video::EVT_STANDARD, 2, 1>(TexUnits(
TexUnit(MeshShader::TransparentShader::getInstance()->TU_tex, true)
), ListAdditiveTransparent::Arguments);
}
if (!UserConfigParams::m_dynamic_lights)
@ -266,8 +402,8 @@ void IrrDriver::renderTransparent()
irr_driver->getFBO(FBO_TMP1_WITH_DS).Bind();
for (unsigned i = 0; i < ListDisplacement::Arguments.size(); i++)
{
const GLMesh &mesh = *(std::get<0>(ListDisplacement::Arguments[i]));
const core::matrix4 &AbsoluteTransformation = std::get<1>(ListDisplacement::Arguments[i]);
const GLMesh &mesh = *(STK::tuple_get<0>(ListDisplacement::Arguments[i]));
const core::matrix4 &AbsoluteTransformation = STK::tuple_get<1>(ListDisplacement::Arguments[i]);
if (mesh.VAOType != video::EVT_2TCOORDS)
{
#ifdef DEBUG
@ -290,8 +426,8 @@ void IrrDriver::renderTransparent()
displaceTex = irr_driver->getTexture(FileManager::TEXTURE, "displace.png");
for (unsigned i = 0; i < ListDisplacement::Arguments.size(); i++)
{
const GLMesh &mesh = *(std::get<0>(ListDisplacement::Arguments[i]));
const core::matrix4 &AbsoluteTransformation = std::get<1>(ListDisplacement::Arguments[i]);
const GLMesh &mesh = *(STK::tuple_get<0>(ListDisplacement::Arguments[i]));
const core::matrix4 &AbsoluteTransformation = STK::tuple_get<1>(ListDisplacement::Arguments[i]);
if (mesh.VAOType != video::EVT_2TCOORDS)
continue;
@ -318,87 +454,111 @@ void IrrDriver::renderTransparent()
}
template<typename T, enum E_VERTEX_TYPE VertexType, typename... Args>
void drawShadow(const T *Shader, const std::vector<GLuint> TextureUnits, const std::vector<std::tuple<GLMesh *, core::matrix4, Args...> >&t)
template<typename T, typename...uniforms>
void drawShadow(const T *Shader, const GLMesh *mesh, uniforms... Args)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh->PrimitiveType;
GLenum itype = mesh->IndexType;
size_t count = mesh->IndexCount;
Shader->setUniforms(Args...);
glDrawElementsInstancedBaseVertex(ptype, count, itype, (GLvoid *)mesh->vaoOffset, 4, mesh->vaoBaseVertex);
}
template<int...List>
struct shadow_custom_unroll_args;
template<>
struct shadow_custom_unroll_args<>
{
template<typename T, typename ...TupleTypes, typename ...Args>
static void exec(const T *Shader, const STK::Tuple<TupleTypes...> &t, Args... args)
{
drawShadow<T>(Shader, STK::tuple_get<0>(t), args...);
}
};
template<int N, int...List>
struct shadow_custom_unroll_args<N, List...>
{
template<typename T, typename ...TupleTypes, typename ...Args>
static void exec(const T *Shader, const STK::Tuple<TupleTypes...> &t, Args... args)
{
shadow_custom_unroll_args<List...>::template exec<T>(Shader, t, STK::tuple_get<N>(t), args...);
}
};
template<typename T, enum E_VERTEX_TYPE VertexType, int...List, typename... Args>
void renderShadow(const T *Shader, const std::vector<GLuint> TextureUnits, const std::vector<STK::Tuple<GLMesh *, core::matrix4, Args...> >&t)
{
glUseProgram(Shader->Program);
glBindVertexArray(getVAO(VertexType));
for (unsigned i = 0; i < t.size(); i++)
{
const GLMesh *mesh = std::get<0>(t[i]);
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh->PrimitiveType;
GLenum itype = mesh->IndexType;
size_t count = mesh->IndexCount;
const GLMesh *mesh = STK::tuple_get<0>(t[i]);
for (unsigned j = 0; j < TextureUnits.size(); j++)
{
compressTexture(mesh->textures[j], true);
setTexture(TextureUnits[j], getTextureGLuint(mesh->textures[j]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
}
Shader->setUniforms(std::get<1>(t[i]));
glDrawElementsInstancedBaseVertex(ptype, count, itype, (GLvoid *)mesh->vaoOffset, 4, mesh->vaoBaseVertex);
}
}
static void drawShadowGrass(const std::vector<GLuint> TextureUnits, const std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, core::vector3df> > &t)
{
glUseProgram(MeshShader::GrassShadowShaderInstance->Program);
glBindVertexArray(getVAO(EVT_STANDARD));
for (unsigned i = 0; i < t.size(); i++)
{
const GLMesh *mesh = std::get<0>(t[i]);
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh->PrimitiveType;
GLenum itype = mesh->IndexType;
size_t count = mesh->IndexCount;
for (unsigned j = 0; j < TextureUnits.size(); j++)
{
compressTexture(mesh->textures[j], true);
setTexture(TextureUnits[j], getTextureGLuint(mesh->textures[j]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
}
MeshShader::GrassShadowShaderInstance->setUniforms(std::get<1>(t[i]), std::get<3>(t[i]));
glDrawElementsInstancedBaseVertex(ptype, count, itype, (GLvoid *)mesh->vaoOffset, 4, mesh->vaoBaseVertex);
shadow_custom_unroll_args<List...>::template exec<T>(Shader, t[i]);
}
}
template<enum E_VERTEX_TYPE VertexType, typename... Args>
void drawRSM(const core::matrix4 & rsm_matrix, const std::vector<GLuint> TextureUnits, const std::vector<std::tuple<GLMesh *, core::matrix4, Args...> >&t)
void drawRSM(const core::matrix4 & rsm_matrix, const std::vector<GLuint> TextureUnits, const std::vector<STK::Tuple<GLMesh *, core::matrix4, Args...> >&t)
{
glUseProgram(MeshShader::RSMShader::Program);
glBindVertexArray(getVAO(VertexType));
for (unsigned i = 0; i < t.size(); i++)
{
const GLMesh *mesh = std::get<0>(t[i]);
GLMesh *mesh = STK::tuple_get<0>(t[i]);
for (unsigned j = 0; j < TextureUnits.size(); j++)
{
if (!mesh->textures[j])
mesh->textures[j] = getUnicolorTexture(video::SColor(255, 255, 255, 255));
compressTexture(mesh->textures[j], true);
setTexture(TextureUnits[j], getTextureGLuint(mesh->textures[j]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
}
draw<MeshShader::RSMShader>(mesh, rsm_matrix, std::get<1>(t[i]));
draw<MeshShader::RSMShader>(mesh, rsm_matrix, STK::tuple_get<1>(t[i]));
}
}
void IrrDriver::renderShadows()
{
irr_driver->setPhase(SHADOW_PASS);
glDepthFunc(GL_LEQUAL);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
glDisable(GL_ALPHA_TEST);
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(1.5, 0.);
m_rtts->getShadowFBO().Bind();
glClear(GL_DEPTH_BUFFER_BIT);
glDrawBuffer(GL_NONE);
glBindBufferBase(GL_UNIFORM_BUFFER, 0, SharedObject::ViewProjectionMatrixesUBO);
irr_driver->setPhase(SHADOW_PASS);
ListMatDefault::Arguments.clear();
ListMatAlphaRef::Arguments.clear();
ListMatSphereMap::Arguments.clear();
ListMatDetails::Arguments.clear();
ListMatUnlit::Arguments.clear();
ListMatNormalMap::Arguments.clear();
ListMatGrass::Arguments.clear();
ListMatSplatting::Arguments.clear();
m_scene_manager->drawAll(scene::ESNRP_SOLID);
drawShadow<MeshShader::ShadowShader, EVT_STANDARD>(MeshShader::ShadowShaderInstance, {}, ListDefaultStandardG::Arguments);
drawShadow<MeshShader::ShadowShader, EVT_2TCOORDS>(MeshShader::ShadowShaderInstance, {}, ListDefault2TCoordG::Arguments);
drawShadow<MeshShader::ShadowShader, EVT_TANGENTS>(MeshShader::ShadowShaderInstance, {}, ListNormalG::Arguments);
drawShadow<MeshShader::RefShadowShader, EVT_STANDARD>(MeshShader::RefShadowShaderInstance, { MeshShader::RefShadowShaderInstance->TU_tex }, ListAlphaRefG::Arguments);
drawShadowGrass({ MeshShader::GrassShadowShaderInstance->TU_tex }, ListGrassG::Arguments);
std::vector<GLuint> noTexUnits;
renderShadow<MeshShader::ShadowShader, EVT_STANDARD, 1>(MeshShader::ShadowShaderInstance, noTexUnits, ListMatDefault::Arguments);
renderShadow<MeshShader::ShadowShader, EVT_STANDARD, 1>(MeshShader::ShadowShaderInstance, noTexUnits, ListMatSphereMap::Arguments);
renderShadow<MeshShader::ShadowShader, EVT_STANDARD, 1>(MeshShader::ShadowShaderInstance, noTexUnits, ListMatUnlit::Arguments);
renderShadow<MeshShader::ShadowShader, EVT_2TCOORDS, 1>(MeshShader::ShadowShaderInstance, noTexUnits, ListMatDetails::Arguments);
renderShadow<MeshShader::ShadowShader, EVT_2TCOORDS, 1>(MeshShader::ShadowShaderInstance, noTexUnits, ListMatSplatting::Arguments);
renderShadow<MeshShader::ShadowShader, EVT_TANGENTS, 1>(MeshShader::ShadowShaderInstance, noTexUnits, ListMatNormalMap::Arguments);
renderShadow<MeshShader::RefShadowShader, EVT_STANDARD, 1>(MeshShader::RefShadowShaderInstance, std::vector<GLuint>{ MeshShader::RefShadowShaderInstance->TU_tex }, ListMatAlphaRef::Arguments);
renderShadow<MeshShader::GrassShadowShader, EVT_STANDARD, 3, 1>(MeshShader::GrassShadowShaderInstance, std::vector<GLuint>{ MeshShader::GrassShadowShaderInstance->TU_tex }, ListMatGrass::Arguments);
glDisable(GL_POLYGON_OFFSET_FILL);
@ -408,6 +568,9 @@ void IrrDriver::renderShadows()
m_rtts->getRSM().Bind();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
drawRSM<EVT_STANDARD>(rsm_matrix, { MeshShader::RSMShader::TU_tex }, ListDefaultStandardG::Arguments);
drawRSM<EVT_2TCOORDS>(rsm_matrix, { MeshShader::RSMShader::TU_tex }, ListDefault2TCoordG::Arguments);
}
drawRSM<EVT_STANDARD>(rsm_matrix, std::vector<GLuint>{ MeshShader::RSMShader::TU_tex }, ListMatDefault::Arguments);
drawRSM<EVT_STANDARD>(rsm_matrix, std::vector<GLuint>{ MeshShader::RSMShader::TU_tex }, ListMatSphereMap::Arguments);
drawRSM<EVT_STANDARD>(rsm_matrix, std::vector<GLuint>{ MeshShader::RSMShader::TU_tex }, ListMatUnlit::Arguments);
drawRSM<EVT_2TCOORDS>(rsm_matrix, std::vector<GLuint>{ MeshShader::RSMShader::TU_tex }, ListMatDetails::Arguments);
drawRSM<EVT_2TCOORDS>(rsm_matrix, std::vector<GLuint>{ MeshShader::RSMShader::TU_tex }, ListMatSplatting::Arguments);
}

3
src/graphics/render_lighting.cpp
View File

@ -168,9 +168,6 @@ void IrrDriver::renderLights(unsigned pointlightcount)
}
m_rtts->getFBO(FBO_COMBINED_TMP1_TMP2).Bind();
if (World::getWorld() && World::getWorld()->getTrack()->hasShadows() && SkyboxCubeMap)
irr_driver->getSceneManager()->setAmbientLight(SColor(0, 0, 0, 0));
// Render sunlight if and only if track supports shadow
if (!World::getWorld() || World::getWorld()->getTrack()->hasShadows())
{

360
src/graphics/shaders.cpp
View File

@ -14,6 +14,81 @@
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
/**
\page shaders_overview Shaders Overview
\section shader_declaration Shader declaration
You need to create a class for each shader in shaders.cpp
This class should inherit from the template ShaderHelper<>.
The template first parameter is the shader class being declared and the following ones are the types
of every uniform (except samplers) required by the shaders.
The template inheritance will provide the shader with a setUniforms() variadic function which calls
the glUniform*() that pass uniforms value to the shader according to the type given as parameter
to the template.
The class constructor is used to
\li \ref shader_declaration_compile
\li \ref shader_declaration_uniform_names
\li \ref shader_declaration_bind_texture_unit
Of course it's possible to use the constructor to declare others things if needed.
\subsection shader_declaration_compile Compile the shader
The LoadProgram() function is provided to ease shader compilation and link.
It takes a flat sequence of SHADER_TYPE, filename pairs that will be linked together.
This way you can add any shader stage you want (geometry, domain/hull shader)
It is highly recommended to use explicit attribute location for a program input.
However as not all hardware support this extension, default location are provided for
input whose name is either Position (location 0) or Normal (location 1) or
Texcoord (location 3) or Color (location 2) or SecondTexcoord (location 4).
You can use these predefined name and location in your vao for shader
that needs GL pre 3.3 support.
\subsection shader_declaration_uniform_names Declare uniforms
Use the AssignUniforms() function to pass name of the uniforms in the program.
The order of name declaration is the same as the argument passed to setUniforms function.
\subsection shader_declaration_bind_texture_unit Bind texture unit and name
Texture are optional but if you have one, you must give them determined texture unit (up to 32).
You can do this using the AssignTextureUnit function that takes pair of texture unit and sampler name
as argument.
\section shader_usage
Shader's class are singleton that can be retrieved using ShaderClassName::getInstance() which automatically
creates an instance the first time it is called.
As the program id of a shader instance is public it can be used to bind a program :
\code
glUseProgram(MyShaderClass::getInstance()->Program);
\endcode
To set uniforms use the automatically generated function setUniforms:
\code
MyShaderClass::getInstance()->setUniforms(Args...)
\endcode
A Vertex Array must be bound (VAO creation process is currently left to the reader) :
\code
glBindVertexAttrib(vao);
\endcode
To actually perform the rendering you also need to call a glDraw* function (left to the reader as well) :
\code
glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT);
\endcode
*/
#define SHADER_NAMES
#include "graphics/callbacks.hpp"
@ -28,6 +103,11 @@
using namespace video;
GLuint getUniformLocation(GLuint program, const char* name)
{
return glGetUniformLocation(program, name);
}
Shaders::Shaders()
{
// Callbacks
@ -325,22 +405,7 @@ void Shaders::loadShaders()
FullScreenShader::MLAABlendWeightSHader::init();
FullScreenShader::MLAAGatherSHader::init();
MeshShader::ColorizeShader::init();
MeshShader::InstancedObjectPass1ShaderInstance = new MeshShader::InstancedObjectPass1Shader();
MeshShader::InstancedObjectRefPass1ShaderInstance = new MeshShader::InstancedObjectRefPass1Shader();
MeshShader::InstancedGrassPass1ShaderInstance = new MeshShader::InstancedGrassPass1Shader();
MeshShader::ObjectPass2ShaderInstance = new MeshShader::ObjectPass2Shader();
MeshShader::InstancedObjectPass2ShaderInstance = new MeshShader::InstancedObjectPass2Shader();
MeshShader::InstancedObjectRefPass2ShaderInstance = new MeshShader::InstancedObjectRefPass2Shader();
MeshShader::InstancedGrassPass2ShaderInstance = new MeshShader::InstancedGrassPass2Shader();
MeshShader::DetailledObjectPass2ShaderInstance = new MeshShader::DetailledObjectPass2Shader();
MeshShader::ObjectRefPass2ShaderInstance = new MeshShader::ObjectRefPass2Shader();
MeshShader::ObjectUnlitShaderInstance = new MeshShader::ObjectUnlitShader();
MeshShader::SphereMapShaderInstance = new MeshShader::SphereMapShader();
MeshShader::SplattingShaderInstance = new MeshShader::SplattingShader();
MeshShader::GrassPass2ShaderInstance = new MeshShader::GrassPass2Shader();
MeshShader::BubbleShader::init();
MeshShader::TransparentShaderInstance = new MeshShader::TransparentShader();
MeshShader::TransparentFogShaderInstance = new MeshShader::TransparentFogShader();
MeshShader::BillboardShader::init();
LightShader::PointLightShader::init();
MeshShader::DisplaceShaderInstance = new MeshShader::DisplaceShader();
@ -438,28 +503,79 @@ namespace UtilShader
glUniform4i(uniform_color, col.getRed(), col.getGreen(), col.getBlue(), col.getAlpha());
glUniformMatrix4fv(glGetUniformLocation(Program, "ModelMatrix"), 1, GL_FALSE, core::IdentityMatrix.pointer());
}
}
static void
AssignTextureUnit(GLuint Program, const std::vector<std::pair<GLuint, const char*> > assoc)
{
glUseProgram(Program);
for (unsigned i = 0; i < assoc.size(); i++)
struct TexUnit
{
GLuint uniform = glGetUniformLocation(Program, assoc[i].second);
glUniform1i(uniform, assoc[i].first);
GLuint m_index;
const char* m_uniform;
TexUnit(GLuint index, const char* uniform)
{
m_index = index;
m_uniform = uniform;
}
};
template <typename T>
std::vector<TexUnit> TexUnits(T curr) // required on older clang versions
{
std::vector<TexUnit> v;
v.push_back(curr);
return v;
}
glUseProgram(0);
}
static void
AssignUniforms(GLuint Program, std::vector<GLuint> &uniforms, const std::vector<const char*> &name)
{
for (unsigned i = 0; i < name.size(); i++)
template <typename T, typename... R>
std::vector<TexUnit> TexUnits(T curr, R... rest) // required on older clang versions
{
uniforms.push_back(glGetUniformLocation(Program, name[i]));
std::vector<TexUnit> v;
v.push_back(curr);
VTexUnits(v, rest...);
return v;
}
template <typename T, typename... R>
void VTexUnits(std::vector<TexUnit>& v, T curr, R... rest) // required on older clang versions
{
v.push_back(curr);
VTexUnits(v, rest...);
}
template <typename T>
void VTexUnits(std::vector<TexUnit>& v, T curr)
{
v.push_back(curr);
}
static void
AssignTextureUnit(GLuint Program, TexUnit texUnit)
{
glUseProgram(Program);
GLuint uniform = glGetUniformLocation(Program, texUnit.m_uniform);
glUniform1i(uniform, texUnit.m_index);
glUseProgram(0);
}
template<typename... T>
static void AssignTextureUnit(GLuint Program, TexUnit texUnit, T... rest)
{
glUseProgram(Program);
GLuint uniform = glGetUniformLocation(Program, texUnit.m_uniform);
glUniform1i(uniform, texUnit.m_index);
AssignTextureUnit_Sub(Program, rest...);
glUseProgram(0);
}
static void AssignTextureUnit_Sub(GLuint Program) {}
template<typename... T>
static void AssignTextureUnit_Sub(GLuint Program, TexUnit texUnit, T... rest)
{
GLuint uniform = glGetUniformLocation(Program, texUnit.m_uniform);
glUniform1i(uniform, texUnit.m_index);
AssignTextureUnit_Sub(Program, rest...);
}
}
using namespace UtilShader;
void glUniformMatrix4fvWraper(GLuint a, size_t b, unsigned c, const float *d)
{
@ -483,7 +599,6 @@ void glUniform1fWrapper(GLuint a, float b)
namespace MeshShader
{
// Solid Normal and depth pass shaders
ObjectPass1Shader::ObjectPass1Shader()
{
@ -491,14 +606,14 @@ namespace MeshShader
GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/encode_normal.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/object_pass1.frag").c_str());
AssignUniforms(Program, uniforms, {"ModelMatrix", "InverseModelMatrix"});
AssignUniforms("ModelMatrix", "InverseModelMatrix");
if (!UserConfigParams::m_ubo_disabled)
{
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
}
TU_tex = 0;
AssignTextureUnit(Program, { { TU_tex, "tex" } });
AssignTextureUnit(Program, TexUnit(TU_tex, "tex"));
}
ObjectRefPass1Shader::ObjectRefPass1Shader()
@ -507,14 +622,14 @@ namespace MeshShader
GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/encode_normal.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/objectref_pass1.frag").c_str());
AssignUniforms(Program, uniforms, { "ModelMatrix", "InverseModelMatrix", "TextureMatrix" });
AssignUniforms("ModelMatrix", "InverseModelMatrix", "TextureMatrix");
if (!UserConfigParams::m_ubo_disabled)
{
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
}
TU_tex = 0;
AssignTextureUnit(Program, { { TU_tex, "tex" } });
AssignTextureUnit(Program, TexUnit(TU_tex, "tex"));
}
GrassPass1Shader::GrassPass1Shader()
@ -523,9 +638,9 @@ namespace MeshShader
GL_VERTEX_SHADER, file_manager->getAsset("shaders/grass_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/encode_normal.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/objectref_pass1.frag").c_str());
AssignUniforms(Program, uniforms, { "ModelMatrix", "InverseModelMatrix", "windDir" });
AssignUniforms("ModelMatrix", "InverseModelMatrix", "windDir");
TU_tex = 0;
AssignTextureUnit(Program, { { TU_tex, "tex" } });
AssignTextureUnit(Program, TexUnit(TU_tex, "tex"));
}
NormalMapShader::NormalMapShader()
@ -534,7 +649,7 @@ namespace MeshShader
GL_VERTEX_SHADER, file_manager->getAsset("shaders/normalmap.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/encode_normal.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/normalmap.frag").c_str());
AssignUniforms(Program, uniforms, {"ModelMatrix", "InverseModelMatrix"});
AssignUniforms("ModelMatrix", "InverseModelMatrix");
if (!UserConfigParams::m_ubo_disabled)
{
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
@ -542,7 +657,7 @@ namespace MeshShader
}
TU_normalmap = 1;
TU_glossy = 0;
AssignTextureUnit(Program, { { TU_normalmap, "normalMap" }, { TU_glossy, "DiffuseForAlpha" } });
AssignTextureUnit(Program, TexUnit(TU_normalmap, "normalMap"), TexUnit(TU_glossy, "DiffuseForAlpha"));
}
InstancedObjectPass1Shader::InstancedObjectPass1Shader()
@ -553,7 +668,7 @@ namespace MeshShader
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/encode_normal.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/object_pass1.frag").c_str());
TU_tex = 0;
AssignTextureUnit(Program, { { TU_tex, "tex" } });
AssignTextureUnit(Program, TexUnit(TU_tex, "tex"));
if (!UserConfigParams::m_ubo_disabled)
{
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
@ -561,8 +676,6 @@ namespace MeshShader
}
}
InstancedObjectPass1Shader *InstancedObjectPass1ShaderInstance;
InstancedObjectRefPass1Shader::InstancedObjectRefPass1Shader()
{
Program = LoadProgram(
@ -571,7 +684,7 @@ namespace MeshShader
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/encode_normal.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/objectref_pass1.frag").c_str());
TU_tex = 0;
AssignTextureUnit(Program, { { TU_tex, "tex" } });
AssignTextureUnit(Program, TexUnit(TU_tex, "tex"));
if (!UserConfigParams::m_ubo_disabled)
{
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
@ -579,8 +692,6 @@ namespace MeshShader
}
}
InstancedObjectRefPass1Shader *InstancedObjectRefPass1ShaderInstance;
InstancedGrassPass1Shader::InstancedGrassPass1Shader()
{
Program = LoadProgram(
@ -588,9 +699,9 @@ namespace MeshShader
GL_VERTEX_SHADER, file_manager->getAsset("shaders/instanced_grass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/encode_normal.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/objectref_pass1.frag").c_str());
AssignUniforms(Program, uniforms, { "windDir" });
AssignUniforms("windDir");
TU_tex = 0;
AssignTextureUnit(Program, { { TU_tex, "tex" } });
AssignTextureUnit(Program, TexUnit(TU_tex, "tex"));
if (!UserConfigParams::m_ubo_disabled)
{
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
@ -598,8 +709,6 @@ namespace MeshShader
}
}
InstancedGrassPass1Shader *InstancedGrassPass1ShaderInstance;
// Solid Lit pass shaders
ObjectPass2Shader::ObjectPass2Shader()
{
@ -607,7 +716,7 @@ namespace MeshShader
GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getLightFactor.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/object_pass2.frag").c_str());
AssignUniforms(Program, uniforms, { "ModelMatrix", "TextureMatrix", "ambient" });
AssignUniforms("ModelMatrix", "TextureMatrix", "ambient");
if (!UserConfigParams::m_ubo_disabled)
{
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
@ -615,11 +724,14 @@ namespace MeshShader
}
TU_Albedo = 3;
AssignTextureUnit(Program, { { 0, "DiffuseMap" }, { 1, "SpecularMap" }, { 2, "SSAO" }, { TU_Albedo, "Albedo" } });
AssignTextureUnit(Program,
TexUnit(0, "DiffuseMap"),
TexUnit(1, "SpecularMap"),
TexUnit(2, "SSAO"),
TexUnit(TU_Albedo, "Albedo")
);
}
ObjectPass2Shader *ObjectPass2ShaderInstance;
InstancedObjectPass2Shader::InstancedObjectPass2Shader()
{
Program = LoadProgram(
@ -627,10 +739,15 @@ namespace MeshShader
GL_VERTEX_SHADER, file_manager->getAsset("shaders/instanced_object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getLightFactor.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/object_pass2.frag").c_str());
AssignUniforms(Program, uniforms, { "ambient" });
AssignUniforms("ambient");
TU_Albedo = 3;
AssignTextureUnit(Program, { { 0, "DiffuseMap" }, { 1, "SpecularMap" }, { 2, "SSAO" }, { TU_Albedo, "Albedo" } });
AssignTextureUnit(Program,
TexUnit(0, "DiffuseMap"),
TexUnit(1, "SpecularMap"),
TexUnit(2, "SSAO"),
TexUnit(TU_Albedo, "Albedo")
);
if (!UserConfigParams::m_ubo_disabled)
{
@ -639,8 +756,6 @@ namespace MeshShader
}
}
InstancedObjectPass2Shader *InstancedObjectPass2ShaderInstance;
InstancedObjectRefPass2Shader::InstancedObjectRefPass2Shader()
{
Program = LoadProgram(
@ -648,40 +763,47 @@ namespace MeshShader
GL_VERTEX_SHADER, file_manager->getAsset("shaders/instanced_object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getLightFactor.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/objectref_pass2.frag").c_str());
AssignUniforms(Program, uniforms, { "ambient" });
AssignUniforms("ambient");
TU_Albedo = 3;
AssignTextureUnit(Program, { { 0, "DiffuseMap" }, { 1, "SpecularMap" }, { 2, "SSAO" }, { TU_Albedo, "Albedo" } });
AssignTextureUnit(Program,
TexUnit(0, "DiffuseMap"),
TexUnit(1, "SpecularMap"),
TexUnit(2, "SSAO"),
TexUnit(TU_Albedo, "Albedo")
);
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
}
InstancedObjectRefPass2Shader *InstancedObjectRefPass2ShaderInstance;
DetailledObjectPass2Shader::DetailledObjectPass2Shader()
{
Program = LoadProgram(
GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getLightFactor.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/detailledobject_pass2.frag").c_str());
AssignUniforms(Program, uniforms, { "ModelMatrix", "ambient" });
AssignUniforms("ModelMatrix", "ambient");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
TU_Albedo = 3;
TU_detail = 4;
AssignTextureUnit(Program, { { 0, "DiffuseMap" }, { 1, "SpecularMap" }, { 2, "SSAO" }, { TU_Albedo, "Albedo" }, { TU_detail, "Detail" } });
AssignTextureUnit(Program,
TexUnit(0, "DiffuseMap"),
TexUnit(1, "SpecularMap"),
TexUnit(2, "SSAO"),
TexUnit(TU_Albedo, "Albedo"),
TexUnit(TU_detail, "Detail")
);
}
DetailledObjectPass2Shader *DetailledObjectPass2ShaderInstance;
ObjectUnlitShader::ObjectUnlitShader()
{
Program = LoadProgram(
GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/object_unlit.frag").c_str());
AssignUniforms(Program, uniforms, { "ModelMatrix" });
AssignUniforms("ModelMatrix");
if (!UserConfigParams::m_ubo_disabled)
{
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
@ -689,18 +811,16 @@ namespace MeshShader
}
TU_tex = 3;
AssignTextureUnit(Program, { { TU_tex, "tex" } });
AssignTextureUnit(Program, TexUnit(TU_tex, "tex"));
}
ObjectUnlitShader *ObjectUnlitShaderInstance;
ObjectRefPass2Shader::ObjectRefPass2Shader()
{
Program = LoadProgram(
GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getLightFactor.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/objectref_pass2.frag").c_str());
AssignUniforms(Program, uniforms, { "ModelMatrix", "TextureMatrix", "ambient" });
AssignUniforms("ModelMatrix", "TextureMatrix", "ambient");
if (!UserConfigParams::m_ubo_disabled)
{
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
@ -708,25 +828,31 @@ namespace MeshShader
}
TU_Albedo = 3;
AssignTextureUnit(Program, { { 0, "DiffuseMap" }, { 1, "SpecularMap" }, { 2, "SSAO" }, { TU_Albedo, "Albedo" } });
AssignTextureUnit(Program,
TexUnit(0, "DiffuseMap"),
TexUnit(1, "SpecularMap"),
TexUnit(2, "SSAO"),
TexUnit(TU_Albedo, "Albedo")
);
}
ObjectRefPass2Shader *ObjectRefPass2ShaderInstance;
GrassPass2Shader::GrassPass2Shader()
{
Program = LoadProgram(
GL_VERTEX_SHADER, file_manager->getAsset("shaders/grass_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getLightFactor.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/grass_pass2.frag").c_str());
AssignUniforms(Program, uniforms, { "ModelMatrix", "windDir", "ambient" });
AssignUniforms("ModelMatrix", "windDir", "ambient");
TU_Albedo = 3;
AssignTextureUnit(Program, { { 0, "DiffuseMap" }, { 1, "SpecularMap" }, { 2, "SSAO" }, { TU_Albedo, "Albedo" } });
AssignTextureUnit(Program,
TexUnit(0, "DiffuseMap"),
TexUnit(1, "SpecularMap"),
TexUnit(2, "SSAO"),
TexUnit(TU_Albedo, "Albedo")
);
}
GrassPass2Shader *GrassPass2ShaderInstance;
InstancedGrassPass2Shader::InstancedGrassPass2Shader()
{
Program = LoadProgram(
@ -734,18 +860,22 @@ namespace MeshShader
GL_VERTEX_SHADER, file_manager->getAsset("shaders/instanced_grass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getLightFactor.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/grass_pass2.frag").c_str());
AssignUniforms(Program, uniforms, { "windDir", "SunDir", "ambient" });
AssignUniforms("windDir", "SunDir", "ambient");
TU_Albedo = 3;
TU_dtex = 4;
AssignTextureUnit(Program, { { 0, "DiffuseMap" }, { 1, "SpecularMap" }, { 2, "SSAO" }, { TU_Albedo, "Albedo" }, { TU_dtex, "dtex" } });
AssignTextureUnit(Program,
TexUnit(0, "DiffuseMap"),
TexUnit(1, "SpecularMap"),
TexUnit(2, "SSAO"),
TexUnit(TU_Albedo, "Albedo"),
TexUnit(TU_dtex, "dtex")
);
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
}
InstancedGrassPass2Shader *InstancedGrassPass2ShaderInstance;
SphereMapShader::SphereMapShader()
{
Program = LoadProgram(
@ -753,7 +883,7 @@ namespace MeshShader
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getLightFactor.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getPosFromUVDepth.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/objectpass_spheremap.frag").c_str());
AssignUniforms(Program, uniforms, { "ModelMatrix", "InverseModelMatrix", "ambient" });
AssignUniforms("ModelMatrix", "InverseModelMatrix", "ambient");
if (!UserConfigParams::m_ubo_disabled)
{
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
@ -761,29 +891,38 @@ namespace MeshShader
}
TU_tex = 3;
AssignTextureUnit(Program, { { 0, "DiffuseMap" }, { 1, "SpecularMap" }, { 2, "SSAO" }, { TU_tex, "tex" } });
AssignTextureUnit(Program,
TexUnit(0, "DiffuseMap"),
TexUnit(1, "SpecularMap"),
TexUnit(2, "SSAO"),
TexUnit(TU_tex, "tex")
);
}
SphereMapShader *SphereMapShaderInstance;
SplattingShader::SplattingShader()
{
Program = LoadProgram(
GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/splatting.frag").c_str());
AssignUniforms(Program, uniforms, {"ModelMatrix", "ambient"});
AssignUniforms("ModelMatrix", "ambient");
TU_tex_layout = 3;
TU_tex_detail0 = 4;
TU_tex_detail1 = 5;
TU_tex_detail2 = 6;
TU_tex_detail3 = 7;
AssignTextureUnit(Program, { { 0, "DiffuseMap" }, { 1, "SpecularMap" }, { 2, "SSAO" }, { TU_tex_layout, "tex_layout" },
{ TU_tex_detail0, "tex_detail0" }, { TU_tex_detail1, "tex_detail1" }, { TU_tex_detail2, "tex_detail2" }, { TU_tex_detail3, "tex_detail3" } });
AssignTextureUnit(Program,
TexUnit(0, "DiffuseMap"),
TexUnit(1, "SpecularMap"),
TexUnit(2, "SSAO"),
TexUnit(TU_tex_layout, "tex_layout"),
TexUnit(TU_tex_detail0, "tex_detail0"),
TexUnit(TU_tex_detail1, "tex_detail1"),
TexUnit(TU_tex_detail2, "tex_detail2"),
TexUnit(TU_tex_detail3, "tex_detail3")
);
}
SplattingShader *SplattingShaderInstance;
GLuint BubbleShader::Program;
GLuint BubbleShader::uniform_MVP;
GLuint BubbleShader::uniform_tex;
@ -813,7 +952,7 @@ namespace MeshShader
Program = LoadProgram(
GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/transparent.frag").c_str());
AssignUniforms(Program, uniforms, {"ModelMatrix", "TextureMatrix" });
AssignUniforms("ModelMatrix", "TextureMatrix");
if (!UserConfigParams::m_ubo_disabled)
{
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
@ -821,17 +960,15 @@ namespace MeshShader
}
TU_tex = 0;
AssignTextureUnit(Program, { { TU_tex, "tex" } });
AssignTextureUnit(Program, TexUnit(TU_tex, "tex"));
}
TransparentShader *TransparentShaderInstance;
TransparentFogShader::TransparentFogShader()
{
Program = LoadProgram(
GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/transparentfog.frag").c_str());
AssignUniforms(Program, uniforms, { "ModelMatrix", "TextureMatrix", "fogmax", "startH", "endH", "start", "end", "col" });
AssignUniforms("ModelMatrix", "TextureMatrix", "fogmax", "startH", "endH", "start", "end", "col");
if (!UserConfigParams::m_ubo_disabled)
{
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
@ -839,11 +976,9 @@ namespace MeshShader
}
TU_tex = 0;
AssignTextureUnit(Program, { { TU_tex, "tex" } });
AssignTextureUnit(Program, TexUnit(TU_tex, "tex"));
}
TransparentFogShader *TransparentFogShaderInstance;
GLuint BillboardShader::Program;
GLuint BillboardShader::attrib_corner;
GLuint BillboardShader::attrib_texcoord;
@ -924,7 +1059,7 @@ namespace MeshShader
GL_GEOMETRY_SHADER, file_manager->getAsset("shaders/shadow.geom").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/white.frag").c_str());
}
AssignUniforms(Program, uniforms, { "ModelMatrix" });
AssignUniforms("ModelMatrix");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
}
@ -945,7 +1080,7 @@ namespace MeshShader
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/rsm.frag").c_str());
uniform_MM = glGetUniformLocation(Program, "ModelMatrix");
uniform_RSMMatrix = glGetUniformLocation(Program, "RSMMatrix");
AssignTextureUnit(Program, { { TU_tex, "tex" } });
AssignTextureUnit(Program, { TexUnit(TU_tex, "tex") });
}
void RSMShader::setUniforms(const core::matrix4 &RSMMatrix, const core::matrix4 &ModelMatrix)
@ -998,12 +1133,12 @@ namespace MeshShader
GL_GEOMETRY_SHADER, file_manager->getAsset("shaders/shadow.geom").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/object_unlit.frag").c_str());
}
AssignUniforms(Program, uniforms, { "ModelMatrix" });
AssignUniforms("ModelMatrix");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
TU_tex = 0;
AssignTextureUnit(Program, { { TU_tex, "tex" } });
AssignTextureUnit(Program, { TexUnit(TU_tex, "tex") });
}
RefShadowShader *RefShadowShaderInstance;
@ -1029,7 +1164,7 @@ namespace MeshShader
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/object_unlit.frag").c_str());
}
TU_tex = 0;
AssignTextureUnit(Program, { { TU_tex, "tex" } });
AssignTextureUnit(Program, { TexUnit(TU_tex, "tex") });
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
}
@ -1054,12 +1189,12 @@ namespace MeshShader
GL_GEOMETRY_SHADER, file_manager->getAsset("shaders/shadow.geom").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/object_unlit.frag").c_str());
}
AssignUniforms(Program, uniforms, { "ModelMatrix", "windDir" });
AssignUniforms("ModelMatrix", "windDir");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
TU_tex = 0;
AssignTextureUnit(Program, { { TU_tex, "tex" } });
AssignTextureUnit(Program, { TexUnit(TU_tex, "tex") });
}
GrassShadowShader *GrassShadowShaderInstance;
@ -1085,9 +1220,9 @@ namespace MeshShader
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/object_unlit.frag").c_str());
}
TU_tex = 0;
AssignTextureUnit(Program, { { TU_tex, "tex" } });
AssignTextureUnit(Program, TexUnit(TU_tex, "tex"));
AssignUniforms(Program, uniforms, { "windDir" });
AssignUniforms("windDir");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
}
@ -1099,7 +1234,7 @@ namespace MeshShader
Program = LoadProgram(
GL_VERTEX_SHADER, file_manager->getAsset("shaders/displace.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/white.frag").c_str());
AssignUniforms(Program, uniforms, { "ModelMatrix"});
AssignUniforms("ModelMatrix");
if (!UserConfigParams::m_ubo_disabled)
{
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
@ -1115,12 +1250,17 @@ namespace MeshShader
Program = LoadProgram(
GL_VERTEX_SHADER, file_manager->getAsset("shaders/displace.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/displace.frag").c_str());
AssignUniforms(Program, uniforms, { "ModelMatrix", "dir", "dir2" });
AssignUniforms("ModelMatrix", "dir", "dir2");
TU_displacement_tex = 0;
TU_color_tex = 1;
TU_mask_tex = 2;
TU_tex = 3;
AssignTextureUnit(Program, { { TU_displacement_tex, "displacement_tex" }, { TU_color_tex, "color_tex" }, { TU_mask_tex, "mask_tex" }, { TU_tex, "tex" } });
AssignTextureUnit(Program,
TexUnit(TU_displacement_tex, "displacement_tex"),
TexUnit(TU_color_tex, "color_tex"),
TexUnit(TU_mask_tex, "mask_tex"),
TexUnit(TU_tex, "tex")
);
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
}

87
src/graphics/shaders.hpp
View File

@ -103,12 +103,26 @@ struct UniformHelper
};
void bypassUBO(GLuint Program);
GLuint getUniformLocation(GLuint program, const char* name);
template<typename... Args>
class ShaderHelper
{
protected:
std::vector<GLuint> uniforms;
void AssignUniforms(const char* name)
{
uniforms.push_back(getUniformLocation(Program, name));
}
template<typename... T>
void AssignUniforms(const char* name, T... rest)
{
uniforms.push_back(getUniformLocation(Program, name));
AssignUniforms(rest...);
}
public:
GLuint Program;
@ -125,6 +139,19 @@ class ShaderHelperSingleton : public Singleton<T>
{
protected:
std::vector<GLuint> uniforms;
void AssignUniforms(const char* name)
{
uniforms.push_back(getUniformLocation(Program, name));
}
template<typename... U>
void AssignUniforms(const char* name, U... rest)
{
uniforms.push_back(getUniformLocation(Program, name));
AssignUniforms(rest...);
}
public:
friend class Singleton<class ObjectPass1Shader>;
GLuint Program;
@ -168,7 +195,7 @@ public:
NormalMapShader();
};
class InstancedObjectPass1Shader : public ShaderHelper<>
class InstancedObjectPass1Shader : public ShaderHelperSingleton<InstancedObjectPass1Shader>
{
public:
GLuint TU_tex;
@ -176,9 +203,7 @@ public:
InstancedObjectPass1Shader();
};
extern InstancedObjectPass1Shader *InstancedObjectPass1ShaderInstance;
class InstancedObjectRefPass1Shader : public ShaderHelper<>
class InstancedObjectRefPass1Shader : public ShaderHelperSingleton<InstancedObjectRefPass1Shader>
{
public:
GLuint TU_tex;
@ -186,9 +211,7 @@ public:
InstancedObjectRefPass1Shader();
};
extern InstancedObjectRefPass1Shader *InstancedObjectRefPass1ShaderInstance;
class InstancedGrassPass1Shader : public ShaderHelper<core::vector3df>
class InstancedGrassPass1Shader : public ShaderHelperSingleton<InstancedGrassPass1Shader, core::vector3df>
{
public:
GLuint TU_tex;
@ -196,9 +219,7 @@ public:
InstancedGrassPass1Shader();
};
extern InstancedGrassPass1Shader *InstancedGrassPass1ShaderInstance;
class ObjectPass2Shader : public ShaderHelper<core::matrix4, core::matrix4, video::SColorf>
class ObjectPass2Shader : public ShaderHelperSingleton<ObjectPass2Shader, core::matrix4, core::matrix4>
{
public:
GLuint TU_Albedo;
@ -206,9 +227,7 @@ public:
ObjectPass2Shader();
};
extern ObjectPass2Shader *ObjectPass2ShaderInstance;
class InstancedObjectPass2Shader : public ShaderHelper<video::SColorf>
class InstancedObjectPass2Shader : public ShaderHelperSingleton<InstancedObjectPass2Shader>
{
public:
GLuint TU_Albedo;
@ -216,9 +235,7 @@ public:
InstancedObjectPass2Shader();
};
extern InstancedObjectPass2Shader *InstancedObjectPass2ShaderInstance;
class InstancedObjectRefPass2Shader : public ShaderHelper<video::SColorf>
class InstancedObjectRefPass2Shader : public ShaderHelperSingleton<InstancedObjectRefPass2Shader>
{
public:
GLuint TU_Albedo;
@ -226,9 +243,7 @@ public:
InstancedObjectRefPass2Shader();
};
extern InstancedObjectRefPass2Shader *InstancedObjectRefPass2ShaderInstance;
class DetailledObjectPass2Shader : public ShaderHelper<core::matrix4, video::SColorf>
class DetailledObjectPass2Shader : public ShaderHelperSingleton<DetailledObjectPass2Shader, core::matrix4>
{
public:
GLuint TU_Albedo, TU_detail;
@ -236,9 +251,7 @@ public:
DetailledObjectPass2Shader();
};
extern DetailledObjectPass2Shader *DetailledObjectPass2ShaderInstance;
class ObjectUnlitShader : public ShaderHelper<core::matrix4>
class ObjectUnlitShader : public ShaderHelperSingleton<ObjectUnlitShader, core::matrix4>
{
public:
GLuint TU_tex;
@ -246,9 +259,7 @@ public:
ObjectUnlitShader();
};
extern ObjectUnlitShader *ObjectUnlitShaderInstance;
class ObjectRefPass2Shader : public ShaderHelper<core::matrix4, core::matrix4, video::SColorf>
class ObjectRefPass2Shader : public ShaderHelperSingleton<ObjectRefPass2Shader, core::matrix4, core::matrix4>
{
public:
GLuint TU_Albedo;
@ -256,9 +267,7 @@ public:
ObjectRefPass2Shader();
};
extern ObjectRefPass2Shader *ObjectRefPass2ShaderInstance;
class GrassPass2Shader : public ShaderHelper<core::matrix4, core::vector3df, video::SColorf>
class GrassPass2Shader : public ShaderHelperSingleton<GrassPass2Shader, core::matrix4, core::vector3df>
{
public:
GLuint TU_Albedo;
@ -266,9 +275,7 @@ public:
GrassPass2Shader();
};
extern GrassPass2Shader *GrassPass2ShaderInstance;
class InstancedGrassPass2Shader : public ShaderHelper<core::vector3df, core::vector3df, video::SColorf>
class InstancedGrassPass2Shader : public ShaderHelperSingleton<InstancedGrassPass2Shader, core::vector3df, core::vector3df>
{
public:
GLuint TU_Albedo, TU_dtex;
@ -276,9 +283,7 @@ public:
InstancedGrassPass2Shader();
};
extern InstancedGrassPass2Shader *InstancedGrassPass2ShaderInstance;
class SphereMapShader : public ShaderHelper<core::matrix4, core::matrix4, video::SColorf>
class SphereMapShader : public ShaderHelperSingleton<SphereMapShader, core::matrix4, core::matrix4>
{
public:
GLuint TU_tex;
@ -286,9 +291,7 @@ public:
SphereMapShader();
};
extern SphereMapShader *SphereMapShaderInstance;
class SplattingShader : public ShaderHelper<core::matrix4, video::SColorf>
class SplattingShader : public ShaderHelperSingleton<SplattingShader, core::matrix4>
{
public:
GLuint TU_tex_layout, TU_tex_detail0, TU_tex_detail1, TU_tex_detail2, TU_tex_detail3;
@ -296,8 +299,6 @@ public:
SplattingShader();
};
extern SplattingShader *SplattingShaderInstance;
class BubbleShader
{
public:
@ -308,7 +309,7 @@ public:
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, unsigned TU_tex, float time, float transparency);
};
class TransparentShader : public ShaderHelper<core::matrix4, core::matrix4>
class TransparentShader : public ShaderHelperSingleton<TransparentShader, core::matrix4, core::matrix4>
{
public:
GLuint TU_tex;
@ -316,9 +317,7 @@ public:
TransparentShader();
};
extern TransparentShader *TransparentShaderInstance;
class TransparentFogShader : public ShaderHelper<core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf>
class TransparentFogShader : public ShaderHelperSingleton<TransparentFogShader, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf>
{
public:
GLuint TU_tex;
@ -326,8 +325,6 @@ public:
TransparentFogShader();
};
extern TransparentFogShader *TransparentFogShaderInstance;
class BillboardShader
{
public:

62
src/graphics/stkanimatedmesh.cpp
View File

@ -8,6 +8,7 @@
#include "tracks/track.hpp"
#include "graphics/camera.hpp"
#include "utils/profiler.hpp"
#include "utils/cpp2011.hpp"
using namespace irr;
@ -39,10 +40,8 @@ void STKAnimatedMesh::setMesh(scene::IAnimatedMesh* mesh)
{
firstTime = true;
GLmeshes.clear();
for (unsigned i = 0; i < FPSM_COUNT; i++)
GeometricMesh[i].clearWithoutDeleting();
for (unsigned i = 0; i < SM_COUNT; i++)
ShadedMesh[i].clearWithoutDeleting();
for (unsigned i = 0; i < MAT_COUNT; i++)
MeshSolidMaterial[i].clearWithoutDeleting();
CAnimatedMeshSceneNode::setMesh(mesh);
}
@ -98,10 +97,8 @@ void STKAnimatedMesh::render()
}
else
{
GeometricMaterial GeometricType = MaterialTypeToGeometricMaterial(type, mb->getVertexType());
ShadedMaterial ShadedType = MaterialTypeToShadedMaterial(type, mesh.textures, mb->getVertexType());
GeometricMesh[GeometricType].push_back(&mesh);
ShadedMesh[ShadedType].push_back(&mesh);
MeshMaterial MatType = MaterialTypeToMeshMaterial(type, mb->getVertexType());
MeshSolidMaterial[MatType].push_back(&mesh);
}
std::pair<unsigned, unsigned> p = getVAOOffsetAndBase(mb);
mesh.vaoBaseVertex = p.first;
@ -117,7 +114,7 @@ void STKAnimatedMesh::render()
const video::SMaterial& material = ReadOnlyMaterials ? mb->getMaterial() : Materials[i];
if (isObject(material.MaterialType))
{
if (irr_driver->getPhase() == SOLID_NORMAL_AND_DEPTH_PASS || irr_driver->getPhase() == TRANSPARENT_PASS)
if (irr_driver->getPhase() == SOLID_NORMAL_AND_DEPTH_PASS || irr_driver->getPhase() == TRANSPARENT_PASS || irr_driver->getPhase() == SHADOW_PASS)
{
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, getVBO(mb->getVertexType()));
@ -137,45 +134,24 @@ void STKAnimatedMesh::render()
continue;
}
if (irr_driver->getPhase() == SOLID_NORMAL_AND_DEPTH_PASS)
if (irr_driver->getPhase() == SOLID_NORMAL_AND_DEPTH_PASS || irr_driver->getPhase() == SHADOW_PASS)
{
ModelViewProjectionMatrix = computeMVP(AbsoluteTransformation);
core::matrix4 invmodel;
AbsoluteTransformation.getInverse(invmodel);
GLMesh* mesh;
for_in(mesh, GeometricMesh[FPSM_DEFAULT_STANDARD])
ListDefaultStandardG::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel));
for_in(mesh, MeshSolidMaterial[MAT_DEFAULT])
pushVector(ListMatDefault::Arguments, mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
for_in(mesh, GeometricMesh[FPSM_DEFAULT_2TCOORD])
ListDefault2TCoordG::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel));
for_in(mesh, MeshSolidMaterial[MAT_ALPHA_REF])
pushVector(ListMatAlphaRef::Arguments, mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
for_in(mesh, GeometricMesh[FPSM_ALPHA_REF_TEXTURE])
ListAlphaRefG::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix));
for_in(mesh, MeshSolidMaterial[MAT_DETAIL])
pushVector(ListMatDetails::Arguments, mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
return;
}
if (irr_driver->getPhase() == SOLID_LIT_PASS)
{
core::matrix4 invmodel;
AbsoluteTransformation.getInverse(invmodel);
GLMesh* mesh;
for_in(mesh, ShadedMesh[SM_DEFAULT_STANDARD])
ListDefaultStandardSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
for_in(mesh, ShadedMesh[SM_DEFAULT_TANGENT])
ListDefaultTangentSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
for_in(mesh, ShadedMesh[SM_ALPHA_REF_TEXTURE])
ListAlphaRefSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
for_in (mesh, ShadedMesh[SM_UNLIT])
ListUnlitSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation));
for_in(mesh, ShadedMesh[SM_DETAILS])
ListDetailSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, irr_driver->getSceneManager()->getAmbientLight()));
for_in(mesh, MeshSolidMaterial[MAT_UNLIT])
pushVector(ListMatUnlit::Arguments, mesh, AbsoluteTransformation, core::matrix4::EM4CONST_IDENTITY);
return;
}
@ -206,20 +182,20 @@ void STKAnimatedMesh::render()
for_in(mesh, TransparentMesh[TM_DEFAULT])
ListBlendTransparentFog::Arguments.push_back(
std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix,
STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix,
fogmax, startH, endH, start, end, col));
for_in(mesh, TransparentMesh[TM_ADDITIVE])
ListAdditiveTransparentFog::Arguments.push_back(
std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix,
STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix,
fogmax, startH, endH, start, end, col));
}
else
{
for_in(mesh, TransparentMesh[TM_DEFAULT])
ListBlendTransparent::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix));
pushVector(ListBlendTransparent::Arguments, mesh, AbsoluteTransformation, mesh->TextureMatrix);
for_in(mesh, TransparentMesh[TM_ADDITIVE])
ListAdditiveTransparent::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix));
pushVector(ListAdditiveTransparent::Arguments, mesh, AbsoluteTransformation, mesh->TextureMatrix);
}
return;
}

3
src/graphics/stkanimatedmesh.hpp
View File

@ -11,8 +11,7 @@ class STKAnimatedMesh : public irr::scene::CAnimatedMeshSceneNode
{
protected:
bool firstTime;
PtrVector<GLMesh, REF> GeometricMesh[FPSM_COUNT];
PtrVector<GLMesh, REF> ShadedMesh[SM_COUNT];
PtrVector<GLMesh, REF> MeshSolidMaterial[MAT_COUNT];
PtrVector<GLMesh, REF> TransparentMesh[TM_COUNT];
std::vector<GLMesh> GLmeshes;
core::matrix4 ModelViewProjectionMatrix;

12
src/graphics/stkbillboard.cpp
View File

@ -2,6 +2,7 @@
#include "graphics/glwrap.hpp"
#include "graphics/shaders.hpp"
#include "graphics/irr_driver.hpp"
#include <ISceneManager.h>
using namespace irr;
@ -28,6 +29,17 @@ STKBillboard::STKBillboard(irr::scene::ISceneNode* parent, irr::scene::ISceneMan
createbillboardvao();
}
void STKBillboard::OnRegisterSceneNode()
{
if (IsVisible)
{
SceneManager->registerNodeForRendering(this, scene::ESNRP_TRANSPARENT);
}
ISceneNode::OnRegisterSceneNode();
}
void STKBillboard::render()
{
if (irr_driver->getPhase() != TRANSPARENT_PASS)

5
src/graphics/stkbillboard.hpp
View File

@ -4,6 +4,7 @@
#include "../lib/irrlicht/source/Irrlicht/CBillboardSceneNode.h"
#include <IBillboardSceneNode.h>
#include <irrTypes.h>
#include "utils/cpp2011.hpp"
class STKBillboard : public irr::scene::CBillboardSceneNode
{
@ -13,7 +14,9 @@ public:
irr::video::SColor colorTop = irr::video::SColor(0xFFFFFFFF),
irr::video::SColor colorBottom = irr::video::SColor(0xFFFFFFFF));
virtual void render();
virtual void OnRegisterSceneNode() OVERRIDE;
virtual void render() OVERRIDE;
};
#endif

110
src/graphics/stkinstancedscenenode.cpp
View File

@ -55,7 +55,7 @@ void STKInstancedSceneNode::createGLMeshes()
isMaterialInitialized = false;
}
void STKInstancedSceneNode::initinstancedvaostate(GLMesh &mesh, GeometricMaterial GeoMat, ShadedMaterial ShadedMat)
void STKInstancedSceneNode::initinstancedvaostate(GLMesh &mesh)
{
mesh.vao = createVAO(mesh.vertex_buffer, mesh.index_buffer, getVTXTYPEFromStride(mesh.Stride));
glGenBuffers(1, &instances_vbo);
@ -99,11 +99,9 @@ void STKInstancedSceneNode::setFirstTimeMaterial()
video::E_MATERIAL_TYPE type = mb->getMaterial().MaterialType;
GLMesh &mesh = GLmeshes[i];
GeometricMaterial GeometricType = MaterialTypeToGeometricMaterial(type, mb->getVertexType());
ShadedMaterial ShadedType = MaterialTypeToShadedMaterial(type, mesh.textures, mb->getVertexType());
initinstancedvaostate(mesh, GeometricType, ShadedType);
GeometricMesh[GeometricType].push_back(&mesh);
ShadedMesh[ShadedType].push_back(&mesh);
MeshMaterial MatType = MaterialTypeToMeshMaterial(type, mb->getVertexType());
initinstancedvaostate(mesh);
MeshSolidMaterial[MatType].push_back(&mesh);
}
isMaterialInitialized = true;
}
@ -131,15 +129,15 @@ static void drawFSPMDefault(GLMesh &mesh, size_t instance_count)
if (mesh.textures[0])
{
compressTexture(mesh.textures[0], true);
setTexture(MeshShader::InstancedObjectPass1ShaderInstance->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
setTexture(MeshShader::InstancedObjectPass1Shader::getInstance()->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
}
else
{
setTexture(MeshShader::InstancedObjectPass1ShaderInstance->TU_tex, 0, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, false);
setTexture(MeshShader::InstancedObjectPass1Shader::getInstance()->TU_tex, 0, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, false);
GLint swizzleMask[] = { GL_ONE, GL_ONE, GL_ONE, GL_ONE };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
MeshShader::InstancedObjectPass1ShaderInstance->setUniforms();
MeshShader::InstancedObjectPass1Shader::getInstance()->setUniforms();
glBindVertexArray(mesh.vao);
glDrawElementsInstanced(ptype, count, itype, 0, instance_count);
@ -172,8 +170,8 @@ static void drawFSPMAlphaRefTexture(GLMesh &mesh, size_t instance_count)
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], true);
setTexture(MeshShader::InstancedObjectRefPass1ShaderInstance->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::InstancedObjectRefPass1ShaderInstance->setUniforms();
setTexture(MeshShader::InstancedObjectRefPass1Shader::getInstance()->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::InstancedObjectRefPass1Shader::getInstance()->setUniforms();
glBindVertexArray(mesh.vao);
glDrawElementsInstanced(ptype, count, itype, 0, instance_count);
@ -217,21 +215,21 @@ static void drawFSPMGrass(GLMesh &mesh, const core::vector3df &windDir, size_t i
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], true);
setTexture(MeshShader::InstancedGrassPass1ShaderInstance->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::InstancedGrassPass1ShaderInstance->setUniforms(windDir);
setTexture(MeshShader::InstancedGrassPass1Shader::getInstance()->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::InstancedGrassPass1Shader::getInstance()->setUniforms(windDir);
glBindVertexArray(mesh.vao);
glDrawElementsInstanced(ptype, count, itype, 0, instance_count);
}
static void drawSMDefault(GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, size_t instance_count)
static void drawSMDefault(GLMesh &mesh, size_t instance_count)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
setTexture(MeshShader::InstancedObjectPass2ShaderInstance->TU_Albedo, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
setTexture(MeshShader::InstancedObjectPass2Shader::getInstance()->TU_Albedo, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
if (irr_driver->getLightViz())
{
GLint swizzleMask[] = { GL_ONE, GL_ONE, GL_ONE, GL_ALPHA };
@ -243,13 +241,13 @@ static void drawSMDefault(GLMesh &mesh, const core::matrix4 &ModelViewProjection
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
MeshShader::InstancedObjectPass2ShaderInstance->setUniforms(irr_driver->getSceneManager()->getAmbientLight());
MeshShader::InstancedObjectPass2Shader::getInstance()->setUniforms();
glBindVertexArray(mesh.vao);
glDrawElementsInstanced(ptype, count, itype, 0, instance_count);
}
static void drawSMAlphaRefTexture(GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, size_t instance_count)
static void drawSMAlphaRefTexture(GLMesh &mesh, size_t instance_count)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType;
@ -257,7 +255,7 @@ static void drawSMAlphaRefTexture(GLMesh &mesh, const core::matrix4 &ModelViewPr
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], true);
setTexture(MeshShader::InstancedObjectRefPass2ShaderInstance->TU_Albedo, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
setTexture(MeshShader::InstancedObjectRefPass2Shader::getInstance()->TU_Albedo, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
if (irr_driver->getLightViz())
{
GLint swizzleMask[] = { GL_ONE, GL_ONE, GL_ONE, GL_ALPHA };
@ -269,13 +267,13 @@ static void drawSMAlphaRefTexture(GLMesh &mesh, const core::matrix4 &ModelViewPr
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
MeshShader::InstancedObjectRefPass2ShaderInstance->setUniforms(irr_driver->getSceneManager()->getAmbientLight());
MeshShader::InstancedObjectRefPass2Shader::getInstance()->setUniforms();
glBindVertexArray(mesh.vao);
glDrawElementsInstanced(ptype, count, itype, 0, instance_count);
}
static void drawSMGrass(GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, const core::vector3df &windDir, size_t instance_count)
static void drawSMGrass(GLMesh &mesh, const core::vector3df &windDir, size_t instance_count)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType;
@ -283,7 +281,7 @@ static void drawSMGrass(GLMesh &mesh, const core::matrix4 &ModelViewProjectionMa
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], true);
setTexture(MeshShader::InstancedGrassPass2ShaderInstance->TU_Albedo, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
setTexture(MeshShader::InstancedGrassPass2Shader::getInstance()->TU_Albedo, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
if (irr_driver->getLightViz())
{
GLint swizzleMask[] = { GL_ONE, GL_ONE, GL_ONE, GL_ALPHA };
@ -294,10 +292,10 @@ static void drawSMGrass(GLMesh &mesh, const core::matrix4 &ModelViewProjectionMa
GLint swizzleMask[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
setTexture(MeshShader::InstancedGrassPass2ShaderInstance->TU_dtex, irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
setTexture(MeshShader::InstancedGrassPass2Shader::getInstance()->TU_dtex, irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
SunLightProvider * const cb = (SunLightProvider *)irr_driver->getCallback(ES_SUNLIGHT);
MeshShader::InstancedGrassPass2ShaderInstance->setUniforms(windDir, cb->getPosition(), irr_driver->getSceneManager()->getAmbientLight());
MeshShader::InstancedGrassPass2Shader::getInstance()->setUniforms(windDir, cb->getPosition());
glBindVertexArray(mesh.vao);
glDrawElementsInstanced(ptype, count, itype, 0, instance_count);
@ -318,59 +316,59 @@ void STKInstancedSceneNode::render()
ModelViewProjectionMatrix = irr_driver->getProjMatrix();
ModelViewProjectionMatrix *= irr_driver->getViewMatrix();
if (!GeometricMesh[FPSM_DEFAULT_STANDARD].empty())
glUseProgram(MeshShader::InstancedObjectPass1ShaderInstance->Program);
for (unsigned i = 0; i < GeometricMesh[FPSM_DEFAULT_STANDARD].size(); i++)
drawFSPMDefault(*GeometricMesh[FPSM_DEFAULT_STANDARD][i], instance_pos.size() / 9);
if (!MeshSolidMaterial[MAT_DEFAULT].empty())
glUseProgram(MeshShader::InstancedObjectPass1Shader::getInstance()->Program);
for (unsigned i = 0; i < MeshSolidMaterial[MAT_DEFAULT].size(); i++)
drawFSPMDefault(*MeshSolidMaterial[MAT_DEFAULT][i], instance_pos.size() / 9);
if (!GeometricMesh[FPSM_ALPHA_REF_TEXTURE].empty())
glUseProgram(MeshShader::InstancedObjectRefPass1ShaderInstance->Program);
for (unsigned i = 0; i < GeometricMesh[FPSM_ALPHA_REF_TEXTURE].size(); i++)
drawFSPMAlphaRefTexture(*GeometricMesh[FPSM_ALPHA_REF_TEXTURE][i], instance_pos.size() / 9);
if (!MeshSolidMaterial[MAT_ALPHA_REF].empty())
glUseProgram(MeshShader::InstancedObjectRefPass1Shader::getInstance()->Program);
for (unsigned i = 0; i < MeshSolidMaterial[MAT_ALPHA_REF].size(); i++)
drawFSPMAlphaRefTexture(*MeshSolidMaterial[MAT_ALPHA_REF][i], instance_pos.size() / 9);
windDir = getWind();
if (!GeometricMesh[FPSM_GRASS].empty())
glUseProgram(MeshShader::InstancedGrassPass1ShaderInstance->Program);
for (unsigned i = 0; i < GeometricMesh[FPSM_GRASS].size(); i++)
drawFSPMGrass(*GeometricMesh[FPSM_GRASS][i], windDir, instance_pos.size() / 9);
if (!MeshSolidMaterial[MAT_GRASS].empty())
glUseProgram(MeshShader::InstancedGrassPass1Shader::getInstance()->Program);
for (unsigned i = 0; i < MeshSolidMaterial[MAT_GRASS].size(); i++)
drawFSPMGrass(*MeshSolidMaterial[MAT_GRASS][i], windDir, instance_pos.size() / 9);
return;
}
if (irr_driver->getPhase() == SOLID_LIT_PASS)
{
if (!ShadedMesh[SM_DEFAULT_STANDARD].empty())
glUseProgram(MeshShader::InstancedObjectPass2ShaderInstance->Program);
for (unsigned i = 0; i < ShadedMesh[SM_DEFAULT_STANDARD].size(); i++)
drawSMDefault(*ShadedMesh[SM_DEFAULT_STANDARD][i], ModelViewProjectionMatrix, instance_pos.size() / 9);
if (!MeshSolidMaterial[MAT_DEFAULT].empty())
glUseProgram(MeshShader::InstancedObjectPass2Shader::getInstance()->Program);
for (unsigned i = 0; i < MeshSolidMaterial[MAT_DEFAULT].size(); i++)
drawSMDefault(*MeshSolidMaterial[MAT_DEFAULT][i], instance_pos.size() / 9);
if (!ShadedMesh[SM_ALPHA_REF_TEXTURE].empty())
glUseProgram(MeshShader::InstancedObjectRefPass2ShaderInstance->Program);
for (unsigned i = 0; i < ShadedMesh[SM_ALPHA_REF_TEXTURE].size(); i++)
drawSMAlphaRefTexture(*ShadedMesh[SM_ALPHA_REF_TEXTURE][i], ModelViewProjectionMatrix, instance_pos.size() / 9);
if (!MeshSolidMaterial[MAT_ALPHA_REF].empty())
glUseProgram(MeshShader::InstancedObjectRefPass2Shader::getInstance()->Program);
for (unsigned i = 0; i < MeshSolidMaterial[MAT_ALPHA_REF].size(); i++)
drawSMAlphaRefTexture(*MeshSolidMaterial[MAT_ALPHA_REF][i], instance_pos.size() / 9);
if (!ShadedMesh[SM_GRASS].empty())
glUseProgram(MeshShader::InstancedGrassPass2ShaderInstance->Program);
for (unsigned i = 0; i < ShadedMesh[SM_GRASS].size(); i++)
drawSMGrass(*ShadedMesh[SM_GRASS][i], ModelViewProjectionMatrix, windDir, instance_pos.size() / 9);
if (!MeshSolidMaterial[MAT_GRASS].empty())
glUseProgram(MeshShader::InstancedGrassPass2Shader::getInstance()->Program);
for (unsigned i = 0; i < MeshSolidMaterial[MAT_GRASS].size(); i++)
drawSMGrass(*MeshSolidMaterial[MAT_GRASS][i], windDir, instance_pos.size() / 9);
return;
}
if (irr_driver->getPhase() == SHADOW_PASS)
{
if (!GeometricMesh[FPSM_DEFAULT_STANDARD].empty())
if (!MeshSolidMaterial[MAT_DEFAULT].empty())
glUseProgram(MeshShader::InstancedShadowShaderInstance->Program);
for (unsigned i = 0; i < GeometricMesh[FPSM_DEFAULT_STANDARD].size(); i++)
drawShadowDefault(*GeometricMesh[FPSM_DEFAULT_STANDARD][i], instance_pos.size() / 9);
for (unsigned i = 0; i < MeshSolidMaterial[MAT_DEFAULT].size(); i++)
drawShadowDefault(*MeshSolidMaterial[MAT_DEFAULT][i], instance_pos.size() / 9);
if (!GeometricMesh[FPSM_ALPHA_REF_TEXTURE].empty())
if (!MeshSolidMaterial[MAT_ALPHA_REF].empty())
glUseProgram(MeshShader::InstancedRefShadowShaderInstance->Program);
for (unsigned i = 0; i < GeometricMesh[FPSM_ALPHA_REF_TEXTURE].size(); i++)
drawShadowAlphaRefTexture(*GeometricMesh[FPSM_ALPHA_REF_TEXTURE][i], instance_pos.size() / 9);
for (unsigned i = 0; i < MeshSolidMaterial[MAT_ALPHA_REF].size(); i++)
drawShadowAlphaRefTexture(*MeshSolidMaterial[MAT_ALPHA_REF][i], instance_pos.size() / 9);
if (!GeometricMesh[FPSM_GRASS].empty())
if (!MeshSolidMaterial[MAT_GRASS].empty())
glUseProgram(MeshShader::InstancedGrassShadowShaderInstance->Program);
for (unsigned i = 0; i < GeometricMesh[FPSM_GRASS].size(); i++)
drawShadowGrass(*GeometricMesh[FPSM_GRASS][i], windDir, instance_pos.size() / 9);
for (unsigned i = 0; i < MeshSolidMaterial[MAT_GRASS].size(); i++)
drawShadowGrass(*MeshSolidMaterial[MAT_GRASS][i], windDir, instance_pos.size() / 9);
return;
}
}

5
src/graphics/stkinstancedscenenode.hpp
View File

@ -8,8 +8,7 @@ class STKInstancedSceneNode : public irr::scene::CMeshSceneNode
{
protected:
int m_ref_count;
std::vector<GLMesh *> GeometricMesh[FPSM_COUNT];
std::vector<GLMesh *> ShadedMesh[SM_COUNT];
std::vector<GLMesh *> MeshSolidMaterial[MAT_COUNT];
std::vector<GLMesh> GLmeshes;
std::vector<float> instance_pos;
core::matrix4 ModelViewProjectionMatrix, TransposeInverseModelView;
@ -17,7 +16,7 @@ protected:
void createGLMeshes();
bool isMaterialInitialized;
void setFirstTimeMaterial();
void initinstancedvaostate(GLMesh &mesh, GeometricMaterial GeoMat, ShadedMaterial ShadedMat);
void initinstancedvaostate(GLMesh &mesh);
void cleanGL();
core::vector3df windDir;
public:

69
src/graphics/stkmesh.cpp
View File

@ -9,37 +9,23 @@
#include "graphics/camera.hpp"
#include "modes/world.hpp"
GeometricMaterial MaterialTypeToGeometricMaterial(video::E_MATERIAL_TYPE MaterialType, video::E_VERTEX_TYPE tp)
MeshMaterial MaterialTypeToMeshMaterial(video::E_MATERIAL_TYPE MaterialType, video::E_VERTEX_TYPE tp)
{
if (MaterialType == irr_driver->getShader(ES_SPHERE_MAP))
return MAT_SPHEREMAP;
if (MaterialType == irr_driver->getShader(ES_NORMAL_MAP))
return FPSM_NORMAL_MAP;
return MAT_NORMAL_MAP;
else if (MaterialType == irr_driver->getShader(ES_OBJECTPASS_REF) || MaterialType == video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF)
return FPSM_ALPHA_REF_TEXTURE;
return MAT_ALPHA_REF;
else if (MaterialType == irr_driver->getShader(ES_GRASS) || MaterialType == irr_driver->getShader(ES_GRASS_REF))
return FPSM_GRASS;
return MAT_GRASS;
else if (MaterialType == irr_driver->getShader(ES_SPLATTING))
return MAT_SPLATTING;
else if (MaterialType == irr_driver->getShader(ES_OBJECT_UNLIT))
return MAT_UNLIT;
else if (tp == video::EVT_2TCOORDS)
return FPSM_DEFAULT_2TCOORD;
assert(tp == video::EVT_STANDARD);
return FPSM_DEFAULT_STANDARD;
}
ShadedMaterial MaterialTypeToShadedMaterial(video::E_MATERIAL_TYPE type, video::ITexture **textures, video::E_VERTEX_TYPE tp)
{
if (type == irr_driver->getShader(ES_SPHERE_MAP))
return SM_SPHEREMAP;
else if (type == irr_driver->getShader(ES_SPLATTING))
return SM_SPLATTING;
else if (type == irr_driver->getShader(ES_OBJECTPASS_REF) || type == video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF)
return SM_ALPHA_REF_TEXTURE;
else if (type == irr_driver->getShader(ES_GRASS) || type == irr_driver->getShader(ES_GRASS_REF))
return SM_GRASS;
else if (type == irr_driver->getShader(ES_OBJECT_UNLIT))
return SM_UNLIT;
else if (tp == video::EVT_2TCOORDS)
return SM_DETAILS;
else if (tp == video::EVT_TANGENTS)
return SM_DEFAULT_TANGENT;
return SM_DEFAULT_STANDARD;
return MAT_DETAIL;
return MAT_DEFAULT;
}
TransparentMaterial MaterialTypeToTransparentMaterial(video::E_MATERIAL_TYPE type, f32 MaterialTypeParam)
@ -307,22 +293,17 @@ bool isObject(video::E_MATERIAL_TYPE type)
return false;
}
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > ListDefaultStandardG::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > ListDefault2TCoordG::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > ListAlphaRefG::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > ListNormalG::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, core::vector3df> > ListGrassG::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > ListMatDefault::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > ListMatAlphaRef::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > ListMatSphereMap::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > ListMatDetails::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::vector3df> > ListMatGrass::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > ListMatUnlit::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > ListMatSplatting::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > ListMatNormalMap::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > ListDefaultStandardSM::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > ListDefaultTangentSM::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > ListAlphaRefSM::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, video::SColorf> > ListSplattingSM::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > ListSphereMapSM::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4> > ListUnlitSM::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, video::SColorf> > ListDetailSM::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > ListBlendTransparent::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > ListAdditiveTransparent::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4> > ListDisplacement::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > ListBlendTransparentFog::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > ListAdditiveTransparentFog::Arguments;
std::vector<std::tuple<GLMesh *, core::matrix4, core::vector3df, video::SColorf> > ListGrassSM::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > ListBlendTransparent::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > ListAdditiveTransparent::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > ListBlendTransparentFog::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > ListAdditiveTransparentFog::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4> > ListDisplacement::Arguments;

132
src/graphics/stkmesh.hpp
View File

@ -3,35 +3,25 @@
#include "graphics/glwrap.hpp"
#include "graphics/irr_driver.hpp"
#include "utils/tuple.hpp"
#include <IMeshSceneNode.h>
#include <IMesh.h>
#include "../lib/irrlicht/source/Irrlicht/CMeshSceneNode.h"
#include <tuple>
#include <vector>
enum GeometricMaterial
enum MeshMaterial
{
FPSM_DEFAULT_STANDARD,
FPSM_DEFAULT_2TCOORD,
FPSM_ALPHA_REF_TEXTURE,
FPSM_NORMAL_MAP,
FPSM_GRASS,
FPSM_COUNT
};
enum ShadedMaterial
{
SM_DEFAULT_STANDARD,
SM_DEFAULT_TANGENT,
SM_ALPHA_REF_TEXTURE,
SM_SPHEREMAP,
SM_SPLATTING,
SM_GRASS,
SM_UNLIT,
SM_DETAILS,
SM_COUNT
MAT_DEFAULT,
MAT_ALPHA_REF,
MAT_NORMAL_MAP,
MAT_GRASS,
MAT_SPHEREMAP,
MAT_SPLATTING,
MAT_UNLIT,
MAT_DETAIL,
MAT_COUNT
};
enum TransparentMaterial
@ -69,145 +59,89 @@ bool isObject(video::E_MATERIAL_TYPE type);
core::vector3df getWind();
// Pass 1 shader (ie shaders that outputs normals and depth)
class ListDefaultStandardG
class ListMatDefault
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > Arguments;
};
class ListDefault2TCoordG
class ListMatAlphaRef
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > Arguments;
};
class ListAlphaRefG
class ListMatNormalMap
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > Arguments;
};
class ListNormalG
class ListMatGrass
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::vector3df> > Arguments;
};
class ListGrassG
class ListMatSphereMap
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, core::vector3df> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > Arguments;
};
template<typename Shader, typename...uniforms>
void draw(const GLMesh *mesh, uniforms... Args)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh->PrimitiveType;
GLenum itype = mesh->IndexType;
size_t count = mesh->IndexCount;
Shader::setUniforms(Args...);
glDrawElementsBaseVertex(ptype, count, itype, (GLvoid *)mesh->vaoOffset, mesh->vaoBaseVertex);
}
template<typename T, typename...uniforms>
void draw(const T *Shader, const GLMesh *mesh, uniforms... Args)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh->PrimitiveType;
GLenum itype = mesh->IndexType;
size_t count = mesh->IndexCount;
Shader->setUniforms(Args...);
glDrawElementsBaseVertex(ptype, count, itype, (GLvoid *)mesh->vaoOffset, mesh->vaoBaseVertex);
}
// Pass 2 shader (ie shaders that outputs final color)
class ListDefaultStandardSM
class ListMatSplatting
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
};
class ListDefaultTangentSM
class ListMatUnlit
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
};
class ListAlphaRefSM
class ListMatDetails
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > Arguments;
};
class ListSphereMapSM
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, video::SColorf> > Arguments;
};
class ListSplattingSM
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, video::SColorf> > Arguments;
};
class ListUnlitSM
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4> > Arguments;
};
class ListDetailSM
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, video::SColorf> > Arguments;
};
class ListGrassSM
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::vector3df, video::SColorf> > Arguments;
};
class ListBlendTransparent
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
};
class ListAdditiveTransparent
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
};
class ListBlendTransparentFog
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > Arguments;
};
class ListAdditiveTransparentFog
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > Arguments;
};
class ListDisplacement
{
public:
static std::vector<std::tuple<GLMesh *, core::matrix4> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4> > Arguments;
};
// Forward pass (for transparents meshes)
void drawBubble(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix);
GeometricMaterial MaterialTypeToGeometricMaterial(video::E_MATERIAL_TYPE, video::E_VERTEX_TYPE);
ShadedMaterial MaterialTypeToShadedMaterial(video::E_MATERIAL_TYPE, irr::video::ITexture **textures, video::E_VERTEX_TYPE tp);
MeshMaterial MaterialTypeToMeshMaterial(video::E_MATERIAL_TYPE, video::E_VERTEX_TYPE);
TransparentMaterial MaterialTypeToTransparentMaterial(video::E_MATERIAL_TYPE, f32 MaterialTypeParam);
#endif // STKMESH_H

153
src/graphics/stkmeshscenenode.cpp
View File

@ -6,9 +6,11 @@
#include <IMaterialRenderer.h>
#include "config/user_config.hpp"
#include "graphics/callbacks.hpp"
#include "utils/helpers.hpp"
#include "graphics/camera.hpp"
#include "modes/world.hpp"
#include "utils/helpers.hpp"
#include "utils/tuple.hpp"
#include "utils/cpp2011.hpp"
STKMeshSceneNode::STKMeshSceneNode(irr::scene::IMesh* mesh, ISceneNode* parent, irr::scene::ISceneManager* mgr, irr::s32 id,
const irr::core::vector3df& position,
@ -78,8 +80,7 @@ void STKMeshSceneNode::setFirstTimeMaterial()
else
{
assert(!isDisplacement);
GeometricMaterial GeometricType = MaterialTypeToGeometricMaterial(type, mb->getVertexType());
ShadedMaterial ShadedType = MaterialTypeToShadedMaterial(type, mesh.textures, mb->getVertexType());
MeshMaterial MatType = MaterialTypeToMeshMaterial(type, mb->getVertexType());
if (immediate_draw)
{
fillLocalBuffer(mesh, mb);
@ -87,10 +88,7 @@ void STKMeshSceneNode::setFirstTimeMaterial()
glBindVertexArray(0);
}
else
{
GeometricMesh[GeometricType].push_back(&mesh);
ShadedMesh[ShadedType].push_back(&mesh);
}
MeshSolidMaterials[MatType].push_back(&mesh);
}
if (!immediate_draw)
@ -117,10 +115,8 @@ void STKMeshSceneNode::cleanGLMeshes()
glDeleteBuffers(1, &(mesh.index_buffer));
}
GLmeshes.clear();
for (unsigned i = 0; i < FPSM_COUNT; i++)
GeometricMesh[i].clearWithoutDeleting();
for (unsigned i = 0; i < SM_COUNT; i++)
ShadedMesh[i].clearWithoutDeleting();
for (unsigned i = 0; i < MAT_COUNT; i++)
MeshSolidMaterials[i].clearWithoutDeleting();
}
void STKMeshSceneNode::setMesh(irr::scene::IMesh* mesh)
@ -215,53 +211,65 @@ void STKMeshSceneNode::render()
GLmeshes[i].TextureMatrix = getMaterial(i).getTextureMatrix(0);
}
if (irr_driver->getPhase() == SOLID_NORMAL_AND_DEPTH_PASS)
if (irr_driver->getPhase() == SOLID_NORMAL_AND_DEPTH_PASS && immediate_draw)
{
core::matrix4 invmodel;
AbsoluteTransformation.getInverse(invmodel);
if (immediate_draw)
glDisable(GL_CULL_FACE);
if (update_each_frame)
updatevbo();
glUseProgram(MeshShader::ObjectPass1Shader::getInstance()->Program);
// Only untextured
for (unsigned i = 0; i < GLmeshes.size(); i++)
{
glDisable(GL_CULL_FACE);
if (update_each_frame)
updatevbo();
glUseProgram(MeshShader::ObjectPass1Shader::getInstance()->Program);
// Only untextured
for (unsigned i = 0; i < GLmeshes.size(); i++)
{
irr_driver->IncreaseObjectCount();
GLMesh &mesh = GLmeshes[i];
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
irr_driver->IncreaseObjectCount();
GLMesh &mesh = GLmeshes[i];
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
MeshShader::ObjectPass1Shader::getInstance()->setUniforms(AbsoluteTransformation, invmodel);
assert(mesh.vao);
glBindVertexArray(mesh.vao);
glDrawElements(ptype, count, itype, 0);
glBindVertexArray(0);
}
glEnable(GL_CULL_FACE);
return;
MeshShader::ObjectPass1Shader::getInstance()->setUniforms(AbsoluteTransformation, invmodel);
assert(mesh.vao);
glBindVertexArray(mesh.vao);
glDrawElements(ptype, count, itype, 0);
glBindVertexArray(0);
}
glEnable(GL_CULL_FACE);
return;
}
if (irr_driver->getPhase() == SOLID_NORMAL_AND_DEPTH_PASS || irr_driver->getPhase() == SHADOW_PASS)
{
core::matrix4 invmodel;
AbsoluteTransformation.getInverse(invmodel);
GLMesh* mesh;
for_in(mesh, GeometricMesh[FPSM_DEFAULT_STANDARD])
ListDefaultStandardG::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel));
for_in(mesh, MeshSolidMaterials[MAT_DEFAULT])
pushVector(ListMatDefault::Arguments, mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
for_in(mesh, GeometricMesh[FPSM_DEFAULT_2TCOORD])
ListDefault2TCoordG::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel));
for_in(mesh, MeshSolidMaterials[MAT_ALPHA_REF])
pushVector(ListMatAlphaRef::Arguments, mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
for_in(mesh, GeometricMesh[FPSM_ALPHA_REF_TEXTURE])
ListAlphaRefG::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix));
for_in(mesh, MeshSolidMaterials[MAT_SPHEREMAP])
pushVector(ListMatSphereMap::Arguments, mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
for_in(mesh, GeometricMesh[FPSM_NORMAL_MAP])
ListNormalG::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel));
for_in(mesh, MeshSolidMaterials[MAT_DETAIL])
pushVector(ListMatDetails::Arguments, mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
windDir = getWind();
for_in(mesh, GeometricMesh[FPSM_GRASS])
ListGrassG::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel, windDir));
for_in(mesh, MeshSolidMaterials[MAT_GRASS])
pushVector(ListMatGrass::Arguments, mesh, AbsoluteTransformation, invmodel, windDir);
for_in(mesh, MeshSolidMaterials[MAT_UNLIT])
pushVector(ListMatUnlit::Arguments, mesh, AbsoluteTransformation, core::matrix4::EM4CONST_IDENTITY);
for_in(mesh, MeshSolidMaterials[MAT_SPLATTING])
pushVector(ListMatSplatting::Arguments, mesh, AbsoluteTransformation, invmodel);
for_in(mesh, MeshSolidMaterials[MAT_NORMAL_MAP])
pushVector( ListMatNormalMap::Arguments, mesh, AbsoluteTransformation, invmodel, core::matrix4::EM4CONST_IDENTITY);
return;
}
@ -276,7 +284,7 @@ void STKMeshSceneNode::render()
glDisable(GL_CULL_FACE);
if (!spareWhiteTex)
spareWhiteTex = getUnicolorTexture(video::SColor(255, 255, 255, 255));
glUseProgram(MeshShader::ObjectPass2ShaderInstance->Program);
glUseProgram(MeshShader::ObjectPass2Shader::getInstance()->Program);
// Only untextured
for (unsigned i = 0; i < GLmeshes.size(); i++)
{
@ -286,8 +294,8 @@ void STKMeshSceneNode::render()
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
setTexture(MeshShader::ObjectPass2ShaderInstance->TU_Albedo, getTextureGLuint(spareWhiteTex), GL_NEAREST, GL_NEAREST, false);
MeshShader::ObjectPass2ShaderInstance->setUniforms(AbsoluteTransformation, mesh.TextureMatrix, irr_driver->getSceneManager()->getAmbientLight());
setTexture(MeshShader::ObjectPass2Shader::getInstance()->TU_Albedo, getTextureGLuint(spareWhiteTex), GL_NEAREST, GL_NEAREST, false);
MeshShader::ObjectPass2Shader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix);
assert(mesh.vao);
glBindVertexArray(mesh.vao);
glDrawElements(ptype, count, itype, 0);
@ -297,31 +305,6 @@ void STKMeshSceneNode::render()
return;
}
GLMesh* mesh;
for_in(mesh, ShadedMesh[SM_DEFAULT_STANDARD])
ListDefaultStandardSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
for_in(mesh, ShadedMesh[SM_DEFAULT_TANGENT])
ListDefaultTangentSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
for_in(mesh, ShadedMesh[SM_ALPHA_REF_TEXTURE])
ListAlphaRefSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix, irr_driver->getSceneManager()->getAmbientLight()));
for_in(mesh, ShadedMesh[SM_SPHEREMAP])
ListSphereMapSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, invmodel, irr_driver->getSceneManager()->getAmbientLight()));
for_in(mesh, ShadedMesh[SM_SPLATTING])
ListSplattingSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, irr_driver->getSceneManager()->getAmbientLight()));
for_in(mesh, ShadedMesh[SM_UNLIT])
ListUnlitSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation));
for_in(mesh, ShadedMesh[SM_DETAILS])
ListDetailSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, irr_driver->getSceneManager()->getAmbientLight()));
for_in(mesh, ShadedMesh[SM_GRASS])
ListGrassSM::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, windDir, irr_driver->getSceneManager()->getAmbientLight()));
return;
}
@ -350,7 +333,7 @@ void STKMeshSceneNode::render()
if (World::getWorld() && World::getWorld()->isFogEnabled())
{
glUseProgram(MeshShader::TransparentFogShaderInstance->Program);
glUseProgram(MeshShader::TransparentFogShader::getInstance()->Program);
for (unsigned i = 0; i < GLmeshes.size(); i++)
{
GLMesh &mesh = GLmeshes[i];
@ -374,8 +357,8 @@ void STKMeshSceneNode::render()
tmpcol.getBlue() / 255.0f);
compressTexture(mesh.textures[0], true);
setTexture(0, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::TransparentFogShaderInstance->setUniforms(AbsoluteTransformation, mesh.TextureMatrix, fogmax, startH, endH, start, end, col);
setTexture(MeshShader::TransparentFogShader::getInstance()->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::TransparentFogShader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix, fogmax, startH, endH, start, end, col);
assert(mesh.vao);
glBindVertexArray(mesh.vao);
@ -385,7 +368,7 @@ void STKMeshSceneNode::render()
}
else
{
glUseProgram(MeshShader::TransparentShaderInstance->Program);
glUseProgram(MeshShader::TransparentShader::getInstance()->Program);
for (unsigned i = 0; i < GLmeshes.size(); i++)
{
irr_driver->IncreaseObjectCount();
@ -395,9 +378,9 @@ void STKMeshSceneNode::render()
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], true);
setTexture(MeshShader::TransparentShaderInstance->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
setTexture(MeshShader::TransparentShader::getInstance()->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::TransparentShaderInstance->setUniforms(AbsoluteTransformation, mesh.TextureMatrix);
MeshShader::TransparentShader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix);
assert(mesh.vao);
glBindVertexArray(mesh.vao);
glDrawElements(ptype, count, itype, 0);
@ -426,25 +409,23 @@ void STKMeshSceneNode::render()
tmpcol.getBlue() / 255.0f);
for_in(mesh, TransparentMesh[TM_DEFAULT])
ListBlendTransparentFog::Arguments.push_back(
std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix,
fogmax, startH, endH, start, end, col));
pushVector(ListBlendTransparentFog::Arguments, mesh, AbsoluteTransformation, mesh->TextureMatrix,
fogmax, startH, endH, start, end, col);
for_in(mesh, TransparentMesh[TM_ADDITIVE])
ListAdditiveTransparentFog::Arguments.push_back(
std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix,
fogmax, startH, endH, start, end, col));
pushVector(ListAdditiveTransparentFog::Arguments, mesh, AbsoluteTransformation, mesh->TextureMatrix,
fogmax, startH, endH, start, end, col);
}
else
{
for_in(mesh, TransparentMesh[TM_DEFAULT])
ListBlendTransparent::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix));
pushVector(ListBlendTransparent::Arguments, mesh, AbsoluteTransformation, mesh->TextureMatrix);
for_in(mesh, TransparentMesh[TM_ADDITIVE])
ListAdditiveTransparent::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix));
pushVector(ListAdditiveTransparent::Arguments, mesh, AbsoluteTransformation, mesh->TextureMatrix);
}
for_in(mesh, TransparentMesh[TM_DISPLACEMENT])
ListDisplacement::Arguments.push_back(std::make_tuple(mesh, AbsoluteTransformation));
pushVector(ListDisplacement::Arguments, mesh, AbsoluteTransformation);
if (!TransparentMesh[TM_BUBBLE].empty())
glUseProgram(MeshShader::BubbleShader::Program);

3
src/graphics/stkmeshscenenode.hpp
View File

@ -7,8 +7,7 @@
class STKMeshSceneNode : public irr::scene::CMeshSceneNode
{
protected:
PtrVector<GLMesh, REF> GeometricMesh[FPSM_COUNT];
PtrVector<GLMesh, REF> ShadedMesh[SM_COUNT];
PtrVector<GLMesh, REF> MeshSolidMaterials[MAT_COUNT];
PtrVector<GLMesh, REF> TransparentMesh[TM_COUNT];
std::vector<GLMesh> GLmeshes;
core::matrix4 ModelViewProjectionMatrix;

2
src/graphics/sun.hpp
View File

@ -20,7 +20,7 @@
#define HEADER_SUN_HPP
#include "graphics/light.hpp"
#include "utils/cpp2011.h"
#include "utils/cpp2011.hpp"
class ScreenQuad;

2
src/graphics/water.hpp
View File

@ -20,7 +20,7 @@
#define HEADER_WATER_HPP
#include <IMeshSceneNode.h>
#include <utils/cpp2011.h>
#include <utils/cpp2011.hpp>
using namespace irr;

3
src/guiengine/abstract_state_manager.cpp
View File

@ -140,6 +140,9 @@ void AbstractStateManager::pushScreen(Screen* screen)
void AbstractStateManager::replaceTopMostScreen(Screen* screen, GUIEngine::GameState gameState)
{
if (gameState == GUIEngine::CURRENT)
gameState = getGameState();
//assert(m_game_mode != GAME);
// you need to close any dialog before calling this
assert(!ModalDialog::isADialogActive());

6
src/guiengine/abstract_state_manager.hpp
View File

@ -40,7 +40,9 @@ namespace GUIEngine
{
MENU,
GAME,
INGAME_MENU
INGAME_MENU,
/** Dummy GameState e. g. for parameters. */
CURRENT = MENU | GAME | INGAME_MENU
}; // GameState
/**
@ -82,7 +84,7 @@ namespace GUIEngine
* without displaying the second-topmost menu of the stack
* in-between)
*/
void replaceTopMostScreen(Screen* screen, GUIEngine::GameState gameState = GUIEngine::MENU);
void replaceTopMostScreen(Screen* screen, GUIEngine::GameState gameState = GUIEngine::CURRENT);
/**
* \brief removes the menu at the top of the screens stack

10
src/guiengine/abstract_top_level_container.hpp
View File

@ -21,6 +21,7 @@
#include "guiengine/widget.hpp"
#include "utils/log.hpp"
#include "utils/ptr_vector.hpp"
#include <cstring> // for NULL
@ -87,12 +88,9 @@ namespace GUIEngine
Widget* out = getWidget(name);
T* outCasted = dynamic_cast<T*>( out );
if (out != NULL && outCasted == NULL)
{
fprintf(stderr, "Screen::getWidget : Widget '%s' of type '%s'"
"cannot be casted to requested type '%s'!\n", name,
typeid(*out).name(), typeid(T).name());
abort();
}
Log::fatal("Screen::getWidget", "Widget '%s' of type '%s'"
"cannot be casted to requested type '%s'!\n", name,
typeid(*out).name(), typeid(T).name());
return outCasted;
}

2
src/guiengine/event_handler.cpp
View File

@ -608,7 +608,7 @@ EventPropagation EventHandler::onGUIEvent(const SEvent& event)
if (w == NULL) break;
if (!w->m_focusable) return GUIEngine::EVENT_BLOCK;
if (!w->isFocusable() || !w->isActivated()) return GUIEngine::EVENT_BLOCK;
// When a modal dialog is shown, don't select widgets out of the dialog
if (ModalDialog::isADialogActive() && !ModalDialog::getCurrent()->isMyChild(w))

16
src/guiengine/layout_manager.cpp
View File

@ -47,7 +47,7 @@ int atoi_p(const char* val)
}
else
{
fprintf(stderr, "[LayoutManager] WARNING: Invalid value '%s' found in XML file where integer was expected\n", val);
Log::warn("LayoutManager", "Invalid value '%s' found in XML file where integer was expected.", val);
return 0;
}
}
@ -461,7 +461,7 @@ void LayoutManager::doCalculateLayout(PtrVector<Widget>& widgets, AbstractTopLev
if (left_space < 0)
{
fprintf(stderr, "[LayoutManager] WARNING: statically sized widgets took all the place!!\n");
Log::warn("LayoutManager", "Statically sized widgets took all the place!!");
left_space = 0;
}
@ -536,9 +536,9 @@ void LayoutManager::doCalculateLayout(PtrVector<Widget>& widgets, AbstractTopLev
if (widgets[n].m_w <= 0)
{
fprintf(stderr, "WARNING: widget '%s' has a width of %i (left_space = %i, "
"fraction = %f, max_width = %s)\n", widgets[n].m_properties[PROP_ID].c_str(),
widgets[n].m_w, left_space, fraction, widgets[n].m_properties[PROP_MAX_WIDTH].c_str());
Log::warn("LayoutManager", "Widget '%s' has a width of %i (left_space = %i, "
"fraction = %f, max_width = %s)", widgets[n].m_properties[PROP_ID].c_str(),
widgets[n].m_w, left_space, fraction, widgets[n].m_properties[PROP_MAX_WIDTH].c_str());
widgets[n].m_w = 1;
}
@ -556,9 +556,9 @@ void LayoutManager::doCalculateLayout(PtrVector<Widget>& widgets, AbstractTopLev
if (widgets[n].m_h <= 0)
{
fprintf(stderr, "WARNING: widget '%s' has a height of %i (left_space = %i, "
"fraction = %f, max_width = %s)\n", widgets[n].m_properties[PROP_ID].c_str(),
widgets[n].m_h, left_space, fraction, widgets[n].m_properties[PROP_MAX_WIDTH].c_str());
Log::warn("LayoutManager", "Widget '%s' has a height of %i (left_space = %i, "
"fraction = %f, max_width = %s)\n", widgets[n].m_properties[PROP_ID].c_str(),
widgets[n].m_h, left_space, fraction, widgets[n].m_properties[PROP_MAX_WIDTH].c_str());
widgets[n].m_h = 1;
}

3
src/guiengine/modaldialog.cpp
View File

@ -26,6 +26,7 @@
#include "utils/log.hpp"
#include <IGUIEnvironment.h>
#include <IGUIButton.h>
using namespace irr;
using namespace core;
@ -134,6 +135,8 @@ void ModalDialog::doInit()
m_irrlicht_window = GUIEngine::getGUIEnv()->addWindow(m_area,
true /* modal */);
m_irrlicht_window->setDrawTitlebar(false);
m_irrlicht_window->getCloseButton()->setVisible(false);
GUIEngine::getSkin()->m_dialog = true;
GUIEngine::getSkin()->m_dialog_size = 0.0f;

11
src/guiengine/scalable_font.cpp
View File

@ -57,8 +57,7 @@ ScalableFont::ScalableFont(IGUIEnvironment *env, const std::string &filename)
io::IXMLReader* reader = file_manager->createXMLReader(filename.c_str());
if (!load( reader ))
{
fprintf(stderr, "[ScalableFont] Loading font failed\n");
assert(false);
Log::fatal("ScalableFont", "Loading font failed");
}
reader->drop();
@ -157,7 +156,7 @@ void ScalableFont::doReadXmlFile(io::IXMLReader* xml)
#ifdef DEBUG
if (m_texture_files.find(i) != m_texture_files.end())
{
fprintf(stderr, "[ScalableFont] WARNING: Font conflict, two images have texture %i\n", i);
Log::warn("ScalableFont", "Font conflict, two images have texture %i.", i);
}
#endif
@ -258,7 +257,7 @@ bool ScalableFont::load(io::IXMLReader* xml)
{
if (!SpriteBank)
{
fprintf(stderr, "[ScalableFont::load] SpriteBank is NULL!!\n");
Log::error("ScalableFont::load", "SpriteBank is NULL!!");
return false;
}
@ -633,7 +632,7 @@ void ScalableFont::draw(const core::stringw& text,
if (texture == NULL)
{
fprintf(stderr, "WARNING: character not found in current font\n");
Log::warn("ScalableFont", "Character not found in current font");
continue; // no such character
}
}
@ -709,7 +708,7 @@ void ScalableFont::lazyLoadTexture(int texID)
// couldn't load texture, abort.
if (!SpriteBank->getTexture(texID))
{
fprintf(stderr, "!!!!! Unable to load all textures in the font\n");
Log::error("ScalableFont::lazyLoadTexture", "Unable to load all textures in the font");
_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
return;
}

8
src/guiengine/screen.cpp
View File

@ -184,7 +184,7 @@ void Screen::addWidgets()
Widget* w = getFirstWidget();
//std::cout << "First widget is " << (w == NULL ? "null" : w->m_properties[PROP_ID].c_str()) << std::endl;
if (w != NULL) w->setFocusForPlayer( PLAYER_ID_GAME_MASTER );
else fprintf(stderr, "Couldn't select first widget, NULL was returned\n");
else Log::warn("Screen::AddWidgets", "Couldn't select first widget, NULL was returned");
} // addWidgets
// -----------------------------------------------------------------------------
@ -206,9 +206,9 @@ void Screen::manualRemoveWidget(Widget* w)
#ifdef DEBUG
if(!m_widgets.contains(w))
{
fprintf(stderr, "Widget '%d' not found in screen when removing.\n",
w->m_id);
fprintf(stderr, "This can be ignored, but is probably wrong.\n");
Log::info("Screen", "Widget '%d' not found in screen when removing.",
w->m_id);
Log::info("Screen", "This can be ignored, but is probably wrong.");
}
#endif
m_widgets.remove(w);

2
src/guiengine/screen.hpp
View File

@ -22,7 +22,7 @@
#include <map>
#include <string>
#include <typeinfo>
#include "utils/cpp2011.h"
#include "utils/cpp2011.hpp"
#include <irrString.h>
#include <IXMLReader.h>

2
src/guiengine/widget.hpp
View File

@ -71,7 +71,7 @@ namespace GUIEngine
GAMEPAD_BADGE = 16,
/** A keyboard icon */
KEYBOARD_BADGE = 32,
/** An hourglass badge to indocate loading */
/** An hourglass badge to indicate loading */
LOADING_BADGE = 64
};

4
src/guiengine/widgets/dynamic_ribbon_widget.cpp
View File

@ -189,7 +189,7 @@ void DynamicRibbonWidget::add()
if (m_child_width <= 0 || m_child_height <= 0)
{
std::cerr << "/!\\ Warning /!\\ : ribbon grid widgets require 'child_width' and 'child_height' arguments" << std::endl;
Log::warn("DynamicRibbonWidget", "Ribbon grid widgets require 'child_width' and 'child_height' arguments");
m_child_width = 256;
m_child_height = 256;
}
@ -206,7 +206,7 @@ void DynamicRibbonWidget::add()
if (m_h - m_label_height < 0)
{
fprintf(stderr, "[DynamicRibbonWidget] WARNING: the widget is too small for anything to fit in it!!\n");
Log::warn("DynamicRibbonWidget", "The widget is too small for anything to fit in it!!");
m_row_amount = 1;
}
else

9
src/guiengine/widgets/icon_button_widget.hpp
View File

@ -109,7 +109,7 @@ namespace GUIEngine
*/
void setImage(const char* path_to_texture,
IconPathType path_type=ICON_PATH_TYPE_NO_CHANGE);
// --------------------------------------------------------------------
/** Convenience function taking std::string. */
void setImage(const std::string &path_to_texture,
IconPathType path_type=ICON_PATH_TYPE_NO_CHANGE)
@ -117,6 +117,7 @@ namespace GUIEngine
setImage(path_to_texture.c_str(), path_type);
}
// --------------------------------------------------------------------
/**
* Change the texture used for this icon.
* \pre At the moment, the new texture must have the same aspct ratio
@ -126,16 +127,22 @@ namespace GUIEngine
*/
void setImage(irr::video::ITexture* texture);
// --------------------------------------------------------------------
void setHighlightedImage(irr::video::ITexture* texture)
{
m_highlight_texture = texture;
}
// --------------------------------------------------------------------
/** \brief override from base class */
virtual EventPropagation focused(const int playerID);
// --------------------------------------------------------------------
/** \brief override from base class */
virtual void unfocused(const int playerID, Widget* new_focus);
// --------------------------------------------------------------------
/** Returns the texture of this button. */
const video::ITexture* getTexture() const { return m_texture; }
};
}

10
src/guiengine/widgets/kart_stats_widget.cpp
View File

@ -66,13 +66,9 @@ KartStatsWidget::KartStatsWidget(core::recti area, const int player_id,
}
if(!props)
{
fprintf(stderr,
"[KartSelectionScreen] WARNING: Can't find default "
"kart '%s' nor any other kart.\n",
default_kart.c_str());
exit(-1);
}
Log::fatal("KartSelectionScreen", "Can't find default "
"kart '%s' nor any other kart.",
default_kart.c_str());
}

2
src/guiengine/widgets/label_widget.cpp
View File

@ -50,6 +50,8 @@ LabelWidget::LabelWidget(bool title, bool bright) : Widget(WTYPE_LABEL)
}
else
m_has_color = false;
setFocusable(false);
} // LabelWidget
// ----------------------------------------------------------------------------

9
src/guiengine/widgets/list_widget.cpp
View File

@ -43,6 +43,7 @@ ListWidget::ListWidget() : Widget(WTYPE_LIST)
m_sort_desc = false;
m_sort_default = true;
m_sort_col = 0;
m_sortable = true;
}
// -----------------------------------------------------------------------------
@ -270,9 +271,11 @@ std::string ListWidget::getSelectionInternalName()
CGUISTKListBox* list = getIrrlichtElement<CGUISTKListBox>();
assert(list != NULL);
if (getSelectionID() == -1 || (getSelectionID() >= (int)list->getItemCount()))
int selectionID = getSelectionID();
if (selectionID == -1 || selectionID >= (int)list->getItemCount())
return "";
return list->getItem(getSelectionID()).m_internal_name;
const CGUISTKListBox::ListItem& item = list->getItem(selectionID);
return item.m_internal_name;
}
// -----------------------------------------------------------------------------
@ -418,6 +421,8 @@ EventPropagation ListWidget::transmitEvent(Widget* w,
if (originator.find(m_properties[PROP_ID] + "_column_") != std::string::npos)
{
if (!m_sortable) return EVENT_BLOCK;
if (m_sort_col != originator[(m_properties[PROP_ID] + "_column_").size()] - '0')
{
m_sort_desc = false;

4
src/guiengine/widgets/list_widget.hpp
View File

@ -87,6 +87,8 @@ namespace GUIEngine
IListWidgetHeaderListener* m_listener;
bool m_sortable;
public:
typedef irr::gui::CGUISTKListBox::ListItem ListItem;
typedef ListItem::ListCell ListCell;
@ -240,6 +242,8 @@ namespace GUIEngine
void addColumn(irr::core::stringw col, int proportion=1) { m_header.push_back( Column(col, proportion) ); }
void clearColumns() { m_header.clear(); }
void setSortable(bool sortable) { m_sortable = sortable; }
};
}

1
src/guiengine/widgets/progress_bar_widget.cpp
View File

@ -34,6 +34,7 @@ ProgressBarWidget::ProgressBarWidget(bool show_label) : Widget(WTYPE_PROGRESS)
{
m_value = 0;
m_show_label = show_label;
setFocusable(false);
}
// -----------------------------------------------------------------------------

9
src/guiengine/widgets/ribbon_widget.cpp
View File

@ -115,8 +115,8 @@ void RibbonWidget::add()
if (m_active_children[i].m_type != WTYPE_ICON_BUTTON &&
m_active_children[i].m_type != WTYPE_BUTTON)
{
fprintf(stderr, "/!\\ Warning /!\\ : ribbon widgets can only have "
"(icon)button widgets as children\n");
Log::warn("RiggonWidget", "Ribbon widgets can only have "
"(icon)button widgets as children");
continue;
}
@ -275,7 +275,7 @@ void RibbonWidget::add()
}
else
{
fprintf(stderr, "Invalid tab bar contents\n");
Log::error("RibbonWidget", "Invalid tab bar contents");
}
m_active_children[i].m_element = subbtn;
@ -375,8 +375,7 @@ void RibbonWidget::add()
}
else
{
fprintf(stderr,
"/!\\ Warning /!\\ : Invalid contents type in ribbon\n");
Log::warn("RiggonWidget", "Invalid contents type in ribbon");
}

4
src/input/binding.cpp
View File

@ -51,7 +51,7 @@ bool Binding::deserialize(irr::io::IrrXMLReader* xml)
// Proceed only if neccesary tags were found
if ((id_string == NULL) || (event_string == NULL))
{
printf("No id-string or event-string given - ignored.\n");
Log::warn("Binding", "No id-string or event-string given - ignored.");
return false;
}
@ -66,7 +66,7 @@ bool Binding::deserialize(irr::io::IrrXMLReader* xml)
// If the action is a stick motion & a direction is defined
if (dir_string == NULL)
{
printf("WARNING: IT_STICKMOTION without direction, ignoring.\n");
Log::warn("Binding", "IT_STICKMOTION without direction, ignoring.");
return false;
}

2
src/input/input_device.cpp
View File

@ -156,7 +156,7 @@ void GamePadDevice::resetAxisDirection(const int axis,
AbstractKart* pk = player->getKart();
if (pk == NULL)
{
fprintf(stderr, "Error, trying to reset axis for an unknown player\n");
Log::error("Binding", "Trying to reset axis for an unknown player.");
return;
}

2
src/input/wiimote_manager.hpp
View File

@ -23,7 +23,7 @@
#include "input/wiimote.hpp"
#include "states_screens/dialogs/message_dialog.hpp"
#include "utils/cpp2011.h"
#include "utils/cpp2011.hpp"
#include "IEventReceiver.h"

2
src/io/file_manager.cpp
View File

@ -724,7 +724,7 @@ void FileManager::checkAndCreateConfigDir()
if(!checkAndCreateDirectory(m_user_config_dir))
{
Log::error("[FileManager]", "Can't create config dir '%s"
", falling back to '.'.", m_user_config_dir);
", falling back to '.'.", m_user_config_dir.c_str());
m_user_config_dir = ".";
}
}

4
src/karts/abstract_kart.hpp
View File

@ -157,6 +157,10 @@ public:
/** Returns true if this kart has no wheels. */
bool isWheeless() const;
// ------------------------------------------------------------------------
/** Returns the coordinates of the front of the kart. This is used for
* determining when the lap line is crossed. */
virtual const Vec3& getFrontXYZ() const = 0;
// ------------------------------------------------------------------------
/** Returns the position of a wheel relative to the kart.
* \param i Index of the wheel: 0=front right, 1 = front left, 2 = rear
* right, 3 = rear left. */

5
src/karts/kart.cpp
View File

@ -408,6 +408,8 @@ void Kart::reset()
m_skidmarks->adjustFog(track->isFogEnabled() );
}
Vec3 front(0, 0, getKartLength()*0.5f);
m_xyz_front = getTrans()(front);
m_terrain_info->update(getTrans());
@ -1190,6 +1192,9 @@ void Kart::update(float dt)
m_body->getBroadphaseHandle()->m_collisionFilterGroup = 0;
}
Vec3 front(0, 0, getKartLength()*0.5f);
m_xyz_front = getTrans()(front);
m_terrain_info->update(getTrans(), epsilon);
if(m_body->getBroadphaseHandle())
{

8
src/karts/kart.hpp
View File

@ -102,6 +102,10 @@ private:
/** Current race position (1-num_karts). */
int m_race_position;
/** The coordinates of the front of the kart, used to determine when a
* new lap is triggered. */
Vec3 m_xyz_front;
/** True if the kart is eliminated. */
bool m_eliminated;
@ -292,6 +296,10 @@ public:
/** Returns the current position of this kart in the race. */
virtual int getPosition () const { return m_race_position; }
// ------------------------------------------------------------------------
/** Returns the coordinates of the front of the kart. This is used for
* determining when the lap line is crossed. */
virtual const Vec3& getFrontXYZ() const { return m_xyz_front; }
// ------------------------------------------------------------------------
/** Returns the initial position of this kart. */
virtual int getInitialPosition () const { return m_initial_position; }
// ------------------------------------------------------------------------

262
src/karts/kart_properties.cpp
View File

@ -461,149 +461,149 @@ void KartProperties::getAllData(const XMLNode * root)
} // if sounds-node exist
if(const XMLNode *nitro_node = root->getNode("nitro"))
{
nitro_node->get("consumption", &m_nitro_consumption );
nitro_node->get("small-container", &m_nitro_small_container );
nitro_node->get("big-container", &m_nitro_big_container );
nitro_node->get("max-speed-increase", &m_nitro_max_speed_increase);
nitro_node->get("engine-force", &m_nitro_engine_force );
nitro_node->get("duration", &m_nitro_duration );
nitro_node->get("fade-out-time", &m_nitro_fade_out_time );
nitro_node->get("max", &m_nitro_max );
nitro_node->get("min-consumption-time", &m_nitro_min_consumption );
}
if(const XMLNode *bubble_node = root->getNode("bubblegum"))
{
bubble_node->get("time", &m_bubblegum_time );
bubble_node->get("speed-fraction", &m_bubblegum_speed_fraction);
bubble_node->get("fade-in-time", &m_bubblegum_fade_in_time );
bubble_node->get("torque", &m_bubblegum_torque );
}
if(const XMLNode *rescue_node = root->getNode("rescue"))
{
rescue_node->get("vert-offset", &m_rescue_vert_offset);
rescue_node->get("time", &m_rescue_time );
rescue_node->get("height", &m_rescue_height );
}
if(const XMLNode *explosion_node = root->getNode("explosion"))
{
explosion_node->get("time", &m_explosion_time );
explosion_node->get("radius", &m_explosion_radius);
explosion_node->get("invulnerability-time",
&m_explosion_invulnerability_time);
}
if(const XMLNode *skid_node = root->getNode("skid"))
{
m_skidding_properties->load(skid_node);
}
if(const XMLNode *slipstream_node = root->getNode("slipstream"))
{
slipstream_node->get("length", &m_slipstream_length );
slipstream_node->get("width", &m_slipstream_width );
slipstream_node->get("collect-time", &m_slipstream_collect_time );
slipstream_node->get("use-time", &m_slipstream_use_time );
slipstream_node->get("add-power", &m_slipstream_add_power );
slipstream_node->get("min-speed", &m_slipstream_min_speed );
slipstream_node->get("max-speed-increase",
&m_slipstream_max_speed_increase);
slipstream_node->get("duration", &m_slipstream_duration );
slipstream_node->get("fade-out-time",&m_slipstream_fade_out_time );
}
if(const XMLNode *turn_node = root->getNode("turn"))
{
turn_node->get("time-full-steer", &m_time_full_steer );
turn_node->get("time-reset-steer", &m_time_reset_steer );
turn_node->get("turn-radius", &m_turn_angle_at_speed );
// For now store the turn radius in turn angle, the correct
// value can only be determined later in ::load
}
if(const XMLNode *engine_node = root->getNode("engine"))
{
engine_node->get("brake-factor", &m_brake_factor);
engine_node->get("max-speed-reverse-ratio", &m_max_speed_reverse_ratio);
engine_node->get("power", &m_engine_power);
if(m_engine_power.size()!=RaceManager::DIFFICULTY_COUNT)
{
nitro_node->get("consumption", &m_nitro_consumption );
nitro_node->get("small-container", &m_nitro_small_container );
nitro_node->get("big-container", &m_nitro_big_container );
nitro_node->get("max-speed-increase", &m_nitro_max_speed_increase);
nitro_node->get("engine-force", &m_nitro_engine_force );
nitro_node->get("duration", &m_nitro_duration );
nitro_node->get("fade-out-time", &m_nitro_fade_out_time );
nitro_node->get("max", &m_nitro_max );
nitro_node->get("min-consumption-time", &m_nitro_min_consumption );
Log::fatal("[KartProperties]",
"Incorrect engine-power specifications for kart '%s'",
getIdent().c_str());
}
if(const XMLNode *bubble_node = root->getNode("bubblegum"))
engine_node->get("max-speed", &m_max_speed);
if(m_max_speed.size()!=RaceManager::DIFFICULTY_COUNT)
{
bubble_node->get("time", &m_bubblegum_time );
bubble_node->get("speed-fraction", &m_bubblegum_speed_fraction);
bubble_node->get("fade-in-time", &m_bubblegum_fade_in_time );
bubble_node->get("torque", &m_bubblegum_torque );
Log::fatal("[KartProperties]",
"Incorrect max-speed specifications for kart '%s'",
getIdent().c_str());
}
} // if getNode("engine")
if(const XMLNode *rescue_node = root->getNode("rescue"))
if(const XMLNode *gear_node = root->getNode("gear"))
{
gear_node->get("switch-ratio", &m_gear_switch_ratio );
gear_node->get("power-increase", &m_gear_power_increase);
}
if(const XMLNode *mass_node = root->getNode("mass"))
mass_node->get("value", &m_mass);
if(const XMLNode *plunger_node= root->getNode("plunger"))
{
plunger_node->get("band-max-length", &m_rubber_band_max_length );
plunger_node->get("band-force", &m_rubber_band_force );
plunger_node->get("band-duration", &m_rubber_band_duration );
plunger_node->get("band-speed-increase",&m_rubber_band_speed_increase);
plunger_node->get("band-fade-out-time", &m_rubber_band_fade_out_time );
plunger_node->get("in-face-time", &m_plunger_in_face_duration);
if(m_plunger_in_face_duration.size()!=RaceManager::DIFFICULTY_COUNT)
{
rescue_node->get("vert-offset", &m_rescue_vert_offset);
rescue_node->get("time", &m_rescue_time );
rescue_node->get("height", &m_rescue_height );
Log::fatal("KartProperties",
"Invalid plunger in-face-time specification.");
}
}
if(const XMLNode *explosion_node = root->getNode("explosion"))
if(const XMLNode *zipper_node= root->getNode("zipper"))
{
zipper_node->get("time", &m_zipper_time );
zipper_node->get("fade-out-time", &m_zipper_fade_out_time );
zipper_node->get("force", &m_zipper_force );
zipper_node->get("speed-gain", &m_zipper_speed_gain );
zipper_node->get("max-speed-increase", &m_zipper_max_speed_increase);
}
if(const XMLNode *swatter_node= root->getNode("swatter"))
{
swatter_node->get("duration", &m_swatter_duration );
swatter_node->get("squash-duration", &m_squash_duration );
swatter_node->get("squash-slowdown", &m_squash_slowdown );
if(swatter_node->get("distance", &m_swatter_distance2) )
{
explosion_node->get("time", &m_explosion_time );
explosion_node->get("radius", &m_explosion_radius);
explosion_node->get("invulnerability-time",
&m_explosion_invulnerability_time);
// Avoid squaring if distance is not defined, so that
// distance2 remains UNDEFINED (which is a negative value)
m_swatter_distance2 *= m_swatter_distance2;
}
}
if(const XMLNode *skid_node = root->getNode("skid"))
{
m_skidding_properties->load(skid_node);
}
if(const XMLNode *lean_node= root->getNode("lean"))
{
lean_node->get("max", &m_max_lean );
lean_node->get("speed", &m_lean_speed);
m_max_lean *= DEGREE_TO_RAD;
m_lean_speed *= DEGREE_TO_RAD;
}
if(const XMLNode *slipstream_node = root->getNode("slipstream"))
{
slipstream_node->get("length", &m_slipstream_length );
slipstream_node->get("width", &m_slipstream_width );
slipstream_node->get("collect-time", &m_slipstream_collect_time );
slipstream_node->get("use-time", &m_slipstream_use_time );
slipstream_node->get("add-power", &m_slipstream_add_power );
slipstream_node->get("min-speed", &m_slipstream_min_speed );
slipstream_node->get("max-speed-increase",
&m_slipstream_max_speed_increase);
slipstream_node->get("duration", &m_slipstream_duration );
slipstream_node->get("fade-out-time",&m_slipstream_fade_out_time );
}
if(const XMLNode *turn_node = root->getNode("turn"))
{
turn_node->get("time-full-steer", &m_time_full_steer );
turn_node->get("time-reset-steer", &m_time_reset_steer );
turn_node->get("turn-radius", &m_turn_angle_at_speed );
// For now store the turn radius in turn angle, the correct
// value can only be determined later in ::load
}
if(const XMLNode *engine_node = root->getNode("engine"))
{
engine_node->get("brake-factor", &m_brake_factor);
engine_node->get("max-speed-reverse-ratio", &m_max_speed_reverse_ratio);
engine_node->get("power", &m_engine_power);
if(m_engine_power.size()!=RaceManager::DIFFICULTY_COUNT)
{
Log::fatal("[KartProperties]",
"Incorrect engine-power specifications for kart '%s'",
getIdent().c_str());
}
engine_node->get("max-speed", &m_max_speed);
if(m_max_speed.size()!=RaceManager::DIFFICULTY_COUNT)
{
Log::fatal("[KartProperties]",
"Incorrect max-speed specifications for kart '%s'",
getIdent().c_str());
}
} // if getNode("engine")
if(const XMLNode *gear_node = root->getNode("gear"))
{
gear_node->get("switch-ratio", &m_gear_switch_ratio );
gear_node->get("power-increase", &m_gear_power_increase);
}
if(const XMLNode *mass_node = root->getNode("mass"))
mass_node->get("value", &m_mass);
if(const XMLNode *plunger_node= root->getNode("plunger"))
{
plunger_node->get("band-max-length", &m_rubber_band_max_length );
plunger_node->get("band-force", &m_rubber_band_force );
plunger_node->get("band-duration", &m_rubber_band_duration );
plunger_node->get("band-speed-increase",&m_rubber_band_speed_increase);
plunger_node->get("band-fade-out-time", &m_rubber_band_fade_out_time );
plunger_node->get("in-face-time", &m_plunger_in_face_duration);
if(m_plunger_in_face_duration.size()!=RaceManager::DIFFICULTY_COUNT)
{
Log::fatal("KartProperties",
"Invalid plunger in-face-time specification.");
}
}
if(const XMLNode *zipper_node= root->getNode("zipper"))
{
zipper_node->get("time", &m_zipper_time );
zipper_node->get("fade-out-time", &m_zipper_fade_out_time );
zipper_node->get("force", &m_zipper_force );
zipper_node->get("speed-gain", &m_zipper_speed_gain );
zipper_node->get("max-speed-increase", &m_zipper_max_speed_increase);
}
if(const XMLNode *swatter_node= root->getNode("swatter"))
{
swatter_node->get("duration", &m_swatter_duration );
swatter_node->get("squash-duration", &m_squash_duration );
swatter_node->get("squash-slowdown", &m_squash_slowdown );
if(swatter_node->get("distance", &m_swatter_distance2) )
{
// Avoid squaring if distance is not defined, so that
// distance2 remains UNDEFINED (which is a negative value)
m_swatter_distance2 *= m_swatter_distance2;
}
}
if(const XMLNode *lean_node= root->getNode("lean"))
{
lean_node->get("max", &m_max_lean );
lean_node->get("speed", &m_lean_speed);
m_max_lean *= DEGREE_TO_RAD;
m_lean_speed *= DEGREE_TO_RAD;
}
if(const XMLNode *startup_node= root->getNode("startup"))
{
startup_node->get("time", &m_startup_times);
startup_node->get("boost", &m_startup_boost);
}
if(const XMLNode *startup_node= root->getNode("startup"))
{
startup_node->get("time", &m_startup_times);
startup_node->get("boost", &m_startup_boost);
}
if(m_kart_model)
m_kart_model->loadInfo(*root);

6
src/karts/kart_properties.hpp
View File

@ -211,7 +211,7 @@ private:
float m_nitro_small_container;
/** Nitro amount for big bittle. */
float m_nitro_big_container;
/* How much the speed of a kart might exceed its maximum speed (in m/s). */
/** How much the speed of a kart might exceed its maximum speed (in m/s). */
float m_nitro_max_speed_increase;
/** Additional engine force to affect the kart. */
float m_nitro_engine_force;
@ -250,7 +250,7 @@ private:
/** The speed with which the roll (when leaning in a curve) changes
* (in radians/second). */
float m_lean_speed;
/** How long a jump must be in order to trigger the jump animation. */
float m_jump_animation_time;
@ -547,7 +547,7 @@ public:
{
return m_speed_weighted_object_properties;
}
// ------------------------------------------------------------------------
/** Returns the wheel base (distance front to rear axis). */
float getWheelBase () const {return m_wheel_base; }

2
src/modes/linear_world.cpp
View File

@ -174,7 +174,7 @@ void LinearWorld::update(float dt)
// rescued or eliminated
if(kart->getKartAnimation()) continue;
kart_info.getTrackSector()->update(kart->getXYZ());
kart_info.getTrackSector()->update(kart->getFrontXYZ());
kart_info.m_overall_distance = kart_info.m_race_lap
* m_track->getTrackLength()
+ getDistanceDownTrackForKart(kart->getWorldKartId());

6
src/modes/world_status.cpp
View File

@ -137,6 +137,12 @@ void WorldStatus::update(const float dt)
return;
case TRACK_INTRO_PHASE:
m_auxiliary_timer += dt;
if (UserConfigParams::m_artist_debug_mode &&
race_manager->getNumberOfKarts() == 1 &&
race_manager->getTrackName() != "tutorial")
m_auxiliary_timer += dt * 6;
// Work around a bug that occurred on linux once:
// the sfx_manager kept on reporting that it is playing,
// while it was not - so STK would never reach the ready

2
src/modes/world_status.hpp
View File

@ -18,7 +18,7 @@
#ifndef HEADER_WORLD_STATUS_HPP
#define HEADER_WORLD_STATUS_HPP
#include "utils/cpp2011.h"
#include "utils/cpp2011.hpp"
class SFXBase;

4
src/network/client_network_manager.hpp
View File

@ -30,7 +30,7 @@
*/
class ClientNetworkManager : public NetworkManager
{
friend class Singleton<NetworkManager>;
friend class AbstractSingleton<NetworkManager>;
public:
/*! \brief Get the instance.
* This is a utility function to avoid passing templates parameters
@ -38,7 +38,7 @@ class ClientNetworkManager : public NetworkManager
*/
static ClientNetworkManager* getInstance()
{
return Singleton<NetworkManager>::getInstance<ClientNetworkManager>();
return AbstractSingleton<NetworkManager>::getInstance<ClientNetworkManager>();
}
/*! \brief Initializes network.

4
src/network/network_interface.hpp
View File

@ -33,9 +33,9 @@
/** \class NetworkInterface
* \ingroup network
*/
class NetworkInterface : public Singleton<NetworkInterface>
class NetworkInterface : public AbstractSingleton<NetworkInterface>
{
friend class Singleton<NetworkInterface>;
friend class AbstractSingleton<NetworkInterface>;
public:
/*! \brief Used to init the network.

4
src/network/network_manager.hpp
View File

@ -43,9 +43,9 @@
* Here are defined some functions that will be specifically implemented by
* the ServerNetworkManager and the ClientNetworkManager.
*/
class NetworkManager : public Singleton<NetworkManager>
class NetworkManager : public AbstractSingleton<NetworkManager>
{
friend class Singleton<NetworkManager>;
friend class AbstractSingleton<NetworkManager>;
public:
/** \brief Function to start the Network Manager (start threads) */
virtual void run();

4
src/network/network_world.hpp
View File

@ -34,9 +34,9 @@ class Item;
/*! \brief Manages the world updates during an online game
* This function's update is to be called instead of the normal World update
*/
class NetworkWorld : public Singleton<NetworkWorld>
class NetworkWorld : public AbstractSingleton<NetworkWorld>
{
friend class Singleton<NetworkWorld>;
friend class AbstractSingleton<NetworkWorld>;
public:
void update(float dt);

4
src/network/protocol_manager.hpp
View File

@ -102,9 +102,9 @@ typedef struct EventProcessingInfo
* frames per second. Then, the management of protocols is thread-safe: any
* object can start/pause/stop protocols whithout problems.
*/
class ProtocolManager : public Singleton<ProtocolManager>
class ProtocolManager : public AbstractSingleton<ProtocolManager>
{
friend class Singleton<ProtocolManager>;
friend class AbstractSingleton<ProtocolManager>;
friend void* protocolManagerAsynchronousUpdate(void* data);
public:

2
src/network/protocols/get_public_address.cpp
View File

@ -118,7 +118,7 @@ void GetPublicAddress::asynchronousUpdate()
hints.ai_socktype = SOCK_STREAM;
if ((status = getaddrinfo(stun_servers[rand_result].c_str(), NULL, &hints, &res)) != 0) {
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(status));
Log::error("getaddrinfo", gai_strerror(status));
return;
}
for(p = res;p != NULL; p = p->ai_next)

4
src/network/server_network_manager.hpp
View File

@ -27,11 +27,11 @@
class ServerNetworkManager : public NetworkManager
{
friend class Singleton<NetworkManager>;
friend class AbstractSingleton<NetworkManager>;
public:
static ServerNetworkManager* getInstance()
{
return Singleton<NetworkManager>::getInstance<ServerNetworkManager>();
return AbstractSingleton<NetworkManager>::getInstance<ServerNetworkManager>();
}
virtual void run();

2
src/online/http_request.hpp
View File

@ -21,7 +21,7 @@
#include "io/file_manager.hpp"
#include "online/request.hpp"
#include "utils/cpp2011.h"
#include "utils/cpp2011.hpp"
#include "utils/string_utils.hpp"
#include "utils/synchronised.hpp"

2
src/online/request.hpp
View File

@ -20,7 +20,7 @@
#define HEADER_ONLINE_REQUEST_HPP
#include "io/file_manager.hpp"
#include "utils/cpp2011.h"
#include "utils/cpp2011.hpp"
#include "utils/leak_check.hpp"
#include "utils/no_copy.hpp"
#include "utils/string_utils.hpp"

2
src/online/xml_request.hpp
View File

@ -21,7 +21,7 @@
#include "io/file_manager.hpp"
#include "online/http_request.hpp"
#include "utils/cpp2011.h"
#include "utils/cpp2011.hpp"
#include "utils/string_utils.hpp"
#include "utils/synchronised.hpp"

12
src/physics/physical_object.cpp
View File

@ -239,10 +239,7 @@ void PhysicalObject::init()
}
else
{
fprintf(stderr, "[PhysicalObject] Unknown node type\n");
max = 1.0f;
min = 0.0f;
assert(false);
Log::fatal("PhysicalObject", "Unknown node type");
}
}
else if (dynamic_cast<TrackObjectPresentationInstancing*>(presentation) != NULL)
@ -257,10 +254,7 @@ void PhysicalObject::init()
}
else
{
fprintf(stderr, "[PhysicalObject] Unknown node type\n");
max = 1.0f;
min = 0.0f;
assert(false);
Log::fatal("PhysicalObject", "Unknown node type");
}
Vec3 extend = max-min;
// Adjust the mesth of the graphical object so that its center is where it
@ -454,7 +448,7 @@ void PhysicalObject::init()
}
case MP_NONE:
default:
fprintf(stderr, "WARNING: Uninitialised moving shape\n");
Log::warn("PhysicalObject", "Uninitialised moving shape");
// intended fall-through
case MP_BOX:
{

2
src/physics/triangle_mesh.cpp
View File

@ -112,7 +112,7 @@ void TriangleMesh::createCollisionShape(bool create_collision_object, const char
btOptimizedBvh* bhv = btOptimizedBvh::deSerializeInPlace(bytes, pos, !IS_LITTLE_ENDIAN);
if (bhv == NULL)
{
fprintf(stderr, "[TriangleMesh] WARNING, failed to load serialized BHV\n");
Log::warn("TriangleMesh", "Failed to load serialized BHV");
bhv_triangle_mesh = new btBvhTriangleMeshShape(&m_mesh, false /* useQuantizedAabbCompression */);
}
else

135
src/race/grand_prix_data.cpp
View File

@ -37,6 +37,9 @@
// ----------------------------------------------------------------------------
/** Loads a grand prix definition from a file.
* \param filename Name of the file to load.
*/
GrandPrixData::GrandPrixData(const std::string& filename)
{
m_filename = filename;
@ -44,18 +47,34 @@ GrandPrixData::GrandPrixData(const std::string& filename)
StringUtils::removeExtension(filename));
m_editable = (filename.find(file_manager->getGPDir(), 0) == 0);
reload();
}
} // GrandPrixData
// ----------------------------------------------------------------------------
GrandPrixData::GrandPrixData(const unsigned int number_of_tracks,
const std::string& track_group,
const RandomGPInfoDialog::REVERSED use_reverse)
/** Creates a random grand prix from the specified parameters.
* \param number_of_tracks How many tracks to select.
* \param track_group From which track group to select the tracks.
* \param use_reverse How the reverse setting is to be determined.
* \param new_tracks If true, new tracks are selected, otherwise existing
* tracks will not be changed (used to e.g. increase the number of
* tracks in an already existing random grand prix).
*
*/
void GrandPrixData::createRandomGP(const unsigned int number_of_tracks,
const std::string &track_group,
const GPReverseType use_reverse,
bool new_tracks)
{
m_filename = "Random GP - Not loaded from a file!";
m_id = "random";
m_name = "Random Grand Prix";
m_editable = false;
if(new_tracks)
{
m_tracks.clear();
m_laps.clear();
m_reversed.clear();
}
m_tracks.reserve(number_of_tracks);
m_laps.reserve(number_of_tracks);
m_reversed.reserve(number_of_tracks);
@ -92,14 +111,15 @@ void GrandPrixData::changeTrackNumber(const unsigned int number_of_tracks,
rand() % available_tracks :
track_indices[rand() % available_tracks];
std::string id = track_manager->getTrack(index)->getIdent();
const Track *track = track_manager->getTrack(index);
std::string id = track->getIdent();
// Avoid duplicate tracks
if (std::find(m_tracks.begin(), m_tracks.end(), id) != m_tracks.end())
continue;
m_tracks.push_back(id);
m_laps.push_back(3); // TODO: Take the default number from the track
m_reversed.push_back(false); // This will be changed later
m_laps.push_back(track->getDefaultNumberOfLaps());
m_reversed.push_back(false); // This will be changed later in the code
}
}
else if (m_tracks.size() > number_of_tracks)
@ -117,48 +137,64 @@ void GrandPrixData::changeTrackNumber(const unsigned int number_of_tracks,
}
// ----------------------------------------------------------------------------
void GrandPrixData::changeReverse(const RandomGPInfoDialog::REVERSED use_reverse)
/** Updates the GP data with newly decided reverse requirements.
* \param use_reverse How reverse setting for each track is to be determined.
*/
void GrandPrixData::changeReverse(const GrandPrixData::GPReverseType use_reverse)
{
for (unsigned int i = 0; i < m_tracks.size(); i++)
{
if (use_reverse == RandomGPInfoDialog::NO_REVERSE)
if (use_reverse == GP_NO_REVERSE)
m_reversed[i] = false;
else if (use_reverse == RandomGPInfoDialog::MIXED)
else if (use_reverse == GP_RANDOM_REVERSE)
if (track_manager->getTrack(m_tracks[i])->reverseAvailable())
m_reversed[i] = (rand() % 2 != 0);
else
m_reversed[i] = false;
else // all reversed
m_reversed[i] = track_manager->getTrack(m_tracks[i])->reverseAvailable();
}
}
} // for i < m_tracks.size()
} // changeReverse
// ----------------------------------------------------------------------------
/** Sets the id of this grand prix.
* \param id The new id.
*/
void GrandPrixData::setId(const std::string& id)
{
m_id = id;
}
} // setId
// ----------------------------------------------------------------------------
/** Sets the name of the grand prix.
* \param name New name.
*/
void GrandPrixData::setName(const irr::core::stringw& name)
{
m_name = name;
}
} // setName
// ----------------------------------------------------------------------------
/** Sets the filename of this grand prix.
* \param filename New filename.
*/
void GrandPrixData::setFilename(const std::string& filename)
{
m_filename = filename;
}
} // setFilename
// ----------------------------------------------------------------------------
/** Sets if this grand prix can be edited.
* \param editable New value.
*/
void GrandPrixData::setEditable(const bool editable)
{
m_editable = editable;
}
} // setEditable
// ----------------------------------------------------------------------------
/** Reloads grand prix from file.
*/
void GrandPrixData::reload()
{
m_tracks.clear();
@ -270,6 +306,8 @@ void GrandPrixData::reload()
} // reload()
// ----------------------------------------------------------------------------
/** Saves the grand prix data to a file.
*/
bool GrandPrixData::writeToFile()
{
try
@ -303,9 +341,12 @@ bool GrandPrixData::writeToFile()
m_filename.c_str(), e.what());
return false;
}
}
} // writeToFile
// ----------------------------------------------------------------------------
/** Checks if the grand prix data are consistent.
* \param log_error: If errors should be sent to the logger.
*/
bool GrandPrixData::checkConsistency(bool log_error) const
{
for (unsigned int i = 0; i < m_tracks.size(); i++)
@ -323,8 +364,7 @@ bool GrandPrixData::checkConsistency(bool log_error) const
}
}
return true;
}
} // checkConsistency
// ----------------------------------------------------------------------------
/** Returns true if the track is available. This is used to test if Fort Magma
@ -332,76 +372,99 @@ bool GrandPrixData::checkConsistency(bool log_error) const
* story mode, but will be available once all challenges are done and nolok
* is unlocked). It also prevents people from using the grand prix editor as
* a way to play tracks that still haven't been unlocked
* \param id Name of the track to test.
* \param include_locked If set to true, all tracks (including locked tracks)
* are considered to be available.
*/
bool GrandPrixData::isTrackAvailable(const std::string &id,
bool includeLocked ) const
bool include_locked ) const
{
if (includeLocked)
if (include_locked)
return true;
else if (id == "fortmagma")
return !PlayerManager::getCurrentPlayer()->isLocked("fortmagma");
else
return (!m_editable ||
!PlayerManager::get()->getCurrentPlayer()->isLocked(id));
}
} // isTrackAvailable
// ----------------------------------------------------------------------------
std::vector<std::string> GrandPrixData::getTrackNames(bool includeLocked) const
/** Returns the list of tracks that is available (i.e. unlocked) of this
* grand prix.
* \param include_locked If data for locked tracks should be included or not.
* \return A copy of the list of available tracks in this grand prix.
*/
std::vector<std::string> GrandPrixData::getTrackNames(bool include_locked) const
{
std::vector<std::string> names;
for (unsigned int i = 0; i < m_tracks.size(); i++)
{
if(isTrackAvailable(m_tracks[i], includeLocked))
if(isTrackAvailable(m_tracks[i], include_locked))
names.push_back(m_tracks[i]);
}
return names;
}
} // getTrackNames
// ----------------------------------------------------------------------------
std::vector<int> GrandPrixData::getLaps(bool includeLocked) const
/** Returns the laps for each available track of the grand prix.
* \param include_locked If data for locked tracks should be included or not.
* \return a std::vector containing the laps for each grand prix.
*/
std::vector<int> GrandPrixData::getLaps(bool include_locked) const
{
std::vector<int> laps;
for (unsigned int i = 0; i< m_tracks.size(); i++)
if(isTrackAvailable(m_tracks[i], includeLocked))
if(isTrackAvailable(m_tracks[i], include_locked))
laps.push_back(m_laps[i]);
return laps;
}
} // getLaps
// ----------------------------------------------------------------------------
std::vector<bool> GrandPrixData::getReverse(bool includeLocked) const
/** Returns the reverse setting for each available grand prix.
* \param include_locked If data for locked tracks should be included or not.
* \return A copy of alist with the reverse status for each track.
*/
std::vector<bool> GrandPrixData::getReverse(bool include_locked) const
{
std::vector<bool> reverse;
for (unsigned int i = 0; i< m_tracks.size(); i++)
if(isTrackAvailable(m_tracks[i], includeLocked))
if(isTrackAvailable(m_tracks[i], include_locked))
reverse.push_back(m_reversed[i]);
return reverse;
}
} // getReverse
// ----------------------------------------------------------------------------
/** Returns true if this grand prix can be edited.
*/
bool GrandPrixData::isEditable() const
{
return m_editable;
}
} // isEditable
// ----------------------------------------------------------------------------
/** Returns the number of tracks in this grand prix.
* \param include_locked If data for locked tracks should be included or not.
*/
unsigned int GrandPrixData::getNumberOfTracks(bool includeLocked) const
{
if (includeLocked)
return m_tracks.size();
else
return getTrackNames(false).size();
}
} // getNumberOfTracks
// ----------------------------------------------------------------------------
/** Returns the (translated) name of the track with the specified index.
*/
irr::core::stringw GrandPrixData::getTrackName(const unsigned int track) const
{
assert(track < getNumberOfTracks(true));
Track* t = track_manager->getTrack(m_tracks[track]);
assert(t != NULL);
return t->getName();
}
} // getTrackName
// ----------------------------------------------------------------------------
const std::string& GrandPrixData::getTrackId(const unsigned int track) const
@ -490,7 +553,7 @@ void GrandPrixData::editTrack(unsigned int index, Track* track,
// ----------------------------------------------------------------------------
void GrandPrixData::remove(const unsigned int track)
{
assert (0 < track && track < getNumberOfTracks(true));
assert (0 <= track && track < getNumberOfTracks(true));
m_tracks.erase(m_tracks.begin() + track);
m_laps.erase(m_laps.begin() + track);

25
src/race/grand_prix_data.hpp
View File

@ -24,7 +24,6 @@
#include <string>
#include <vector>
#include "states_screens/dialogs/random_gp_dialog.hpp"
#include "utils/translation.hpp"
using irr::core::stringw;
@ -69,21 +68,35 @@ private:
*/
bool isTrackAvailable(const std::string &id, bool includeLocked) const;
public:
/** Used to define the reverse setting when creating a random GP:
* No reverse, all reverse (if available on the track), random
* selection. */
enum GPReverseType
{
GP_NO_REVERSE = 0,
GP_ALL_REVERSE = 1,
GP_RANDOM_REVERSE = 2
}; // GPReverseType
public:
#if (defined(WIN32) || defined(_WIN32)) && !defined(__MINGW32__)
# pragma warning(disable:4290)
#endif
/** Load the GrandPrixData from the given filename */
GrandPrixData(const std::string& filename);
/** Needed for simple creation of an instance of GrandPrixData */
GrandPrixData() {};
/** Creates a new random GP */
GrandPrixData(const unsigned int number_of_tracks,
const std::string& track_group,
const RandomGPInfoDialog::REVERSED use_reverse);
void changeTrackNumber(const unsigned int number_of_tracks,
const std::string& track_group);
void changeReverse(const RandomGPInfoDialog::REVERSED use_reverse);
void changeReverse(const GPReverseType use_reverse);
void createRandomGP(const unsigned int number_of_tracks,
const std::string& track_group,
const GPReverseType use_reverse,
bool new_tracks=false);
// Methods for the GP editor
void setId(const std::string& id);

9
src/race/grand_prix_manager.cpp
View File

@ -34,7 +34,6 @@ const char* GrandPrixManager::SUFFIX = ".grandprix";
// ----------------------------------------------------------------------------
GrandPrixManager::GrandPrixManager()
{
m_random_gp = NULL; // better do it explicitly and avoid weird stuff
loadFiles();
} // GrandPrixManager
@ -42,10 +41,7 @@ GrandPrixManager::GrandPrixManager()
GrandPrixManager::~GrandPrixManager()
{
for(unsigned int i=0; i<m_gp_data.size(); i++)
{
delete m_gp_data[i];
}
delete m_random_gp;
} // ~GrandPrixManager
// ----------------------------------------------------------------------------
@ -97,7 +93,7 @@ void GrandPrixManager::load(const std::string& filename)
catch (std::runtime_error& e)
{
Log::error("GrandPrixManager",
"Ignoring grand prix %s (%s)\n", filename.c_str(), e.what());
"Ignoring Grand Prix %s (%s)\n", filename.c_str(), e.what());
}
} // load
@ -156,9 +152,6 @@ GrandPrixData* GrandPrixManager::getGrandPrix(const std::string& s) const
// ----------------------------------------------------------------------------
GrandPrixData* GrandPrixManager::editGrandPrix(const std::string& s) const
{
if (s == "random")
return m_random_gp;
for(unsigned int i=0; i<m_gp_data.size(); i++)
{
if(m_gp_data[i]->getId() == s)

7
src/race/grand_prix_manager.hpp
View File

@ -22,7 +22,8 @@
#include <vector>
#include <string>
#include "race/grand_prix_data.hpp"
#include "irrlicht.h"
class GrandPrixData;
/**
* \ingroup race
@ -47,10 +48,6 @@ private:
bool existsName(const irr::core::stringw& name) const;
public:
/** saved here by a random GP dialog to avoid dangling pinters or
* memory leaks */
GrandPrixData* m_random_gp;
GrandPrixManager();
~GrandPrixManager();
void reload();

8
src/race/highscores.cpp
View File

@ -212,10 +212,10 @@ void Highscores::getEntry(int number, std::string &kart_name,
{
if(number<0 || number>getNumberEntries())
{
fprintf(stderr, "Error, accessing undefined highscore entry:\n");
fprintf(stderr,"number %d, but %d entries are defined\n",number,
getNumberEntries());
fprintf(stderr, "This error can be ignored, but no highscores are available\n");
Log::warn("Highscores", "Accessing undefined highscore entry:");
Log::warn("Highscores", "Number %d, but %d entries are defined.", number,
getNumberEntries());
Log::warn("Highscores", "This error can be ignored, but no highscores are available.");
return;
}
kart_name = m_kart_name[number];

80
src/race/history.cpp
View File

@ -127,7 +127,7 @@ void History::updateReplay(float dt)
World *world = World::getWorld();
if(m_current>=(int)m_all_deltas.size())
{
printf("Replay finished.\n");
Log::info("History", "Replay finished");
m_current = 0;
// Note that for physics replay all physics parameters
// need to be reset, e.g. velocity, ...
@ -158,20 +158,19 @@ void History::Save()
{
FILE *fd = fopen("history.dat","w");
if(fd)
printf("History saved in ./history.dat.\n");
Log::info("History", "Saved in ./history.dat.");
else
{
std::string fn = file_manager->getUserConfigFile("history.dat");
fd = fopen(fn.c_str(), "w");
if(fd)
printf("History saved in '%s'.\n",fn.c_str());
Log::info("History", "Saved in '%s'.", fn.c_str());
}
if(!fd)
{
printf("Can't open history.dat file for writing - can't save history.\n");
printf("Make sure history.dat in the current directory or the config\n");
printf("directory is writable.\n");
Log::info("History", "Can't open history.dat file for writing - can't save history.");
Log::info("History", "Make sure history.dat in the current directory "
"or the config directory is writable.");
return;
}
@ -231,75 +230,46 @@ void History::Load()
FILE *fd = fopen("history.dat","r");
if(fd)
printf("Reading ./history.dat\n");
Log::info("History", "Reading ./history.dat");
else
{
std::string fn = file_manager->getUserConfigFile("history.dat");
fd = fopen(fn.c_str(), "r");
if(fd)
printf("Reading '%s'.\n", fn.c_str());
Log::info("History", "Reading '%s'.", fn.c_str());
}
if(!fd)
{
fprintf(stderr, "ERROR: could not open history.dat\n");
exit(-2);
}
Log::fatal("History", "Could not open history.dat");
if (fgets(s, 1023, fd) == NULL)
{
fprintf(stderr, "ERROR: could not read history.dat\n");
exit(-2);
}
Log::fatal("History", "Could not read history.dat.");
if (sscanf(s,"Version: %1023s",s1)!=1)
{
fprintf(stderr, "ERROR: no Version information found in history file (bogus history file)\n");
exit(-2);
}
else
{
if (strcmp(s1,STK_VERSION))
{
fprintf(stderr, "WARNING: history is version '%s'\n",s1);
fprintf(stderr, " STK version is '%s'\n",STK_VERSION);
}
}
Log::fatal("History", "No Version information found in history file (bogus history file).");
else if (strcmp(s1,STK_VERSION))
Log::warn("History", "History is version '%s', STK version is '%s'.", s1, STK_VERSION);
if (fgets(s, 1023, fd) == NULL)
{
fprintf(stderr, "ERROR: could not read history.dat\n");
exit(-2);
}
Log::fatal("History", "Could not read history.dat.");
unsigned int num_karts;
if(sscanf(s, "numkarts: %d",&num_karts)!=1)
{
fprintf(stderr,"WARNING: No number of karts found in history file.\n");
exit(-2);
}
Log::fatal("History", "No number of karts found in history file.");
race_manager->setNumKarts(num_karts);
fgets(s, 1023, fd);
if(sscanf(s, "numplayers: %d",&n)!=1)
{
fprintf(stderr,"WARNING: No number of players found in history file.\n");
exit(-2);
}
Log::fatal("History", "No number of players found in history file.");
race_manager->setNumLocalPlayers(n);
fgets(s, 1023, fd);
if(sscanf(s, "difficulty: %d",&n)!=1)
{
fprintf(stderr,"WARNING: No difficulty found in history file.\n");
exit(-2);
}
Log::fatal("History", "No difficulty found in history file.");
race_manager->setDifficulty((RaceManager::Difficulty)n);
fgets(s, 1023, fd);
if(sscanf(s, "track: %1023s",s1)!=1)
{
fprintf(stderr,"WARNING: Track not found in history file.\n");
}
Log::warn("History", "Track not found in history file.");
race_manager->setTrack(s1);
// This value doesn't really matter, but should be defined, otherwise
// the racing phase can switch to 'ending'
@ -308,12 +278,8 @@ void History::Load()
for(unsigned int i=0; i<num_karts; i++)
{
fgets(s, 1023, fd);
if(sscanf(s, "model %d: %1023s",&n, s1)!=2)
{
fprintf(stderr,"WARNING: No model information for kart %d found.\n",
i);
exit(-2);
}
if(sscanf(s, "model %d: %1023s",&n, s1) != 2)
Log::fatal("History", "No model information for kart %d found.", i);
m_kart_ident.push_back(s1);
if(i<race_manager->getNumPlayers())
{
@ -323,10 +289,8 @@ void History::Load()
// FIXME: The model information is currently ignored
fgets(s, 1023, fd);
if(sscanf(s,"size: %d",&m_size)!=1)
{
fprintf(stderr,"WARNING: Number of records not found in history file.\n");
exit(-2);
}
Log::fatal("History", "Number of records not found in history file.");
allocateMemory(m_size);
m_current = -1;

95
src/replay/replay_play.cpp
View File

@ -88,70 +88,51 @@ void ReplayPlay::Load()
FILE *fd = openReplayFile(/*writeable*/false);
if(!fd)
{
printf("Can't read '%s', ghost replay disabled.\n",
Log::error("Replay", "Can't read '%s', ghost replay disabled.",
getReplayFilename().c_str());
destroy();
return;
}
printf("Reading replay file '%s'.\n", getReplayFilename().c_str());
Log::info("Replay", "Reading replay file '%s'.", getReplayFilename().c_str());
if (fgets(s, 1023, fd) == NULL)
{
fprintf(stderr, "ERROR: could not read '%s'.\n",
getReplayFilename().c_str());
exit(-2);
}
Log::fatal("Replay", "Could not read '%s'.", getReplayFilename().c_str());
unsigned int version;
if (sscanf(s,"Version: %d", &version)!=1)
{
fprintf(stderr, "ERROR: no Version information found in replay file"
" (bogus replay file)\n");
exit(-2);
}
if (sscanf(s,"Version: %d", &version) != 1)
Log::fatal("Replay", "No Version information found in replay file (bogus replay file).");
if (version!=getReplayVersion())
if (version != getReplayVersion())
{
fprintf(stderr, "WARNING: replay is version '%d'\n",version);
fprintf(stderr, " STK version is '%d'\n",getReplayVersion());
fprintf(stderr, " We try to proceed, but it may fail.\n");
Log::warn("Replay", "Replay is version '%d'",version);
Log::warn("Replay", "STK version is '%d'",getReplayVersion());
Log::warn("Replay", "We try to proceed, but it may fail.");
}
if (fgets(s, 1023, fd) == NULL)
{
fprintf(stderr, "ERROR: could not read '%s'.\n",
getReplayFilename().c_str());
exit(-2);
}
Log::fatal("Replay", "Could not read '%s'.", getReplayFilename().c_str());
int n;
if(sscanf(s, "difficulty: %d",&n)!=1)
{
fprintf(stderr,"WARNING: No difficulty found in replay file.\n");
exit(-2);
}
if(sscanf(s, "difficulty: %d", &n) != 1)
Log::fatal("Replay", " No difficulty found in replay file.");
if(race_manager->getDifficulty()!=(RaceManager::Difficulty)n)
printf("Warning, difficulty of replay is '%d', "
"while '%d' is selected.\n",
race_manager->getDifficulty(), n);
Log::warn("Replay", "Difficulty of replay is '%d', "
"while '%d' is selected.",
race_manager->getDifficulty(), n);
fgets(s, 1023, fd);
if(sscanf(s, "track: %s",s1)!=1)
{
fprintf(stderr,"WARNING: Track not found in replay file.\n");
}
if(sscanf(s, "track: %s", s1) != 1)
Log::warn("Replay", "Track not found in replay file.");
assert(std::string(s1)==race_manager->getTrackName());
race_manager->setTrack(s1);
unsigned int num_laps;
fgets(s, 1023, fd);
if(sscanf(s, "Laps: %d",&num_laps)!=1)
{
fprintf(stderr,"WARNING: No number of laps found in replay file.\n");
exit(-2);
}
if(sscanf(s, "Laps: %d", &num_laps) != 1)
Log::fatal("Replay", "No number of laps found in replay file.");
race_manager->setNumLaps(num_laps);
// eof actually doesn't trigger here, since it requires first to try
@ -175,25 +156,18 @@ void ReplayPlay::readKartData(FILE *fd, char *next_line)
{
char s[1024];
if(sscanf(next_line, "model: %s", s)!=1)
{
fprintf(stderr,
"WARNING: No model information for kart %d found.\n",
Log::fatal("Replay", "No model information for kart %d found.",
m_ghost_karts.size());
exit(-2);
}
m_ghost_karts.push_back(new GhostKart(std::string(s)));
m_ghost_karts[m_ghost_karts.size()-1].init(RaceManager::KT_GHOST);
fgets(s, 1023, fd);
unsigned int size;
if(sscanf(s,"size: %d",&size)!=1)
{
fprintf(stderr,
"WARNING: Number of records not found in replay file "
"for kart %d.\n",
Log::fatal("Replay", "Number of records not found in replay file "
"for kart %d.",
m_ghost_karts.size()-1);
exit(-2);
}
for(unsigned int i=0; i<size; i++)
{
@ -217,20 +191,17 @@ void ReplayPlay::readKartData(FILE *fd, char *next_line)
{
// Invalid record found
// ---------------------
fprintf(stderr, "Can't read replay data line %d:\n", i);
fprintf(stderr, "%s", s);
fprintf(stderr, "Ignored.\n");
Log::warn("Replay", "Can't read replay data line %d:", i);
Log::warn("Replay", "%s", s);
Log::warn("Replay", "Ignored.");
}
} // for i
fgets(s, 1023, fd);
unsigned int num_events;
if(sscanf(s,"events: %d",&num_events)!=1)
{
fprintf(stderr,
"WARNING: Number of events not found in replay file "
"for kart %d.\n",
m_ghost_karts.size()-1);
}
Log::warn("Replay", "Number of events not found in replay file "
"for kart %d.", m_ghost_karts.size()-1);
for(unsigned int i=0; i<num_events; i++)
{
fgets(s, 1023, fd);
@ -245,9 +216,9 @@ void ReplayPlay::readKartData(FILE *fd, char *next_line)
{
// Invalid record found
// ---------------------
fprintf(stderr, "Can't read replay event line %d:\n", i);
fprintf(stderr, "%s", s);
fprintf(stderr, "Ignored.\n");
Log::warn("Replay", "Can't read replay event line %d:", i);
Log::warn("Replay", "%s", s);
Log::warn("Replay", "Ignored.");
}
} // for i < events

12
src/replay/replay_recorder.cpp
View File

@ -130,8 +130,12 @@ void ReplayRecorder::update(float dt)
{
// Only print this message once.
if(m_count_transforms[i]==m_transform_events[i].size())
printf("Can't store more events for kart %s.\n",
{
char buffer[100];
sprintf(buffer, "Can't store more events for kart %s.",
kart->getIdent().c_str());
Log::warn("ReplayRecorder", buffer);
}
continue;
}
TransformEvent *p = &(m_transform_events[i][m_count_transforms[i]-1]);
@ -153,12 +157,12 @@ void ReplayRecorder::Save()
FILE *fd = openReplayFile(/*writeable*/true);
if(!fd)
{
printf("Can't open '%s' for writing - can't save replay data.\n",
getReplayFilename().c_str());
Log::error("ReplayRecorder", "Can't open '%s' for writing - can't save replay data.",
getReplayFilename().c_str());
return;
}
printf("Replay saved in '%s'.\n", getReplayFilename().c_str());
Log::info("ReplayRecorder", "Replay saved in '%s'.\n", getReplayFilename().c_str());
World *world = World::getWorld();
unsigned int num_karts = world->getNumKarts();

16
src/states_screens/credits.cpp
View File

@ -85,7 +85,7 @@ bool CreditsScreen::getWideLine(std::ifstream& file, core::stringw* out)
{
if (!file.good())
{
fprintf(stderr, "getWideLine : File is not good!\n");
Log::error("CreditsScreen", "getWideLine: File is not good!");
return false;
}
wchar_t wide_char;
@ -147,8 +147,8 @@ void CreditsScreen::loadedFromFile()
if (file.fail() || !file.is_open() || file.eof())
{
fprintf(stderr, "\n/!\\ Failed to open file at '%s'\n\n",
creditsfile.c_str());
Log::error("CreditsScreen", "Failed to open file at '%s'.",
creditsfile.c_str());
return;
}
@ -160,10 +160,8 @@ void CreditsScreen::loadedFromFile()
if (file.fail() || !file.is_open() || file.eof())
{
fprintf(stderr,
"\n/!\\ Failed to read file at '%s', unexpected EOF\n\n",
creditsfile.c_str());
assert(false);
Log::error("CreditsScreen", "Failed to read file at '%s', unexpected EOF.",
creditsfile.c_str());
return;
}
@ -203,9 +201,7 @@ void CreditsScreen::loadedFromFile()
if (lineCount == 0)
{
fprintf(stderr,
"\n/!\\ Could not read anything from CREDITS file!\n\n");
assert(false);
Log::error("CreditsScreen", "Could not read anything from CREDITS file!");
return;
}

2
src/states_screens/cutscene_gui.hpp
View File

@ -26,7 +26,7 @@
using namespace irr;
#include "states_screens/race_gui_base.hpp"
#include "utils/cpp2011.h"
#include "utils/cpp2011.hpp"
class AbstractKart;
class InputMap;

2
src/states_screens/dialogs/add_device_dialog.cpp
View File

@ -26,7 +26,7 @@
#include "states_screens/dialogs/message_dialog.hpp"
#include "states_screens/options_screen_input.hpp"
#include "states_screens/state_manager.hpp"
#include "utils/cpp2011.h"
#include "utils/cpp2011.hpp"
#include "utils/string_utils.hpp"
#include "utils/translation.hpp"
#include "input/wiimote_manager.hpp"

16
src/states_screens/dialogs/addons_loading.cpp
View File

@ -294,6 +294,13 @@ void AddonsLoading::onUpdate(float delta)
const std::string icon = "icons/"+m_addon.getIconBasename();
m_icon->setImage( file_manager->getAddonsFile(icon).c_str(),
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE );
// Check if there was an error displaying the icon. If so, the icon
// file is (likely) corrupt, and the file needs to be downloaded again.
std::string s = m_icon->getTexture()->getName().getPath().c_str();
if(StringUtils::getBasename(s)!=StringUtils::getBasename(icon))
{
m_addon.deleteInvalidIconFile();
}
m_icon_shown = true;
}
} // onUpdate
@ -384,11 +391,10 @@ void AddonsLoading::doUninstall()
error = !addons_manager->uninstall(m_addon);
if(error)
{
printf("[addons]Directory '%s' can not be removed.\n",
m_addon.getDataDir().c_str());
printf("[addons]Please remove this directory manually.\n");
core::stringw msg = StringUtils::insertValues(
_("Problems removing the addon '%s'."),
Log::warn("Addons", "Directory '%s' can not be removed.",
m_addon.getDataDir().c_str());
Log::warn("Addons", "Please remove this directory manually.");
core::stringw msg = StringUtils::insertValues(_("Problems removing the addon '%s'."),
core::stringw(m_addon.getName().c_str()));
getWidget<BubbleWidget>("description")->setText(msg.c_str());
}

53
src/states_screens/dialogs/custom_video_settings.cpp
View File

@ -102,29 +102,19 @@ GUIEngine::EventPropagation CustomVideoSettingsDialog::processEvent(const std::s
{
if (eventSource == "close")
{
bool dynamic_light = getWidget<CheckBoxWidget>("dynamiclight")->getState();
UserConfigParams::m_dynamic_lights = dynamic_light;
bool advanced_pipeline = getWidget<CheckBoxWidget>("dynamiclight")->getState();
UserConfigParams::m_dynamic_lights = advanced_pipeline;
UserConfigParams::m_graphical_effects =
getWidget<CheckBoxWidget>("anim_gfx")->getState();
UserConfigParams::m_weather_effects =
getWidget<CheckBoxWidget>("weather_gfx")->getState();
UserConfigParams::m_ubo_disabled =
!getWidget<CheckBoxWidget>("ubo")->getState();
UserConfigParams::m_dof =
getWidget<CheckBoxWidget>("dof")->getState();
UserConfigParams::m_high_definition_textures =
getWidget<CheckBoxWidget>("hd-textures")->getState();
advanced_pipeline && getWidget<CheckBoxWidget>("dof")->getState();
UserConfigParams::m_motionblur =
getWidget<CheckBoxWidget>("motionblur")->getState();
UserConfigParams::m_show_steering_animations =
getWidget<SpinnerWidget>("steering_animations")->getValue();
if (dynamic_light)
advanced_pipeline && getWidget<CheckBoxWidget>("motionblur")->getState();
if (advanced_pipeline)
{
UserConfigParams::m_shadows =
getWidget<SpinnerWidget>("shadows")->getValue();
advanced_pipeline && getWidget<SpinnerWidget>("shadows")->getValue();
}
else
{
@ -132,26 +122,41 @@ GUIEngine::EventPropagation CustomVideoSettingsDialog::processEvent(const std::s
}
UserConfigParams::m_mlaa =
getWidget<CheckBoxWidget>("mlaa")->getState();
advanced_pipeline && getWidget<CheckBoxWidget>("mlaa")->getState();
UserConfigParams::m_ssao =
getWidget<CheckBoxWidget>("ssao")->getState();
advanced_pipeline && getWidget<CheckBoxWidget>("ssao")->getState();
UserConfigParams::m_light_shaft =
getWidget<CheckBoxWidget>("lightshaft")->getState();
advanced_pipeline && getWidget<CheckBoxWidget>("lightshaft")->getState();
UserConfigParams::m_gi =
getWidget<CheckBoxWidget>("global_illumination")->getState();
advanced_pipeline && getWidget<CheckBoxWidget>("global_illumination")->getState();
UserConfigParams::m_glow =
getWidget<CheckBoxWidget>("glow")->getState();
advanced_pipeline && getWidget<CheckBoxWidget>("glow")->getState();
UserConfigParams::m_bloom =
getWidget<CheckBoxWidget>("bloom")->getState();
advanced_pipeline && getWidget<CheckBoxWidget>("bloom")->getState();
UserConfigParams::m_texture_compression =
getWidget<CheckBoxWidget>("texture_compression")->getState();
UserConfigParams::m_graphical_effects =
getWidget<CheckBoxWidget>("anim_gfx")->getState();
UserConfigParams::m_weather_effects =
getWidget<CheckBoxWidget>("weather_gfx")->getState();
UserConfigParams::m_ubo_disabled =
!getWidget<CheckBoxWidget>("ubo")->getState();
UserConfigParams::m_high_definition_textures =
getWidget<CheckBoxWidget>("hd-textures")->getState();
UserConfigParams::m_show_steering_animations =
getWidget<SpinnerWidget>("steering_animations")->getValue();
switch (getWidget<SpinnerWidget>("filtering")->getValue())
{
case 0:

2
src/states_screens/dialogs/debug_slider.hpp
View File

@ -20,7 +20,7 @@
#define HEADER_DEBUG_SLIDER_DIALOG_HPP
#include "guiengine/modaldialog.hpp"
#include "utils/cpp2011.h"
#include "utils/cpp2011.hpp"
#include "utils/leak_check.hpp"
/**

24
src/states_screens/dialogs/gp_info_dialog.cpp
View File

@ -53,8 +53,8 @@ GPInfoDialog::GPInfoDialog(const std::string& gp_ident)
doInit();
m_curr_time = 0.0f;
m_gp = grand_prix_manager->getGrandPrix(gp_ident);
m_gp->checkConsistency();
m_gp = *grand_prix_manager->getGrandPrix(gp_ident);
m_gp.checkConsistency();
m_under_title = m_area.getHeight()/7;
m_over_body = m_area.getHeight()/7;
@ -72,7 +72,7 @@ GPInfoDialog::~GPInfoDialog()
{
GUIEngine::Screen* curr_screen = GUIEngine::getCurrentScreen();
if (curr_screen->getName() == "tracks.stkgui")
static_cast<TracksScreen*>(curr_screen)->setFocusOnGP(m_gp->getId());
static_cast<TracksScreen*>(curr_screen)->setFocusOnGP(m_gp.getId());
}
// ----------------------------------------------------------------------------
@ -81,7 +81,7 @@ void GPInfoDialog::addTitle()
{
core::rect< s32 > area_top(0, 0, m_area.getWidth(), m_under_title);
IGUIStaticText* title = GUIEngine::getGUIEnv()->addStaticText(
translations->fribidize(m_gp->getName()),
translations->fribidize(m_gp.getName()),
area_top, false, true, // border, word wrap
m_irrlicht_window);
title->setTabStop(false);
@ -92,7 +92,7 @@ void GPInfoDialog::addTitle()
void GPInfoDialog::addTracks()
{
const std::vector<std::string> tracks = m_gp->getTrackNames();
const std::vector<std::string> tracks = m_gp.getTrackNames();
const unsigned int track_amount = tracks.size();
int height_of_one_line = std::min((m_lower_bound - m_over_body)/(track_amount+1),
@ -119,7 +119,7 @@ void GPInfoDialog::addTracks()
Label* widget = dynamic_cast<Label*>(m_widgets.get(widgets_iter));
widget->setText(translations->fribidize(track->getName()), false);
widget->move(20, m_over_body + height_of_one_line*(i+1),
widget->move(20, m_over_body + height_of_one_line*i,
m_area.getWidth()/2 - 20, height_of_one_line);
widgets_iter++;
@ -141,7 +141,7 @@ void GPInfoDialog::addTracks()
m_widgets.push_back(widget);
widget->add();
widget->move(20, m_over_body + height_of_one_line*(i+1),
widget->move(20, m_over_body + height_of_one_line*i,
m_area.getWidth()/2 - 20, height_of_one_line);
}
}
@ -185,7 +185,7 @@ void GPInfoDialog::addScreenshot()
m_screenshot_widget->m_h = m_area.getWidth()*3/8; // *(3/4)*(1/2)
}
Track* track = track_manager->getTrack(m_gp->getTrackNames()[0]);
Track* track = track_manager->getTrack(m_gp.getTrackNames()[0]);
m_screenshot_widget->m_properties[GUIEngine::PROP_ICON] = (track->getScreenshotFile().c_str());
m_screenshot_widget->setParent(m_irrlicht_window);
m_screenshot_widget->add();
@ -203,7 +203,7 @@ void GPInfoDialog::addButtons()
SavedGrandPrix* saved_gp = SavedGrandPrix::getSavedGP( StateManager::get()
->getActivePlayerProfile(0)
->getUniqueID(),
m_gp->getId(),
m_gp.getId(),
race_manager->getDifficulty(),
race_manager->getNumberOfKarts(),
race_manager->getNumLocalPlayers());
@ -250,7 +250,7 @@ void GPInfoDialog::addButtons()
void GPInfoDialog::onEnterPressedInternal()
{
// Save the GP id because dismiss() will destroy this instance
std::string gp_id = m_gp->getId();
std::string gp_id = m_gp.getId();
ModalDialog::dismiss();
// Disable accidentally unlocking of a challenge
PlayerManager::getCurrentPlayer()->setCurrentChallenge("");
@ -264,7 +264,7 @@ GUIEngine::EventPropagation GPInfoDialog::processEvent(const std::string& event_
if (event_source == "start" || event_source == "continue")
{
// Save GP identifier, since dismiss will delete this object.
std::string gp_id = m_gp->getId();
std::string gp_id = m_gp.getId();
// Also create a copy of the string: it is a reference to data
// in a widget in the dialog - so if we call dismiss, this reference
// becomes invalid!
@ -288,7 +288,7 @@ void GPInfoDialog::onUpdate(float dt)
m_curr_time += dt;
int frameAfter = (int)(m_curr_time / 1.5f);
const std::vector<std::string> tracks = m_gp->getTrackNames();
const std::vector<std::string> tracks = m_gp.getTrackNames();
if (frameAfter >= (int)tracks.size())
{
frameAfter = 0;

Some files were not shown because too many files have changed in this diff Show More