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

Merge master

Browse Source
This commit is contained in:
Sachith Hasaranga Seneviratne 2014-08-13 12:12:51 +05:30
commit a695c197b2
106 changed files with 2784 additions and 2856 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.gitignore vendored
View File

@ -1,8 +1,5 @@
bld*/
build/
build-32/
build-64/
build-win/
build*/
cmake_build/
dependencies/
CMakeFiles/

14
CMakeLists.txt
View File

@ -30,6 +30,7 @@ endif()
if(UNIX AND NOT APPLE)
option(USE_XRANDR "Use xrandr instead of vidmode" ON)
option(USE_ASAN "Build with Leak/Address sanitizer" OFF)
endif()
set(STK_SOURCE_DIR "src")
@ -71,6 +72,13 @@ add_subdirectory("${PROJECT_SOURCE_DIR}/lib/angelscript/projects/cmake")
include_directories("${PROJECT_SOURCE_DIR}/lib/angelscript/include")
# Build the angelscript library
add_subdirectory("${PROJECT_SOURCE_DIR}/lib/angelscript/projects/cmake")
include_directories("${PROJECT_SOURCE_DIR}/lib/angelscript/include")
# Set include paths
include_directories(${STK_SOURCE_DIR})
@ -260,6 +268,11 @@ if(UNIX AND NOT APPLE)
else()
target_link_libraries(supertuxkart ${IRRLICHT_XF86VM_LIBRARY})
endif()
if(USE_ASAN)
add_definitions("-fsanitize=address")
add_definitions("-fno-omit-frame-pointer")
target_link_libraries(supertuxkart "-fsanitize=address")
endif()
endif()
if(APPLE)
@ -370,3 +383,4 @@ install(FILES data/supertuxkart.appdata DESTINATION share/appdata)
set(PREFIX ${CMAKE_INSTALL_PREFIX})
configure_file(data/supertuxkart_desktop.template supertuxkart.desktop)
add_dependencies(supertuxkart supertuxkart.desktop)
>>>>>>> 7111eb55eeced3f44df7f069652ebb627616684a

27
data/gui/custom_video_settings.stkgui
View File

@ -131,40 +131,21 @@
<spacer height="4" width="10" />
<div layout="horizontal-row" width="100%" proportion="1">
<div layout="horizontal-row" proportion="1" height="fit">
<checkbox id="ubo"/>
<spacer width="10" height="10"/>
<label text="Uniform buffer objects" 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 height="4" width="10" />
<div layout="horizontal-row" proportion="1" height="fit">
<checkbox id="hd-textures"/>
<spacer width="10" height="10"/>
<label text="Use high definition textures" I18N="Video settings"/>
</div>
<spacer height="4" width="10" />
<!--
<div layout="horizontal-row" proportion="1" height="fit">
<checkbox id="anim_gfx"/>
<spacer width="10" height="10"/>
<label text="Animated Scenery" I18N="Video settings"/>
</div>
-->
</div>
<spacer height="20" width="10" />
<div layout="horizontal-row" width="100%" proportion="1">

37
data/gui/debug_slider.stkgui
View File

@ -1,7 +1,40 @@
<?xml version="1.0" encoding="UTF-8"?>
<stkgui>
<div x="2%" y="10%" width="96%" height="80%" layout="vertical-row" >
<label id="title" width="100%"/>
<gauge id="value_slider" min_value="0" max_value="100" width="100%" />
<div proportion="1" width="100%" layout="horizontal-row">
<label id="Red" text="Red"/>
<spacer width="25"/>
<gauge id="red_slider" min_value="0" max_value="100" proportion="1"/>
</div>
<div proportion="1" width="100%" layout="horizontal-row">
<label id="Green" text="Green"/>
<spacer width="25"/>
<gauge id="green_slider" min_value="0" max_value="100" proportion="1"/>
</div>
<div proportion="1" width="100%" layout="horizontal-row">
<label id="Blue" text="Blue"/>
<spacer width="25"/>
<gauge id="blue_slider" min_value="0" max_value="100" proportion="1"/>
</div>
<div proportion="1" width="100%" layout="horizontal-row">
<label id="SSAO radius" text="SSAO Radius"/>
<spacer width="50"/>
<gauge id="ssao_radius" min_value="0" max_value="100" proportion="1" />
</div>
<div proportion="1" width="100%" layout="horizontal-row">
<label id="SSAO k" text="SSAO K"/>
<spacer width="25"/>
<gauge id="ssao_k" min_value="0" max_value="100" proportion="1"/>
</div>
<div proportion="1" width="100%" layout="horizontal-row">
<label id="SSAO Sigma" text="SSAO sigma"/>
<spacer width="50"/>
<gauge id="ssao_sigma" min_value="0" max_value="100" proportion="1"/>
</div>
</div>
</stkgui>

2
data/gui/user_screen.stkgui
View File

@ -54,6 +54,8 @@
I18N="Login dialog" text="Add user" label_location="bottom"/>
<icon-button id="delete" width="64" height="64" icon="gui/gp_remove_track.png"
I18N="Login dialog" text="Delete" label_location="bottom"/>
<icon-button id="recover" width="64" height="64" icon="gui/main_options.png"
I18N="Login dialog" text="Recovery" label_location="bottom"/>
<icon-button id="rename" width="64" height="64" icon="gui/gp_rename.png"
I18N="Login dialog" text="Rename" label_location="bottom"/>
<icon-button id="cancel" width="64" height="64" icon="gui/main_quit.png"

11
data/shaders/billboard.vert
View File

@ -2,16 +2,15 @@ uniform mat4 ModelViewMatrix;
uniform vec3 Position;
uniform vec2 Size;
#if __VERSION__ >= 130
#if __VERSION__ >= 330
layout(location = 0) in vec2 Corner;
layout(location = 3) in vec2 Texcoord;
#else
in vec2 Corner;
in vec2 Texcoord;
out vec2 uv;
#else
attribute vec2 Corner;
attribute vec2 Texcoord;
varying vec2 uv;
#endif
out vec2 uv;
void main(void)
{

22
data/shaders/normal_visualizer.geom Normal file
View File

@ -0,0 +1,22 @@
layout(triangles) in;
layout(line_strip, max_vertices = 6) out;
in vec3 nor[];
void main()
{
for(int i=0; i < gl_in.length(); i++)
{
vec4 pos = gl_in[i].gl_Position;
gl_Position = pos;
EmitVertex();
vec3 normal = normalize(nor[i]);
pos = inverse(ProjectionMatrix) * pos;
pos /= pos.w;
gl_Position = ProjectionMatrix * (pos + .2 * vec4(normal, 0.));
EmitVertex();
EndPrimitive();
}
}

14
data/shaders/object_unlit.frag
View File

@ -1,17 +1,13 @@
uniform sampler2D tex;
#if __VERSION__ >= 130
in vec2 uv;
in vec4 color;
out vec4 FragColor;
#else
varying vec2 uv;
#define FragColor gl_FragColor
#endif
void main(void)
{
vec4 color = texture(tex, uv);
if (color.a < 0.5) discard;
FragColor = vec4(color.xyz, 1.);
vec4 col = texture(tex, uv);
col.xyz *= pow(color.xyz, vec3(2.2));
if (col.a < 0.5) discard;
FragColor = vec4(col.xyz, 1.);
}

13
data/shaders/objectref_pass2.frag
View File

@ -1,19 +1,16 @@
uniform sampler2D Albedo;
#if __VERSION__ >= 130
in vec2 uv;
in vec4 color;
out vec4 FragColor;
#else
varying vec2 uv;
#define FragColor gl_FragColor
#endif
vec3 getLightFactor(float specMapValue);
void main(void)
{
vec4 color = texture(Albedo, uv);
if (color.a < 0.5) discard;
vec4 col = texture(Albedo, uv);
col.xyz *= pow(color.xyz, vec3(2.2));
if (col.a * color.a < 0.5) discard;
vec3 LightFactor = getLightFactor(1.);
FragColor = vec4(color.xyz * LightFactor, 1.);
FragColor = vec4(col.xyz * LightFactor, 1.);
}

4
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 = texture(dtex, uv).z;
float depth = texture(dtex, uv).x;
vec4 RSMPos = inverse(RSMMatrix) * (2. * vec4(uv, depth, 1.) - 1.);
RSMPos /= RSMPos.w;
vec3 RSMAlbedo = texture(ctex, uv).xyz;
@ -74,7 +74,7 @@ void main(void)
float dist = distance(SamplePos, RSMPos.xyz) / R_wcs;
// Determine the incident direction.
// Avoid very close samples (and numerical instability problems)
vec3 RSM_to_RH_dir = (dist <= 0.00) ? vec3(0.) : normalize(SamplePos - RSMPos.xyz);
vec3 RSM_to_RH_dir = (dist <= 0.1) ? vec3(0.) : normalize(SamplePos - RSMPos.xyz);
float dotprod = max(dot(RSM_to_RH_dir, normal.xyz), 0.);
float factor = dotprod / (0.1 + dist * dist);

2
data/shaders/rhdebug.frag
View File

@ -10,5 +10,5 @@ void main()
float r = texture(SHR, uvw).w;
float g = texture(SHG, uvw).w;
float b = texture(SHB, uvw).w;
FragColor = max(vec4(r, g, b, 1.0), vec4(0.));
FragColor = max(10. * vec4(r, g, b, 1.0), vec4(0.));
}

2
data/shaders/rhdebug.vert
View File

@ -15,6 +15,6 @@ void main(void)
uvw = vec3(gx, gy, gz) / vec3(resolution);
vec3 WorldPos = (2. * uvw - 1.) * extents;
gl_Position = ProjectionMatrix * ViewMatrix * RHMatrix * vec4(WorldPos, 1.);
gl_PointSize = 100. / gl_Position.w;
gl_PointSize = 500. / gl_Position.w;
}

1
data/shaders/rsm.frag
View File

@ -8,6 +8,7 @@ layout (location = 1) out vec3 RSMNormals;
void main()
{
if (texture(tex, uv).a < .5) discard;
RSMColor = texture(tex, uv).xyz * color.rgb;
RSMNormals = .5 * normalize(nor) + .5;
}

9
data/shaders/rsm.vert
View File

@ -1,5 +1,4 @@
uniform mat4 ModelMatrix;
uniform mat4 InverseModelMatrix;
uniform mat4 RSMMatrix;
uniform mat4 TextureMatrix =
@ -13,24 +12,28 @@ layout(location = 0) in vec3 Position;
layout(location = 1) in vec3 Normal;
layout(location = 2) in vec4 Color;
layout(location = 3) in vec2 Texcoord;
layout(location = 4) in vec2 SecondTexcoord;
#else
in vec3 Position;
in vec3 Normal;
in vec4 Color;
in vec2 Texcoord;
in vec2 SecondTexcoord;
#endif
out vec3 nor;
out vec2 uv;
out vec2 uv_bis;
out vec4 color;
void main(void)
{
mat4 ModelViewProjectionMatrix = RSMMatrix * ModelMatrix;
mat4 TransposeInverseModel = transpose(InverseModelMatrix);
mat4 TransposeInverseModel = transpose(inverse(ModelMatrix));
gl_Position = ModelViewProjectionMatrix * vec4(Position, 1.);
nor = (vec4(Normal, 0.)).xyz;
nor = (TransposeInverseModel * vec4(Normal, 0.)).xyz;
uv = (TextureMatrix * vec4(Texcoord, 1., 1.)).xy;
uv_bis = SecondTexcoord;
color = Color.zyxw;
}

17
data/shaders/screenquad.vert
View File

@ -1,14 +1,15 @@
#if __VERSION__ >= 330
layout(location = 0) in vec2 Position;
layout(location = 3) in vec2 Texcoord;
#else
in vec2 Position;
in vec2 Texcoord;
#if __VERSION__ >= 130
out vec2 uv;
#else
varying vec2 uv;
#endif
out vec2 uv;
void main() {
uv = Texcoord;
gl_Position = vec4(Position, 0., 1.);
void main()
{
uv = Texcoord;
gl_Position = vec4(Position, 0., 1.);
}

36
data/shaders/splatting.frag
View File

@ -3,10 +3,6 @@ uniform sampler2D tex_detail0;
uniform sampler2D tex_detail1;
uniform sampler2D tex_detail2;
uniform sampler2D tex_detail3;
uniform sampler2D DiffuseMap;
uniform sampler2D SpecularMap;
uniform sampler2D SSAO;
uniform vec3 ambient;
#if __VERSION__ >= 130
in vec2 uv;
@ -18,26 +14,22 @@ varying vec2 uv_bis;
#define FragColor gl_FragColor
#endif
vec3 getLightFactor(float specMapValue);
void main() {
// Splatting part
vec4 splatting = texture(tex_layout, uv_bis);
vec4 detail0 = texture(tex_detail0, uv);
vec4 detail1 = texture(tex_detail1, uv);
vec4 detail2 = texture(tex_detail2, uv);
vec4 detail3 = texture(tex_detail3, uv);
vec4 detail4 = vec4(0.0);
// Splatting part
vec4 splatting = texture(tex_layout, uv_bis);
vec4 detail0 = texture(tex_detail0, uv);
vec4 detail1 = texture(tex_detail1, uv);
vec4 detail2 = texture(tex_detail2, uv);
vec4 detail3 = texture(tex_detail3, uv);
vec4 detail4 = vec4(0.0);
vec4 splatted = splatting.r * detail0 +
splatting.g * detail1 +
splatting.b * detail2 +
max(0., (1.0 - splatting.r - splatting.g - splatting.b)) * detail3;
vec4 splatted = splatting.r * detail0 +
splatting.g * detail1 +
splatting.b * detail2 +
max(0., (1.0 - splatting.r - splatting.g - splatting.b)) * detail3;
vec2 tc = gl_FragCoord.xy / screen;
vec3 DiffuseComponent = texture(DiffuseMap, tc).xyz;
vec3 SpecularComponent = texture(SpecularMap, tc).xyz;
float ao = texture(SSAO, tc).x;
vec3 LightFactor = ao * ambient + DiffuseComponent + SpecularComponent;
FragColor = vec4(splatted.xyz * LightFactor, 1.);
vec3 LightFactor = getLightFactor(1.);
FragColor = vec4(splatted.xyz * LightFactor, 1.);
}

27
data/shaders/splatting_rsm.frag Normal file
View File

@ -0,0 +1,27 @@
uniform sampler2D tex_layout;
uniform sampler2D tex_detail0;
uniform sampler2D tex_detail1;
uniform sampler2D tex_detail2;
uniform sampler2D tex_detail3;
in vec2 uv;
in vec2 uv_bis;
in vec3 nor;
layout (location = 0) out vec3 RSMColor;
layout (location = 1) out vec3 RSMNormals;
void main()
{
vec4 splatting = texture(tex_layout, uv_bis);
vec4 detail0 = texture(tex_detail0, uv);
vec4 detail1 = texture(tex_detail1, uv);
vec4 detail2 = texture(tex_detail2, uv);
vec4 detail3 = texture(tex_detail3, uv);
vec4 splatted = splatting.r * detail0 +
splatting.g * detail1 +
splatting.b * detail2 +
max(0., (1.0 - splatting.r - splatting.g - splatting.b)) * detail3;
RSMColor = splatted.rgb;
RSMNormals = .5 * normalize(nor) + .5;
}

7
data/shaders/ssao.frag
View File

@ -2,15 +2,14 @@
// and improvements here http://graphics.cs.williams.edu/papers/SAOHPG12/
uniform sampler2D dtex;
uniform vec4 samplePoints[16];
uniform float radius = 1.;
uniform float k = 1.5;
uniform float sigma = 1.;
out float AO;
const float sigma = 1.;
const float tau = 7.;
const float beta = 0.002;
const float epsilon = .00001;
const float radius = 1.;
const float k = 1.5;
#define SAMPLES 16

58
data/shaders/sunlightshadowdebug.frag
View File

@ -1,58 +0,0 @@
uniform sampler2D ntex;
uniform sampler2D dtex;
uniform sampler2DArrayShadow shadowtex;
uniform vec3 direction;
uniform vec3 col;
in vec2 uv;
out vec4 Diff;
out vec4 Spec;
vec3 DecodeNormal(vec2 n);
vec3 getSpecular(vec3 normal, vec3 eyedir, vec3 lightdir, vec3 color, float roughness);
vec3 getShadowFactor(vec3 pos)
{
vec3 cascadeColor[] = vec3[](
vec3(1., 0., 0.),
vec3(0., 1., 0.),
vec3(0., 0., 1.),
vec3(1., 1., 1.)
);
for (int i = 0; i < 4; i++)
{
vec4 shadowcoord = (ShadowViewProjMatrixes[i] * vec4(pos, 1.0));
shadowcoord /= shadowcoord.w;
vec2 shadowtexcoord = shadowcoord.xy * 0.5 + 0.5;
if (shadowtexcoord.x < 0. || shadowtexcoord.x > 1. || shadowtexcoord.y < 0. || shadowtexcoord.y > 1.)
continue;
return cascadeColor[i] * texture(shadowtex, vec4(shadowtexcoord, float(i), 0.5 * shadowcoord.z + 0.5));
}
return vec3(1.);
}
void main() {
float z = texture(dtex, uv).x;
vec4 xpos = 2.0 * vec4(uv, z, 1.0) - 1.0;
xpos = InverseViewMatrix * InverseProjectionMatrix * xpos;
xpos.xyz /= xpos.w;
vec3 norm = normalize(DecodeNormal(2. * texture(ntex, uv).xy - 1.));
float roughness =texture(ntex, uv).z;
vec3 eyedir = -normalize(xpos.xyz);
// Normalized on the cpu
vec3 L = direction;
float NdotL = max(0., dot(norm, L));
vec3 Specular = getSpecular(norm, eyedir, L, col, roughness) * NdotL;
vec3 outcol = NdotL * col;
// Shadows
vec3 factor = getShadowFactor(xpos.xyz);
Diff = vec4(factor * NdotL * col, 1.);
Spec = vec4(factor * Specular, 1.);
return;
}

31
data/stk_config.xml
View File

@ -341,7 +341,7 @@
exp-string-response: dampen the suspension spring reaction
exponentially.
max-force: Maximum suspension force -->
<suspension stiffness="248" rest="0.2" travel-cm="19"
<suspension stiffness="140" rest="0.3" travel-cm="29"
exp-spring-response="false" max-force="12000"/>
<!-- Wheel related parameters: damping-relaxation/compression: for
@ -350,7 +350,7 @@
position of the physics raycast wheels relative to the center of
gravity. Default is to use the corners of the chassis to attach
the wheels to. -->
<wheels damping-relaxation="20" damping-compression="4.4" radius="0.25">
<wheels damping-relaxation="35" damping-compression="5" radius="0.25">
<front-right position="0.38 0 0.6" />
<front-left position="-0.38 0 0.6" />
<rear-right position="0.38 0 -0.6" />
@ -373,12 +373,15 @@
track-connection-accel: An artificial force that pulls a wheel to
the ground if its off ground. Reduces the affect if a kart loses
contact with the ground (i.e. it then can't steer or accelerate
anymore). -->
<stability roll-influence="0.03"
anymore).
smooth-flying-impulse: apply a torque impulse to flying kart to keep
them parallel to the ground.-->
<stability roll-influence="0.3"
chassis-linear-damping="0.2"
chassis-angular-damping="0"
downward-impulse-factor="0"
track-connection-accel="2"/>
track-connection-accel="2"
smooth-flying-impulse="25"/>
<!-- collision
impulse-type: STK can apply an additional impulse in case of
@ -408,10 +411,15 @@
(1-bevelY). A value of 0 for all bevel coordinates disables
bevelling, and uses a simple box shape.
As an example, a value of 1 for x and z will result in a
sharp 'arrow' like shape. -->
sharp 'arrow' like shape.
physical-wheel-position: Defines where the 'physical' (raycast)
wheel will be located. It's a weight factor with 0 = being
at the widest side of the bevel, 1 = at the front and
narrowest part of the kart. -->
<collision impulse-type="normal"
impulse="3000" impulse-time="0.1" terrain-impulse="8000"
restitution="1.0" bevel-factor="0.5 0.0 0.5" />
restitution="1.0" bevel-factor="0.5 0.0 0.7"
physical-wheel-position="0.5" />
<!-- If a kart starts within the specified time after 'go',
it receives the corresponding bonus from 'boost'. Those
@ -568,9 +576,14 @@
<!-- Speed and acceleration related values: power and max-speed (in m/s)
have 3 values, one for low, medium, and hard.
brake-factor: Value used when braking. max-speed-reverse-ratio is
the percentage of max speed for reverse gear. -->
brake-factor: Value used when braking.
brake-time-increase: The brake force is multiplied by
(1+brake_time*brake_time_increase - i.e. the longer the brake was
pressed, the harder the kart will brake.
max-speed-reverse-ratio is the percentage of max speed for reverse gear.
-->
<engine power="450 475 500 510" max-speed="17 21 23 25" brake-factor="11.0"
brake-time-increase="6"
max-speed-reverse-ratio="0.3"/>
<!-- Simulated gears: switch-ratio defines at what ratio of the maximum

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

@ -345,6 +345,7 @@ bool CIrrDeviceLinux::switchToFullscreen(bool reset)
XRROutputInfo* output = XRRGetOutputInfo(display, res, output_id);
XRRCrtcInfo* crtc = XRRGetCrtcInfo(display, res, output->crtc);
float refresh_rate, refresh_rate_new;
unsigned int mode0_width = -1, mode0_height = -1;
for (int i = 0; i < res->nmode; i++)
{
@ -361,6 +362,12 @@ bool CIrrDeviceLinux::switchToFullscreen(bool reset)
w = mode->width;
h = mode->height;
}
if (bestMode == -1 && mode->id == output->modes[0])
{
mode0_width = w;
mode0_height = h;
}
if (bestMode == -1 && w == Width && h == Height)
{
@ -397,6 +404,8 @@ bool CIrrDeviceLinux::switchToFullscreen(bool reset)
if (bestMode == -1)
{
bestMode = 0;
Width = mode0_width;
Height = mode0_height;
}
Status s = XRRSetCrtcConfig(display, res, output->crtc, CurrentTime,

3
src/addons/news_manager.cpp
View File

@ -138,6 +138,7 @@ void* NewsManager::downloadNews(void *obj)
HTTPRequest *download_req = new HTTPRequest("news.xml");
download_req->setAddonsURL("news.xml");
// Initialise the online portion of the addons manager.
if(UserConfigParams::logAddons())
Log::info("addons", "Downloading news.");
@ -150,10 +151,12 @@ void* NewsManager::downloadNews(void *obj)
// that a redirect went wrong, or a wrong/incorrect
// address somehow made its way into the config file.
delete download_req;
// We need a new object, since the state of the old
// download request is now done.
download_req = new HTTPRequest("news.xml");
UserConfigParams::m_server_addons.revertToDefaults();
// make sure the new server address is actually used
download_req->setAddonsURL("news.xml");
download_req->executeNow();

4
src/challenges/challenge_data.hpp
View File

@ -42,8 +42,8 @@ public:
UNLOCK_GP,
UNLOCK_MODE,
UNLOCK_KART,
UNLOCK_DIFFICULTY}
;
UNLOCK_DIFFICULTY
};
// ------------------------------------------------------------------------
class UnlockableFeature
{

4
src/config/player_manager.hpp
View File

@ -156,8 +156,4 @@ public:
} // increaseAchievement
// ------------------------------------------------------------------------
}; // PlayerManager
#endif
/*EOF*/

2
src/config/player_profile.hpp
View File

@ -127,7 +127,7 @@ public:
/** Abstract virtual classes, to be implemented by the OnlinePlayer. */
virtual void setUserDetails(Online::HTTPRequest *request,
const std::string &action,
const std::string &php_script = "") const = 0;
const std::string &url_path = "") const = 0;
virtual uint32_t getOnlineId() const = 0;
virtual PlayerProfile::OnlineState getOnlineState() const = 0;
virtual Online::OnlineProfile* getProfile() const = 0;

9
src/config/user_config.hpp
View File

@ -446,9 +446,6 @@ namespace UserConfigParams
PARAM_PREFIX BoolUserConfigParam m_high_definition_textures
PARAM_DEFAULT(BoolUserConfigParam(true, "enable_high_definition_textures",
&m_video_group, "Enable high definition textures"));
PARAM_PREFIX BoolUserConfigParam m_ubo_disabled
PARAM_DEFAULT(BoolUserConfigParam(false, "disable_ubo_support",
&m_video_group, "Disable UBO support"));
PARAM_PREFIX BoolUserConfigParam m_glow
PARAM_DEFAULT(BoolUserConfigParam(false, "enable_glow",
&m_video_group, "Enable Glow"));
@ -697,6 +694,12 @@ namespace UserConfigParams
&m_online_group,
"The server used for online multiplayer."));
PARAM_PREFIX IntUserConfigParam m_server_version
PARAM_DEFAULT( IntUserConfigParam( 1,
"server-version",
&m_online_group,
"Version of the server API to use."));
// ---- Addon server related entries
PARAM_PREFIX GroupUserConfigParam m_addon_group
PARAM_DEFAULT( GroupUserConfigParam("AddonAndNews",

2
src/graphics/callbacks.cpp
View File

@ -220,7 +220,7 @@ void SunLightProvider::OnSetConstants(IMaterialRendererServices *srv, int)
m_wind[1] += winddir.Z;
srv->setVertexShaderConstant("wind", m_wind, 2);
if (UserConfigParams::m_shadows && !UserConfigParams::m_ubo_disabled)
if (UserConfigParams::m_shadows)
{
srv->setVertexShaderConstant("shadowmat", m_shadowmat.pointer(), 16);
}

1
src/graphics/camera.cpp
View File

@ -669,7 +669,6 @@ void Camera::activate()
{
irr::scene::ISceneManager *sm = irr_driver->getSceneManager();
sm->setActiveCamera(m_camera);
sm->setAmbientLight(m_ambient_light);
irr_driver->getVideoDriver()->setViewPort(m_viewport);
} // activate

2
src/graphics/glwrap.cpp
View File

@ -274,7 +274,7 @@ GLuint LoadShader(const char * file, unsigned type)
std::string Code = versionString;
std::ifstream Stream(file, std::ios::in);
Code += "//" + std::string(file) + "\n";
if (UserConfigParams::m_ubo_disabled)
if (irr_driver->needUBOWorkaround())
Code += "#define UBO_DISABLED\n";
if (irr_driver->hasVSLayerExtension())
Code += "#define VSLayer\n";

66
src/graphics/irr_driver.cpp
View File

@ -335,8 +335,24 @@ void IrrDriver::initDevice()
{
Log::warn("irr_driver", "The window size specified in "
"user config is larger than your screen!");
UserConfigParams::m_width = 800;
UserConfigParams::m_height = 600;
UserConfigParams::m_width = (int)ssize.Width;
UserConfigParams::m_height = (int)ssize.Height;
}
core::dimension2d<u32> res = core::dimension2du(UserConfigParams::m_width, UserConfigParams::m_height);
res = m_device->getVideoModeList()->getVideoModeResolution(res, res);
if (res.Width > 0 && res.Height > 0)
{
UserConfigParams::m_width = res.Width;
UserConfigParams::m_height = res.Height;
}
else
{
Log::verbose("irr_driver", "Cannot get information about "
"resolutions. Try to use the default one.");
UserConfigParams::m_width = MIN_SUPPORTED_WIDTH;
UserConfigParams::m_height = MIN_SUPPORTED_HEIGHT;
}
m_device->closeDevice();
@ -398,17 +414,18 @@ void IrrDriver::initDevice()
}
*/
m_device = createDeviceEx(params);
if(m_device)
break;
} // for bits=32, 24, 16
// if still no device, try with a standard 800x600 window size, maybe
// if still no device, try with a default screen size, maybe
// size is the problem
if(!m_device)
{
UserConfigParams::m_width = 800;
UserConfigParams::m_height = 600;
UserConfigParams::m_width = MIN_SUPPORTED_WIDTH;
UserConfigParams::m_height = MIN_SUPPORTED_HEIGHT;
m_device = createDevice(video::EDT_OPENGL,
core::dimension2du(UserConfigParams::m_width,
@ -447,6 +464,13 @@ void IrrDriver::initDevice()
Log::info("IrrDriver", "OpenGL vendor: %s", glGetString(GL_VENDOR));
Log::info("IrrDriver", "OpenGL renderer: %s", glGetString(GL_RENDERER));
Log::info("IrrDriver", "OpenGL version string: %s", glGetString(GL_VERSION));
m_need_ubo_workaround = false;
#ifdef WIN32
// Fix for Intel Sandy Bridge on Windows which supports GL up to 3.1 only
if (strstr((const char *)glGetString(GL_VENDOR), "Intel") != nullptr && (GLMajorVersion == 3 && GLMinorVersion == 1))
m_need_ubo_workaround = true;
#endif
}
m_glsl = (GLMajorVersion > 3 || (GLMajorVersion == 3 && GLMinorVersion >= 1));
@ -865,12 +889,20 @@ void IrrDriver::setAllMaterialFlags(scene::IMesh *mesh) const
{
scene::IMeshBuffer *mb = mesh->getMeshBuffer(i);
video::SMaterial &irr_material=mb->getMaterial();
for(unsigned int j=0; j<video::MATERIAL_MAX_TEXTURES; j++)
{
video::ITexture* t=irr_material.getTexture(j);
if(t) material_manager->setAllMaterialFlags(t, mb);
video::ITexture* t=irr_material.getTexture(0);
if(t) material_manager->setAllMaterialFlags(t, mb);
// special case : for splatting, the main material is on layer 1.
// it was done this way to provide a fallback for computers
// where shaders are not supported
t = irr_material.getTexture(1);
if (t)
{
Material* mat = material_manager->getMaterialFor(t, mb);
if (mat != NULL && mat->getShaderType() == Material::SHADERTYPE_SPLATTING)
material_manager->setAllMaterialFlags(t, mb);
}
} // for j<MATERIAL_MAX_TEXTURES
material_manager->setAllUntexturedMaterialFlags(mb);
} // for i<getMeshBufferCount()
} // setAllMaterialFlags
@ -1201,6 +1233,7 @@ scene::ISceneNode *IrrDriver::addSkyBox(const std::vector<video::ITexture*> &tex
SkyboxTextures = texture;
SphericalHarmonicsTextures = sphericalHarmonics;
SkyboxCubeMap = 0;
m_SH_dirty = true;
return m_scene_manager->addSkyBoxSceneNode(texture[0], texture[1],
texture[2], texture[3],
texture[4], texture[5]);
@ -1210,6 +1243,7 @@ void IrrDriver::suppressSkyBox()
{
SkyboxTextures.clear();
SphericalHarmonicsTextures.clear();
m_SH_dirty = true;
if ((SkyboxCubeMap) && (!ProfileWorld::isNoGraphics()))
glDeleteTextures(1, &SkyboxCubeMap);
SkyboxCubeMap = 0;
@ -1587,11 +1621,17 @@ void IrrDriver::onUnloadWorld()
/** Sets the ambient light.
* \param light The colour of the light to set.
*/
void IrrDriver::setAmbientLight(const video::SColor &light)
void IrrDriver::setAmbientLight(const video::SColorf &light)
{
m_scene_manager->setAmbientLight(light);
m_SH_dirty = true;
} // setAmbientLight
video::SColorf IrrDriver::getAmbientLight() const
{
return m_scene_manager->getAmbientLight();
}
// ----------------------------------------------------------------------------
/** Displays the FPS on the screen.
*/
@ -1679,7 +1719,7 @@ void IrrDriver::displayFPS()
core::stringw fpsString = buffer;
static video::SColor fpsColor = video::SColor(255, 0, 0, 0);
font->draw( fpsString.c_str(), core::rect< s32 >(100,0,400,50), fpsColor, false );
} // updateFPS
@ -2307,7 +2347,7 @@ void IrrDriver::applyObjectPassShader(scene::ISceneNode * const node, bool rimli
// viamb = (dynamic_cast<scene::IMeshSceneNode*>(node))->isReadOnlyMaterials();
// mesh = (dynamic_cast<scene::IMeshSceneNode*>(node))->getMesh();
//}
for (i = 0; i < mcount; i++)
{
video::SMaterial &nodemat = node->getMaterial(i);

69
src/graphics/irr_driver.hpp
View File

@ -196,6 +196,7 @@ class IrrDriver : public IEventReceiver, public NoCopy
private:
int GLMajorVersion, GLMinorVersion;
bool hasVSLayer;
bool m_need_ubo_workaround;
/** The irrlicht device. */
IrrlichtDevice *m_device;
/** Irrlicht scene manager. */
@ -212,14 +213,13 @@ private:
Shaders *m_shaders;
/** Wind. */
Wind *m_wind;
float m_exposure;
float m_lwhite;
/** RTTs. */
RTT *m_rtts;
std::vector<core::matrix4> sun_ortho_matrix;
core::vector3df rh_extend;
core::matrix4 rh_matrix;
core::matrix4 rsm_matrix;
core::vector2df m_current_screen_size;
/** Additional details to be shown in case that a texture is not found.
* This is used to specify details like: "while loading kart '...'" */
@ -233,6 +233,7 @@ private:
std::vector<video::ITexture *> SkyboxTextures;
std::vector<video::ITexture *> SphericalHarmonicsTextures;
bool m_SH_dirty;
float blueSHCoeff[9];
float greenSHCoeff[9];
@ -278,30 +279,17 @@ public:
return 120;
}
bool needUBOWorkaround() const
{
return m_need_ubo_workaround;
}
bool hasVSLayerExtension() const
{
return hasVSLayer;
}
float getExposure() const
{
return m_exposure;
}
void setExposure(float v)
{
m_exposure = v;
}
float getLwhite() const
{
return m_lwhite;
}
void setLwhite(float v)
{
m_lwhite = v;
}
video::SColorf getAmbientLight() const;
struct GlowData {
scene::ISceneNode * node;
@ -356,6 +344,10 @@ private:
STKRenderingPass m_phase;
float m_ssao_radius;
float m_ssao_k;
float m_ssao_sigma;
#ifdef DEBUG
/** Used to visualise skeletons. */
std::vector<irr::scene::IAnimatedMeshSceneNode*> m_debug_meshes;
@ -370,6 +362,7 @@ private:
void renderGLSL(float dt);
void renderSolidFirstPass();
void renderSolidSecondPass();
void renderNormalsVisualisation();
void renderTransparent();
void renderParticles();
void computeSunVisibility();
@ -385,6 +378,7 @@ public:
void initDevice();
void reset();
void generateSkyboxCubemap();
void generateDiffuseCoefficients();
void renderSkybox(const scene::ICameraSceneNode *camera);
void setPhase(STKRenderingPass);
STKRenderingPass getPhase() const;
@ -402,7 +396,7 @@ public:
const std::string& mask_path);
void displayFPS();
bool OnEvent(const irr::SEvent &event);
void setAmbientLight(const video::SColor &light);
void setAmbientLight(const video::SColorf &light);
std::string generateSmallerTextures(const std::string& dir);
std::string getSmallerTexture(const std::string& texture);
video::ITexture *getTexture(FileManager::AssetType type,
@ -688,6 +682,37 @@ public:
const core::matrix4 & getPreviousPVMatrix() { return m_previousProjViewMatrix; }
const core::matrix4 &getProjViewMatrix() const { return m_ProjViewMatrix; }
const core::matrix4 &getInvProjViewMatrix() const { return m_InvProjViewMatrix; }
const core::vector2df &getCurrentScreenSize() const { return m_current_screen_size; }
// ------------------------------------------------------------------------
float getSSAORadius() const
{
return m_ssao_radius;
}
void setSSAORadius(float v)
{
m_ssao_radius = v;
}
float getSSAOK() const
{
return m_ssao_k;
}
void setSSAOK(float v)
{
m_ssao_k = v;
}
float getSSAOSigma() const
{
return m_ssao_sigma;
}
void setSSAOSigma(float v)
{
m_ssao_sigma = v;
}
#ifdef DEBUG
/** Removes debug meshes. */
void clearDebugMesh() { m_debug_meshes.clear(); }

334
src/graphics/post_processing.cpp
View File

@ -204,16 +204,20 @@ void PostProcessing::update(float dt)
}
} // update
template<typename T,typename... Args>
static void DrawFullScreenEffect(Args...args)
{
glUseProgram(T::getInstance()->Program);
glBindVertexArray(SharedObject::FullScreenQuadVAO);
T::getInstance()->setUniforms(args...);
glDrawArrays(GL_TRIANGLES, 0, 3);
}
static
void renderBloom(GLuint in)
{
glUseProgram(FullScreenShader::BloomShader::Program);
glBindVertexArray(FullScreenShader::BloomShader::vao);
setTexture(0, in, GL_NEAREST, GL_NEAREST);
FullScreenShader::BloomShader::setUniforms(0);
glDrawArrays(GL_TRIANGLES, 0, 3);
setTexture(FullScreenShader::BloomShader::getInstance()->TU_tex, in, GL_NEAREST, GL_NEAREST);
DrawFullScreenEffect<FullScreenShader::BloomShader>();
}
void PostProcessing::renderDiffuseEnvMap(const float *bSHCoeff, const float *gSHCoeff, const float *rSHCoeff)
@ -224,7 +228,7 @@ void PostProcessing::renderDiffuseEnvMap(const float *bSHCoeff, const float *gSH
glBlendFunc(GL_ONE, GL_ONE);
glUseProgram(FullScreenShader::DiffuseEnvMapShader::Program);
glBindVertexArray(FullScreenShader::DiffuseEnvMapShader::vao);
glBindVertexArray(SharedObject::FullScreenQuadVAO);
setTexture(0, irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), GL_NEAREST, GL_NEAREST);
core::matrix4 TVM = irr_driver->getViewMatrix().getTransposed();
@ -238,35 +242,48 @@ void PostProcessing::renderDiffuseEnvMap(const float *bSHCoeff, const float *gSH
glDisable(GL_BLEND);
}
void PostProcessing::renderRHDebug(unsigned SHR, unsigned SHG, unsigned SHB, const core::matrix4 &rh_matrix, const core::vector3df &rh_extend)
{
glEnable(GL_PROGRAM_POINT_SIZE);
glUseProgram(FullScreenShader::RHDebug::getInstance()->Program);
glActiveTexture(GL_TEXTURE0 + FullScreenShader::RHDebug::getInstance()->TU_SHR);
glBindTexture(GL_TEXTURE_3D, SHR);
glActiveTexture(GL_TEXTURE0 + FullScreenShader::RHDebug::getInstance()->TU_SHG);
glBindTexture(GL_TEXTURE_3D, SHG);
glActiveTexture(GL_TEXTURE0 + FullScreenShader::RHDebug::getInstance()->TU_SHB);
glBindTexture(GL_TEXTURE_3D, SHB);
FullScreenShader::RHDebug::getInstance()->setUniforms(rh_matrix, rh_extend);
glDrawArrays(GL_POINTS, 0, 32 * 16 * 32);
glDisable(GL_PROGRAM_POINT_SIZE);
}
void PostProcessing::renderGI(const core::matrix4 &RHMatrix, const core::vector3df &rh_extend, GLuint shr, GLuint shg, GLuint shb)
{
core::matrix4 InvRHMatrix;
RHMatrix.getInverse(InvRHMatrix);
glDisable(GL_DEPTH_TEST);
glUseProgram(FullScreenShader::GlobalIlluminationReconstructionShader::Program);
glBindVertexArray(FullScreenShader::GlobalIlluminationReconstructionShader::vao);
glActiveTexture(GL_TEXTURE0);
glActiveTexture(GL_TEXTURE0 + FullScreenShader::GlobalIlluminationReconstructionShader::getInstance()->TU_SHR);
glBindTexture(GL_TEXTURE_3D, shr);
{
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
glActiveTexture(GL_TEXTURE1);
glActiveTexture(GL_TEXTURE0 + FullScreenShader::GlobalIlluminationReconstructionShader::getInstance()->TU_SHG);
glBindTexture(GL_TEXTURE_3D, shg);
{
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
glActiveTexture(GL_TEXTURE2);
glActiveTexture(GL_TEXTURE0 + FullScreenShader::GlobalIlluminationReconstructionShader::getInstance()->TU_SHB);
glBindTexture(GL_TEXTURE_3D, shb);
{
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
setTexture(3, irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), GL_NEAREST, GL_NEAREST);
setTexture(4, irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
FullScreenShader::GlobalIlluminationReconstructionShader::setUniforms(RHMatrix, InvRHMatrix, rh_extend, 3, 4, 0, 1, 2);
glDrawArrays(GL_TRIANGLES, 0, 3);
setTexture(FullScreenShader::GlobalIlluminationReconstructionShader::getInstance()->TU_ntex, irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), GL_NEAREST, GL_NEAREST);
setTexture(FullScreenShader::GlobalIlluminationReconstructionShader::getInstance()->TU_dtex, irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
DrawFullScreenEffect<FullScreenShader::GlobalIlluminationReconstructionShader>(RHMatrix, InvRHMatrix, rh_extend);
}
void PostProcessing::renderSunlight()
@ -278,13 +295,9 @@ void PostProcessing::renderSunlight()
glBlendFunc(GL_ONE, GL_ONE);
glBlendEquation(GL_FUNC_ADD);
glUseProgram(FullScreenShader::SunLightShader::Program);
glBindVertexArray(FullScreenShader::SunLightShader::vao);
setTexture(0, irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), GL_NEAREST, GL_NEAREST);
setTexture(1, irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
FullScreenShader::SunLightShader::setUniforms(cb->getPosition(), cb->getRed(), cb->getGreen(), cb->getBlue(), 0, 1);
glDrawArrays(GL_TRIANGLES, 0, 3);
glBindVertexArray(0);
setTexture(FullScreenShader::SunLightShader::getInstance()->TU_ntex, irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), GL_NEAREST, GL_NEAREST);
setTexture(FullScreenShader::SunLightShader::getInstance()->TU_dtex, irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
DrawFullScreenEffect<FullScreenShader::SunLightShader>(cb->getPosition(), video::SColorf(cb->getRed(), cb->getGreen(), cb->getBlue()));
}
void PostProcessing::renderShadowedSunlight(const std::vector<core::matrix4> &sun_ortho_matrix, GLuint depthtex)
@ -296,9 +309,9 @@ void PostProcessing::renderShadowedSunlight(const std::vector<core::matrix4> &su
glBlendFunc(GL_ONE, GL_ONE);
glBlendEquation(GL_FUNC_ADD);
setTexture(0, irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), GL_NEAREST, GL_NEAREST);
setTexture(1, irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
glActiveTexture(GL_TEXTURE2);
setTexture(FullScreenShader::ShadowedSunLightShader::getInstance()->TU_ntex, irr_driver->getRenderTargetTexture(RTT_NORMAL_AND_DEPTH), GL_NEAREST, GL_NEAREST);
setTexture(FullScreenShader::ShadowedSunLightShader::getInstance()->TU_dtex, irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
glActiveTexture(GL_TEXTURE0 + FullScreenShader::ShadowedSunLightShader::getInstance()->TU_shadowtex);
glBindTexture(GL_TEXTURE_2D_ARRAY, depthtex);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
@ -307,21 +320,7 @@ void PostProcessing::renderShadowedSunlight(const std::vector<core::matrix4> &su
glTexParameterf(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
glTexParameterf(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
if (irr_driver->getShadowViz())
{
glUseProgram(FullScreenShader::ShadowedSunLightDebugShader::Program);
glBindVertexArray(FullScreenShader::ShadowedSunLightDebugShader::vao);
FullScreenShader::ShadowedSunLightDebugShader::setUniforms(cb->getPosition(), cb->getRed(), cb->getGreen(), cb->getBlue(), 0, 1, 2);
}
else
{
glUseProgram(FullScreenShader::ShadowedSunLightShader::Program);
glBindVertexArray(FullScreenShader::ShadowedSunLightShader::vao);
FullScreenShader::ShadowedSunLightShader::setUniforms(cb->getPosition(), cb->getRed(), cb->getGreen(), cb->getBlue(), 0, 1, 2);
}
glDrawArrays(GL_TRIANGLES, 0, 3);
glBindVertexArray(0);
DrawFullScreenEffect<FullScreenShader::ShadowedSunLightShader>(cb->getPosition(), video::SColorf(cb->getRed(), cb->getGreen(), cb->getBlue()));
}
@ -331,31 +330,19 @@ void PostProcessing::renderGaussian3Blur(FrameBuffer &in_fbo, FrameBuffer &auxil
float inv_width = 1.0f / in_fbo.getWidth(), inv_height = 1.0f / in_fbo.getHeight();
{
auxiliary.Bind();
glUseProgram(FullScreenShader::Gaussian3VBlurShader::Program);
glBindVertexArray(FullScreenShader::Gaussian3VBlurShader::vao);
glUniform2f(FullScreenShader::Gaussian3VBlurShader::uniform_pixel, inv_width, inv_height);
setTexture(0, in_fbo.getRTT()[0], GL_LINEAR, GL_LINEAR);
setTexture(FullScreenShader::Gaussian3VBlurShader::getInstance()->TU_tex, in_fbo.getRTT()[0], GL_LINEAR, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glUniform1i(FullScreenShader::Gaussian3VBlurShader::uniform_tex, 0);
glDrawArrays(GL_TRIANGLES, 0, 3);
DrawFullScreenEffect<FullScreenShader::Gaussian3VBlurShader>(core::vector2df(inv_width, inv_height));
}
{
in_fbo.Bind();
glUseProgram(FullScreenShader::Gaussian3HBlurShader::Program);
glBindVertexArray(FullScreenShader::Gaussian3HBlurShader::vao);
glUniform2f(FullScreenShader::Gaussian3HBlurShader::uniform_pixel, inv_width, inv_height);
setTexture(0, auxiliary.getRTT()[0], GL_LINEAR, GL_LINEAR);
setTexture(FullScreenShader::Gaussian3HBlurShader::getInstance()->TU_tex, auxiliary.getRTT()[0], GL_LINEAR, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glUniform1i(FullScreenShader::Gaussian3HBlurShader::uniform_tex, 0);
glDrawArrays(GL_TRIANGLES, 0, 3);
DrawFullScreenEffect<FullScreenShader::Gaussian3HBlurShader>(core::vector2df(inv_width, inv_height));
}
}
@ -365,31 +352,19 @@ void PostProcessing::renderGaussian6Blur(FrameBuffer &in_fbo, FrameBuffer &auxil
float inv_width = 1.0f / in_fbo.getWidth(), inv_height = 1.0f / in_fbo.getHeight();
{
auxiliary.Bind();
glUseProgram(FullScreenShader::Gaussian6VBlurShader::Program);
glBindVertexArray(FullScreenShader::Gaussian6VBlurShader::vao);
glUniform2f(FullScreenShader::Gaussian6VBlurShader::uniform_pixel, inv_width, inv_height);
setTexture(0, in_fbo.getRTT()[0], GL_LINEAR, GL_LINEAR);
setTexture(FullScreenShader::Gaussian6VBlurShader::getInstance()->TU_tex, in_fbo.getRTT()[0], GL_LINEAR, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glUniform1i(FullScreenShader::Gaussian6VBlurShader::uniform_tex, 0);
glDrawArrays(GL_TRIANGLES, 0, 3);
DrawFullScreenEffect<FullScreenShader::Gaussian6VBlurShader>(core::vector2df(inv_width, inv_height));
}
{
in_fbo.Bind();
glUseProgram(FullScreenShader::Gaussian6HBlurShader::Program);
glBindVertexArray(FullScreenShader::Gaussian6HBlurShader::vao);
glUniform2f(FullScreenShader::Gaussian6HBlurShader::uniform_pixel, inv_width, inv_height);
setTexture(0, auxiliary.getRTT()[0], GL_LINEAR, GL_LINEAR);
setTexture(FullScreenShader::Gaussian6HBlurShader::getInstance()->TU_tex, auxiliary.getRTT()[0], GL_LINEAR, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glUniform1i(FullScreenShader::Gaussian6HBlurShader::uniform_tex, 0);
glDrawArrays(GL_TRIANGLES, 0, 3);
DrawFullScreenEffect<FullScreenShader::Gaussian6HBlurShader>(core::vector2df(inv_width, inv_height));
}
}
@ -403,33 +378,24 @@ void PostProcessing::renderGaussian17TapBlur(FrameBuffer &in_fbo, FrameBuffer &a
#endif
{
auxiliary.Bind();
glUseProgram(FullScreenShader::Gaussian17TapHShader::Program);
glBindVertexArray(FullScreenShader::Gaussian17TapHShader::vao);
glUniform2f(FullScreenShader::Gaussian17TapHShader::uniform_pixel, inv_width, inv_height);
setTexture(0, in_fbo.getRTT()[0], GL_LINEAR, GL_LINEAR);
setTexture(FullScreenShader::Gaussian17TapHShader::getInstance()->TU_tex, in_fbo.getRTT()[0], GL_LINEAR, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
setTexture(1, irr_driver->getFBO(FBO_LINEAR_DEPTH).getRTT()[0], GL_LINEAR, GL_LINEAR);
setTexture(FullScreenShader::Gaussian17TapHShader::getInstance()->TU_depth, irr_driver->getFBO(FBO_LINEAR_DEPTH).getRTT()[0], GL_LINEAR, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glUniform1i(FullScreenShader::Gaussian17TapHShader::uniform_tex, 0);
glUniform1i(FullScreenShader::Gaussian17TapHShader::uniform_depth, 1);
glDrawArrays(GL_TRIANGLES, 0, 3);
DrawFullScreenEffect<FullScreenShader::Gaussian17TapHShader>(core::vector2df(inv_width, inv_height));
}
#if WIN32
else
{
glUseProgram(FullScreenShader::ComputeGaussian17TapHShader::Program);
glBindImageTexture(0, in_fbo.getRTT()[0], 0, false, 0, GL_READ_ONLY, GL_R16F);
glBindImageTexture(1, irr_driver->getFBO(FBO_LINEAR_DEPTH).getRTT()[0], 1, false, 0, GL_READ_ONLY, GL_R32F);
glBindImageTexture(2, auxiliary.getRTT()[0], 0, false, 0, GL_WRITE_ONLY, GL_R16F);
glUniform1i(FullScreenShader::ComputeGaussian17TapHShader::uniform_source, 0);
glUniform1i(FullScreenShader::ComputeGaussian17TapHShader::uniform_depth, 1);
glUniform1i(FullScreenShader::ComputeGaussian17TapHShader::uniform_dest, 2);
glUseProgram(FullScreenShader::ComputeGaussian17TapHShader::getInstance()->Program);
glBindImageTexture(FullScreenShader::ComputeGaussian17TapHShader::getInstance()->TU_source, in_fbo.getRTT()[0], 0, false, 0, GL_READ_ONLY, GL_R16F);
glBindImageTexture(FullScreenShader::ComputeGaussian17TapHShader::getInstance()->TU_depth, irr_driver->getFBO(FBO_LINEAR_DEPTH).getRTT()[0], 1, false, 0, GL_READ_ONLY, GL_R32F);
glBindImageTexture(FullScreenShader::ComputeGaussian17TapHShader::getInstance()->TU_dest, auxiliary.getRTT()[0], 0, false, 0, GL_WRITE_ONLY, GL_R16F);
FullScreenShader::ComputeGaussian17TapHShader::getInstance()->setUniforms();
glDispatchCompute(in_fbo.getWidth() / 8, in_fbo.getHeight() / 8, 1);
}
#endif
@ -440,32 +406,23 @@ void PostProcessing::renderGaussian17TapBlur(FrameBuffer &in_fbo, FrameBuffer &a
#endif
{
in_fbo.Bind();
glUseProgram(FullScreenShader::Gaussian17TapVShader::Program);
glBindVertexArray(FullScreenShader::Gaussian17TapVShader::vao);
glUniform2f(FullScreenShader::Gaussian17TapVShader::uniform_pixel, inv_width, inv_height);
setTexture(0, auxiliary.getRTT()[0], GL_LINEAR, GL_LINEAR);
setTexture(FullScreenShader::Gaussian17TapVShader::getInstance()->TU_tex, auxiliary.getRTT()[0], GL_LINEAR, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
setTexture(1, irr_driver->getFBO(FBO_LINEAR_DEPTH).getRTT()[0], GL_LINEAR, GL_LINEAR);
setTexture(FullScreenShader::Gaussian17TapVShader::getInstance()->TU_depth, irr_driver->getFBO(FBO_LINEAR_DEPTH).getRTT()[0], GL_LINEAR, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glUniform1i(FullScreenShader::Gaussian17TapVShader::uniform_tex, 0);
glUniform1i(FullScreenShader::Gaussian17TapVShader::uniform_depth, 1);
glDrawArrays(GL_TRIANGLES, 0, 3);
DrawFullScreenEffect<FullScreenShader::Gaussian17TapVShader>(core::vector2df(inv_width, inv_height));
}
#if WIN32
else
{
glUseProgram(FullScreenShader::ComputeGaussian17TapVShader::Program);
glBindImageTexture(0, auxiliary.getRTT()[0], 0, false, 0, GL_READ_ONLY, GL_R16F);
glBindImageTexture(1, irr_driver->getFBO(FBO_LINEAR_DEPTH).getRTT()[0], 1, false, 0, GL_READ_ONLY, GL_R32F);
glBindImageTexture(2, in_fbo.getRTT()[0], 0, false, 0, GL_WRITE_ONLY, GL_R16F);
glUniform1i(FullScreenShader::ComputeGaussian17TapVShader::uniform_source, 0);
glUniform1i(FullScreenShader::ComputeGaussian17TapVShader::uniform_depth, 1);
glUniform1i(FullScreenShader::ComputeGaussian17TapVShader::uniform_dest, 2);
glUseProgram(FullScreenShader::ComputeGaussian17TapVShader::getInstance()->Program);
glBindImageTexture(FullScreenShader::ComputeGaussian17TapVShader::getInstance()->TU_source, auxiliary.getRTT()[0], 0, false, 0, GL_READ_ONLY, GL_R16F);
glBindImageTexture(FullScreenShader::ComputeGaussian17TapVShader::getInstance()->TU_depth, irr_driver->getFBO(FBO_LINEAR_DEPTH).getRTT()[0], 1, false, 0, GL_READ_ONLY, GL_R32F);
glBindImageTexture(FullScreenShader::ComputeGaussian17TapVShader::getInstance()->TU_dest, in_fbo.getRTT()[0], 0, false, 0, GL_WRITE_ONLY, GL_R16F);
FullScreenShader::ComputeGaussian17TapVShader::getInstance()->setUniforms();
glDispatchCompute(in_fbo.getWidth() / 8, in_fbo.getHeight() / 8, 1);
}
#endif
@ -474,48 +431,40 @@ void PostProcessing::renderGaussian17TapBlur(FrameBuffer &in_fbo, FrameBuffer &a
void PostProcessing::renderPassThrough(GLuint tex)
{
glUseProgram(FullScreenShader::PassThroughShader::getInstance()->Program);
glBindVertexArray(FullScreenShader::PassThroughShader::getInstance()->vao);
glUseProgram(FullScreenShader::PassThroughShader::Program);
glBindVertexArray(FullScreenShader::PassThroughShader::vao);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glUniform1i(FullScreenShader::PassThroughShader::uniform_texture, 0);
setTexture(FullScreenShader::PassThroughShader::getInstance()->TU_tex, tex, GL_LINEAR, GL_LINEAR);
FullScreenShader::PassThroughShader::getInstance()->setUniforms();
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
void PostProcessing::renderTextureLayer(unsigned tex, unsigned layer)
{
glUseProgram(FullScreenShader::LayerPassThroughShader::Program);
glBindVertexArray(FullScreenShader::LayerPassThroughShader::vao);
glUseProgram(FullScreenShader::LayerPassThroughShader::getInstance()->Program);
glBindVertexArray(FullScreenShader::LayerPassThroughShader::getInstance()->vao);
glActiveTexture(GL_TEXTURE0);
glActiveTexture(GL_TEXTURE0 + FullScreenShader::LayerPassThroughShader::getInstance()->TU_texture);
glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glUniform1i(FullScreenShader::LayerPassThroughShader::uniform_texture, 0);
glUniform1i(FullScreenShader::LayerPassThroughShader::uniform_layer, layer);
FullScreenShader::LayerPassThroughShader::getInstance()->setUniforms(layer);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
void PostProcessing::renderGlow(unsigned tex)
{
glUseProgram(FullScreenShader::GlowShader::getInstance()->Program);
glBindVertexArray(FullScreenShader::GlowShader::getInstance()->vao);
glUseProgram(FullScreenShader::GlowShader::Program);
glBindVertexArray(FullScreenShader::GlowShader::vao);
setTexture(0, tex, GL_LINEAR, GL_LINEAR);
glUniform1i(FullScreenShader::GlowShader::uniform_tex, 0);
setTexture(FullScreenShader::GlowShader::getInstance()->TU_tex, tex, GL_LINEAR, GL_LINEAR);
FullScreenShader::GlowShader::getInstance()->setUniforms();
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
ITexture *noise_tex = 0;
void PostProcessing::renderSSAO()
{
glDisable(GL_DEPTH_TEST);
@ -524,28 +473,14 @@ void PostProcessing::renderSSAO()
// Generate linear depth buffer
irr_driver->getFBO(FBO_LINEAR_DEPTH).Bind();
glUseProgram(FullScreenShader::LinearizeDepthShader::Program);
glBindVertexArray(FullScreenShader::LinearizeDepthShader::vao);
setTexture(0, irr_driver->getDepthStencilTexture(), GL_LINEAR, GL_LINEAR);
FullScreenShader::LinearizeDepthShader::setUniforms(irr_driver->getSceneManager()->getActiveCamera()->getNearValue(), irr_driver->getSceneManager()->getActiveCamera()->getFarValue(), 0);
glDrawArrays(GL_TRIANGLES, 0, 3);
setTexture(FullScreenShader::LinearizeDepthShader::getInstance()->TU_tex, irr_driver->getDepthStencilTexture(), GL_LINEAR, GL_LINEAR);
DrawFullScreenEffect<FullScreenShader::LinearizeDepthShader>(irr_driver->getSceneManager()->getActiveCamera()->getNearValue(), irr_driver->getSceneManager()->getActiveCamera()->getFarValue());
irr_driver->getFBO(FBO_SSAO).Bind();
if (!noise_tex)
noise_tex = irr_driver->getTexture(file_manager->getAsset("textures/noise.png").c_str());
glUseProgram(FullScreenShader::SSAOShader::Program);
glBindVertexArray(FullScreenShader::SSAOShader::vao);
setTexture(0, irr_driver->getRenderTargetTexture(RTT_LINEAR_DEPTH), GL_LINEAR, GL_LINEAR_MIPMAP_NEAREST);
setTexture(FullScreenShader::SSAOShader::getInstance()->TU_dtex, irr_driver->getRenderTargetTexture(RTT_LINEAR_DEPTH), GL_LINEAR, GL_LINEAR_MIPMAP_NEAREST);
glGenerateMipmap(GL_TEXTURE_2D);
setTexture(1, getTextureGLuint(noise_tex), GL_LINEAR, GL_LINEAR);
FullScreenShader::SSAOShader::setUniforms(core::vector2df(float(UserConfigParams::m_width),
float(UserConfigParams::m_height)),
0, 1);
glDrawArrays(GL_TRIANGLES, 0, 3);
DrawFullScreenEffect<FullScreenShader::SSAOShader>(irr_driver->getSSAORadius(), irr_driver->getSSAOK(), irr_driver->getSSAOSigma());
}
void PostProcessing::renderFog()
@ -569,16 +504,10 @@ void PostProcessing::renderFog()
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glUseProgram(FullScreenShader::FogShader::Program);
glBindVertexArray(FullScreenShader::FogShader::vao);
setTexture(0, irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
FullScreenShader::FogShader::setUniforms(fogmax, startH, endH, start, end, col, 0);
setTexture(FullScreenShader::FogShader::getInstance()->TU_tex, irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
DrawFullScreenEffect<FullScreenShader::FogShader>(fogmax, startH, endH, start, end, col);
glDrawArrays(GL_TRIANGLES, 0, 3);
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
}
@ -604,40 +533,34 @@ void PostProcessing::renderMotionBlur(unsigned cam, FrameBuffer &in_fbo, FrameBu
out_fbo.Bind();
glClear(GL_COLOR_BUFFER_BIT);
glUseProgram(FullScreenShader::MotionBlurShader::Program);
glBindVertexArray(FullScreenShader::MotionBlurShader::vao);
setTexture(0, in_fbo.getRTT()[0], GL_LINEAR, GL_LINEAR);
setTexture(FullScreenShader::MotionBlurShader::getInstance()->TU_cb, in_fbo.getRTT()[0], GL_LINEAR, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
setTexture(1, irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
FullScreenShader::MotionBlurShader
::setUniforms(cb->getBoostTime(0) * 10, // Todo : should be framerate dependent
setTexture(FullScreenShader::MotionBlurShader::getInstance()->TU_dtex, irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
DrawFullScreenEffect<FullScreenShader::MotionBlurShader>(
// Todo : use a previousPVMatrix per cam, not global
irr_driver->getPreviousPVMatrix(),
cb->getCenter(cam),
0.15f,
0, 1);
glDrawArrays(GL_TRIANGLES, 0, 3);
cb->getBoostTime(0) * 10, // Todo : should be framerate dependent
0.15f);
}
static void renderGodFade(GLuint tex, const SColor &col)
{
glUseProgram(FullScreenShader::GodFadeShader::Program);
glBindVertexArray(FullScreenShader::GodFadeShader::vao);
setTexture(0, tex, GL_LINEAR, GL_LINEAR);
FullScreenShader::GodFadeShader::setUniforms(col, 0);
glUseProgram(FullScreenShader::GodFadeShader::getInstance()->Program);
glBindVertexArray(FullScreenShader::GodFadeShader::getInstance()->vao);
setTexture(FullScreenShader::GodFadeShader::getInstance()->TU_tex, tex, GL_LINEAR, GL_LINEAR);
FullScreenShader::GodFadeShader::getInstance()->setUniforms(col);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
static void renderGodRay(GLuint tex, const core::vector2df &sunpos)
{
glUseProgram(FullScreenShader::GodRayShader::Program);
glBindVertexArray(FullScreenShader::GodRayShader::vao);
setTexture(0, tex, GL_LINEAR, GL_LINEAR);
FullScreenShader::GodRayShader::setUniforms(sunpos, 0);
glUseProgram(FullScreenShader::GodRayShader::getInstance()->Program);
glBindVertexArray(FullScreenShader::GodRayShader::getInstance()->vao);
setTexture(FullScreenShader::GodRayShader::getInstance()->TU_tex, tex, GL_LINEAR, GL_LINEAR);
FullScreenShader::GodRayShader::getInstance()->setUniforms(sunpos);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
@ -645,32 +568,16 @@ static void renderGodRay(GLuint tex, const core::vector2df &sunpos)
static void toneMap(FrameBuffer &fbo, GLuint rtt)
{
fbo.Bind();
glUseProgram(FullScreenShader::ToneMapShader::Program);
glBindVertexArray(FullScreenShader::ToneMapShader::vao);
setTexture(0, rtt, GL_NEAREST, GL_NEAREST);
setTexture(1, irr_driver->getRenderTargetTexture(RTT_LOG_LUMINANCE), GL_NEAREST, GL_NEAREST_MIPMAP_NEAREST);
FullScreenShader::ToneMapShader::setUniforms(irr_driver->getExposure(), irr_driver->getLwhite(), 0, 1);
glDrawArrays(GL_TRIANGLES, 0, 3);
setTexture(FullScreenShader::ToneMapShader::getInstance()->TU_tex, rtt, GL_NEAREST, GL_NEAREST);
DrawFullScreenEffect<FullScreenShader::ToneMapShader>();
}
static void renderDoF(FrameBuffer &fbo, GLuint rtt)
{
fbo.Bind();
glUseProgram(FullScreenShader::DepthOfFieldShader::Program);
glBindVertexArray(FullScreenShader::DepthOfFieldShader::vao);
setTexture(0, rtt, GL_LINEAR, GL_LINEAR);
setTexture(1, irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
FullScreenShader::DepthOfFieldShader::setUniforms(0, 1);
glDrawArrays(GL_TRIANGLES, 0, 3);
}
static void averageTexture(GLuint tex)
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, tex);
glGenerateMipmap(GL_TEXTURE_2D);
setTexture(FullScreenShader::DepthOfFieldShader::getInstance()->TU_tex, rtt, GL_LINEAR, GL_LINEAR);
setTexture(FullScreenShader::DepthOfFieldShader::getInstance()->TU_depth, irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
DrawFullScreenEffect<FullScreenShader::DepthOfFieldShader>();
}
void PostProcessing::applyMLAA()
@ -685,11 +592,11 @@ void PostProcessing::applyMLAA()
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
// Pass 1: color edge detection
setTexture(0, irr_driver->getRenderTargetTexture(RTT_MLAA_COLORS), GL_NEAREST, GL_NEAREST);
glUseProgram(FullScreenShader::MLAAColorEdgeDetectionSHader::Program);
FullScreenShader::MLAAColorEdgeDetectionSHader::setUniforms(PIXEL_SIZE, 0);
setTexture(FullScreenShader::MLAAColorEdgeDetectionSHader::getInstance()->TU_colorMapG, irr_driver->getRenderTargetTexture(RTT_MLAA_COLORS), GL_NEAREST, GL_NEAREST);
glUseProgram(FullScreenShader::MLAAColorEdgeDetectionSHader::getInstance()->Program);
FullScreenShader::MLAAColorEdgeDetectionSHader::getInstance()->setUniforms(PIXEL_SIZE);
glBindVertexArray(FullScreenShader::MLAAColorEdgeDetectionSHader::vao);
glBindVertexArray(FullScreenShader::MLAAColorEdgeDetectionSHader::getInstance()->vao);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glStencilFunc(GL_EQUAL, 1, ~0);
@ -699,12 +606,12 @@ void PostProcessing::applyMLAA()
irr_driver->getFBO(FBO_MLAA_BLEND).Bind();
glClear(GL_COLOR_BUFFER_BIT);
glUseProgram(FullScreenShader::MLAABlendWeightSHader::Program);
setTexture(0, irr_driver->getRenderTargetTexture(RTT_MLAA_TMP), GL_LINEAR, GL_LINEAR);
setTexture(1, getTextureGLuint(m_areamap), GL_NEAREST, GL_NEAREST);
FullScreenShader::MLAABlendWeightSHader::setUniforms(PIXEL_SIZE, 0, 1);
glUseProgram(FullScreenShader::MLAABlendWeightSHader::getInstance()->Program);
setTexture(FullScreenShader::MLAABlendWeightSHader::getInstance()->TU_edgesMap, irr_driver->getRenderTargetTexture(RTT_MLAA_TMP), GL_LINEAR, GL_LINEAR);
setTexture(FullScreenShader::MLAABlendWeightSHader::getInstance()->TU_areaMap, getTextureGLuint(m_areamap), GL_NEAREST, GL_NEAREST);
FullScreenShader::MLAABlendWeightSHader::getInstance()->setUniforms(PIXEL_SIZE);
glBindVertexArray(FullScreenShader::MLAABlendWeightSHader::vao);
glBindVertexArray(FullScreenShader::MLAABlendWeightSHader::getInstance()->vao);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// Blit in to tmp1
@ -713,12 +620,12 @@ void PostProcessing::applyMLAA()
// Pass 3: gather
irr_driver->getFBO(FBO_MLAA_COLORS).Bind();
glUseProgram(FullScreenShader::MLAAGatherSHader::Program);
setTexture(0, irr_driver->getRenderTargetTexture(RTT_MLAA_TMP), GL_NEAREST, GL_NEAREST);
setTexture(1, irr_driver->getRenderTargetTexture(RTT_MLAA_BLEND), GL_NEAREST, GL_NEAREST);
FullScreenShader::MLAAGatherSHader::setUniforms(PIXEL_SIZE, 0, 1);
glUseProgram(FullScreenShader::MLAAGatherSHader::getInstance()->Program);
setTexture(FullScreenShader::MLAAGatherSHader::getInstance()->TU_colorMap, irr_driver->getRenderTargetTexture(RTT_MLAA_TMP), GL_NEAREST, GL_NEAREST);
setTexture(FullScreenShader::MLAAGatherSHader::getInstance()->TU_blendMap, irr_driver->getRenderTargetTexture(RTT_MLAA_BLEND), GL_NEAREST, GL_NEAREST);
FullScreenShader::MLAAGatherSHader::getInstance()->setUniforms(PIXEL_SIZE);
glBindVertexArray(FullScreenShader::MLAAGatherSHader::vao);
glBindVertexArray(FullScreenShader::MLAAGatherSHader::getInstance()->vao);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// Done.
@ -846,13 +753,10 @@ FrameBuffer *PostProcessing::render(scene::ICameraSceneNode * const camnode, boo
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glBlendEquation(GL_FUNC_ADD);
setTexture(0, irr_driver->getRenderTargetTexture(RTT_BLOOM_128), GL_LINEAR, GL_LINEAR);
setTexture(1, irr_driver->getRenderTargetTexture(RTT_BLOOM_256), GL_LINEAR, GL_LINEAR);
setTexture(2, irr_driver->getRenderTargetTexture(RTT_BLOOM_512), GL_LINEAR, GL_LINEAR);
glUseProgram(FullScreenShader::BloomBlendShader::Program);
FullScreenShader::BloomBlendShader::setUniforms(0, 1, 2);
glBindVertexArray(FullScreenShader::BloomBlendShader::vao);
glDrawArrays(GL_TRIANGLES, 0, 3);
setTexture(FullScreenShader::BloomBlendShader::getInstance()->TU_tex_128, irr_driver->getRenderTargetTexture(RTT_BLOOM_128), GL_LINEAR, GL_LINEAR);
setTexture(FullScreenShader::BloomBlendShader::getInstance()->TU_tex_256, irr_driver->getRenderTargetTexture(RTT_BLOOM_256), GL_LINEAR, GL_LINEAR);
setTexture(FullScreenShader::BloomBlendShader::getInstance()->TU_tex_512, irr_driver->getRenderTargetTexture(RTT_BLOOM_512), GL_LINEAR, GL_LINEAR);
DrawFullScreenEffect<FullScreenShader::BloomBlendShader>();
glDisable(GL_BLEND);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

1
src/graphics/post_processing.hpp
View File

@ -81,6 +81,7 @@ public:
void renderFog();
void renderSSAO();
void renderDiffuseEnvMap(const float *bSHCoeff, const float *gSHCoeff, const float *rSHCoeff);
void renderRHDebug(unsigned SHR, unsigned SHG, unsigned SHB, const core::matrix4 &rh_matrix, const core::vector3df &rh_extend);
void renderGI(const core::matrix4 &RHMatrix, const core::vector3df &rh_extend, unsigned shr, unsigned shg, unsigned shb);
/** Blur the in texture */

41
src/graphics/render.cpp
View File

@ -41,6 +41,7 @@
#include "items/item_manager.hpp"
#include "modes/world.hpp"
#include "physics/physics.hpp"
#include "physics/triangle_mesh.hpp"
#include "tracks/track.hpp"
#include "utils/constants.hpp"
#include "utils/helpers.hpp"
@ -144,6 +145,9 @@ void IrrDriver::renderGLSL(float dt)
if (World::getWorld() && World::getWorld()->getTrack()->hasShadows() && !SphericalHarmonicsTextures.empty())
irr_driver->getSceneManager()->setAmbientLight(SColor(0, 0, 0, 0));
// TODO: put this outside of the rendering loop
generateDiffuseCoefficients();
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);
@ -276,7 +280,7 @@ void IrrDriver::renderScene(scene::ICameraSceneNode * const camnode, unsigned po
// To avoid wrong culling, use the largest view possible
m_scene_manager->setActiveCamera(m_suncam);
if (!m_mipviz && !m_wireframe && UserConfigParams::m_dynamic_lights &&
UserConfigParams::m_shadows && !UserConfigParams::m_ubo_disabled && hasShadow)
UserConfigParams::m_shadows && !irr_driver->needUBOWorkaround() && hasShadow)
renderShadows();
m_scene_manager->setActiveCamera(camnode);
PROFILER_POP_CPU_MARKER();
@ -315,6 +319,13 @@ void IrrDriver::renderScene(scene::ICameraSceneNode * const camnode, unsigned po
renderSolidSecondPass();
PROFILER_POP_CPU_MARKER();
if (getNormals())
{
m_rtts->getFBO(FBO_NORMAL_AND_DEPTHS).Bind();
renderNormalsVisualisation();
m_rtts->getFBO(FBO_COLORS).Bind();
}
if (UserConfigParams::m_dynamic_lights && World::getWorld() != NULL &&
World::getWorld()->isFogEnabled())
{
@ -329,18 +340,8 @@ void IrrDriver::renderScene(scene::ICameraSceneNode * const camnode, unsigned po
if (getRH())
{
glEnable(GL_PROGRAM_POINT_SIZE);
m_rtts->getFBO(FBO_COLORS).Bind();
glUseProgram(FullScreenShader::RHDebug::Program);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_3D, m_rtts->getRH().getRTT()[0]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_3D, m_rtts->getRH().getRTT()[1]);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_3D, m_rtts->getRH().getRTT()[2]);
FullScreenShader::RHDebug::setUniforms(rh_matrix, rh_extend, 0, 1, 2);
glDrawArrays(GL_POINTS, 0, 32 * 16 * 32);
glDisable(GL_PROGRAM_POINT_SIZE);
m_post_processing->renderRHDebug(m_rtts->getRH().getRTT()[0], m_rtts->getRH().getRTT()[1], m_rtts->getRH().getRTT()[2], rh_matrix, rh_extend);
}
if (getGI())
@ -380,6 +381,8 @@ void IrrDriver::renderScene(scene::ICameraSceneNode * const camnode, unsigned po
if (!UserConfigParams::m_dynamic_lights && !forceRTT)
{
glDisable(GL_FRAMEBUFFER_SRGB);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
return;
}
@ -558,6 +561,8 @@ void IrrDriver::computeCameraMatrix(scene::ICameraSceneNode * const camnode, siz
irr_driver->setViewMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW));
irr_driver->genProjViewMatrix();
m_current_screen_size = core::vector2df(float(width), float(height));
const float oldfar = camnode->getFarValue();
const float oldnear = camnode->getNearValue();
float FarValues[] =
@ -587,8 +592,12 @@ void IrrDriver::computeCameraMatrix(scene::ICameraSceneNode * const camnode, siz
if (World::getWorld() && World::getWorld()->getTrack())
{
const Vec3 *vmin, *vmax;
World::getWorld()->getTrack()->getAABB(&vmin, &vmax);
btVector3 btmin, btmax;
if (World::getWorld()->getTrack()->getPtrTriangleMesh())
{
World::getWorld()->getTrack()->getTriangleMesh().getCollisionShape().getAabb(btTransform::getIdentity(), btmin, btmax);
}
const Vec3 vmin = btmin , vmax = btmax;
// Build the 3 ortho projection (for the 3 shadow resolution levels)
for (unsigned i = 0; i < 4; i++)
@ -626,7 +635,7 @@ void IrrDriver::computeCameraMatrix(scene::ICameraSceneNode * const camnode, siz
memcpy(m_shadows_cam[i], tmp, 24 * sizeof(float));
const core::aabbox3df smallcambox = camnode->
getViewFrustum()->getBoundingBox();
core::aabbox3df trackbox(vmin->toIrrVector(), vmax->toIrrVector() -
core::aabbox3df trackbox(vmin.toIrrVector(), vmax.toIrrVector() -
core::vector3df(0, 30, 0));
// Set up a nice ortho projection that contains our camera frustum
@ -663,7 +672,7 @@ void IrrDriver::computeCameraMatrix(scene::ICameraSceneNode * const camnode, siz
}
{
core::aabbox3df trackbox(vmin->toIrrVector(), vmax->toIrrVector() -
core::aabbox3df trackbox(vmin.toIrrVector(), vmax.toIrrVector() -
core::vector3df(0, 30, 0));
if (trackbox.MinEdge.X != trackbox.MaxEdge.X &&
trackbox.MinEdge.Y != trackbox.MaxEdge.Y &&

437
src/graphics/render_geometry.cpp
View File

@ -78,18 +78,6 @@ namespace RenderGeometry
}
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)
@ -103,33 +91,6 @@ void draw(const T *Shader, const GLMesh *mesh, uniforms... 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 STK::Tuple<TupleTypes...> &t, Args... args)
{
unroll_args_instance<N - 1>::template exec<T>(Shader, t, STK::tuple_get<N - 1>(t), args...);
}
};
template<>
struct unroll_args_instance<0>
{
template<typename T, typename ...TupleTypes, typename ...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 STK::Tuple<TupleType...> &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<int...List>
struct custom_unroll_args;
@ -155,13 +116,13 @@ struct custom_unroll_args<N, List...>
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)
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++)
for (unsigned i = 0; i < meshes->size(); i++)
{
GLMesh &mesh = *(STK::tuple_get<0>(meshes[i]));
GLMesh &mesh = *(STK::tuple_get<0>(meshes->at(i)));
for (unsigned j = 0; j < TexUnits.size(); j++)
{
if (!mesh.textures[j])
@ -176,7 +137,57 @@ void renderMeshes1stPass(const std::vector<TexUnit> &TexUnits, std::vector<STK::
#endif
continue;
}
custom_unroll_args<List...>::template exec(Shader::getInstance(), meshes[i]);
custom_unroll_args<List...>::template exec(Shader::getInstance(), meshes->at(i));
}
}
template<int...List>
struct instanced_custom_unroll_args;
template<>
struct instanced_custom_unroll_args<>
{
template<typename T, typename ...TupleTypes, typename ...Args>
static void exec(const T *Shader, const STK::Tuple<TupleTypes...> &t, Args... args)
{
const GLMesh *mesh = STK::tuple_get<0>(t);
size_t instance_count = STK::tuple_get<1>(t);
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh->PrimitiveType;
GLenum itype = mesh->IndexType;
size_t count = mesh->IndexCount;
Shader->setUniforms(args...);
glDrawElementsInstanced(ptype, count, itype, 0, instance_count);
}
};
template<int N, int...List>
struct instanced_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)
{
instanced_custom_unroll_args<List...>::template exec<T>(Shader, t, STK::tuple_get<N>(t), args...);
}
};
template<typename Shader, int ...List, typename... TupleType>
void renderInstancedMeshes1stPass(const std::vector<TexUnit> &TexUnits, std::vector<STK::Tuple<TupleType...> > *meshes)
{
glUseProgram(Shader::getInstance()->Program);
for (unsigned i = 0; i < meshes->size(); i++)
{
GLMesh &mesh = *(STK::tuple_get<0>(meshes->at(i)));
glBindVertexArray(mesh.vao);
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], TexUnits[j].m_premul_alpha);
setTexture(TexUnits[j].m_id, getTextureGLuint(mesh.textures[j]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
}
instanced_custom_unroll_args<List...>::template exec(Shader::getInstance(), meshes->at(i));
}
}
@ -193,14 +204,17 @@ void IrrDriver::renderSolidFirstPass()
glDisable(GL_BLEND);
glEnable(GL_CULL_FACE);
irr_driver->setPhase(SOLID_NORMAL_AND_DEPTH_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();
ListMatDefault::getInstance()->clear();
ListMatAlphaRef::getInstance()->clear();
ListMatSphereMap::getInstance()->clear();
ListMatDetails::getInstance()->clear();
ListMatUnlit::getInstance()->clear();
ListMatNormalMap::getInstance()->clear();
ListMatGrass::getInstance()->clear();
ListMatSplatting::getInstance()->clear();
ListInstancedMatDefault::getInstance()->clear();
ListInstancedMatAlphaRef::getInstance()->clear();
ListInstancedMatGrass::getInstance()->clear();
m_scene_manager->drawAll(scene::ESNRP_SOLID);
if (!UserConfigParams::m_dynamic_lights)
@ -210,28 +224,38 @@ void IrrDriver::renderSolidFirstPass()
ScopedGPUTimer Timer(getGPUTimer(Q_SOLID_PASS1));
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::ObjectPass1Shader, video::EVT_STANDARD, 2, 1>(object_pass1_texunits, ListMatDefault::getInstance());
renderMeshes1stPass<MeshShader::ObjectPass1Shader, video::EVT_STANDARD, 2, 1>(object_pass1_texunits, ListMatSphereMap::getInstance());
renderMeshes1stPass<MeshShader::ObjectPass1Shader, video::EVT_2TCOORDS, 2, 1>(object_pass1_texunits, ListMatDetails::getInstance());
renderMeshes1stPass<MeshShader::ObjectPass1Shader, video::EVT_2TCOORDS, 2, 1>(object_pass1_texunits, ListMatSplatting::getInstance());
renderMeshes1stPass<MeshShader::ObjectRefPass1Shader, video::EVT_STANDARD, 3, 2, 1>(object_pass1_texunits, ListMatUnlit::getInstance());
renderMeshes1stPass<MeshShader::ObjectRefPass1Shader, video::EVT_STANDARD, 3, 2, 1>(TexUnits(TexUnit(MeshShader::ObjectRefPass1Shader::getInstance()->TU_tex, true)), ListMatAlphaRef::getInstance());
renderMeshes1stPass<MeshShader::GrassPass1Shader, video::EVT_STANDARD, 3, 2, 1>(TexUnits(TexUnit(MeshShader::GrassPass1Shader::getInstance()->TU_tex, true)), ListMatGrass::getInstance());
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);
), ListMatNormalMap::getInstance());
renderInstancedMeshes1stPass<MeshShader::InstancedObjectPass1Shader>(
TexUnits(TexUnit(MeshShader::InstancedObjectPass1Shader::getInstance()->TU_tex, true)),
ListInstancedMatDefault::getInstance());
renderInstancedMeshes1stPass<MeshShader::InstancedObjectRefPass1Shader>(
TexUnits(TexUnit(MeshShader::InstancedObjectRefPass1Shader::getInstance()->TU_tex, true)),
ListInstancedMatAlphaRef::getInstance());
renderInstancedMeshes1stPass<MeshShader::InstancedGrassPass1Shader, 2>(
TexUnits(TexUnit(MeshShader::InstancedGrassPass1Shader::getInstance()->TU_tex, true)),
ListInstancedMatGrass::getInstance());
}
}
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)
void renderMeshes2ndPass(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++)
for (unsigned i = 0; i < meshes->size(); i++)
{
GLMesh &mesh = *(STK::tuple_get<0>(meshes[i]));
GLMesh &mesh = *(STK::tuple_get<0>(meshes->at(i)));
for (unsigned j = 0; j < TexUnits.size(); j++)
{
if (!mesh.textures[j])
@ -257,7 +281,37 @@ void renderMeshes2ndPass(const std::vector<TexUnit> &TexUnits, std::vector<STK::
#endif
continue;
}
custom_unroll_args<List...>::template exec(Shader::getInstance(), meshes[i]);
custom_unroll_args<List...>::template exec(Shader::getInstance(), meshes->at(i));
}
}
template<typename Shader, int...List, typename... TupleType>
void renderInstancedMeshes2ndPass(const std::vector<TexUnit> &TexUnits, std::vector<STK::Tuple<TupleType...> > *meshes)
{
glUseProgram(Shader::getInstance()->Program);
for (unsigned i = 0; i < meshes->size(); i++)
{
GLMesh &mesh = *(STK::tuple_get<0>(meshes->at(i)));
glBindVertexArray(mesh.vao);
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], 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 };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
else
{
GLint swizzleMask[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
}
instanced_custom_unroll_args<List...>::template exec(Shader::getInstance(), meshes->at(i));
}
}
@ -294,28 +348,28 @@ void IrrDriver::renderSolidSecondPass()
renderMeshes2ndPass<MeshShader::ObjectPass2Shader, video::EVT_STANDARD, 3, 1>(TexUnits(
TexUnit(MeshShader::ObjectPass2Shader::getInstance()->TU_Albedo, true)
), ListMatDefault::Arguments);
), ListMatDefault::getInstance());
renderMeshes2ndPass<MeshShader::ObjectRefPass2Shader, video::EVT_STANDARD, 3, 1 >(TexUnits(
TexUnit(MeshShader::ObjectRefPass2Shader::getInstance()->TU_Albedo, true)
), ListMatAlphaRef::Arguments);
), ListMatAlphaRef::getInstance());
renderMeshes2ndPass<MeshShader::SphereMapShader, video::EVT_STANDARD, 2, 1>(TexUnits(
TexUnit(MeshShader::SphereMapShader::getInstance()->TU_tex, true)
), ListMatSphereMap::Arguments);
), ListMatSphereMap::getInstance());
renderMeshes2ndPass<MeshShader::DetailledObjectPass2Shader, video::EVT_2TCOORDS, 1>(TexUnits(
TexUnit(MeshShader::DetailledObjectPass2Shader::getInstance()->TU_Albedo, true),
TexUnit(MeshShader::DetailledObjectPass2Shader::getInstance()->TU_detail, true)
), ListMatDetails::Arguments);
), ListMatDetails::getInstance());
renderMeshes2ndPass<MeshShader::GrassPass2Shader, video::EVT_STANDARD, 3, 1>(TexUnits(
TexUnit(MeshShader::GrassPass2Shader::getInstance()->TU_Albedo, true)
), ListMatGrass::Arguments);
), ListMatGrass::getInstance());
renderMeshes2ndPass<MeshShader::ObjectUnlitShader, video::EVT_STANDARD, 1>(TexUnits(
TexUnit(MeshShader::ObjectUnlitShader::getInstance()->TU_tex, true)
), ListMatUnlit::Arguments);
), ListMatUnlit::getInstance());
renderMeshes2ndPass<MeshShader::SplattingShader, video::EVT_2TCOORDS, 1>(TexUnits(
TexUnit(8, true),
@ -324,14 +378,62 @@ void IrrDriver::renderSolidSecondPass()
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);
), ListMatSplatting::getInstance());
renderMeshes2ndPass<MeshShader::ObjectPass2Shader, video::EVT_TANGENTS, 3, 1>(TexUnits(
TexUnit(MeshShader::ObjectPass2Shader::getInstance()->TU_Albedo, true)
), ListMatNormalMap::Arguments);
), ListMatNormalMap::getInstance());
renderInstancedMeshes2ndPass<MeshShader::InstancedObjectPass2Shader>(
TexUnits(TexUnit(MeshShader::InstancedObjectPass2Shader::getInstance()->TU_Albedo, true)),
ListInstancedMatDefault::getInstance());
renderInstancedMeshes2ndPass<MeshShader::InstancedObjectRefPass2Shader>(
TexUnits(TexUnit(MeshShader::InstancedObjectRefPass2Shader::getInstance()->TU_Albedo, true)),
ListInstancedMatAlphaRef::getInstance());
setTexture(MeshShader::InstancedGrassPass2Shader::getInstance()->TU_dtex,
irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
renderInstancedMeshes2ndPass<MeshShader::InstancedGrassPass2Shader, 3, 2>(
TexUnits(TexUnit(MeshShader::InstancedGrassPass2Shader::getInstance()->TU_Albedo, true)),
ListInstancedMatGrass::getInstance());
}
}
template<enum E_VERTEX_TYPE VertexType, typename... TupleType>
static void renderMeshNormals(std::vector<STK::Tuple<TupleType...> > *meshes)
{
glUseProgram(MeshShader::NormalVisualizer::getInstance()->Program);
glBindVertexArray(getVAO(VertexType));
for (unsigned i = 0; i < meshes->size(); i++)
{
GLMesh &mesh = *(STK::tuple_get<0>(meshes->at(i)));
if (mesh.VAOType != VertexType)
{
#ifdef DEBUG
Log::error("Materials", "Wrong vertex Type associed to pass 2 (hint texture : %s)", mesh.textures[0]->getName().getPath().c_str());
#endif
continue;
}
draw(MeshShader::NormalVisualizer::getInstance(), STK::tuple_get<0>(meshes->at(i)), STK::tuple_get<1>(meshes->at(i)), STK::tuple_get<2>(meshes->at(i)), video::SColor(255, 0, 255, 0));
}
}
void IrrDriver::renderNormalsVisualisation()
{
renderMeshNormals<video::EVT_STANDARD>(ListMatDefault::getInstance());
renderMeshNormals<video::EVT_STANDARD>(ListMatAlphaRef::getInstance());
renderMeshNormals<video::EVT_STANDARD>(ListMatSphereMap::getInstance());
// renderMeshNormals<video::EVT_STANDARD>(ListMatGrass::getInstance());
renderMeshNormals<video::EVT_2TCOORDS>(ListMatDetails::getInstance());
renderMeshNormals<video::EVT_STANDARD>(ListMatUnlit::getInstance());
renderMeshNormals<video::EVT_2TCOORDS>(ListMatSplatting::getInstance());
renderMeshNormals<video::EVT_TANGENTS>(ListMatNormalMap::getInstance());
}
static video::ITexture *displaceTex = 0;
void IrrDriver::renderTransparent()
@ -343,11 +445,11 @@ void IrrDriver::renderTransparent()
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glDisable(GL_CULL_FACE);
ListBlendTransparent::Arguments.clear();
ListAdditiveTransparent::Arguments.clear();
ListBlendTransparentFog::Arguments.clear();
ListAdditiveTransparentFog::Arguments.clear();
ListDisplacement::Arguments.clear();
ListBlendTransparent::getInstance()->clear();
ListAdditiveTransparent::getInstance()->clear();
ListBlendTransparentFog::getInstance()->clear();
ListAdditiveTransparentFog::getInstance()->clear();
ListDisplacement::getInstance()->clear();
m_scene_manager->drawAll(scene::ESNRP_TRANSPARENT);
glBindVertexArray(getVAO(EVT_STANDARD));
@ -357,22 +459,22 @@ void IrrDriver::renderTransparent()
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
renderMeshes2ndPass<MeshShader::TransparentFogShader, video::EVT_STANDARD, 8, 7, 6, 5, 4, 3, 2, 1>(TexUnits(
TexUnit(MeshShader::TransparentFogShader::getInstance()->TU_tex, true)
), ListBlendTransparentFog::Arguments);
), ListBlendTransparentFog::getInstance());
glBlendFunc(GL_ONE, GL_ONE);
renderMeshes2ndPass<MeshShader::TransparentFogShader, video::EVT_STANDARD, 8, 7, 6, 5, 4, 3, 2, 1>(TexUnits(
TexUnit(MeshShader::TransparentFogShader::getInstance()->TU_tex, true)
), ListAdditiveTransparentFog::Arguments);
), ListAdditiveTransparentFog::getInstance());
}
else
{
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
renderMeshes2ndPass<MeshShader::TransparentShader, video::EVT_STANDARD, 2, 1>(TexUnits(
TexUnit(MeshShader::TransparentShader::getInstance()->TU_tex, true)
), ListBlendTransparent::Arguments);
), ListBlendTransparent::getInstance());
glBlendFunc(GL_ONE, GL_ONE);
renderMeshes2ndPass<MeshShader::TransparentShader, video::EVT_STANDARD, 2, 1>(TexUnits(
TexUnit(MeshShader::TransparentShader::getInstance()->TU_tex, true)
), ListAdditiveTransparent::Arguments);
), ListAdditiveTransparent::getInstance());
}
if (!UserConfigParams::m_dynamic_lights)
@ -400,10 +502,10 @@ void IrrDriver::renderTransparent()
// Generate displace mask
// Use RTT_TMP4 as displace mask
irr_driver->getFBO(FBO_TMP1_WITH_DS).Bind();
for (unsigned i = 0; i < ListDisplacement::Arguments.size(); i++)
for (unsigned i = 0; i < ListDisplacement::getInstance()->size(); i++)
{
const GLMesh &mesh = *(STK::tuple_get<0>(ListDisplacement::Arguments[i]));
const core::matrix4 &AbsoluteTransformation = STK::tuple_get<1>(ListDisplacement::Arguments[i]);
const GLMesh &mesh = *(STK::tuple_get<0>(ListDisplacement::getInstance()->at(i)));
const core::matrix4 &AbsoluteTransformation = STK::tuple_get<1>(ListDisplacement::getInstance()->at(i));
if (mesh.VAOType != video::EVT_2TCOORDS)
{
#ifdef DEBUG
@ -416,18 +518,18 @@ void IrrDriver::renderTransparent()
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
glUseProgram(MeshShader::DisplaceMaskShaderInstance->Program);
MeshShader::DisplaceMaskShaderInstance->setUniforms(AbsoluteTransformation);
glUseProgram(MeshShader::DisplaceMaskShader::getInstance()->Program);
MeshShader::DisplaceMaskShader::getInstance()->setUniforms(AbsoluteTransformation);
glDrawElementsBaseVertex(ptype, count, itype, (GLvoid *)mesh.vaoOffset, mesh.vaoBaseVertex);
}
irr_driver->getFBO(FBO_DISPLACE).Bind();
if (!displaceTex)
displaceTex = irr_driver->getTexture(FileManager::TEXTURE, "displace.png");
for (unsigned i = 0; i < ListDisplacement::Arguments.size(); i++)
for (unsigned i = 0; i < ListDisplacement::getInstance()->size(); i++)
{
const GLMesh &mesh = *(STK::tuple_get<0>(ListDisplacement::Arguments[i]));
const core::matrix4 &AbsoluteTransformation = STK::tuple_get<1>(ListDisplacement::Arguments[i]);
const GLMesh &mesh = *(STK::tuple_get<0>(ListDisplacement::getInstance()->at(i)));
const core::matrix4 &AbsoluteTransformation = STK::tuple_get<1>(ListDisplacement::getInstance()->at(i));
if (mesh.VAOType != video::EVT_2TCOORDS)
continue;
@ -435,12 +537,12 @@ void IrrDriver::renderTransparent()
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
// Render the effect
setTexture(MeshShader::DisplaceShaderInstance->TU_displacement_tex, getTextureGLuint(displaceTex), GL_LINEAR, GL_LINEAR, true);
setTexture(MeshShader::DisplaceShaderInstance->TU_mask_tex, irr_driver->getRenderTargetTexture(RTT_TMP1), GL_LINEAR, GL_LINEAR, true);
setTexture(MeshShader::DisplaceShaderInstance->TU_color_tex, irr_driver->getRenderTargetTexture(RTT_COLOR), GL_LINEAR, GL_LINEAR, true);
setTexture(MeshShader::DisplaceShaderInstance->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR, true);
glUseProgram(MeshShader::DisplaceShaderInstance->Program);
MeshShader::DisplaceShaderInstance->setUniforms(AbsoluteTransformation,
setTexture(MeshShader::DisplaceShader::getInstance()->TU_displacement_tex, getTextureGLuint(displaceTex), GL_LINEAR, GL_LINEAR, true);
setTexture(MeshShader::DisplaceShader::getInstance()->TU_mask_tex, irr_driver->getRenderTargetTexture(RTT_TMP1), GL_LINEAR, GL_LINEAR, true);
setTexture(MeshShader::DisplaceShader::getInstance()->TU_color_tex, irr_driver->getRenderTargetTexture(RTT_COLOR), GL_LINEAR, GL_LINEAR, true);
setTexture(MeshShader::DisplaceShader::getInstance()->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR, true);
glUseProgram(MeshShader::DisplaceShader::getInstance()->Program);
MeshShader::DisplaceShader::getInstance()->setUniforms(AbsoluteTransformation,
core::vector2df(cb->getDirX(), cb->getDirY()),
core::vector2df(cb->getDir2X(), cb->getDir2Y()));
@ -490,31 +592,103 @@ struct shadow_custom_unroll_args<N, List...>
};
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)
void renderShadow(const std::vector<GLuint> TextureUnits, const std::vector<STK::Tuple<GLMesh *, core::matrix4, Args...> > *t)
{
glUseProgram(Shader->Program);
glUseProgram(T::getInstance()->Program);
glBindVertexArray(getVAO(VertexType));
for (unsigned i = 0; i < t.size(); i++)
for (unsigned i = 0; i < t->size(); i++)
{
const GLMesh *mesh = STK::tuple_get<0>(t[i]);
const GLMesh *mesh = STK::tuple_get<0>(t->at(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);
}
shadow_custom_unroll_args<List...>::template exec<T>(Shader, t[i]);
shadow_custom_unroll_args<List...>::template exec<T>(T::getInstance(), t->at(i));
}
}
template<enum E_VERTEX_TYPE VertexType, typename... Args>
void drawRSM(const core::matrix4 & rsm_matrix, const std::vector<GLuint> TextureUnits, const std::vector<STK::Tuple<GLMesh *, core::matrix4, Args...> >&t)
static void drawShadowDefault(GLMesh &mesh, size_t instance_count)
{
glUseProgram(MeshShader::RSMShader::Program);
glBindVertexArray(getVAO(VertexType));
for (unsigned i = 0; i < t.size(); i++)
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
MeshShader::InstancedShadowShader::getInstance()->setUniforms();
glBindVertexArray(mesh.vao_shadow_pass);
glDrawElementsInstanced(ptype, count, itype, 0, 4 * instance_count);
}
static void drawShadowAlphaRefTexture(GLMesh &mesh, size_t instance_count)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], true);
setTexture(MeshShader::InstancedRefShadowShader::getInstance()->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::InstancedRefShadowShader::getInstance()->setUniforms();
glBindVertexArray(mesh.vao_shadow_pass);
glDrawElementsInstanced(ptype, count, itype, 0, 4 * instance_count);
}
static void drawShadowGrass(GLMesh &mesh, const core::vector3df &windDir, size_t instance_count)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], true);
setTexture(MeshShader::InstancedGrassShadowShader::getInstance()->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::InstancedGrassShadowShader::getInstance()->setUniforms(windDir);
glBindVertexArray(mesh.vao_shadow_pass);
glDrawElementsInstanced(ptype, count, itype, 0, 4 * instance_count);
}
template<int...List>
struct rsm_custom_unroll_args;
template<>
struct rsm_custom_unroll_args<>
{
template<typename T, typename ...TupleTypes, typename ...Args>
static void exec(const core::matrix4 &rsm_matrix, const STK::Tuple<TupleTypes...> &t, Args... args)
{
GLMesh *mesh = STK::tuple_get<0>(t[i]);
draw<T>(T::getInstance(), STK::tuple_get<0>(t), rsm_matrix, args...);
}
};
template<int N, int...List>
struct rsm_custom_unroll_args<N, List...>
{
template<typename T, typename ...TupleTypes, typename ...Args>
static void exec(const core::matrix4 &rsm_matrix, const STK::Tuple<TupleTypes...> &t, Args... args)
{
rsm_custom_unroll_args<List...>::template exec<T>(rsm_matrix, t, STK::tuple_get<N>(t), args...);
}
};
template<typename T, enum E_VERTEX_TYPE VertexType, int... Selector, typename... Args>
void drawRSM(const core::matrix4 & rsm_matrix, const std::vector<GLuint> TextureUnits, const std::vector<STK::Tuple<GLMesh *, core::matrix4, Args...> > *t)
{
glUseProgram(T::getInstance()->Program);
glBindVertexArray(getVAO(VertexType));
for (unsigned i = 0; i < t->size(); i++)
{
GLMesh *mesh = STK::tuple_get<0>(t->at(i));
for (unsigned j = 0; j < TextureUnits.size(); j++)
{
if (!mesh->textures[j])
@ -522,7 +696,7 @@ void drawRSM(const core::matrix4 & rsm_matrix, const std::vector<GLuint> Texture
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, STK::tuple_get<1>(t[i]));
rsm_custom_unroll_args<Selector...>::template exec<T>(rsm_matrix, t->at(i));
}
}
@ -540,25 +714,25 @@ void IrrDriver::renderShadows()
glDrawBuffer(GL_NONE);
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();
ListMatDefault::getInstance()->clear();
ListMatAlphaRef::getInstance()->clear();
ListMatSphereMap::getInstance()->clear();
ListMatDetails::getInstance()->clear();
ListMatUnlit::getInstance()->clear();
ListMatNormalMap::getInstance()->clear();
ListMatGrass::getInstance()->clear();
ListMatSplatting::getInstance()->clear();
m_scene_manager->drawAll(scene::ESNRP_SOLID);
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);
renderShadow<MeshShader::ShadowShader, EVT_STANDARD, 1>(noTexUnits, ListMatDefault::getInstance());
renderShadow<MeshShader::ShadowShader, EVT_STANDARD, 1>(noTexUnits, ListMatSphereMap::getInstance());
renderShadow<MeshShader::ShadowShader, EVT_2TCOORDS, 1>(noTexUnits, ListMatDetails::getInstance());
renderShadow<MeshShader::ShadowShader, EVT_2TCOORDS, 1>(noTexUnits, ListMatSplatting::getInstance());
renderShadow<MeshShader::ShadowShader, EVT_TANGENTS, 1>(noTexUnits, ListMatNormalMap::getInstance());
renderShadow<MeshShader::RefShadowShader, EVT_STANDARD, 1>(std::vector<GLuint>{ MeshShader::RefShadowShader::getInstance()->TU_tex }, ListMatAlphaRef::getInstance());
renderShadow<MeshShader::RefShadowShader, EVT_STANDARD, 1>(std::vector<GLuint>{ MeshShader::RefShadowShader::getInstance()->TU_tex }, ListMatUnlit::getInstance());
renderShadow<MeshShader::GrassShadowShader, EVT_STANDARD, 3, 1>(std::vector<GLuint>{ MeshShader::GrassShadowShader::getInstance()->TU_tex }, ListMatGrass::getInstance());
glDisable(GL_POLYGON_OFFSET_FILL);
@ -568,9 +742,18 @@ void IrrDriver::renderShadows()
m_rtts->getRSM().Bind();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
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);
drawRSM<MeshShader::RSMShader, EVT_STANDARD, 3, 1>(rsm_matrix, std::vector<GLuint>{ MeshShader::RSMShader::getInstance()->TU_tex }, ListMatDefault::getInstance());
drawRSM<MeshShader::RSMShader, EVT_STANDARD, 3, 1>(rsm_matrix, std::vector<GLuint>{ MeshShader::RSMShader::getInstance()->TU_tex }, ListMatAlphaRef::getInstance());
// drawRSM<EVT_STANDARD, 2, 1>(rsm_matrix, std::vector<GLuint>{ MeshShader::RSMShader::getInstance()->TU_tex }, ListMatSphereMap::getInstance());
drawRSM<MeshShader::RSMShader, EVT_STANDARD, 3, 1>(rsm_matrix, std::vector<GLuint>{ MeshShader::RSMShader::getInstance()->TU_tex }, ListMatUnlit::getInstance());
drawRSM<MeshShader::RSMShader, EVT_2TCOORDS, 3, 1>(rsm_matrix, std::vector<GLuint>{ MeshShader::RSMShader::getInstance()->TU_tex }, ListMatDetails::getInstance());
drawRSM<MeshShader::SplattingRSMShader, EVT_2TCOORDS, 1>(rsm_matrix,
std::vector<GLuint>{
8,
MeshShader::SplattingRSMShader::getInstance()->TU_layout,
MeshShader::SplattingRSMShader::getInstance()->TU_detail0,
MeshShader::SplattingRSMShader::getInstance()->TU_detail1,
MeshShader::SplattingRSMShader::getInstance()->TU_detail2,
MeshShader::SplattingRSMShader::getInstance()->TU_detail3},
ListMatSplatting::getInstance());
}

25
src/graphics/render_lighting.cpp
View File

@ -136,12 +136,12 @@ void IrrDriver::renderLights(unsigned pointlightcount)
ScopedGPUTimer timer(irr_driver->getGPUTimer(Q_RH));
glDisable(GL_BLEND);
m_rtts->getRH().Bind();
glUseProgram(FullScreenShader::RadianceHintsConstructionShader::Program);
glBindVertexArray(FullScreenShader::RadianceHintsConstructionShader::vao);
setTexture(0, m_rtts->getRSM().getRTT()[0], GL_LINEAR, GL_LINEAR);
setTexture(1, m_rtts->getRSM().getRTT()[1], GL_LINEAR, GL_LINEAR);
setTexture(2, m_rtts->getRSM().getDepthTexture(), GL_LINEAR, GL_LINEAR);
FullScreenShader::RadianceHintsConstructionShader::setUniforms(rsm_matrix, rh_matrix, rh_extend, 0, 1, 2);
glUseProgram(FullScreenShader::RadianceHintsConstructionShader::getInstance()->Program);
glBindVertexArray(SharedObject::FullScreenQuadVAO);
setTexture(FullScreenShader::RadianceHintsConstructionShader::getInstance()->TU_ctex, m_rtts->getRSM().getRTT()[0], GL_LINEAR, GL_LINEAR);
setTexture(FullScreenShader::RadianceHintsConstructionShader::getInstance()->TU_ntex, m_rtts->getRSM().getRTT()[1], GL_LINEAR, GL_LINEAR);
setTexture(FullScreenShader::RadianceHintsConstructionShader::getInstance()->TU_dtex, m_rtts->getRSM().getDepthTexture(), GL_LINEAR, GL_LINEAR);
FullScreenShader::RadianceHintsConstructionShader::getInstance()->setUniforms(rsm_matrix, rh_matrix, rh_extend);
glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, 32);
}
@ -161,18 +161,17 @@ void IrrDriver::renderLights(unsigned pointlightcount)
m_post_processing->renderGI(rh_matrix, rh_extend, m_rtts->getRH().getRTT()[0], m_rtts->getRH().getRTT()[1], m_rtts->getRH().getRTT()[2]);
}
if (SkyboxCubeMap)
{
ScopedGPUTimer timer(irr_driver->getGPUTimer(Q_ENVMAP));
m_post_processing->renderDiffuseEnvMap(blueSHCoeff, greenSHCoeff, redSHCoeff);
}
ScopedGPUTimer timer(irr_driver->getGPUTimer(Q_ENVMAP));
m_post_processing->renderDiffuseEnvMap(blueSHCoeff, greenSHCoeff, redSHCoeff);
m_rtts->getFBO(FBO_COMBINED_TMP1_TMP2).Bind();
// Render sunlight if and only if track supports shadow
if (!World::getWorld() || World::getWorld()->getTrack()->hasShadows())
{
ScopedGPUTimer timer(irr_driver->getGPUTimer(Q_SUN));
if (World::getWorld() && UserConfigParams::m_shadows && !UserConfigParams::m_ubo_disabled)
if (World::getWorld() && UserConfigParams::m_shadows && !irr_driver->needUBOWorkaround())
m_post_processing->renderShadowedSunlight(sun_ortho_matrix, m_rtts->getShadowDepthTex());
else
m_post_processing->renderSunlight();
@ -193,4 +192,4 @@ void IrrDriver::renderSSAO()
FrameBuffer::Blit(m_rtts->getFBO(FBO_SSAO), m_rtts->getFBO(FBO_HALF1_R), GL_COLOR_BUFFER_BIT, GL_LINEAR);
m_post_processing->renderGaussian17TapBlur(irr_driver->getFBO(FBO_HALF1_R), irr_driver->getFBO(FBO_HALF2_R));
}
}

47
src/graphics/render_skybox.cpp
View File

@ -370,9 +370,22 @@ static void testSH(unsigned char *color[6], size_t width, size_t height,
delete[] Y1minus1[face];
delete[] Y10[face];
delete[] Y11[face];
delete[] Y2minus2[face];
delete[] Y2minus1[face];
delete[] Y20[face];
delete[] Y21[face];
delete[] Y22[face];
}
}
static void swapPixels(char *old_img, char *new_img, unsigned stride, unsigned old_i, unsigned old_j, unsigned new_i, unsigned new_j)
{
new_img[4 * (stride * new_i + new_j)] = old_img[4 * (stride * old_i + old_j)];
new_img[4 * (stride * new_i + new_j) + 1] = old_img[4 * (stride * old_i + old_j) + 1];
new_img[4 * (stride * new_i + new_j) + 2] = old_img[4 * (stride * old_i + old_j) + 2];
new_img[4 * (stride * new_i + new_j) + 3] = old_img[4 * (stride * old_i + old_j) + 3];
}
/** Generate an opengl cubemap texture from 6 2d textures.
Out of legacy the sequence of textures maps to :
- 1st texture maps to GL_TEXTURE_CUBE_MAP_POSITIVE_Y
@ -416,6 +429,19 @@ GLuint generateCubeMapFromTextures(const std::vector<video::ITexture *> &texture
image->copyToScaling(rgba[i], w, h);
image->drop();
if (i == 2 || i == 3)
{
char *tmp = new char[w * h * 4];
memcpy(tmp, rgba[i], w * h * 4);
for (unsigned x = 0; x < w; x++)
{
for (unsigned y = 0; y < h; y++)
{
swapPixels(tmp, rgba[i], h, x, y, (w - y - 1), x);
}
}
}
glBindTexture(GL_TEXTURE_CUBE_MAP, result);
if (UserConfigParams::m_texture_compression)
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_COMPRESSED_SRGB_ALPHA, w, h, 0, GL_BGRA, GL_UNSIGNED_BYTE, (GLvoid*)rgba[i]);
@ -433,6 +459,13 @@ void IrrDriver::generateSkyboxCubemap()
assert(SkyboxTextures.size() == 6);
SkyboxCubeMap = generateCubeMapFromTextures(SkyboxTextures);
}
void IrrDriver::generateDiffuseCoefficients()
{
if (!m_SH_dirty)
return;
m_SH_dirty = false;
const unsigned texture_permutation[] = { 2, 3, 0, 1, 5, 4 };
if (SphericalHarmonicsTextures.size() == 6)
@ -460,7 +493,7 @@ void IrrDriver::generateSkyboxCubemap()
SphericalHarmonicsTextures[idx]->unlock();
image->copyToScaling(sh_rgba[i], sh_w, sh_h);
image->drop();
delete image;
}
testSH(sh_rgba, sh_w, sh_h, blueSHCoeff, greenSHCoeff, redSHCoeff);
@ -473,8 +506,7 @@ void IrrDriver::generateSkyboxCubemap()
int sh_w = 16;
int sh_h = 16;
const video::SColorf& ambientf = irr_driver->getSceneManager()->getAmbientLight();
video::SColor ambient = ambientf.toSColor();
video::SColor ambient = m_scene_manager->getAmbientLight().toSColor();
unsigned char *sh_rgba[6];
for (unsigned i = 0; i < 6; i++)
@ -492,6 +524,14 @@ void IrrDriver::generateSkyboxCubemap()
testSH(sh_rgba, sh_w, sh_h, blueSHCoeff, greenSHCoeff, redSHCoeff);
// Diffuse env map is x 0.25, compensate
for (unsigned i = 0; i < 9; i++)
{
blueSHCoeff[i] *= 4;
greenSHCoeff[i] *= 4;
redSHCoeff[i] *= 4;
}
for (unsigned i = 0; i < 6; i++)
delete[] sh_rgba[i];
}
@ -503,6 +543,7 @@ void IrrDriver::generateSkyboxCubemap()
}
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);*/
}
void IrrDriver::renderSkybox(const scene::ICameraSceneNode *camera)

6
src/graphics/rtts.cpp
View File

@ -226,7 +226,7 @@ RTT::RTT(size_t width, size_t height)
somevector.push_back(RenderTargetTextures[RTT_TMP_128]);
FrameBuffers.push_back(new FrameBuffer(somevector, 128, 128));
if (UserConfigParams::m_shadows && !UserConfigParams::m_ubo_disabled)
if (UserConfigParams::m_shadows && !irr_driver->needUBOWorkaround())
{
shadowColorTex = generateRTT3D(GL_TEXTURE_2D_ARRAY, 1024, 1024, 4, GL_R8, GL_RED, GL_UNSIGNED_BYTE);
shadowDepthTex = generateRTT3D(GL_TEXTURE_2D_ARRAY, 1024, 1024, 4, GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
@ -265,7 +265,7 @@ RTT::~RTT()
{
glDeleteTextures(RTT_COUNT, RenderTargetTextures);
glDeleteTextures(1, &DepthStencilTexture);
if (UserConfigParams::m_shadows && !UserConfigParams::m_ubo_disabled)
if (UserConfigParams::m_shadows && !irr_driver->needUBOWorkaround())
{
delete m_shadow_FBO;
glDeleteTextures(1, &shadowColorTex);
@ -291,6 +291,8 @@ FrameBuffer* RTT::render(scene::ICameraSceneNode* camera, float dt)
irr_driver->getSceneManager()->setActiveCamera(camera);
std::vector<IrrDriver::GlowData> glows;
// TODO: put this outside of the rendering loop
irr_driver->generateDiffuseCoefficients();
irr_driver->computeCameraMatrix(camera, m_width, m_height);
unsigned plc = irr_driver->UpdateLightsInfo(camera, dt);
irr_driver->renderScene(camera, plc, glows, dt, false, true);

1158
src/graphics/shaders.cpp
View File

File diff suppressed because it is too large Load Diff

418
src/graphics/shaders.hpp
View File

@ -33,6 +33,7 @@ public:
static GLuint billboardvbo;
static GLuint cubevbo, cubeindexes, frustrumvbo, frustrumindexes;
static GLuint ViewProjectionMatrixesUBO;
static GLuint FullScreenQuadVAO;
};
namespace UtilShader
@ -51,8 +52,11 @@ public:
void glUniformMatrix4fvWraper(GLuint, size_t, unsigned, const float *mat);
void glUniform3fWraper(GLuint, float, float, float);
void glUniform4iWraper(GLuint, int, int, int, int);
void glUniform2fWraper(GLuint a, float b, float c);
void glUniform1fWrapper(GLuint, float);
void glUniform1iWrapper(GLuint, int);
bool needsUBO();
struct UniformHelper
{
@ -78,6 +82,13 @@ struct UniformHelper
setUniformsHelper<N + 1>(uniforms, arg...);
}
template<unsigned N = 0, typename... Args>
static void setUniformsHelper(const std::vector<GLuint> &uniforms, const video::SColor &col, Args... arg)
{
glUniform4iWraper(uniforms[N], col.getRed(), col.getGreen(), col.getBlue(), col.getAlpha());
setUniformsHelper<N + 1>(uniforms, arg...);
}
template<unsigned N = 0, typename... Args>
static void setUniformsHelper(const std::vector<GLuint> &uniforms, const core::vector3df &v, Args... arg)
{
@ -93,6 +104,13 @@ struct UniformHelper
setUniformsHelper<N + 1>(uniforms, arg...);
}
template<unsigned N = 0, typename... Args>
static void setUniformsHelper(const std::vector<GLuint> &uniforms, const core::dimension2df &v, Args... arg)
{
glUniform2fWraper(uniforms[N], v.Width, v.Height);
setUniformsHelper<N + 1>(uniforms, arg...);
}
template<unsigned N = 0, typename... Args>
static void setUniformsHelper(const std::vector<GLuint> &uniforms, float f, Args... arg)
{
@ -100,65 +118,48 @@ struct UniformHelper
setUniformsHelper<N + 1>(uniforms, arg...);
}
template<unsigned N = 0, typename... Args>
static void setUniformsHelper(const std::vector<GLuint> &uniforms, int f, Args... arg)
{
glUniform1iWrapper(uniforms[N], f);
setUniformsHelper<N + 1>(uniforms, arg...);
}
};
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;
void setUniforms(const Args & ... args) const
{
if (UserConfigParams::m_ubo_disabled)
bypassUBO(Program);
UniformHelper::setUniformsHelper(uniforms, args...);
}
};
template<typename T, typename... Args>
class ShaderHelperSingleton : public Singleton<T>
{
protected:
std::vector<GLuint> uniforms;
void AssignUniforms(const char* name)
void AssignUniforms_impl()
{
uniforms.push_back(getUniformLocation(Program, name));
}
template<typename... U>
void AssignUniforms(const char* name, U... rest)
void AssignUniforms_impl(const char* name, U... rest)
{
uniforms.push_back(getUniformLocation(Program, name));
AssignUniforms(rest...);
AssignUniforms_impl(rest...);
}
template<typename... U>
void AssignUniforms(U... rest)
{
static_assert(sizeof...(rest) == sizeof...(Args), "Count of Uniform's name mismatch");
AssignUniforms_impl(rest...);
}
public:
friend class Singleton<class ObjectPass1Shader>;
GLuint Program;
void setUniforms(const Args & ... args) const
{
if (UserConfigParams::m_ubo_disabled)
if (needsUBO())
bypassUBO(Program);
UniformHelper::setUniformsHelper(uniforms, args...);
}
@ -325,102 +326,84 @@ public:
TransparentFogShader();
};
class BillboardShader
class BillboardShader : public ShaderHelperSingleton<BillboardShader, core::matrix4, core::matrix4, core::vector3df, core::dimension2df>
{
public:
static GLuint Program;
static GLuint attrib_corner, attrib_texcoord;
static GLuint uniform_MV, uniform_P, uniform_tex, uniform_Position, uniform_Size;
GLuint TU_tex;
static void init();
static void setUniforms(const core::matrix4 &ModelViewMatrix, const core::matrix4 &ProjectionMatrix, const core::vector3df &Position, const core::dimension2d<float> &size, unsigned TU_tex);
BillboardShader();
};
class ColorizeShader
class ColorizeShader : public ShaderHelperSingleton<ColorizeShader, core::matrix4, video::SColorf>
{
public:
static GLuint Program;
static GLuint uniform_MM, uniform_col;
static void init();
static void setUniforms(const core::matrix4 &ModelMatrix, float r, float g, float b);
ColorizeShader();
};
class ShadowShader : public ShaderHelper<core::matrix4>
class ShadowShader : public ShaderHelperSingleton<ShadowShader, core::matrix4>
{
public:
ShadowShader();
};
extern ShadowShader *ShadowShaderInstance;
class RSMShader
class RSMShader : public ShaderHelperSingleton<RSMShader, core::matrix4, core::matrix4, core::matrix4>
{
public:
static GLuint Program;
static GLuint uniform_MM, uniform_RSMMatrix;
static GLuint TU_tex;
GLuint TU_tex;
static void init();
static void setUniforms(const core::matrix4 &RSMMatrix, const core::matrix4 &ModelMatrix);
RSMShader();
};
class InstancedShadowShader : public ShaderHelper<>
class SplattingRSMShader : public ShaderHelperSingleton<SplattingRSMShader, core::matrix4, core::matrix4>
{
public:
GLuint TU_layout, TU_detail0, TU_detail1, TU_detail2, TU_detail3;
SplattingRSMShader();
};
class InstancedShadowShader : public ShaderHelperSingleton<InstancedShadowShader>
{
public:
InstancedShadowShader();
};
extern InstancedShadowShader *InstancedShadowShaderInstance;
class RefShadowShader : public ShaderHelper<core::matrix4>
class RefShadowShader : public ShaderHelperSingleton<RefShadowShader, core::matrix4>
{
public:
GLuint TU_tex;
RefShadowShader();
};
extern RefShadowShader *RefShadowShaderInstance;
class InstancedRefShadowShader : public ShaderHelper<>
class InstancedRefShadowShader : public ShaderHelperSingleton<InstancedRefShadowShader>
{
public:
GLuint TU_tex;
InstancedRefShadowShader();
};
extern InstancedRefShadowShader *InstancedRefShadowShaderInstance;
class GrassShadowShader : public ShaderHelper<core::matrix4, core::vector3df>
class GrassShadowShader : public ShaderHelperSingleton<GrassShadowShader, core::matrix4, core::vector3df>
{
public:
GLuint TU_tex;
GrassShadowShader();
};
extern GrassShadowShader *GrassShadowShaderInstance;
class InstancedGrassShadowShader : public ShaderHelper<core::vector3df>
class InstancedGrassShadowShader : public ShaderHelperSingleton<InstancedGrassShadowShader, core::vector3df>
{
public:
GLuint TU_tex;
InstancedGrassShadowShader();
};
extern InstancedGrassShadowShader *InstancedGrassShadowShaderInstance;
class DisplaceMaskShader : public ShaderHelper<core::matrix4>
class DisplaceMaskShader : public ShaderHelperSingleton<DisplaceMaskShader, core::matrix4>
{
public:
DisplaceMaskShader();
};
extern DisplaceMaskShader *DisplaceMaskShaderInstance;
class DisplaceShader : public ShaderHelper<core::matrix4, core::vector2df, core::vector2df>
class DisplaceShader : public ShaderHelperSingleton<DisplaceShader, core::matrix4, core::vector2df, core::vector2df>
{
public:
GLuint TU_displacement_tex, TU_mask_tex, TU_color_tex, TU_tex;
@ -428,8 +411,6 @@ public:
DisplaceShader();
};
extern DisplaceShader *DisplaceShaderInstance;
class SkyboxShader
{
public:
@ -442,6 +423,12 @@ public:
static void setUniforms(const core::matrix4 &ModelMatrix, const core::vector2df &screen, unsigned TU_tex);
};
class NormalVisualizer : public ShaderHelperSingleton<NormalVisualizer, core::matrix4, core::matrix4, video::SColor>
{
public:
NormalVisualizer();
};
class ViewFrustrumShader
{
public:
@ -541,59 +528,44 @@ public:
namespace FullScreenShader
{
class BloomShader
class BloomShader : public ShaderHelperSingleton<BloomShader>
{
public:
static GLuint Program;
static GLuint uniform_texture;
static GLuint vao;
GLuint TU_tex;
static void init();
static void setUniforms(unsigned TU_tex);
BloomShader();
};
class BloomBlendShader
class BloomBlendShader : public ShaderHelperSingleton<BloomBlendShader>
{
public:
static GLuint Program;
static GLuint uniform_tex_128, uniform_tex_256, uniform_tex_512;
static GLuint vao;
GLuint TU_tex_128, TU_tex_256, TU_tex_512;
static void init();
static void setUniforms(unsigned TU_tex_128, unsigned TU_tex_256, unsigned TU_tex_512);
BloomBlendShader();
};
class ToneMapShader
class ToneMapShader : public ShaderHelperSingleton<ToneMapShader>
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_logluminancetex, uniform_exposure, uniform_lwhite;
static GLuint vao;
GLuint TU_tex;
static void init();
static void setUniforms(float exposure, float Lwhite, unsigned TU_tex, unsigned TU_logluminance);
ToneMapShader();
};
class DepthOfFieldShader
class DepthOfFieldShader : public ShaderHelperSingleton<DepthOfFieldShader>
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_depth;
static GLuint vao;
GLuint TU_tex, TU_depth;
static void init();
static void setUniforms(unsigned TU_tex, unsigned TU_depth);
DepthOfFieldShader();
};
class SunLightShader
class SunLightShader : public ShaderHelperSingleton<SunLightShader, core::vector3df, video::SColorf>
{
public:
static GLuint Program;
static GLuint uniform_ntex, uniform_dtex, uniform_direction, uniform_col;
static GLuint vao;
GLuint TU_ntex, TU_dtex;
static void init();
static void setUniforms(const core::vector3df &direction, float r, float g, float b, unsigned TU_ntex, unsigned TU_dtex);
SunLightShader();
};
class DiffuseEnvMapShader
@ -601,275 +573,209 @@ class DiffuseEnvMapShader
public:
static GLuint Program;
static GLuint uniform_ntex, uniform_TVM, uniform_blueLmn, uniform_greenLmn, uniform_redLmn;
static GLuint vao;
static void init();
static void setUniforms(const core::matrix4 &TransposeViewMatrix, const float *blueSHCoeff, const float *greenSHCoeff, const float *redSHCoeff, unsigned TU_ntex);
};
class ShadowedSunLightShader
class ShadowedSunLightShader : public ShaderHelperSingleton<ShadowedSunLightShader, core::vector3df, video::SColorf>
{
public:
static GLuint Program;
static GLuint uniform_ntex, uniform_dtex, uniform_shadowtex, uniform_direction, uniform_col;
static GLuint vao;
GLuint TU_ntex, TU_dtex, TU_shadowtex;
static void init();
static void setUniforms(const core::vector3df &direction, float r, float g, float b, unsigned TU_ntex, unsigned TU_dtex, unsigned TU_shadowtex);
ShadowedSunLightShader();
};
class ShadowedSunLightDebugShader
class RadianceHintsConstructionShader : public ShaderHelperSingleton<RadianceHintsConstructionShader, core::matrix4, core::matrix4, core::vector3df>
{
public:
static GLuint Program;
static GLuint uniform_ntex, uniform_dtex, uniform_shadowtex, uniform_direction, uniform_col;
static GLuint vao;
GLuint TU_ctex, TU_ntex, TU_dtex;
static void init();
static void setUniforms(const core::vector3df &direction, float r, float g, float b, unsigned TU_ntex, unsigned TU_dtex, unsigned TU_shadowtex);
RadianceHintsConstructionShader();
};
class RadianceHintsConstructionShader
class RHDebug : public ShaderHelperSingleton<RHDebug, core::matrix4, core::vector3df>
{
public:
static GLuint Program;
static GLuint uniform_ctex, uniform_ntex, uniform_dtex, uniform_extents, uniform_RHMatrix, uniform_RSMMatrix;
static GLuint vao;
GLuint TU_SHR, TU_SHG, TU_SHB;
static void init();
static void setUniforms(const core::matrix4 &RSMMatrix, const core::matrix4 &RHMatrix, const core::vector3df &extents, unsigned TU_ctex, unsigned TU_ntex, unsigned TU_dtex);
RHDebug();
};
class RHDebug
class GlobalIlluminationReconstructionShader : public ShaderHelperSingleton<GlobalIlluminationReconstructionShader, core::matrix4, core::matrix4, core::vector3df>
{
public:
static GLuint Program;
static GLuint uniform_extents, uniform_SHR, uniform_SHG, uniform_SHB, uniform_RHMatrix;
GLuint TU_ntex, TU_dtex, TU_SHR, TU_SHG, TU_SHB, uniform_RHMatrix;
static void init();
static void setUniforms(const core::matrix4 &RHMatrix, const core::vector3df &extents, unsigned TU_SHR, unsigned TU_SHG, unsigned TU_SHB);
GlobalIlluminationReconstructionShader();
};
class GlobalIlluminationReconstructionShader
class Gaussian17TapHShader : public ShaderHelperSingleton<Gaussian17TapHShader, core::vector2df>
{
public:
static GLuint Program;
static GLuint uniform_ntex, uniform_dtex, uniform_extents, uniform_SHR, uniform_SHG, uniform_SHB, uniform_RHMatrix, uniform_InvRHMatrix;
static GLuint vao;
GLuint TU_tex, TU_depth;
static void init();
static void setUniforms(const core::matrix4 &RHMatrix, const core::matrix4 &InvRHMatrix, const core::vector3df &extents, unsigned TU_ntex, unsigned TU_dtex, unsigned TU_SHR, unsigned TU_SHG, unsigned TU_SHB);
Gaussian17TapHShader();
};
class Gaussian17TapHShader
class ComputeGaussian17TapHShader : public ShaderHelperSingleton<ComputeGaussian17TapHShader>
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_depth, uniform_pixel;
static GLuint vao;
static void init();
GLuint TU_source, TU_dest, TU_depth;
ComputeGaussian17TapHShader();
};
class ComputeGaussian17TapHShader
class Gaussian6HBlurShader : public ShaderHelperSingleton<Gaussian6HBlurShader, core::vector2df>
{
public:
static GLuint Program;
static GLuint uniform_source, uniform_depth, uniform_dest;
GLuint TU_tex;
static void init();
Gaussian6HBlurShader();
};
class Gaussian6HBlurShader
class Gaussian3HBlurShader : public ShaderHelperSingleton<Gaussian3HBlurShader, core::vector2df>
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_pixel;
static GLuint vao;
GLuint TU_tex;
static void init();
Gaussian3HBlurShader();
};
class Gaussian3HBlurShader
class Gaussian17TapVShader : public ShaderHelperSingleton<Gaussian17TapVShader, core::vector2df>
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_pixel;
static GLuint vao;
GLuint TU_tex, TU_depth;
static void init();
Gaussian17TapVShader();
};
class Gaussian17TapVShader
class ComputeGaussian17TapVShader : public ShaderHelperSingleton<ComputeGaussian17TapVShader>
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_depth, uniform_pixel;
static GLuint vao;
GLuint TU_source, TU_depth, TU_dest;
static void init();
};
class ComputeGaussian17TapVShader
{
public:
static GLuint Program;
static GLuint uniform_source, uniform_depth, uniform_dest;
static void init();
ComputeGaussian17TapVShader();
};
class Gaussian6VBlurShader
class Gaussian6VBlurShader : public ShaderHelperSingleton<Gaussian6VBlurShader, core::vector2df>
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_pixel;
static GLuint vao;
GLuint TU_tex;
static void init();
Gaussian6VBlurShader();
};
class Gaussian3VBlurShader
class Gaussian3VBlurShader : public ShaderHelperSingleton<Gaussian3VBlurShader, core::vector2df>
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_pixel;
static GLuint vao;
GLuint TU_tex;
static void init();
Gaussian3VBlurShader();
};
class PassThroughShader
class PassThroughShader : public ShaderHelperSingleton<PassThroughShader>
{
public:
static GLuint Program;
static GLuint uniform_texture;
static GLuint vao;
GLuint TU_tex;
GLuint vao;
static void init();
PassThroughShader();
};
class LayerPassThroughShader
class LayerPassThroughShader : public ShaderHelperSingleton<LayerPassThroughShader, int>
{
public:
static GLuint Program;
static GLuint uniform_layer, uniform_texture;
static GLuint vao;
GLuint TU_texture;
GLuint vao;
static void init();
LayerPassThroughShader();
};
class LinearizeDepthShader
class LinearizeDepthShader : public ShaderHelperSingleton<LinearizeDepthShader, float, float>
{
public:
static GLuint Program;
static GLuint uniform_zn, uniform_zf, uniform_texture;
static GLuint vao;
GLuint TU_tex;
static void init();
static void setUniforms(float zn, float zf, unsigned TU_tex);
LinearizeDepthShader();
};
class GlowShader
class GlowShader : public ShaderHelperSingleton<GlowShader>
{
public:
static GLuint Program;
static GLuint uniform_tex;
static GLuint vao;
GLuint TU_tex;
GLuint vao;
static void init();
GlowShader();
};
class SSAOShader
class SSAOShader : public ShaderHelperSingleton<SSAOShader, float, float, float>
{
public:
static GLuint Program;
static GLuint uniform_ntex, uniform_dtex, uniform_noise_texture, uniform_samplePoints;
static GLuint vao;
static float SSAOSamples[64];
static void init();
static void setUniforms(const core::vector2df &screen, unsigned TU_dtex, unsigned TU_noise);
GLuint TU_dtex;
SSAOShader();
};
class FogShader
class FogShader : public ShaderHelperSingleton<FogShader, float, float, float, float, float, core::vector3df>
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_fogmax, uniform_startH, uniform_endH, uniform_start, uniform_end, uniform_col;
static GLuint vao;
GLuint TU_tex;
static void init();
static void setUniforms(float fogmax, float startH, float endH, float start, float end, const core::vector3df &col, unsigned TU_ntex);
FogShader();
};
class MotionBlurShader
class MotionBlurShader : public ShaderHelperSingleton<MotionBlurShader, core::matrix4, core::vector2df, float, float>
{
public:
static GLuint Program;
static GLuint uniform_boost_amount, uniform_color_buffer, uniform_dtex, uniform_previous_viewproj, uniform_center, uniform_mask_radius;
static GLuint vao;
GLuint TU_cb, TU_dtex;
static void init();
static void setUniforms(float boost_amount, const core::matrix4 &previousVP, const core::vector2df &center, float mask_radius, unsigned TU_cb, unsigned TU_dtex);
MotionBlurShader();
};
class GodFadeShader
class GodFadeShader : public ShaderHelperSingleton<GodFadeShader, video::SColorf>
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_col;
static GLuint vao;
GLuint TU_tex;
GLuint vao;
static void init();
static void setUniforms(const video::SColor &col, unsigned TU_tex);
GodFadeShader();
};
class GodRayShader
class GodRayShader : public ShaderHelperSingleton<GodRayShader, core::vector2df>
{
public:
static GLuint Program;
static GLuint uniform_tex, uniform_sunpos;
static GLuint vao;
GLuint TU_tex;
GLuint vao;
static void init();
static void setUniforms(const core::vector2df &sunpos, unsigned TU_tex);
GodRayShader();
};
class MLAAColorEdgeDetectionSHader
class MLAAColorEdgeDetectionSHader : public ShaderHelperSingleton<MLAAColorEdgeDetectionSHader, core::vector2df>
{
public:
static GLuint Program;
static GLuint uniform_colorMapG, uniform_PIXEL_SIZE;
static GLuint vao;
GLuint TU_colorMapG;
GLuint vao;
static void init();
static void setUniforms(const core::vector2df &PIXEL_SIZE, unsigned TU_colorMapG);
MLAAColorEdgeDetectionSHader();
};
class MLAABlendWeightSHader
class MLAABlendWeightSHader : public ShaderHelperSingleton<MLAABlendWeightSHader, core::vector2df>
{
public:
static GLuint Program;
static GLuint uniform_PIXEL_SIZE, uniform_edgesMap, uniform_areaMap;
static GLuint vao;
static void init();
static void setUniforms(const core::vector2df &PIXEL_SIZE, unsigned TU_edgesMap, unsigned TU_areaMap);
GLuint TU_edgesMap, TU_areaMap;
GLuint vao;
MLAABlendWeightSHader();
};
class MLAAGatherSHader
class MLAAGatherSHader : public ShaderHelperSingleton<MLAAGatherSHader, core::vector2df>
{
public:
static GLuint Program;
static GLuint uniform_PIXEL_SIZE, uniform_colorMap, uniform_blendMap;
static GLuint vao;
GLuint TU_colorMap, TU_blendMap;
GLuint vao;
static void init();
static void setUniforms(const core::vector2df &PIXEL_SIZE, unsigned TU_colormap, unsigned TU_blendmap);
MLAAGatherSHader();
};
}

178
src/graphics/stk_text_billboard.cpp Normal file
View File

@ -0,0 +1,178 @@
#include "graphics/stk_text_billboard.hpp"
#include "graphics/glwrap.hpp"
#include "graphics/shaders.hpp"
#include "graphics/irr_driver.hpp"
#include "graphics/stkbillboard.hpp"
#include "graphics/stkmeshscenenode.hpp"
#include "guiengine/engine.hpp"
#include "guiengine/scalable_font.hpp"
#include <SMesh.h>
#include <SMeshBuffer.h>
#include <ISceneManager.h>
#include <ICameraSceneNode.h>
using namespace irr;
STKTextBillboard::STKTextBillboard(core::stringw text, gui::ScalableFont* font,
const video::SColor& color_top, const video::SColor& color_bottom,
irr::scene::ISceneNode* parent,
irr::scene::ISceneManager* mgr, irr::s32 id,
const irr::core::vector3df& position, const irr::core::vector3df& size) :
STKMeshSceneNode(new scene::SMesh(),
parent, irr_driver->getSceneManager(), -1,
position, core::vector3df(0.0f, 0.0f, 0.0f), size, false)
{
m_color_top = color_top;
m_color_bottom = color_bottom;
getTextMesh(text, font);
createGLMeshes();
Mesh->drop();
//setAutomaticCulling(0);
updateAbsolutePosition();
}
void STKTextBillboard::updateAbsolutePosition()
{
if (Parent)
{
// Override to not use the parent's rotation
AbsoluteTransformation = getRelativeTransformation();
AbsoluteTransformation.setTranslation(AbsoluteTransformation.getTranslation() + Parent->getAbsolutePosition());
}
else
AbsoluteTransformation = getRelativeTransformation();
}
scene::IMesh* STKTextBillboard::getTextMesh(core::stringw text, gui::ScalableFont* font)
{
font->doDraw(text, core::rect<s32>(0, 0, 1000, 1000), video::SColor(255,255,255,255),
false, false, NULL, this);
const float scale = 0.018f;
//scene::SMesh* mesh = new scene::SMesh();
std::map<video::ITexture*, scene::SMeshBuffer*> buffers;
int max_x = 0;
int min_y = 0;
int max_y = 0;
for (unsigned int i = 0; i < m_chars.size(); i++)
{
int char_x = m_chars[i].m_destRect.LowerRightCorner.X;
if (char_x > max_x)
max_x = char_x;
int char_min_y = m_chars[i].m_destRect.UpperLeftCorner.Y;
int char_max_y = m_chars[i].m_destRect.LowerRightCorner.Y;
if (char_min_y < min_y)
min_y = char_min_y;
if (char_max_y > min_y)
max_y = char_max_y;
}
float scaled_center_x = (max_x / 2.0f) * scale;
float scaled_y = (max_y / 2.0f) * scale; // -max_y * scale;
for (unsigned int i = 0; i < m_chars.size(); i++)
{
core::vector3df char_pos(m_chars[i].m_destRect.UpperLeftCorner.X,
m_chars[i].m_destRect.UpperLeftCorner.Y, 0);
char_pos *= scale;
core::vector3df char_pos2(m_chars[i].m_destRect.LowerRightCorner.X,
m_chars[i].m_destRect.LowerRightCorner.Y, 0);
char_pos2 *= scale;
core::dimension2di char_size_i = m_chars[i].m_destRect.getSize();
core::dimension2df char_size(char_size_i.Width*scale, char_size_i.Height*scale);
std::map<video::ITexture*, scene::SMeshBuffer*>::iterator map_itr = buffers.find(m_chars[i].m_texture);
scene::SMeshBuffer* buffer;
if (map_itr == buffers.end())
{
buffer = new scene::SMeshBuffer();
buffer->getMaterial().setTexture(0, m_chars[i].m_texture);
buffer->getMaterial().MaterialType = irr_driver->getShader(ES_OBJECT_UNLIT);
buffers[m_chars[i].m_texture] = buffer;
}
else
{
buffer = map_itr->second;
}
float tex_width = m_chars[i].m_texture->getSize().Width;
float tex_height = m_chars[i].m_texture->getSize().Height;
video::S3DVertex vertices[] =
{
video::S3DVertex(char_pos.X - scaled_center_x, char_pos.Y - scaled_y, 0.0f,
0.0f, 0.0f, 1.0f,
m_color_bottom,
m_chars[i].m_sourceRect.UpperLeftCorner.X / tex_width,
m_chars[i].m_sourceRect.LowerRightCorner.Y / tex_height),
video::S3DVertex(char_pos2.X - scaled_center_x, char_pos.Y - scaled_y, 0.0f,
0.0f, 0.0f, 1.0f,
m_color_bottom,
m_chars[i].m_sourceRect.LowerRightCorner.X / tex_width,
m_chars[i].m_sourceRect.LowerRightCorner.Y / tex_height),
video::S3DVertex(char_pos2.X - scaled_center_x, char_pos2.Y - scaled_y, 0.0f,
0.0f, 0.0f, 1.0f,
m_color_top,
m_chars[i].m_sourceRect.LowerRightCorner.X / tex_width,
m_chars[i].m_sourceRect.UpperLeftCorner.Y / tex_height),
video::S3DVertex(char_pos.X - scaled_center_x, char_pos2.Y - scaled_y, 0.0f,
0.0f, 0.0f, 1.0f,
m_color_top,
m_chars[i].m_sourceRect.UpperLeftCorner.X / tex_width,
m_chars[i].m_sourceRect.UpperLeftCorner.Y / tex_height)
};
irr::u16 indices[] = { 2, 1, 0, 3, 2, 0 };
buffer->append(vertices, 4, indices, 6);
}
for (std::map<video::ITexture*, scene::SMeshBuffer*>::iterator map_itr = buffers.begin();
map_itr != buffers.end(); map_itr++)
{
((scene::SMesh*)Mesh)->addMeshBuffer(map_itr->second);
map_itr->second->recalculateBoundingBox();
Mesh->setBoundingBox(map_itr->second->getBoundingBox()); // TODO: wrong if several buffers
map_itr->second->drop();
}
getMaterial(0).MaterialType = irr_driver->getShader(ES_OBJECT_UNLIT);
return Mesh;
}
void STKTextBillboard::OnRegisterSceneNode()
{
if (IsVisible)
{
SceneManager->registerNodeForRendering(this, scene::ESNRP_SOLID);
scene::ICameraSceneNode* curr_cam = irr_driver->getSceneManager()->getActiveCamera();
core::vector3df cam_pos = curr_cam->getPosition();
core::vector3df text_pos = this->getAbsolutePosition();
float angle = atan2(text_pos.X - cam_pos.X, text_pos.Z - cam_pos.Z);
this->setRotation(core::vector3df(0.0f, angle * 180.0f / M_PI, 0.0f));
updateAbsolutePosition();
}
ISceneNode::OnRegisterSceneNode();
}
void STKTextBillboard::collectChar(video::ITexture* texture,
const core::rect<s32>& destRect,
const core::rect<s32>& sourceRect,
const video::SColor* const colors)
{
m_chars.push_back(STKTextBillboardChar(texture, destRect, sourceRect, colors));
}

69
src/graphics/stk_text_billboard.hpp Normal file
View File

@ -0,0 +1,69 @@
#ifndef STK_TEXT_BILLBOARD_HPP
#define STK_TEXT_BILLBOARD_HPP
#include "../lib/irrlicht/source/Irrlicht/CBillboardSceneNode.h"
#include <IBillboardSceneNode.h>
#include <irrTypes.h>
#include <IMesh.h>
#include "graphics/stkmeshscenenode.hpp"
#include "guiengine/scalable_font.hpp"
#include "utils/cpp2011.hpp"
class STKTextBillboardChar
{
public:
irr::video::ITexture* m_texture;
irr::core::rect<irr::s32> m_destRect;
irr::core::rect<irr::s32> m_sourceRect;
//irr::video::SColor m_colors[4];
STKTextBillboardChar(irr::video::ITexture* texture,
const irr::core::rect<irr::s32>& destRect,
const irr::core::rect<irr::s32>& sourceRect,
const irr::video::SColor* const colors)
{
m_texture = texture;
m_destRect = destRect;
m_sourceRect = sourceRect;
//if (colors == NULL)
//{
// m_colors[0] = m_colors[1] = m_colors[2] = m_colors[3] = NULL;
//}
//else
//{
// m_colors[0] = colors[0];
// m_colors[1] = colors[1];
// m_colors[2] = colors[2];
// m_colors[3] = colors[3];
//}
}
};
class STKTextBillboard : public STKMeshSceneNode, irr::gui::FontCharCollector
{
std::vector<STKTextBillboardChar> m_chars;
irr::video::SColor m_color_top;
irr::video::SColor m_color_bottom;
irr::scene::IMesh* getTextMesh(irr::core::stringw text, gui::ScalableFont* font);
public:
STKTextBillboard(irr::core::stringw text, irr::gui::ScalableFont* font,
const irr::video::SColor& color_top,
const irr::video::SColor& color_bottom,
irr::scene::ISceneNode* parent,
irr::scene::ISceneManager* mgr, irr::s32 id,
const irr::core::vector3df& position,
const irr::core::vector3df& size);
virtual void OnRegisterSceneNode() OVERRIDE;
virtual void collectChar(irr::video::ITexture* texture,
const irr::core::rect<irr::s32>& destRect,
const irr::core::rect<irr::s32>& sourceRect,
const irr::video::SColor* const colors);
virtual void updateAbsolutePosition() OVERRIDE;
};
#endif

16
src/graphics/stkanimatedmesh.cpp
View File

@ -142,16 +142,16 @@ void STKAnimatedMesh::render()
GLMesh* mesh;
for_in(mesh, MeshSolidMaterial[MAT_DEFAULT])
pushVector(ListMatDefault::Arguments, mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
pushVector(ListMatDefault::getInstance(), mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
for_in(mesh, MeshSolidMaterial[MAT_ALPHA_REF])
pushVector(ListMatAlphaRef::Arguments, mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
pushVector(ListMatAlphaRef::getInstance(), mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
for_in(mesh, MeshSolidMaterial[MAT_DETAIL])
pushVector(ListMatDetails::Arguments, mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
pushVector(ListMatDetails::getInstance(), mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
for_in(mesh, MeshSolidMaterial[MAT_UNLIT])
pushVector(ListMatUnlit::Arguments, mesh, AbsoluteTransformation, core::matrix4::EM4CONST_IDENTITY);
pushVector(ListMatUnlit::getInstance(), mesh, AbsoluteTransformation, core::matrix4::EM4CONST_IDENTITY, mesh->TextureMatrix);
return;
}
@ -181,21 +181,21 @@ void STKAnimatedMesh::render()
tmpcol.getBlue() / 255.0f);
for_in(mesh, TransparentMesh[TM_DEFAULT])
ListBlendTransparentFog::Arguments.push_back(
ListBlendTransparentFog::getInstance()->push_back(
STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix,
fogmax, startH, endH, start, end, col));
for_in(mesh, TransparentMesh[TM_ADDITIVE])
ListAdditiveTransparentFog::Arguments.push_back(
ListAdditiveTransparentFog::getInstance()->push_back(
STK::make_tuple(mesh, AbsoluteTransformation, mesh->TextureMatrix,
fogmax, startH, endH, start, end, col));
}
else
{
for_in(mesh, TransparentMesh[TM_DEFAULT])
pushVector(ListBlendTransparent::Arguments, mesh, AbsoluteTransformation, mesh->TextureMatrix);
pushVector(ListBlendTransparent::getInstance(), mesh, AbsoluteTransformation, mesh->TextureMatrix);
for_in(mesh, TransparentMesh[TM_ADDITIVE])
pushVector(ListAdditiveTransparent::Arguments, mesh, AbsoluteTransformation, mesh->TextureMatrix);
pushVector(ListAdditiveTransparent::getInstance(), mesh, AbsoluteTransformation, mesh->TextureMatrix);
}
return;
}

12
src/graphics/stkbillboard.cpp
View File

@ -13,10 +13,10 @@ static void createbillboardvao()
glGenVertexArrays(1, &billboardvao);
glBindVertexArray(billboardvao);
glBindBuffer(GL_ARRAY_BUFFER, SharedObject::billboardvbo);
glEnableVertexAttribArray(MeshShader::BillboardShader::attrib_corner);
glEnableVertexAttribArray(MeshShader::BillboardShader::attrib_texcoord);
glVertexAttribPointer(MeshShader::BillboardShader::attrib_corner, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
glVertexAttribPointer(MeshShader::BillboardShader::attrib_texcoord, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (GLvoid*) (2 * sizeof(float)));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(3);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (GLvoid*) (2 * sizeof(float)));
glBindVertexArray(0);
}
@ -50,8 +50,8 @@ void STKBillboard::render()
compressTexture(tex, true, true);
GLuint texid = getTextureGLuint(tex);
setTexture(0, texid, GL_LINEAR, GL_LINEAR);
glUseProgram(MeshShader::BillboardShader::Program);
MeshShader::BillboardShader::setUniforms(irr_driver->getViewMatrix(), irr_driver->getProjMatrix(), pos, Size, 0);
glUseProgram(MeshShader::BillboardShader::getInstance()->Program);
MeshShader::BillboardShader::getInstance()->setUniforms(irr_driver->getViewMatrix(), irr_driver->getProjMatrix(), pos, Size);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);
return;

259
src/graphics/stkinstancedscenenode.cpp
View File

@ -119,186 +119,25 @@ void STKInstancedSceneNode::addInstance(const core::vector3df &origin, const cor
instance_pos.push_back(scale.Z);
}
static void drawFSPMDefault(GLMesh &mesh, size_t instance_count)
core::matrix4 STKInstancedSceneNode::getInstanceTransform(int id)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
core::matrix4 mat;
if (mesh.textures[0])
{
compressTexture(mesh.textures[0], true);
setTexture(MeshShader::InstancedObjectPass1Shader::getInstance()->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
}
else
{
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::InstancedObjectPass1Shader::getInstance()->setUniforms();
int offset = id * 9;
mat.setTranslation(core::vector3df(
instance_pos[offset],
instance_pos[offset + 1],
instance_pos[offset + 2]));
mat.setRotationDegrees(core::vector3df(
instance_pos[offset + 3],
instance_pos[offset + 4],
instance_pos[offset + 5]));
mat.setScale(core::vector3df(
instance_pos[offset + 6],
instance_pos[offset + 7],
instance_pos[offset + 8]));
glBindVertexArray(mesh.vao);
glDrawElementsInstanced(ptype, count, itype, 0, instance_count);
if (!mesh.textures[0])
{
GLint swizzleMask[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
}
static void drawShadowDefault(GLMesh &mesh, size_t instance_count)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
MeshShader::InstancedShadowShaderInstance->setUniforms();
glBindVertexArray(mesh.vao_shadow_pass);
glDrawElementsInstanced(ptype, count, itype, 0, 4 * instance_count);
}
static void drawFSPMAlphaRefTexture(GLMesh &mesh, size_t instance_count)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], true);
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);
}
static void drawShadowAlphaRefTexture(GLMesh &mesh, size_t instance_count)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], true);
setTexture(MeshShader::InstancedRefShadowShaderInstance->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::InstancedRefShadowShaderInstance->setUniforms();
glBindVertexArray(mesh.vao_shadow_pass);
glDrawElementsInstanced(ptype, count, itype, 0, 4 * instance_count);
}
static void drawShadowGrass(GLMesh &mesh, const core::vector3df &windDir, size_t instance_count)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], true);
setTexture(MeshShader::InstancedGrassShadowShaderInstance->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::InstancedGrassShadowShaderInstance->setUniforms(windDir);
glBindVertexArray(mesh.vao_shadow_pass);
glDrawElementsInstanced(ptype, count, itype, 0, 4 * instance_count);
}
static void drawFSPMGrass(GLMesh &mesh, const core::vector3df &windDir, size_t instance_count)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], true);
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, size_t instance_count)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
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 };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
else
{
GLint swizzleMask[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
MeshShader::InstancedObjectPass2Shader::getInstance()->setUniforms();
glBindVertexArray(mesh.vao);
glDrawElementsInstanced(ptype, count, itype, 0, instance_count);
}
static void drawSMAlphaRefTexture(GLMesh &mesh, size_t instance_count)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], 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 };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
else
{
GLint swizzleMask[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
MeshShader::InstancedObjectRefPass2Shader::getInstance()->setUniforms();
glBindVertexArray(mesh.vao);
glDrawElementsInstanced(ptype, count, itype, 0, instance_count);
}
static void drawSMGrass(GLMesh &mesh, const core::vector3df &windDir, size_t instance_count)
{
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], 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 };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
else
{
GLint swizzleMask[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
setTexture(MeshShader::InstancedGrassPass2Shader::getInstance()->TU_dtex, irr_driver->getDepthStencilTexture(), GL_NEAREST, GL_NEAREST);
SunLightProvider * const cb = (SunLightProvider *)irr_driver->getCallback(ES_SUNLIGHT);
MeshShader::InstancedGrassPass2Shader::getInstance()->setUniforms(windDir, cb->getPosition());
glBindVertexArray(mesh.vao);
glDrawElementsInstanced(ptype, count, itype, 0, instance_count);
return mat;
}
void STKInstancedSceneNode::render()
@ -311,64 +150,14 @@ void STKInstancedSceneNode::render()
setFirstTimeMaterial();
if (irr_driver->getPhase() == SOLID_NORMAL_AND_DEPTH_PASS)
{
ModelViewProjectionMatrix = irr_driver->getProjMatrix();
ModelViewProjectionMatrix *= irr_driver->getViewMatrix();
for (auto mesh : MeshSolidMaterial[MAT_DEFAULT])
ListInstancedMatDefault::getInstance()->push_back(STK::make_tuple(mesh, 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);
for (auto mesh : MeshSolidMaterial[MAT_ALPHA_REF])
ListInstancedMatAlphaRef::getInstance()->push_back(STK::make_tuple(mesh, 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 (!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 (!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 (!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 (!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 (!MeshSolidMaterial[MAT_DEFAULT].empty())
glUseProgram(MeshShader::InstancedShadowShaderInstance->Program);
for (unsigned i = 0; i < MeshSolidMaterial[MAT_DEFAULT].size(); i++)
drawShadowDefault(*MeshSolidMaterial[MAT_DEFAULT][i], instance_pos.size() / 9);
if (!MeshSolidMaterial[MAT_ALPHA_REF].empty())
glUseProgram(MeshShader::InstancedRefShadowShaderInstance->Program);
for (unsigned i = 0; i < MeshSolidMaterial[MAT_ALPHA_REF].size(); i++)
drawShadowAlphaRefTexture(*MeshSolidMaterial[MAT_ALPHA_REF][i], instance_pos.size() / 9);
if (!MeshSolidMaterial[MAT_GRASS].empty())
glUseProgram(MeshShader::InstancedGrassShadowShaderInstance->Program);
for (unsigned i = 0; i < MeshSolidMaterial[MAT_GRASS].size(); i++)
drawShadowGrass(*MeshSolidMaterial[MAT_GRASS][i], windDir, instance_pos.size() / 9);
return;
}
windDir = getWind();
SunLightProvider * const cb = (SunLightProvider *)irr_driver->getCallback(ES_SUNLIGHT);
for (auto mesh : MeshSolidMaterial[MAT_GRASS])
ListInstancedMatGrass::getInstance()->push_back(STK::make_tuple(mesh, instance_pos.size() / 9, windDir, cb->getPosition()));
}

13
src/graphics/stkinstancedscenenode.hpp
View File

@ -4,6 +4,15 @@
#include "stkmesh.hpp"
#include "utils/leak_check.hpp"
class ListInstancedMatDefault : public MeshList<ListInstancedMatDefault, GLMesh *, size_t>
{};
class ListInstancedMatAlphaRef : public MeshList<ListInstancedMatAlphaRef, GLMesh *, size_t>
{};
class ListInstancedMatGrass : public MeshList<ListInstancedMatGrass, GLMesh *, size_t, core::vector3df, core::vector3df>
{};
class STKInstancedSceneNode : public irr::scene::CMeshSceneNode
{
protected:
@ -28,6 +37,10 @@ public:
virtual void render();
void addInstance(const core::vector3df &origin, const core::vector3df &orientation, const core::vector3df &scale);
int getInstanceCount() const { return instance_pos.size() / 9; }
core::matrix4 getInstanceTransform(int id);
void instanceGrab() { m_ref_count++; }
void instanceDrop()
{

17
src/graphics/stkmesh.cpp
View File

@ -291,19 +291,4 @@ bool isObject(video::E_MATERIAL_TYPE type)
if (type == video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF)
return true;
return false;
}
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<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;
}

96
src/graphics/stkmesh.hpp
View File

@ -58,85 +58,49 @@ bool isObject(video::E_MATERIAL_TYPE type);
core::vector3df getWind();
// Pass 1 shader (ie shaders that outputs normals and depth)
class ListMatDefault
{
public:
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > Arguments;
};
template<typename T, typename... Args>
class MeshList : public Singleton<T>, public std::vector<STK::Tuple<Args...> >
{};
class ListMatAlphaRef
{
public:
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > Arguments;
};
class ListMatDefault : public MeshList<ListMatDefault, GLMesh *, core::matrix4, core::matrix4, core::matrix4>
{};
class ListMatNormalMap
{
public:
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > Arguments;
};
class ListMatAlphaRef : public MeshList<ListMatAlphaRef, GLMesh *, core::matrix4, core::matrix4, core::matrix4>
{};
class ListMatGrass
{
public:
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::vector3df> > Arguments;
};
class ListMatNormalMap : public MeshList<ListMatNormalMap, GLMesh *, core::matrix4, core::matrix4, core::matrix4>
{};
class ListMatSphereMap
{
public:
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > Arguments;
};
class ListMatGrass : public MeshList<ListMatGrass, GLMesh *, core::matrix4, core::matrix4, core::vector3df>
{};
class ListMatSplatting
{
public:
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
};
class ListMatSphereMap : public MeshList<ListMatSphereMap, GLMesh *, core::matrix4, core::matrix4, core::matrix4>
{};
class ListMatUnlit
{
public:
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
};
class ListMatSplatting : public MeshList<ListMatSplatting, GLMesh *, core::matrix4, core::matrix4>
{};
class ListMatDetails
{
public:
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > Arguments;
};
class ListMatUnlit : public MeshList<ListMatUnlit, GLMesh *, core::matrix4, core::matrix4, core::matrix4>
{};
class ListMatDetails : public MeshList<ListMatDetails, GLMesh *, core::matrix4, core::matrix4, core::matrix4>
{};
class ListBlendTransparent
{
public:
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
};
class ListBlendTransparent : public MeshList<ListBlendTransparent, GLMesh *, core::matrix4, core::matrix4>
{};
class ListAdditiveTransparent
{
public:
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
};
class ListAdditiveTransparent : public MeshList<ListAdditiveTransparent, GLMesh *, core::matrix4, core::matrix4>
{};
class ListBlendTransparentFog
{
public:
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > Arguments;
};
class ListBlendTransparentFog : public MeshList<ListBlendTransparentFog, GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf>
{};
class ListAdditiveTransparentFog
{
public:
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf> > Arguments;
};
class ListAdditiveTransparentFog : public MeshList<ListAdditiveTransparentFog, GLMesh *, core::matrix4, core::matrix4, float, float, float, float, float, video::SColorf>
{};
class ListDisplacement
{
public:
static std::vector<STK::Tuple<GLMesh *, core::matrix4> > Arguments;
};
class ListDisplacement : public MeshList<ListDisplacement, GLMesh *, core::matrix4>
{};
// Forward pass (for transparents meshes)
void drawBubble(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix);

36
src/graphics/stkmeshscenenode.cpp
View File

@ -15,13 +15,15 @@
STKMeshSceneNode::STKMeshSceneNode(irr::scene::IMesh* mesh, ISceneNode* parent, irr::scene::ISceneManager* mgr, irr::s32 id,
const irr::core::vector3df& position,
const irr::core::vector3df& rotation,
const irr::core::vector3df& scale) :
const irr::core::vector3df& scale, bool createGLMeshes) :
CMeshSceneNode(mesh, parent, mgr, id, position, rotation, scale)
{
isDisplacement = false;
immediate_draw = false;
update_each_frame = false;
createGLMeshes();
if (createGLMeshes)
this->createGLMeshes();
}
void STKMeshSceneNode::setReloadEachFrame(bool val)
@ -140,7 +142,7 @@ void STKMeshSceneNode::drawGlow(const GLMesh &mesh)
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
MeshShader::ColorizeShader::setUniforms(AbsoluteTransformation, cb->getRed(), cb->getGreen(), cb->getBlue());
MeshShader::ColorizeShader::getInstance()->setUniforms(AbsoluteTransformation, video::SColorf(cb->getRed(), cb->getGreen(), cb->getBlue()));
glDrawElementsBaseVertex(ptype, count, itype, (GLvoid *)mesh.vaoOffset, mesh.vaoBaseVertex);
}
@ -247,29 +249,29 @@ void STKMeshSceneNode::render()
GLMesh* mesh;
for_in(mesh, MeshSolidMaterials[MAT_DEFAULT])
pushVector(ListMatDefault::Arguments, mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
pushVector(ListMatDefault::getInstance(), mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
for_in(mesh, MeshSolidMaterials[MAT_ALPHA_REF])
pushVector(ListMatAlphaRef::Arguments, mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
pushVector(ListMatAlphaRef::getInstance(), mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
for_in(mesh, MeshSolidMaterials[MAT_SPHEREMAP])
pushVector(ListMatSphereMap::Arguments, mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
pushVector(ListMatSphereMap::getInstance(), mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
for_in(mesh, MeshSolidMaterials[MAT_DETAIL])
pushVector(ListMatDetails::Arguments, mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
pushVector(ListMatDetails::getInstance(), mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
windDir = getWind();
for_in(mesh, MeshSolidMaterials[MAT_GRASS])
pushVector(ListMatGrass::Arguments, mesh, AbsoluteTransformation, invmodel, windDir);
pushVector(ListMatGrass::getInstance(), mesh, AbsoluteTransformation, invmodel, windDir);
for_in(mesh, MeshSolidMaterials[MAT_UNLIT])
pushVector(ListMatUnlit::Arguments, mesh, AbsoluteTransformation, core::matrix4::EM4CONST_IDENTITY);
pushVector(ListMatUnlit::getInstance(), mesh, AbsoluteTransformation, core::matrix4::EM4CONST_IDENTITY, mesh->TextureMatrix);
for_in(mesh, MeshSolidMaterials[MAT_SPLATTING])
pushVector(ListMatSplatting::Arguments, mesh, AbsoluteTransformation, invmodel);
pushVector(ListMatSplatting::getInstance(), mesh, AbsoluteTransformation, invmodel);
for_in(mesh, MeshSolidMaterials[MAT_NORMAL_MAP])
pushVector( ListMatNormalMap::Arguments, mesh, AbsoluteTransformation, invmodel, core::matrix4::EM4CONST_IDENTITY);
pushVector(ListMatNormalMap::getInstance(), mesh, AbsoluteTransformation, invmodel, core::matrix4::EM4CONST_IDENTITY);
return;
}
@ -310,7 +312,7 @@ void STKMeshSceneNode::render()
if (irr_driver->getPhase() == GLOW_PASS)
{
glUseProgram(MeshShader::ColorizeShader::Program);
glUseProgram(MeshShader::ColorizeShader::getInstance()->Program);
for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i)
{
scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i);
@ -409,23 +411,23 @@ void STKMeshSceneNode::render()
tmpcol.getBlue() / 255.0f);
for_in(mesh, TransparentMesh[TM_DEFAULT])
pushVector(ListBlendTransparentFog::Arguments, mesh, AbsoluteTransformation, mesh->TextureMatrix,
pushVector(ListBlendTransparentFog::getInstance(), mesh, AbsoluteTransformation, mesh->TextureMatrix,
fogmax, startH, endH, start, end, col);
for_in(mesh, TransparentMesh[TM_ADDITIVE])
pushVector(ListAdditiveTransparentFog::Arguments, mesh, AbsoluteTransformation, mesh->TextureMatrix,
pushVector(ListAdditiveTransparentFog::getInstance(), mesh, AbsoluteTransformation, mesh->TextureMatrix,
fogmax, startH, endH, start, end, col);
}
else
{
for_in(mesh, TransparentMesh[TM_DEFAULT])
pushVector(ListBlendTransparent::Arguments, mesh, AbsoluteTransformation, mesh->TextureMatrix);
pushVector(ListBlendTransparent::getInstance(), mesh, AbsoluteTransformation, mesh->TextureMatrix);
for_in(mesh, TransparentMesh[TM_ADDITIVE])
pushVector(ListAdditiveTransparent::Arguments, mesh, AbsoluteTransformation, mesh->TextureMatrix);
pushVector(ListAdditiveTransparent::getInstance(), mesh, AbsoluteTransformation, mesh->TextureMatrix);
}
for_in(mesh, TransparentMesh[TM_DISPLACEMENT])
pushVector(ListDisplacement::Arguments, mesh, AbsoluteTransformation);
pushVector(ListDisplacement::getInstance(), mesh, AbsoluteTransformation);
if (!TransparentMesh[TM_BUBBLE].empty())
glUseProgram(MeshShader::BubbleShader::Program);

3
src/graphics/stkmeshscenenode.hpp
View File

@ -29,7 +29,8 @@ public:
STKMeshSceneNode(irr::scene::IMesh* mesh, ISceneNode* parent, irr::scene::ISceneManager* mgr, irr::s32 id,
const irr::core::vector3df& position = irr::core::vector3df(0, 0, 0),
const irr::core::vector3df& rotation = irr::core::vector3df(0, 0, 0),
const irr::core::vector3df& scale = irr::core::vector3df(1.0f, 1.0f, 1.0f));
const irr::core::vector3df& scale = irr::core::vector3df(1.0f, 1.0f, 1.0f),
bool createGLMeshes = true);
virtual void render();
virtual void setMesh(irr::scene::IMesh* mesh);
virtual void OnRegisterSceneNode();

65
src/guiengine/scalable_font.cpp
View File

@ -463,6 +463,14 @@ core::dimension2d<u32> ScalableFont::getDimension(const wchar_t* text) const
return dim;
}
void ScalableFont::draw(const core::stringw& text,
const core::rect<s32>& position, video::SColor color,
bool hcenter, bool vcenter,
const core::rect<s32>* clip)
{
doDraw(text, position, color, hcenter, vcenter, clip, NULL);
}
void ScalableFont::draw(const core::stringw& text,
const core::rect<s32>& position, video::SColor color,
bool hcenter, bool vcenter,
@ -471,16 +479,17 @@ void ScalableFont::draw(const core::stringw& text,
bool previousRTL = m_rtl;
if (ignoreRTL) m_rtl = false;
draw(text, position, color, hcenter, vcenter, clip);
doDraw(text, position, color, hcenter, vcenter, clip, NULL);
if (ignoreRTL) m_rtl = previousRTL;
}
//! draws some text and clips it to the specified rectangle if wanted
void ScalableFont::draw(const core::stringw& text,
const core::rect<s32>& position, video::SColor color,
bool hcenter, bool vcenter,
const core::rect<s32>* clip)
void ScalableFont::doDraw(const core::stringw& text,
const core::rect<s32>& position, video::SColor color,
bool hcenter, bool vcenter,
const core::rect<s32>* clip,
FontCharCollector* charCollector)
{
if (!Driver) return;
@ -637,7 +646,7 @@ void ScalableFont::draw(const core::stringw& text,
}
}
if (m_black_border)
if (m_black_border && charCollector == NULL)
{
// draw black border
video::SColor black(color.getAlpha(),0,0,0);
@ -658,23 +667,45 @@ void ScalableFont::draw(const core::stringw& text,
if (fallback[n])
{
// draw text over
// TODO: don't hardcode colors?
static video::SColor orange(color.getAlpha(), 255, 100, 0);
static video::SColor yellow(color.getAlpha(), 255, 220, 15);
video::SColor title_colors[] = {yellow, orange, orange, yellow};
draw2DImage(texture,
dest,
source,
clip,
title_colors, true);
if (charCollector != NULL)
{
charCollector->collectChar(texture,
dest,
source,
title_colors);
}
else
{
draw2DImage(texture,
dest,
source,
clip,
title_colors, true);
}
}
else
{
draw2DImage(texture,
dest,
source,
clip,
color, true);
if (charCollector != NULL)
{
video::SColor colors[] = { color, color, color, color };
charCollector->collectChar(texture,
dest,
source,
colors);
}
else
{
draw2DImage(texture,
dest,
source,
clip,
color, true);
}
#ifdef FONT_DEBUG
driver->draw2DLine(core::position2d<s32>(dest.UpperLeftCorner.X, dest.UpperLeftCorner.Y),
core::position2d<s32>(dest.UpperLeftCorner.X, dest.LowerRightCorner.Y),

24
src/guiengine/scalable_font.hpp
View File

@ -26,6 +26,7 @@ namespace video
{
class IVideoDriver;
class IImage;
class ITexture;
}
namespace gui
@ -33,6 +34,14 @@ namespace gui
class IGUIEnvironment;
class FontCharCollector
{
public:
virtual void collectChar(video::ITexture* texture, const core::rect<s32>& destRect,
const core::rect<s32>& sourceRect, const video::SColor* const colors) = 0;
};
class ScalableFont : public IGUIFontBitmap
{
float m_scale;
@ -101,12 +110,17 @@ public:
//! draws an text and clips it to the specified rectangle if wanted
virtual void draw(const core::stringw& text, const core::rect<s32>& position,
video::SColor color, bool hcenter=false,
bool vcenter=false, const core::rect<s32>* clip=0);
video::SColor color, bool hcenter = false,
bool vcenter = false, const core::rect<s32>* clip = 0);
virtual void draw(const core::stringw& text, const core::rect<s32>& position,
video::SColor color, bool hcenter,
bool vcenter, const core::rect<s32>* clip, bool ignoreRTL);
void draw(const core::stringw& text, const core::rect<s32>& position,
video::SColor color, bool hcenter,
bool vcenter, const core::rect<s32>* clip, bool ignoreRTL);
void doDraw(const core::stringw& text, const core::rect<s32>& position,
video::SColor color, bool hcenter,
bool vcenter, const core::rect<s32>* clip,
FontCharCollector* charCollector = NULL);
//! returns the dimension of a text
virtual core::dimension2d<u32> getDimension(const wchar_t* text) const;

5
src/guiengine/widgets/spinner_widget.cpp
View File

@ -19,6 +19,7 @@
#include "graphics/irr_driver.hpp"
#include "guiengine/engine.hpp"
#include "guiengine/scalable_font.hpp"
#include "guiengine/widgets/spinner_widget.hpp"
#include "io/file_manager.hpp"
#include "utils/string_utils.hpp"
@ -161,6 +162,10 @@ void SpinnerWidget::add()
label->setText(m_labels[m_value].c_str() );
}
if (widget_size.getHeight() < GUIEngine::getFontHeight())
{
label->setOverrideFont(GUIEngine::getSmallFont());
}
}

163
src/karts/kart.cpp
View File

@ -36,6 +36,7 @@
#include "graphics/shadow.hpp"
#include "graphics/skid_marks.hpp"
#include "graphics/slip_stream.hpp"
#include "graphics/stk_text_billboard.hpp"
#include "graphics/stars.hpp"
#include "guiengine/scalable_font.hpp"
#include "karts/explosion_animation.hpp"
@ -342,6 +343,7 @@ void Kart::reset()
m_has_started = false;
m_wheel_rotation = 0;
m_bounce_back_time = 0.0f;
m_brake_time = 0.0f;
m_time_last_crash = 0.0f;
m_speed = 0.0f;
m_current_lean = 0.0f;
@ -581,39 +583,40 @@ void Kart::createPhysics()
btCollisionShape *shape;
const Vec3 &bevel = m_kart_properties->getBevelFactor();
if(bevel.getX() || bevel.getY() || bevel.getZ())
Vec3 wheel_pos[4];
assert(bevel.getX() || bevel.getY() || bevel.getZ());
Vec3 orig_factor(1, 1, 1 - bevel.getZ());
Vec3 bevel_factor(1.0f - bevel.getX(), 1.0f - bevel.getY(), 1.0f);
btConvexHullShape *hull = new btConvexHullShape();
for (int y = -1; y <= 1; y += 2)
{
Vec3 orig_factor(1, 1, 1-bevel.getZ());
Vec3 bevel_factor(1.0f-bevel.getX(),
1.0f-bevel.getY(),
1.0f );
btConvexHullShape *hull = new btConvexHullShape();
for(int x=-1; x<=1; x+=2)
for (int z = -1; z <= 1; z += 2)
{
for(int y=-1; y<=1; y+=2)
for (int x = -1; x <= 1; x += 2)
{
for(int z=-1; z<=1; z+=2)
Vec3 p(x*getKartModel()->getWidth() *0.5f,
y*getKartModel()->getHeight()*0.5f,
z*getKartModel()->getLength()*0.5f);
hull->addPoint(p*orig_factor);
hull->addPoint(p*bevel_factor);
// Store the x/z position for the wheels as a weighted average
// of the two bevelled points.
if (y == -1)
{
Vec3 p(x*getKartModel()->getWidth()*0.5f,
y*getKartModel()->getHeight()*0.5f,
z*getKartModel()->getLength()*0.5f);
int index = (x + 1) / 2 + 1 - z; // get index of wheel
float f = getKartProperties()->getPhysicalWheelPosition();
wheel_pos[index] = p*(orig_factor*(1.0f-f) + bevel_factor*f);
wheel_pos[index].setY(0);
} // if z==-1
} // for x
} // for z
} // for y
hull->addPoint(p*orig_factor);
hull->addPoint(p*bevel_factor);
} // for z
} // for y
} // for x
// This especially enables proper drawing of the point cloud
hull->initializePolyhedralFeatures();
shape = hull;
} // bevel.getX()!=0
else
{
shape = new btBoxShape(btVector3(0.5f*kart_width,
0.5f*kart_height,
0.5f*kart_length));
}
// This especially enables proper drawing of the point cloud
hull->initializePolyhedralFeatures();
shape = hull;
btTransform shiftCenterOfGravity;
shiftCenterOfGravity.setIdentity();
@ -670,7 +673,7 @@ void Kart::createPhysics()
{
bool is_front_wheel = i<2;
btWheelInfo& wheel = m_vehicle->addWheel(
m_kart_model->getWheelPhysicsPosition(i),
wheel_pos[i],
wheel_direction, wheel_axle, suspension_rest,
wheel_radius, tuning, is_front_wheel);
wheel.m_suspensionStiffness = m_kart_properties->getSuspensionStiffness();
@ -1097,7 +1100,7 @@ void Kart::update(float dt)
// TODO: hiker said this probably will be moved to btKart or so when updating bullet engine.
// Neutralize any yaw change if the kart leaves the ground, so the kart falls more or less
// straight after jumping, but still allowing some "boat shake" (roll and pitch).
// straight after jumping, but still allowing some "boat shake" (roIll and pitch).
// Otherwise many non perfect jumps end in a total roll over or a serious change of
// direction, sometimes 90 or even full U turn (real but less fun for a karting game).
// As side effect steering becames a bit less responsive (any wheel on air), but not too bad.
@ -2022,30 +2025,6 @@ void Kart::updatePhysics(float dt)
m_max_speed->setMinSpeed(min_speed);
m_max_speed->update(dt);
// If the kart is flying, keep its up-axis aligned to gravity (which in
// turn typically means the kart is parallel to the ground). This avoids
// that the kart rotates in mid-air and lands on its side.
if(m_vehicle->getNumWheelsOnGround()==0)
{
btVector3 kart_up = getTrans().getBasis().getColumn(1); // up vector
btVector3 terrain_up = m_body->getGravity();
float g = World::getWorld()->getTrack()->getGravity();
// Normalize the gravity, g is the length of the vector
btVector3 new_up = 0.9f * kart_up + 0.1f * terrain_up/-g;
// Get the rotation (hpr) based on current heading.
Vec3 rotation(getHeading(), new_up);
btMatrix3x3 m;
m.setEulerZYX(rotation.getX(), rotation.getY(), rotation.getZ());
// We can't use getXYZ() for the position here, since the position is
// based on interpolation, while the actual center-of-mass-transform
// is based on the actual value every 1/60 of a second (using getXYZ()
// would result in the kart being pushed ahead a bit, making it jump
// much further, depending on fps)
btTransform new_trans(m, m_body->getCenterOfMassTransform().getOrigin());
//setTrans(new_trans);
m_body->setCenterOfMassTransform(new_trans);
}
// To avoid tunneling (which can happen on long falls), clamp the
// velocity in Y direction. Tunneling can happen if the Y velocity
// is larger than the maximum suspension travel (per frame), since then
@ -2173,6 +2152,7 @@ void Kart::updateEnginePowerAndBrakes(float dt)
if(m_vehicle->getWheelInfo(0).m_brake &&
!World::getWorld()->isStartPhase())
m_vehicle->setAllBrakes(0);
m_brake_time = 0;
}
else
{ // not accelerating
@ -2182,9 +2162,11 @@ void Kart::updateEnginePowerAndBrakes(float dt)
if(m_speed > 0.0f)
{ // Still going forward while braking
applyEngineForce(0.f);
//apply the brakes
m_vehicle->setAllBrakes(m_kart_properties->getBrakeFactor());
m_brake_time += dt;
// Apply the brakes - include the time dependent brake increase
float f = 1 + m_brake_time
* getKartProperties()->getBrakeTimeIncrease();
m_vehicle->setAllBrakes(m_kart_properties->getBrakeFactor()*f);
}
else // m_speed < 0
{
@ -2208,6 +2190,7 @@ void Kart::updateEnginePowerAndBrakes(float dt)
}
else // !m_brake
{
m_brake_time = 0;
// lift the foot from throttle, brakes with 10% engine_power
assert(!isnan(m_controls.m_accel));
assert(!isnan(engine_power));
@ -2518,38 +2501,29 @@ void Kart::updateGraphics(float dt, const Vec3& offset_xyz,
for(unsigned int i=0; i<4; i++)
{
// Set the suspension length
height_above_terrain[i] =
( m_vehicle->getWheelInfo(i).m_raycastInfo.m_hardPointWS
- m_vehicle->getWheelInfo(i).m_raycastInfo.m_contactPointWS).length()
- m_vehicle->getWheelInfo(i).m_chassisConnectionPointCS.getY();
const btWheelInfo &wi = m_vehicle->getWheelInfo(i);
height_above_terrain[i] = wi.m_raycastInfo.m_suspensionLength;
if(height_above_terrain[i] < min_hat) min_hat = height_above_terrain[i];
}
float kart_hat = m_kart_model->getLowestPoint();
float chassis_delta = 0;
// Check if the chassis needs to be moved down so that the wheels look
// like they are in the rest state, i.e. the wheels are not too far down.
if(min_hat > m_kart_model->getLowestPoint())
if(min_hat >= kart_hat)
{
chassis_delta = min_hat - m_kart_model->getLowestPoint();
for(unsigned int i=0; i<4; i++)
height_above_terrain[i] -= chassis_delta;
height_above_terrain[i] = kart_hat;
}
m_kart_model->update(dt, m_wheel_rotation_dt, getSteerPercent(),
height_above_terrain, m_speed);
height_above_terrain, m_speed);
// If the kart is leaning, part of the kart might end up 'in' the track.
// To avoid this, raise the kart enough to offset the leaning.
float lean_height = tan(fabsf(m_current_lean)) * getKartWidth()*0.5f;
Vec3 center_shift = m_kart_properties->getGravityCenterShift();
center_shift.setY(m_skidding->getGraphicalJumpOffset() + lean_height
- m_kart_model->getLowestPoint() -chassis_delta );
float heading = m_skidding->getVisualSkidRotation();
Vec3 center_shift = Vec3(0, m_skidding->getGraphicalJumpOffset() - kart_hat
+ lean_height-m_kart_model->getLowestPoint(), 0);
center_shift = getTrans().getBasis() * center_shift;
float heading = m_skidding->getVisualSkidRotation();
Moveable::updateGraphics(dt, center_shift,
btQuaternion(heading, 0, m_current_lean));
@ -2598,21 +2572,36 @@ btQuaternion Kart::getVisualRotation() const
void Kart::setOnScreenText(const wchar_t *text)
{
core::dimension2d<u32> textsize = GUIEngine::getFont()->getDimension(text);
// FIXME: Titlefont is the only font guaranteed to be loaded if STK
// is started without splash screen (since "Loading" is shown even in this
// case). A smaller font would be better
// TODO: Add support in the engine for BillboardText or find a replacement
/*scene::ISceneManager* sm = irr_driver->getSceneManager();
sm->addBillboardTextSceneNode(GUIEngine::getFont() ? GUIEngine::getFont()
: GUIEngine::getTitleFont(),
text,
getNode(),
core::dimension2df(textsize.Width/55.0f,
textsize.Height/55.0f),
core::vector3df(0.0f, 1.5f, 0.0f),
-1, // id
video::SColor(255, 255, 225, 0),
video::SColor(255, 255, 89, 0));*/
if (irr_driver->isGLSL())
{
gui::ScalableFont* font = GUIEngine::getFont() ? GUIEngine::getFont() : GUIEngine::getTitleFont();
STKTextBillboard* tb = new STKTextBillboard(text, font,
video::SColor(255, 255, 225, 0),
video::SColor(255, 255, 89, 0),
getNode(), irr_driver->getSceneManager(), -1,
core::vector3df(0.0f, 1.5f, 0.0f),
core::vector3df(1.0f, 1.0f, 1.0f));
}
else
{
scene::ISceneManager* sm = irr_driver->getSceneManager();
sm->addBillboardTextSceneNode(GUIEngine::getFont() ? GUIEngine::getFont()
: GUIEngine::getTitleFont(),
text,
getNode(),
core::dimension2df(textsize.Width/55.0f,
textsize.Height/55.0f),
core::vector3df(0.0f, 1.5f, 0.0f),
-1, // id
video::SColor(255, 255, 225, 0),
video::SColor(255, 255, 89, 0));
}
// No need to store the reference to the billboard scene node:
// It has one reference to the parent, and will get deleted
// when the parent is deleted.

6
src/karts/kart.hpp
View File

@ -116,9 +116,13 @@ private:
* determine startup boost. */
bool m_has_started;
/**<Maximum engine rpm's for the current gear*/
/** Maximum engine rpm's for the current gear. */
float m_max_gear_rpm;
/** How long the brake key has been pressed - the longer the harder
* the kart will brake. */
float m_brake_time;
/** A short time after a collision acceleration is disabled to allow
* the karts to bounce back*/
float m_bounce_back_time;

38
src/karts/kart_model.cpp
View File

@ -107,7 +107,6 @@ KartModel::KartModel(bool is_master)
for(unsigned int i=0; i<4; i++)
{
m_wheel_graphics_position[i] = Vec3(UNDEFINED);
m_wheel_physics_position[i] = Vec3(UNDEFINED);
m_wheel_graphics_radius[i] = 0.0f; // for kart without separate wheels
m_wheel_model[i] = NULL;
m_wheel_node[i] = NULL;
@ -299,7 +298,6 @@ KartModel* KartModel::makeCopy()
assert(!m_wheel_node[i]);
km->m_wheel_filename[i] = m_wheel_filename[i];
km->m_wheel_graphics_position[i] = m_wheel_graphics_position[i];
km->m_wheel_physics_position[i] = m_wheel_physics_position[i];
km->m_wheel_graphics_radius[i] = m_wheel_graphics_radius[i];
km->m_min_suspension[i] = m_min_suspension[i];
km->m_max_suspension[i] = m_max_suspension[i];
@ -626,43 +624,10 @@ void KartModel::loadWheelInfo(const XMLNode &node,
}
wheel_node->get("model", &m_wheel_filename[index] );
wheel_node->get("position", &m_wheel_graphics_position[index]);
wheel_node->get("physics-position", &m_wheel_physics_position[index] );
wheel_node->get("min-suspension", &m_min_suspension[index] );
wheel_node->get("max-suspension", &m_max_suspension[index] );
} // loadWheelInfo
// ----------------------------------------------------------------------------
/** Sets the default position for the physical wheels if they are not defined
* in the data file. The default position is to have the wheels at the corner
* of the chassis. But since the position is relative to the center of mass,
* this must be specified.
* \param center_shift Amount the kart chassis is moved relative to the center
* of mass.
* \param wheel_radius Radius of the physics wheels.
*/
void KartModel::setDefaultPhysicsPosition(const Vec3 &center_shift,
float wheel_radius)
{
for(unsigned int i=0; i<4; i++)
{
if(m_wheel_physics_position[i].getX()==UNDEFINED)
{
m_wheel_physics_position[i].setX( ( i==1||i==3)
? -0.5f*m_kart_width
: 0.5f*m_kart_width
+center_shift.getX( ));
// Set the connection point so that a maximum compressed wheel
// (susp. length=0) will still poke a little bit out under the
// kart
m_wheel_physics_position[i].setY(wheel_radius-0.05f);
m_wheel_physics_position[i].setZ( (0.5f*m_kart_length-wheel_radius)
* ( (i<2) ? 1 : -1)
+center_shift.getZ());
} // if physics position is not defined
}
} // setDefaultPhysicsPosition
// ----------------------------------------------------------------------------
/** Resets the kart model. It stops animation from being played and resets
* the wheels to the correct position (i.e. no suspension).
@ -804,7 +769,8 @@ void KartModel::update(float dt, float rotation_dt, float steer,
}
#endif
core::vector3df pos = m_wheel_graphics_position[i].toIrrVector();
pos.Y = m_kart_lowest_point - height_above_terrain[i]
//
pos.Y = - height_above_terrain[i] + m_kart_lowest_point
+ m_wheel_graphics_radius[i];
m_wheel_node[i]->setPosition(pos);

14
src/karts/kart_model.hpp
View File

@ -157,10 +157,6 @@ private:
/** The position of all four wheels in the 3d model. */
Vec3 m_wheel_graphics_position[4];
/** The position of the wheels for the physics, which can be different
* from the graphical position. */
Vec3 m_wheel_physics_position[4];
/** Radius of the graphical wheels. */
float m_wheel_graphics_radius[4];
@ -233,8 +229,6 @@ public:
bool loadModels(const KartProperties &kart_properties);
void update(float dt, float rotation_dt, float steer,
const float height_abve_terrain[4], float speed);
void setDefaultPhysicsPosition(const Vec3 &center_shift,
float wheel_radius);
void finishedRace();
scene::ISceneNode*
attachModel(bool animatedModels, bool always_animated);
@ -263,14 +257,6 @@ public:
const Vec3* getWheelsGraphicsPosition() const
{return m_wheel_graphics_position;}
// ------------------------------------------------------------------------
/** Returns the position of a wheel relative to the kart for the physics.
* The physics wheels can be attached at a different place to make the
* karts more stable.
* \param i Index of the wheel: 0=front right, 1 = front left, 2 = rear
* right, 3 = rear left. */
const Vec3& getWheelPhysicsPosition(unsigned int i) const
{assert(i<4); return m_wheel_physics_position[i];}
// ------------------------------------------------------------------------
/** Returns the radius of the graphical wheels.
* \param i Index of the wheel: 0=front right, 1 = front left, 2 = rear
* right, 3 = rear left. */

18
src/karts/kart_properties.cpp
View File

@ -64,7 +64,7 @@ KartProperties::KartProperties(const std::string &filename)
// Set all other values to undefined, so that it can later be tested
// if everything is defined properly.
m_mass = m_brake_factor =
m_mass = m_brake_factor = m_brake_time_increase =
m_time_reset_steer = m_nitro_consumption = m_nitro_engine_force =
m_nitro_small_container = m_nitro_big_container = m_nitro_max =
m_nitro_max_speed_increase = m_nitro_duration = m_nitro_fade_out_time =
@ -92,6 +92,7 @@ KartProperties::KartProperties(const std::string &filename)
m_squash_duration = m_downward_impulse_factor =
m_bubblegum_fade_in_time = m_bubblegum_speed_fraction =
m_bubblegum_time = m_bubblegum_torque = m_jump_animation_time =
m_smooth_flying_impulse = m_physical_wheel_position =
UNDEFINED;
m_engine_power.resize(RaceManager::DIFFICULTY_COUNT, UNDEFINED);
@ -270,10 +271,9 @@ void KartProperties::load(const std::string &filename, const std::string &node)
m_gravity_center_shift.setY(m_kart_model->getHeight()*0.5f);
m_gravity_center_shift.setZ(0);
}
m_kart_model->setDefaultPhysicsPosition(m_gravity_center_shift,
m_wheel_radius );
m_wheel_base = fabsf( m_kart_model->getWheelPhysicsPosition(0).getZ()
-m_kart_model->getWheelPhysicsPosition(2).getZ());
//FIXME: magix 0.25 factor to keep it compatible with previous tourning
m_wheel_base = fabsf( m_kart_model->getLength()-0.25f);
// Now convert the turn radius into turn angle:
for(unsigned int i=0; i<m_turn_angle_at_speed.size(); i++)
@ -370,6 +370,7 @@ void KartProperties::getAllData(const XMLNode * root)
&m_downward_impulse_factor);
stability_node->get("track-connection-accel",
&m_track_connection_accel );
stability_node->get("smooth-flying-impulse", &m_smooth_flying_impulse);
}
if(const XMLNode *collision_node = root->getNode("collision"))
@ -379,6 +380,7 @@ void KartProperties::getAllData(const XMLNode * root)
collision_node->get("terrain-impulse", &m_collision_terrain_impulse);
collision_node->get("restitution", &m_restitution );
collision_node->get("bevel-factor", &m_bevel_factor );
collision_node->get("physical-wheel-position",&m_physical_wheel_position);
std::string s;
collision_node->get("impulse-type", &s );
s = StringUtils::toLowerCase(s);
@ -527,7 +529,8 @@ void KartProperties::getAllData(const XMLNode * root)
if(const XMLNode *engine_node = root->getNode("engine"))
{
engine_node->get("brake-factor", &m_brake_factor);
engine_node->get("brake-factor", &m_brake_factor);
engine_node->get("brake-time-increase", &m_brake_time_increase);
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)
@ -659,8 +662,10 @@ void KartProperties::checkAllSet(const std::string &filename)
CHECK_NEG(m_chassis_angular_damping, "stability chassis-angular-damping");
CHECK_NEG(m_downward_impulse_factor, "stability downward-impulse-factor");
CHECK_NEG(m_track_connection_accel, "stability track-connection-accel" );
CHECK_NEG(m_smooth_flying_impulse, "smooth-flying-impulse" );
CHECK_NEG(m_max_speed_reverse_ratio, "engine max-speed-reverse-ratio");
CHECK_NEG(m_brake_factor, "engine brake-factor" );
CHECK_NEG(m_brake_time_increase, "engine brake-time-increase" );
CHECK_NEG(m_suspension_stiffness, "suspension stiffness" );
CHECK_NEG(m_suspension_rest, "suspension rest" );
CHECK_NEG(m_suspension_travel_cm, "suspension travel-cm" );
@ -672,6 +677,7 @@ void KartProperties::checkAllSet(const std::string &filename)
CHECK_NEG(m_bevel_factor.getX(), "collision bevel-factor" );
CHECK_NEG(m_bevel_factor.getY(), "collision bevel-factor" );
CHECK_NEG(m_bevel_factor.getZ(), "collision bevel-factor" );
CHECK_NEG(m_physical_wheel_position, "collision physical-wheel-position");
CHECK_NEG(m_rubber_band_max_length, "plunger band-max-length" );
CHECK_NEG(m_rubber_band_force, "plunger band-force" );
CHECK_NEG(m_rubber_band_duration, "plunger band-duration" );

35
src/karts/kart_properties.hpp
View File

@ -130,12 +130,19 @@ private:
/** Braking factor * engine_power braking force. */
float m_brake_factor;
/** Brake_time * m_brake_time_increase will increase the break time
* over time. */
float m_brake_time_increase;
/** Time for player karts to reach full steer angle. */
InterpolationArray m_time_full_steer;
/** Time for steering to go back to zero from full steer. */
float m_time_reset_steer;
/** A torque impulse applied to keep the kart parallel to the ground. */
float m_smooth_flying_impulse;;
/** The turn angle depending on speed. */
InterpolationArray m_turn_angle_at_speed;
@ -143,6 +150,11 @@ private:
* collision shape. */
Vec3 m_bevel_factor;
/** The position of the physical wheel is a weighted average of the
* two ends of the beveled shape. This determines the weight: 0 =
* a the widest end, 1 = at the narrowest front end. */
float m_physical_wheel_position;
/** Time a kart is moved upwards after when it is rescued. */
float m_rescue_time;
@ -501,10 +513,21 @@ public:
/** Get braking information. */
float getBrakeFactor () const {return m_brake_factor; }
// ------------------------------------------------------------------------
/** Returns the additional brake factor which depends on time. */
float getBrakeTimeIncrease() const { return m_brake_time_increase; }
// ------------------------------------------------------------------------
/** Returns the torque scaling factor used to keep the karts parallel to
* the ground when flying. */
float getSmoothFlyingImpulse() const
{
return m_smooth_flying_impulse;
} // getSmoothFlyingImpulse
// ------------------------------------------------------------------------
/** Get maximum reverse speed ratio. */
float getMaxSpeedReverseRatio () const
{return m_max_speed_reverse_ratio; }
float getMaxSpeedReverseRatio() const {return m_max_speed_reverse_ratio; }
// ------------------------------------------------------------------------
/** Returns the engine type (used to change sfx depending on kart size). */
@ -890,6 +913,14 @@ public:
// ------------------------------------------------------------------------
/** Returns the bevel factor (!=0 indicates to use a bevelled box). */
const Vec3 &getBevelFactor() const { return m_bevel_factor; }
// ------------------------------------------------------------------------
/** Returns position of the physical wheel is a weighted average of the
* two ends of the beveled shape. This determines the weight: 0 =
* a the widest end, 1 = at the narrowest, front end. */
const float getPhysicalWheelPosition() const
{
return m_physical_wheel_position;
} // getPhysicalWheelPosition
}; // KartProperties
#endif

7
src/network/protocols/get_peer_address.cpp
View File

@ -45,9 +45,8 @@ void GetPeerAddress::asynchronousUpdate()
if (m_state == NONE)
{
m_request = new Online::XMLRequest();
PlayerManager::setUserDetails(m_request, "get",
"address-management.php");
m_request->addParameter("peer_id",m_peer_id);
PlayerManager::setUserDetails(m_request, "get", Online::API::SERVER_PATH);
m_request->addParameter("peer_id", m_peer_id);
Online::RequestManager::get()->addRequest(m_request);
m_state = REQUEST_PENDING;
@ -63,10 +62,12 @@ void GetPeerAddress::asynchronousUpdate()
{
TransportAddress* addr = static_cast<TransportAddress*>(m_callback_object);
result->get("ip", &addr->ip);
if (addr->ip == NetworkManager::getInstance()->getPublicAddress().ip)
result->get("private_port", &addr->port);
else
result->get("port", &addr->port);
Log::debug("GetPeerAddress", "Address gotten successfully.");
}
else

3
src/network/protocols/hide_public_address.cpp
View File

@ -42,8 +42,7 @@ void HidePublicAddress::asynchronousUpdate()
if (m_state == NONE)
{
m_request = new Online::XMLRequest();
PlayerManager::setUserDetails(m_request, "unset",
"address-management.php");
PlayerManager::setUserDetails(m_request, "unset", Online::API::SERVER_PATH);
Online::RequestManager::get()->addRequest(m_request);
m_state = REQUEST_PENDING;

3
src/network/protocols/quick_join_protocol.cpp
View File

@ -44,8 +44,7 @@ void QuickJoinProtocol::asynchronousUpdate()
{
TransportAddress addr = NetworkManager::getInstance()->getPublicAddress();
m_request = new Online::XMLRequest();
PlayerManager::setUserDetails(m_request, "quick-join");
m_request->setServerURL("address-management.php");
PlayerManager::setUserDetails(m_request, "quick-join", Online::API::SERVER_PATH);
Online::RequestManager::get()->addRequest(m_request);
m_state = REQUEST_PENDING;

7
src/network/protocols/request_connection.cpp
View File

@ -72,9 +72,9 @@ void RequestConnection::asynchronousUpdate()
case NONE:
{
m_request = new ServerJoinRequest();
PlayerManager::setUserDetails(m_request, "request-connection",
"address-management.php");
m_request->addParameter("server_id",m_server_id);
PlayerManager::setUserDetails(m_request, "request-connection", Online::API::SERVER_PATH);
m_request->addParameter("server_id", m_server_id);
m_request->queue();
m_state = REQUEST_PENDING;
break;
@ -83,6 +83,7 @@ void RequestConnection::asynchronousUpdate()
{
if (!m_request->isDone())
return;
const XMLNode * result = m_request->getXMLData();
std::string rec_success;

15
src/network/protocols/server_lobby_room_protocol.cpp
View File

@ -183,16 +183,17 @@ void ServerLobbyRoomProtocol::checkIncomingConnectionRequests()
last_poll_time = StkTime::getRealTime();
TransportAddress addr = NetworkManager::getInstance()->getPublicAddress();
Online::XMLRequest* request = new Online::XMLRequest();
PlayerManager::setUserDetails(request, "poll-connection-requests",
"address-management.php");
request->addParameter("address",addr.ip);
request->addParameter("port",addr.port);
PlayerManager::setUserDetails(request, "poll-connection-requests", Online::API::SERVER_PATH);
request->addParameter("address", addr.ip);
request->addParameter("port", addr.port);
request->executeNow();
assert(request->isDone());
const XMLNode * result = request->getXMLData();
std::string rec_success;
if(result->get("success", &rec_success))
{
if(rec_success == "yes")
@ -564,7 +565,7 @@ void ServerLobbyRoomProtocol::playerMinorVote(Event* event)
* Byte 0 1 5 6 N+6 N+7 N+8
* -----------------------------------------------------------
* Size | 1 | 4 | 1 | N | 1 | 1 |
* Data | 4 | priv token | N | track name | 1 | track number (gp) |
* Data | 4 | priv token | N | track name | 1 | track number (gp) |
* -----------------------------------------------------------
*/
void ServerLobbyRoomProtocol::playerTrackVote(Event* event)
@ -597,7 +598,7 @@ void ServerLobbyRoomProtocol::playerTrackVote(Event* event)
* Byte 0 1 5 6 7 8 9
* ---------------------------------------------------------
* Size | 1 | 4 | 1 | 1 | 1 | 1 |
* Data | 4 | priv token | 1 | reversed | 1 | track number (gp) |
* Data | 4 | priv token | 1 | reversed | 1 | track number (gp) |
* ---------------------------------------------------------
*/
void ServerLobbyRoomProtocol::playerReversedVote(Event* event)
@ -630,7 +631,7 @@ void ServerLobbyRoomProtocol::playerReversedVote(Event* event)
* Byte 0 1 5 6 7 8 9
* -----------------------------------------------------
* Size | 1 | 4 | 1 | 1 | 1 | 1 |
* Data | 4 | priv token | 1 | laps | 1 | track number (gp) |
* Data | 4 | priv token | 1 | laps | 1 | track number (gp) |
* -----------------------------------------------------
*/
void ServerLobbyRoomProtocol::playerLapsVote(Event* event)

11
src/network/protocols/show_public_address.cpp
View File

@ -43,11 +43,12 @@ void ShowPublicAddress::asynchronousUpdate()
{
TransportAddress addr = NetworkManager::getInstance()->getPublicAddress();
m_request = new Online::XMLRequest();
PlayerManager::setUserDetails(m_request, "set",
"address-management.php");
m_request->addParameter("address",addr.ip);
m_request->addParameter("port",addr.port);
m_request->addParameter("private_port",NetworkManager::getInstance()->getHost()->getPort());
PlayerManager::setUserDetails(m_request, "set", Online::API::SERVER_PATH);
m_request->addParameter("address", addr.ip);
m_request->addParameter("port", addr.port);
m_request->addParameter("private_port", NetworkManager::getInstance()->getHost()->getPort());
Log::info("ShowPublicAddress", "Showing addr %u and port %d", addr.ip, addr.port);
Online::RequestManager::get()->addRequest(m_request);

13
src/network/protocols/start_server.cpp
View File

@ -42,12 +42,13 @@ void StartServer::asynchronousUpdate()
{
TransportAddress addr = NetworkManager::getInstance()->getPublicAddress();
m_request = new Online::XMLRequest();
PlayerManager::setUserDetails(m_request, "start-server",
"address-management.php");
m_request->addParameter("address",addr.ip);
m_request->addParameter("port",addr.port);
m_request->addParameter("private_port",NetworkManager::getInstance()->getHost()->getPort());
m_request->addParameter("max_players",UserConfigParams::m_server_max_players);
PlayerManager::setUserDetails(m_request, "start", Online::API::SERVER_PATH);
m_request->addParameter("address", addr.ip);
m_request->addParameter("port", addr.port);
m_request->addParameter("private_port", NetworkManager::getInstance()->getHost()->getPort());
m_request->addParameter("max_players", UserConfigParams::m_server_max_players);
Log::info("ShowPublicAddress", "Showing addr %u and port %d", addr.ip, addr.port);
Online::RequestManager::get()->addRequest(m_request);

9
src/network/protocols/stop_server.cpp
View File

@ -47,10 +47,11 @@ void StopServer::asynchronousUpdate()
{
TransportAddress addr = NetworkManager::getInstance()->getPublicAddress();
m_request = new Online::XMLRequest();
PlayerManager::setUserDetails(m_request, "stop-server",
"address-management.php");
m_request->addParameter("address",addr.ip);
m_request->addParameter("port",addr.port);
PlayerManager::setUserDetails(m_request, "stop", Online::API::SERVER_PATH);
m_request->addParameter("address", addr.ip);
m_request->addParameter("port", addr.port);
Log::info("StopServer", "address %u, port %d", addr.ip, addr.port);
Online::RequestManager::get()->addRequest(m_request);

109
src/online/http_request.cpp
View File

@ -26,12 +26,13 @@
#endif
#include <curl/curl.h>
#include <assert.h>
namespace Online
{
const std::string API::USER_PATH = "user/";
const std::string API::SERVER_PATH = "server/";
/** Creates a HTTP(S) request that will have a raw string as result. (Can
* of course be used if the result doesn't matter.)
* \param manage_memory whether or not the RequestManager should take care of
@ -60,7 +61,8 @@ namespace Online
// A http request should not even be created when internet is disabled
assert(UserConfigParams::m_internet_status ==
RequestManager::IPERM_ALLOWED);
assert(filename.size()>0);
assert(filename.size() > 0);
init();
m_filename = file_manager->getAddonsFile(filename);
} // HTTPRequest(filename ...)
@ -76,6 +78,7 @@ namespace Online
// A http request should not even be created when internet is disabled
assert(UserConfigParams::m_internet_status ==
RequestManager::IPERM_ALLOWED);
init();
m_filename = file_manager->getAddonsFile(filename);
} // HTTPRequest(filename ...)
@ -95,25 +98,48 @@ namespace Online
// ------------------------------------------------------------------------
/** A handy shortcut that appends the given path to the URL of the
* mutiplayer server.
* \param path The path to add to the server.
* mutiplayer server. It also supports the old (version 1) api,
* where a 'action' parameter was sent to 'client-user.php'.
* \param path The path to add to the server.(see API::USER_*)
* \param action The action to perform. eg: connect, pool
*/
void HTTPRequest::setServerURL(const std::string& path)
void HTTPRequest::setApiURL(const std::string& path,
const std::string &action)
{
setURL((std::string)UserConfigParams::m_server_multiplayer+path);
// Old (0.8.1) API: send to client-user.php, and add action as a parameter
if(UserConfigParams::m_server_version==1)
{
setURL( (std::string)UserConfigParams::m_server_multiplayer +
"client-user.php" );
if(action=="change-password")
addParameter("action", "change_password");
else if(action=="recover")
addParameter("action", "recovery");
else
addParameter("action", action);
}
else
{
setURL(
(std::string)UserConfigParams::m_server_multiplayer +
+"v"+StringUtils::toString(UserConfigParams::m_server_version)
+ "/" + path + // eg: /user/, /server/
action + "/" // eg: connect/, pool/, get-server-list/
);
}
} // setServerURL
// ------------------------------------------------------------------------
/** A handy shortcut that appends the given path to the URL of the addons
* server.
* \param path The path to add to the server.
* \param path The path to add to the server, without the trailing slash
*/
void HTTPRequest::setAddonsURL(const std::string& path)
{
setURL((std::string)UserConfigParams::m_server_addons
+ "/" + path);
setURL((std::string)UserConfigParams::m_server_addons + "/" + path);
} // set AddonsURL
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
/** Checks the request if it has enough (correct) information to be
* executed (and thus allowed to add to the queue).
*/
@ -128,7 +154,7 @@ namespace Online
void HTTPRequest::prepareOperation()
{
m_curl_session = curl_easy_init();
if(!m_curl_session)
if (!m_curl_session)
{
Log::error("HTTPRequest::prepareOperation",
"LibCurl session not initialized.");
@ -145,9 +171,9 @@ namespace Online
curl_easy_setopt(m_curl_session, CURLOPT_LOW_SPEED_LIMIT, 10);
curl_easy_setopt(m_curl_session, CURLOPT_LOW_SPEED_TIME, 20);
//curl_easy_setopt(m_curl_session, CURLOPT_VERBOSE, 1L);
if(m_filename.size()==0)
if (m_filename.size() == 0)
{
//https
// https, load certificate info
struct curl_slist *chunk = NULL;
chunk = curl_slist_append(chunk, "Host: api.stkaddons.net");
curl_easy_setopt(m_curl_session, CURLOPT_HTTPHEADER, chunk);
@ -163,15 +189,15 @@ namespace Online
*/
void HTTPRequest::operation()
{
if(!m_curl_session)
if (!m_curl_session)
return;
FILE *fout = NULL;
if(m_filename.size()>0)
if (m_filename.size() > 0)
{
fout = fopen((m_filename+".part").c_str(), "wb");
if(!fout)
if (!fout)
{
Log::error("HTTPRequest",
"Can't open '%s' for writing, ignored.",
@ -190,23 +216,26 @@ namespace Online
}
// All parameters added have a '&' added
if(m_parameters.size()>0)
if (m_parameters.size() > 0)
{
m_parameters.erase(m_parameters.size()-1);
}
if(m_parameters.size()==0)
if (m_parameters.size() == 0)
{
Log::info("HTTPRequest", "Downloading %s", m_url.c_str());
else if (Log::getLogLevel()<=Log::LL_INFO)
}
else if (Log::getLogLevel() <= Log::LL_INFO)
{
// Avoid printing the password or token, just replace them with *s
std::string param = m_parameters;
// List of strings whose values should not be printed. "" is the
// end indicator.
static std::string dont_print[] = { "&password=", "&token=", "&current=",
"&new1=", "&new2=", ""};
"&new1=", "&new2=", "&password_confirm=", ""};
unsigned int j = 0;
while (dont_print[j].size()>0)
while (dont_print[j].size() > 0)
{
// Get the string that should be replaced.
std::size_t pos = param.find(dont_print[j]);
@ -221,11 +250,11 @@ namespace Online
} // if string found
j++;
} // while dont_print[j].size()>0
Log::info("HTTPRequest", "Sending %s to %s",
param.c_str(), m_url.c_str());
}
curl_easy_setopt(m_curl_session, CURLOPT_POSTFIELDS,
m_parameters.c_str());
Log::info("HTTPRequest", "Sending %s to %s", param.c_str(), m_url.c_str());
} // end log http request
curl_easy_setopt(m_curl_session, CURLOPT_POSTFIELDS, m_parameters.c_str());
std::string uagent( std::string("SuperTuxKart/") + STK_VERSION );
#ifdef WIN32
uagent += (std::string)" (Windows)";
@ -243,17 +272,18 @@ namespace Online
m_curl_code = curl_easy_perform(m_curl_session);
Request::operation();
if(fout)
if (fout)
{
fclose(fout);
if(m_curl_code==CURLE_OK)
if (m_curl_code == CURLE_OK)
{
if(UserConfigParams::logAddons())
Log::info("HTTPRequest", "Download successful.");
// The behaviour of rename is unspecified if the target
// file should already exist - so remove it.
bool ok = file_manager->removeFile(m_filename);
if(!ok)
if (!ok)
{
Log::error("addons",
"Could not removed existing addons.xml file.");
@ -261,8 +291,9 @@ namespace Online
}
int ret = rename((m_filename+".part").c_str(),
m_filename.c_str() );
// In case of an error, set the status to indicate this
if(ret!=0)
if (ret != 0)
{
Log::error("addons",
"Could not rename downloaded addons.xml file!");
@ -279,10 +310,11 @@ namespace Online
*/
void HTTPRequest::afterOperation()
{
if(m_curl_code == CURLE_OK)
if (m_curl_code == CURLE_OK)
setProgress(1.0f);
else
setProgress(-1.0f);
Request::afterOperation();
curl_easy_cleanup(m_curl_session);
} // afterOperation
@ -322,7 +354,7 @@ namespace Online
// Check if we are asked to abort the download. If so, signal this
// back to libcurl by returning a non-zero status.
if( (request_manager->getAbort() || request->isCancelled()) &&
if ((request_manager->getAbort() || request->isCancelled()) &&
request->isAbortable() )
{
// Indicates to abort the current download, which means that this
@ -331,23 +363,24 @@ namespace Online
}
float f;
if(download_now < download_total)
if (download_now < download_total)
{
f = (float)download_now / (float)download_total;
// In case of floating point rouding errors make sure that
// 1.0 is only reached when downloadFileInternal is finished
if (f>=1.0f) f=0.99f;
if (f >= 1.0f)
f = 0.99f;
}
else
{
// Don't set progress to 1.0f; this is done in afterOperation()
// after checking curls return code!
f= download_total==0 ? 0 : 0.99f;
f = (download_total == 0) ? 0 : 0.99f;
}
request->setProgress(f);
return 0;
} // progressDownload
} // namespace Online

65
src/online/http_request.hpp
View File

@ -34,6 +34,13 @@
namespace Online
{
class API
{
public:
static const std::string USER_PATH;
static const std::string SERVER_PATH;
};
/** A http request.
*/
class HTTPRequest : public Request
@ -78,22 +85,20 @@ namespace Online
void init();
public :
HTTPRequest(bool manage_memory = false,
int priority = 1);
HTTPRequest(const std::string &filename,
bool manage_memory = false,
int priority = 1);
HTTPRequest(const char * const filename,
bool manage_memory = false,
int priority = 1);
virtual ~HTTPRequest() {};
HTTPRequest(bool manage_memory = false, int priority = 1);
HTTPRequest(const std::string &filename, bool manage_memory = false,
int priority = 1);
HTTPRequest(const char * const filename, bool manage_memory = false,
int priority = 1);
virtual ~HTTPRequest() {}
virtual bool isAllowedToAdd() const OVERRIDE;
void setServerURL(const std::string& url);
void setApiURL(const std::string& url, const std::string &action);
void setAddonsURL(const std::string& path);
// ------------------------------------------------------------------------
/** Returns true if there was an error downloading the file.
*/
bool hadDownloadError() const { return m_curl_code!=CURLE_OK; }
/** Returns true if there was an error downloading the file. */
bool hadDownloadError() const { return m_curl_code != CURLE_OK; }
// ------------------------------------------------------------------------
/** Returns the curl error message if an error has occurred.
* \pre m_curl_code!=CURLE_OK
@ -116,47 +121,50 @@ namespace Online
} // getData
// --------------------------------------------------------------------
/** Sets a parameter to 'value' (std::string).
*/
/** Sets a parameter to 'value' (std::string). */
void addParameter(const std::string & name, const std::string &value)
{
// Call the template, so that the strings are escaped properly
addParameter(name, value.c_str());
}; // addParameter
} // addParameter
// --------------------------------------------------------------------
/** Sets a parameter to 'value' (stringw).
*/
void addParameter(const std::string & name,
/** Sets a parameter to 'value' (stringw). */
void addParameter(const std::string &name,
const irr::core::stringw &value)
{
core::stringc s = core::stringc(value.c_str());
// Call the template to escape strings properly
addParameter(name, s.c_str());
} // addParameter
// --------------------------------------------------------------------
/** Sets a parameter to 'value' (arbitrary types).
*/
/** Sets a parameter to 'value' (arbitrary types). */
template <typename T>
void addParameter(const std::string & name, const T& value)
void addParameter(const std::string &name, const T& value)
{
assert(isPreparing());
std::string s = StringUtils::toString(value);
char *s1 = curl_easy_escape(m_curl_session, name.c_str(),
name.size() );
char *s1 = curl_easy_escape(m_curl_session, name.c_str(), name.size());
char *s2 = curl_easy_escape(m_curl_session, s.c_str(), s.size());
m_parameters.append(std::string(s1)+"="+s2+"&");
m_parameters.append(std::string(s1) + "=" + s2 + "&");
curl_free(s1);
curl_free(s2);
} // addParameter
// --------------------------------------------------------------------
/** Returns the current progress. */
float getProgress() const { return m_progress.getAtomic(); }
// --------------------------------------------------------------------
/** Sets the current progress. */
void setProgress(float f) { m_progress.setAtomic(f); }
void setProgress(float f) { m_progress.setAtomic(f); }
// --------------------------------------------------------------------
const std::string & getURL() const { assert(isBusy()); return m_url;}
// --------------------------------------------------------------------
/** Sets the URL for this request. */
void setURL(const std::string & url)
@ -166,8 +174,5 @@ namespace Online
} // setURL
}; // class HTTPRequest
} //namespace Online
#endif
#endif // HEADER_HTTP_REQUEST_HPP

298
src/online/online_player_profile.cpp
View File

@ -16,7 +16,6 @@
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "online/online_player_profile.hpp"
#include "achievements/achievements_manager.hpp"
@ -49,23 +48,25 @@ namespace Online
/** Adds the login credential to a http request. It sets the name of
* the script to invokce, token, and user id.
* \param request The http request.
* \param action If not empty, the action to be set.
* \param action the action performed
*/
void OnlinePlayerProfile::setUserDetails(HTTPRequest *request,
const std::string &action,
const std::string &php_script) const
const std::string &url_path) const
{
if (php_script.size()>0)
request->setServerURL(php_script);
else
request->setServerURL("client-user.php");
if (url_path.size())
{
request->setApiURL(url_path, action);
}
else // default path
{
request->setApiURL(API::USER_PATH, action);
}
if (m_profile)
request->addParameter("userid", m_profile->getID());
if(m_online_state == OS_SIGNED_IN)
if (m_online_state == OS_SIGNED_IN)
request->addParameter("token", m_token);
if (action.size() > 0)
request->addParameter("action", action);
} // setUserDetails
// ========================================================================
@ -86,16 +87,17 @@ namespace Online
m_profile = NULL;
} // OnlinePlayerProfile
// ------------------------------------------------------------------------
/** Request a login using the saved credentials of the user.
*/
/** Request a login using the saved credentials of the user. */
void OnlinePlayerProfile::requestSavedSession()
{
SignInRequest * request = NULL;
SignInRequest *request = NULL;
if (m_online_state == OS_SIGNED_OUT && hasSavedSession())
{
request = new SignInRequest(true);
setUserDetails(request, "saved-session");
// The userid must be taken from the saved data,
// setUserDetails takes it from current data.
request->addParameter("userid", getSavedUserId());
@ -117,18 +119,19 @@ namespace Online
// If the player changes the online account, there can be a
// logout stil happening.
assert(m_online_state == OS_SIGNED_OUT ||
m_online_state == OS_SIGNING_OUT );
m_online_state == OS_SIGNING_OUT);
SignInRequest * request = new SignInRequest(false);
// We can't use setUserDetail here, since there is no token yet
request->setServerURL("client-user.php");
request->addParameter("action","connect");
request->addParameter("username",username);
request->addParameter("password",password);
request->setApiURL(API::USER_PATH, "connect");
request->addParameter("username", username);
request->addParameter("password", password);
request->addParameter("save-session",
rememberPassword() ? "true"
: "false");
request->queue();
m_online_state = OS_SIGNING_IN;
return request;
} // requestSignIn
@ -143,13 +146,13 @@ namespace Online
// If the login is successful, reset any saved session of other
// local players using the same online account (which are now invalid)
if(isSuccess())
if (isSuccess())
{
PlayerProfile *current = PlayerManager::getCurrentPlayer();
for(unsigned int i=0; i<PlayerManager::get()->getNumPlayers(); i++)
for (unsigned int i = 0; i < PlayerManager::get()->getNumPlayers(); i++)
{
PlayerProfile *player = PlayerManager::get()->getPlayer(i);
if(player!=current &&
if(player != current &&
player->hasSavedSession() &&
player->getLastOnlineName() == current->getLastOnlineName())
{
@ -157,7 +160,8 @@ namespace Online
}
}
}
if(login)
if (login)
{
if(isSuccess())
login->loginSuccessful();
@ -178,12 +182,14 @@ namespace Online
{
if (success)
{
int token_fetched = input->get("token", &m_token);
core::stringw username("");
int username_fetched = input->get("username", &username);
uint32_t userid(0);
int token_fetched = input->get("token", &m_token);
int username_fetched = input->get("username", &username);
int userid_fetched = input->get("userid", &userid);
setLastOnlineName(username);
m_profile = new OnlineProfile(userid, username, true);
assert(token_fetched && username_fetched && userid_fetched);
m_online_state = OS_SIGNED_IN;
@ -191,8 +197,10 @@ namespace Online
{
saveSession(getOnlineId(), getToken());
}
ProfileManager::get()->addPersistent(m_profile);
std::string achieved_string("");
// Even if no achievements were sent, we have to call sync
// in order to upload local achievements to the server
input->get("achieved", &achieved_string);
@ -260,6 +268,7 @@ namespace Online
{
GUIEngine::Screen *screen = GUIEngine::getCurrentScreen();
BaseUserScreen *user_screen = dynamic_cast<BaseUserScreen*>(screen);
// We can't do much of error handling here, no screen waits for
// a logout to finish, so we can only log the message to screen,
// and otherwise mark the player logged out internally.
@ -269,20 +278,21 @@ namespace Online
"There were some connection issues while signing out. "
"Report a bug if this caused issues.");
Log::warn("OnlinePlayerProfile::signOut", core::stringc(info.c_str()).c_str());
if(user_screen)
if (user_screen)
user_screen->logoutError(info);
}
else
{
if(user_screen)
if (user_screen)
user_screen->logoutSuccessful();
}
ProfileManager::get()->clearPersistent();
m_profile = NULL;
m_online_state = OS_SIGNED_OUT;
// Discard token if session should not be saved.
if(!rememberPassword())
if (!rememberPassword())
clearSession();
} // signOut
@ -293,7 +303,8 @@ namespace Online
void OnlinePlayerProfile::requestPoll() const
{
assert(m_online_state == OS_SIGNED_IN);
OnlinePlayerProfile::PollRequest * request = new OnlinePlayerProfile::PollRequest();
OnlinePlayerProfile::PollRequest *request = new OnlinePlayerProfile::PollRequest();
setUserDetails(request, "poll");
request->queue();
} // requestPoll()
@ -304,127 +315,137 @@ namespace Online
*/
void OnlinePlayerProfile::PollRequest::callback()
{
if(isSuccess())
// connection error
if (!isSuccess())
{
if (!PlayerManager::getCurrentPlayer()->isLoggedIn())
return;
if (PlayerManager::getCurrentPlayer()->getProfile()->hasFetchedFriends())
Log::error("Online Player Profile", "Poll request failed");
return;
}
if (!PlayerManager::getCurrentPlayer()->isLoggedIn())
return;
if (PlayerManager::getCurrentPlayer()->getProfile()->hasFetchedFriends())
{
std::string online_friends_string("");
if (getXMLData()->get("online", &online_friends_string) == 1)
{
std::string online_friends_string("");
if(getXMLData()->get("online", &online_friends_string) == 1)
std::vector<uint32_t> online_friends =
StringUtils::splitToUInt(online_friends_string, ' ');
// flag that indicates if a current online friend went offline
bool went_offline = false;
// iterate over all friends and find out if they come online or not
// filling the notification messages
std::vector<uint32_t> friends =
PlayerManager::getCurrentPlayer()->getProfile()->getFriends();
std::vector<core::stringw> to_notify;
for (unsigned int i = 0; i < friends.size(); ++i)
{
std::vector<uint32_t> online_friends =
StringUtils::splitToUInt(online_friends_string, ' ');
bool went_offline = false;
std::vector<uint32_t> friends =
PlayerManager::getCurrentPlayer()->getProfile()->getFriends();
std::vector<core::stringw> to_notify;
for(unsigned int i = 0; i < friends.size(); ++i)
{
bool now_online = false;
std::vector<uint32_t>::iterator iter =
std::find(online_friends.begin(),
online_friends.end(), friends[i]);
if (iter != online_friends.end())
{
now_online = true;
online_friends.erase(iter);
}
OnlineProfile * profile =
ProfileManager::get()->getProfileByID(friends[i]);
OnlineProfile::RelationInfo * relation_info =
profile->getRelationInfo();
if( relation_info->isOnline() )
{
if (!now_online)
{
relation_info->setOnline(false);
went_offline = true;
}
}
else
{
if (now_online)
{
//User came online
relation_info->setOnline(true);
// Do this because a user might have accepted
// a pending friend request.
profile->setFriend();
to_notify.push_back(profile->getUserName());
}
}
bool now_online = false;
std::vector<uint32_t>::iterator found_friend =
std::find(online_friends.begin(),
online_friends.end(), friends[i]);
if (found_friend != online_friends.end())
{
now_online = true;
online_friends.erase(found_friend);
}
}
OnlineProfile * profile =
ProfileManager::get()->getProfileByID(friends[i]);
OnlineProfile::RelationInfo * relation_info =
profile->getRelationInfo();
if(to_notify.size() > 0)
{
core::stringw message("");
if(to_notify.size() == 1)
{
message = _("%s is now online.", to_notify[0]);
}
else if(to_notify.size() == 2)
{
message = _("%s and %s are now online.",
to_notify[0], to_notify[1] );
}
else if(to_notify.size() == 3)
{
message = _("%s, %s and %s are now online.",
to_notify[0], to_notify[1], to_notify[2]);
}
else if(to_notify.size() > 3)
{
message = _("%d friends are now online.",
to_notify.size());
}
MessageQueue::add(MessageQueue::MT_FRIEND, message);
}
else if(went_offline)
{
OnlineProfileFriends::getInstance()->refreshFriendsList();
}
if (relation_info->isOnline())
{
if (!now_online) // the friend went offline
{
relation_info->setOnline(false);
went_offline = true;
}
}
else
{
if (now_online) // friend came online
{
relation_info->setOnline(true);
// Do this because a user might have accepted
// a pending friend request.
profile->setFriend();
to_notify.push_back(profile->getUserName());
}
}
}
if (to_notify.size() > 0)
{
core::stringw message("");
if(to_notify.size() == 1)
{
message = _("%s is now online.", to_notify[0]);
}
else if(to_notify.size() == 2)
{
message = _("%s and %s are now online.",
to_notify[0], to_notify[1] );
}
else if(to_notify.size() == 3)
{
message = _("%s, %s and %s are now online.",
to_notify[0], to_notify[1], to_notify[2]);
}
else if(to_notify.size() > 3)
{
message = _("%d friends are now online.",
to_notify.size());
}
MessageQueue::add(MessageQueue::MT_FRIEND, message);
}
else if (went_offline)
{
OnlineProfileFriends::getInstance()->refreshFriendsList();
}
}
}
else
{
PlayerManager::getCurrentPlayer()->getProfile()->fetchFriends();
}
int friend_request_count = 0;
for (unsigned int i = 0; i < getXMLData()->getNumNodes(); i++)
{
const XMLNode * node = getXMLData()->getNode(i);
if (node->getName() == "new_friend_request")
{
OnlineProfile::RelationInfo * ri =
new OnlineProfile::RelationInfo("New", false, true, true);
OnlineProfile * p = new OnlineProfile(node);
p->setRelationInfo(ri);
ProfileManager::get()->addPersistent(p);
friend_request_count++;
}
}
if (friend_request_count > 0)
{
core::stringw message("");
if (friend_request_count > 1)
{
message = _("You have %d new friend requests!",
friend_request_count);
}
else
{
PlayerManager::getCurrentPlayer()->getProfile()->fetchFriends();
message = _("You have a new friend request!");
}
int friend_request_count = 0;
for(unsigned int i = 0; i < getXMLData()->getNumNodes(); i++)
{
const XMLNode * node = getXMLData()->getNode(i);
if(node->getName() == "new_friend_request")
{
OnlineProfile::RelationInfo * ri =
new OnlineProfile::RelationInfo("New", false, true, true);
OnlineProfile * p = new OnlineProfile(node);
p->setRelationInfo(ri);
ProfileManager::get()->addPersistent(p);
friend_request_count++;
}
}
if(friend_request_count > 0)
{
core::stringw message("");
if(friend_request_count > 1)
{
message = _("You have %d new friend requests!",
friend_request_count);
}
else
{
message = _("You have a new friend request!");
}
MessageQueue::add(MessageQueue::MT_FRIEND, message);
OnlineProfileFriends::getInstance()->refreshFriendsList();
}
MessageQueue::add(MessageQueue::MT_FRIEND, message);
OnlineProfileFriends::getInstance()->refreshFriendsList();
}
// FIXME show connection error??
// Perhaps show something after 2 misses.
} // PollRequest::callback
// ------------------------------------------------------------------------
@ -432,11 +453,12 @@ namespace Online
*/
uint32_t OnlinePlayerProfile::getOnlineId() const
{
if((m_online_state == OS_SIGNED_IN ))
if (m_online_state == OS_SIGNED_IN)
{
assert(m_profile != NULL);
return m_profile->getID();
}
return 0;
} // getOnlineId

131
src/online/online_player_profile.hpp
View File

@ -37,7 +37,6 @@ class PlayerManager;
namespace Online
{
class OnlineProfile;
// ============================================================================
@ -48,75 +47,73 @@ namespace Online
*/
class OnlinePlayerProfile : public PlayerProfile
{
public:
// ----------------------------------------------------------------
class SignInRequest : public XMLRequest
{
virtual void callback ();
public:
// ----------------------------------------------------------------
class SignInRequest : public XMLRequest
{
virtual void callback ();
public:
SignInRequest(bool manage_memory = false)
: XMLRequest(manage_memory, /*priority*/10) {}
}; // SignInRequest
// ----------------------------------------------------------------
class PollRequest : public XMLRequest {
virtual void callback ();
public:
PollRequest() : XMLRequest(true) {}
}; // PollRequest
private:
std::string m_token;
OnlineProfile *m_profile;
/** The state of the player (logged in, logging in, ...) */
PlayerProfile::OnlineState m_online_state;
virtual void signIn(bool success, const XMLNode * input);
virtual void signOut(bool success, const XMLNode * input,
const irr::core::stringw &info);
virtual uint32_t getOnlineId() const;
virtual void setUserDetails(Online::HTTPRequest *request,
const std::string &action,
const std::string &php_script = "") const;
virtual void requestPoll() const;
// ----------------------------------------------------------------
/** Returns if this user is logged in. */
virtual bool isLoggedIn() const
{
return m_online_state == PlayerProfile::OS_SIGNED_IN;
} // isLoggedIn
// ----------------------------------------------------------------
/** The online state of the player (i.e. logged out, logging in,
* logged in, ...). */
PlayerProfile::OnlineState getOnlineState() const
{
return m_online_state;
} // getOnlineState
// ----------------------------------------------------------------
/** Returns a pointer to the profile associated with the current
* user. */
OnlineProfile* getProfile() const { return m_profile; }
// ----------------------------------------------------------------
/** Returns the session token of the signed in user. */
const std::string& getToken() const { return m_token; }
virtual void requestSavedSession();
virtual void requestSignOut();
virtual SignInRequest *requestSignIn(const irr::core::stringw &username,
const irr::core::stringw &password);
SignInRequest(bool manage_memory = false)
: XMLRequest(manage_memory, /*priority*/10) {}
}; // SignInRequest
// ----------------------------------------------------------------
class PollRequest : public XMLRequest
{
virtual void callback ();
public:
OnlinePlayerProfile(const XMLNode *player);
OnlinePlayerProfile(const core::stringw &name, bool is_guest = false);
virtual ~OnlinePlayerProfile() {};
// ----------------------------------------------------------------
PollRequest() : XMLRequest(true) {}
}; // PollRequest
}; // class OnlinePlayerProfile
private:
std::string m_token;
OnlineProfile *m_profile;
/** The state of the player (logged in, logging in, ...) */
PlayerProfile::OnlineState m_online_state;
virtual void signIn(bool success, const XMLNode * input);
virtual void signOut(bool success, const XMLNode * input,
const irr::core::stringw &info);
virtual uint32_t getOnlineId() const;
virtual void setUserDetails(Online::HTTPRequest *request,
const std::string &action,
const std::string &url_path = "") const;
virtual void requestPoll() const;
// ----------------------------------------------------------------
/** Returns if this user is logged in. */
virtual bool isLoggedIn() const
{
return m_online_state == PlayerProfile::OS_SIGNED_IN;
} // isLoggedIn
// ----------------------------------------------------------------
/** The online state of the player (i.e. logged out, logging in,
* logged in, ...). */
PlayerProfile::OnlineState getOnlineState() const
{
return m_online_state;
} // getOnlineState
// ----------------------------------------------------------------
/** Returns a pointer to the profile associated with the current user. */
OnlineProfile* getProfile() const { return m_profile; }
// ----------------------------------------------------------------
/** Returns the session token of the signed in user. */
const std::string& getToken() const { return m_token; }
virtual void requestSavedSession();
virtual void requestSignOut();
virtual SignInRequest *requestSignIn(const irr::core::stringw &username,
const irr::core::stringw &password);
public:
OnlinePlayerProfile(const XMLNode *player);
OnlinePlayerProfile(const core::stringw &name, bool is_guest = false);
virtual ~OnlinePlayerProfile() {}
// ----------------------------------------------------------------
}; // class OnlinePlayerProfile
} // namespace Online
#endif
/*EOF*/
#endif // HEADER_CURRENT_ONLINE_USER_HPP

58
src/online/online_profile.cpp
View File

@ -16,7 +16,6 @@
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "online/online_profile.hpp"
#include "config/player_manager.hpp"
@ -39,10 +38,10 @@ OnlineProfile::RelationInfo::RelationInfo(const irr::core::stringw & date,
bool is_online, bool is_pending,
bool is_asker)
{
m_date = date;
m_is_online = is_online;
m_is_pending = is_pending;
m_is_asker = is_asker;
m_date = date;
m_is_online = is_online;
m_is_pending = is_pending;
m_is_asker = is_asker;
} // RelationInfo::RelationInfo
// ----------------------------------------------------------------------------
@ -91,12 +90,11 @@ OnlineProfile::OnlineProfile(const XMLNode * xml, ConstructorType type)
if (type == C_RELATION_INFO)
{
irr::core::stringw date("");
bool is_pending = false, is_asker = false, is_online = false;
xml->get("date", &date);
std::string is_pending_string("");
bool is_pending = false;
xml->get("is_pending", &is_pending);
bool is_asker = false;
bool is_online = false;
if (is_pending)
{
xml->get("is_asker", &is_asker);
@ -113,7 +111,7 @@ OnlineProfile::OnlineProfile(const XMLNode * xml, ConstructorType type)
xml->get("id", &m_id );
xml->get("user_name", &m_username);
m_is_current_user = (m_id == PlayerManager::getCurrentOnlineId());
m_is_current_user = (m_id == PlayerManager::getCurrentOnlineId());
m_state = S_READY;
} // OnlineProfile(XMLNode)
@ -133,6 +131,7 @@ void OnlineProfile::fetchAchievements()
assert(PlayerManager::isCurrentLoggedIn());
if (m_has_fetched_achievements || m_is_current_user)
return;
m_state = S_FETCHING;
// ------------------------------------------------------------------------
@ -187,6 +186,7 @@ void OnlineProfile::fetchFriends()
assert(PlayerManager::isCurrentLoggedIn());
if (m_has_fetched_friends)
return;
m_state = S_FETCHING;
// ------------------------------------------------------------------------
@ -258,9 +258,11 @@ void OnlineProfile::removeFriend(const uint32_t id)
break;
}
else
{
++iter;
}
} // removeFriend
}
} // for friend in friends
} // removeFriend
// ----------------------------------------------------------------------------
/** Adds a friend to the friend list.
@ -269,9 +271,14 @@ void OnlineProfile::removeFriend(const uint32_t id)
void OnlineProfile::addFriend(const uint32_t id)
{
assert(m_has_fetched_friends);
// find if friend id is is already in the user list
for (unsigned int i = 0; i < m_friends.size(); i++)
if (m_friends[i] == id)
return;
{
if (m_friends[i] == id)
return;
}
m_friends.push_back(id);
} // addFriend
@ -310,18 +317,25 @@ const OnlineProfile::IDList& OnlineProfile::getAchievements()
void OnlineProfile::merge(OnlineProfile *profile)
{
assert(profile != NULL);
if (!this->m_has_fetched_friends && profile->m_has_fetched_friends)
this->m_friends = profile->m_friends;
if (!this->m_has_fetched_achievements && profile->m_has_fetched_achievements)
this->m_achievements = profile->m_achievements;
if (this->m_relation_info == NULL && profile->m_relation_info != NULL)
// profile has fetched friends, use that instead
if (!m_has_fetched_friends && profile->m_has_fetched_friends)
m_friends = profile->m_friends;
// profile has fetched achievements, use that instead
if (!m_has_fetched_achievements && profile->m_has_fetched_achievements)
m_achievements = profile->m_achievements;
// current relation is not set, use the profile one
if (m_relation_info == NULL && profile->m_relation_info != NULL)
{
this->m_relation_info = profile->m_relation_info;
m_relation_info = profile->m_relation_info;
// We don't want the destructor of the profile instance to destroy
// the relation info
profile->m_relation_info = NULL;
}
delete profile;
} // merge
delete profile;
} // merge
} // namespace Online

38
src/online/online_profile.hpp
View File

@ -24,9 +24,7 @@
#include "utils/types.hpp"
#include "utils/ptr_vector.hpp"
#include <irrString.h>
#include <string>
namespace Online
@ -54,16 +52,21 @@ public:
bool m_is_pending;
bool m_is_asker;
irr::core::stringw m_date;
public:
RelationInfo(const irr::core::stringw & date, bool is_online,
bool is_pending, bool is_asker = false);
void setOnline(bool online);
// --------------------------------------------------------------------
bool isPending() const { return m_is_pending; }
// --------------------------------------------------------------------
bool isAsker() const { return m_is_asker; }
// --------------------------------------------------------------------
const irr::core::stringw & getDate() const { return m_date; }
// --------------------------------------------------------------------
bool isOnline() const { return m_is_online; }
}; // class RelationInfo
@ -104,12 +107,11 @@ private:
void storeAchievements(const XMLNode * input);
public:
OnlineProfile(const uint32_t & userid,
const irr::core::stringw & username,
bool is_current_user = false );
OnlineProfile(const XMLNode * xml,
ConstructorType type = C_DEFAULT);
~OnlineProfile();
OnlineProfile(const uint32_t & userid,
const irr::core::stringw & username,
bool is_current_user = false );
OnlineProfile(const XMLNode * xml, ConstructorType type = C_DEFAULT);
~OnlineProfile();
void fetchFriends();
const IDList& getFriends();
void fetchAchievements();
@ -118,49 +120,55 @@ public:
void deleteRelationalInfo();
const IDList& getAchievements();
void merge(OnlineProfile * profile);
// ------------------------------------------------------------------------
/** Returns true if the achievements for this profile have been fetched. */
bool hasFetchedAchievements() const { return m_has_fetched_achievements; }
// ------------------------------------------------------------------------
/** Returns true if the friend list for this profile has been fetched. */
bool hasFetchedFriends() const { return m_has_fetched_friends; }
// ------------------------------------------------------------------------
/** True if the profile is not fetching data atm. */
bool isReady() const { return m_state == S_READY; }
// ------------------------------------------------------------------------
/** Returns true if this item is the current user. */
bool isCurrentUser() const { return m_is_current_user; }
// ------------------------------------------------------------------------
bool isFriend() const { return m_is_friend; }
// ------------------------------------------------------------------------
void setFriend() { m_is_friend = true; }
// ------------------------------------------------------------------------
RelationInfo* getRelationInfo() { return m_relation_info; }
// ------------------------------------------------------------------------
void setRelationInfo(RelationInfo * r)
{
delete m_relation_info; m_relation_info = r;
} // setRelationInfo
// ------------------------------------------------------------------------
/** Sets the cache bit of this profile. Used by the cache eviction
* algorithm. */
void setCacheBit(bool cache_bit) { m_cache_bit = cache_bit; }
// ------------------------------------------------------------------------
/** Returns the cache bit for this profile. Used by the cache eviction
* algorithm. */
bool getCacheBit() const { return m_cache_bit; }
// ------------------------------------------------------------------------
/** Returns the online id of this profile. */
uint32_t getID() const { return m_id; }
// ------------------------------------------------------------------------
/** Returns the user name of this profile. */
const irr::core::stringw& getUserName() const { return m_username; }
// ------------------------------------------------------------------------
}; // class OnlineProfile
} // namespace Online
#endif
/*EOF*/
#endif // HEADER_ONLINE_PROFILE_HPP

24
src/online/profile_manager.cpp
View File

@ -16,7 +16,6 @@
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "online/profile_manager.hpp"
#include "online/online_profile.hpp"
@ -50,7 +49,8 @@ ProfileManager::~ProfileManager()
{
clearPersistent();
ProfilesMap::iterator it;
for (it = m_profiles_cache.begin(); it != m_profiles_cache.end(); ++it) {
for (it = m_profiles_cache.begin(); it != m_profiles_cache.end(); ++it)
{
delete it->second;
}
} // ~ProfileManager
@ -72,8 +72,8 @@ int ProfileManager::guaranteeCacheSize(unsigned int min_num)
min_num = 100;
m_max_cache_size = min_num;
}
return m_max_cache_size;
return m_max_cache_size;
} // guaranteeCacheSize
// ------------------------------------------------------------------------
@ -88,7 +88,8 @@ OnlineProfile* ProfileManager::getProfileByID(const uint32_t id)
return m_profiles_persistent[id];
if (isInCache(id))
return m_profiles_cache[id];
//FIXME not able to get! Now this should actually fetch the info from the
// FIXME not able to get! Now this should actually fetch the info from the
// server, but I haven't come up with a good asynchronous idea yet.
return NULL;
} // getProfileByID
@ -135,12 +136,14 @@ void ProfileManager::addDirectToCache(OnlineProfile* profile)
break;
}
else
{
++iter;
}
}
} // for profile in cache
}
m_profiles_cache[profile->getID()] = profile;
assert(m_profiles_cache.size() <= m_max_cache_size);
} // addDirectToCache
// ------------------------------------------------------------------------
@ -155,6 +158,7 @@ bool ProfileManager::isInCache(const uint32_t id)
updateCacheBits(i->second);
return true;
}
return false;
} // isInCache
@ -180,6 +184,7 @@ void ProfileManager::updateCacheBits(OnlineProfile * profile)
if (!iter->second->getCacheBit())
return;
}
// All cache bits are set! Set them all to zero except the one
// currently being visited
for (iter = m_profiles_cache.begin();
@ -189,7 +194,6 @@ void ProfileManager::updateCacheBits(OnlineProfile * profile)
}
profile->setCacheBit(true);
}
} // updateCacheBits
// ------------------------------------------------------------------------
@ -232,11 +236,14 @@ void ProfileManager::deleteFromPersistent(const uint32_t id)
m_profiles_persistent.erase(id);
}
else
{
Log::warn("ProfileManager",
"Tried to remove profile with id %d from persistent while "
"not present", id);
}
} // deleteFromPersistent
// ------------------------------------------------------------------------
/** Deletes all persistent profiles.
*/
@ -265,10 +272,11 @@ void ProfileManager::moveToCache(const uint32_t id)
addToCache(profile);
}
else
{
Log::warn("ProfileManager",
"Tried to move profile with id %d from persistent to "
"cache while not present", id);
}
} // moveToCache
} // namespace Online

10
src/online/profile_manager.hpp
View File

@ -29,7 +29,6 @@
namespace Online
{
class OnlineProfile;
/** Class that manages all online profiles. Profiles are used for storing
@ -81,6 +80,7 @@ public:
assert(!m_profile_manager);
m_profile_manager = new ProfileManager();
} // create
// ----------------------------------------------------------------
/** Returns the singleton.
* \pre create has been called to create the singleton.
@ -109,6 +109,7 @@ public:
bool isInCache(const uint32_t id);
bool inPersistent(const uint32_t id);
OnlineProfile* getProfileByID(const uint32_t id);
// ----------------------------------------------------------------
/** Marks a given profile to be the currently visited one. This
* is used to mark the profiles that ave its data display (e.g.
@ -117,15 +118,12 @@ public:
{
m_currently_visiting = getProfileByID(id);
} // setVisiting
// ----------------------------------------------------------------
/** \return the instance of the profile that's currently being
* visited */
OnlineProfile* getVisitingProfile() { return m_currently_visiting; }
}; // class CurrentUser
} // namespace Online
#endif
/*EOF*/
#endif // HEADER_ONLINE_PROFILE_MANAGER_HPP

4
src/online/request.cpp
View File

@ -25,10 +25,8 @@
#include <assert.h>
namespace Online
{
// ========================================================================
/**
* Creates a request that can be handled by the RequestManager
@ -67,6 +65,7 @@ namespace Online
setExecuted();
afterOperation();
} // execute
// ------------------------------------------------------------------------
/** Executes the request now, i.e. in the main thread and without involving
* the manager thread.. This calles prepareOperation, operation, and
@ -81,5 +80,4 @@ namespace Online
setDone();
} // executeNow
} // namespace Online

36
src/online/request.hpp
View File

@ -35,7 +35,6 @@
namespace Online
{
/** Stores a request for the HTTP Manager. They will be sorted by
* prioritiy. Requests have four different states they can be in, and
* this state determines which thread can access it. This allows
@ -119,9 +118,11 @@ namespace Online
/** The actual operation to be executed. Empty as default, which
* allows to create a 'quit' request without any additional code. */
virtual void operation() {}
// --------------------------------------------------------------------
/** Virtual function to be called before an operation. */
virtual void prepareOperation() {}
// --------------------------------------------------------------------
/** Virtual function to be called after an operation. */
virtual void afterOperation() {}
@ -132,71 +133,87 @@ namespace Online
RT_QUIT = 1
};
Request(bool manage_memory, int priority, int type);
Request(bool manage_memory, int priority, int type);
virtual ~Request() {}
void execute();
void executeNow();
void queue();
// --------------------------------------------------------------------
/** Executed when a request has finished. */
virtual void callback() {}
// --------------------------------------------------------------------
/** Returns the type of the request. */
int getType() const { return m_type; }
// --------------------------------------------------------------------
/** Returns if the memory for this object should be managed by
* by network_http (i.e. freed once the request is handled). */
bool manageMemory() const { return m_manage_memory; }
// --------------------------------------------------------------------
/** Sets the memory management flag of this request. This function
* must only be called by the main thread, since it is only tested by
* the main thread. */
void setManageMemory(bool m) { m_manage_memory = m; }
// --------------------------------------------------------------------
/** Returns the priority of this request. */
int getPriority() const { return m_priority; }
// --------------------------------------------------------------------
/** Signals that this request should be canceled. */
void cancel() { m_cancel.setAtomic(true); }
// --------------------------------------------------------------------
/** Returns if this request is to be canceled. */
bool isCancelled() const { return m_cancel.getAtomic(); }
// --------------------------------------------------------------------
/** Returns if this request can be aborted. */
bool isAbortable() const { return m_is_abortable.getAtomic(); }
// --------------------------------------------------------------------
/** Sets if this request is abortable or not. */
void setAbortable(bool b) { m_is_abortable.setAtomic(b); }
// --------------------------------------------------------------------
/** Sets the request state to busy. */
void setBusy()
{
assert(m_state.getAtomic()==S_PREPARING);
assert(m_state.getAtomic() == S_PREPARING);
m_state.setAtomic(S_BUSY);
} // setBusy
// --------------------------------------------------------------------
/** Sets the request to be completed. */
void setExecuted()
{
assert(m_state.getAtomic()==S_BUSY);
assert(m_state.getAtomic() == S_BUSY);
m_state.setAtomic(S_EXECUTED);
} // setExecuted
// --------------------------------------------------------------------
/** Should only be called by the manager */
void setDone()
{
assert(m_state.getAtomic()==S_EXECUTED);
assert(m_state.getAtomic() == S_EXECUTED);
m_state.setAtomic(S_DONE);
} // setDone
// --------------------------------------------------------------------
/** Returns if this request is done. */
bool isDone() const { return m_state.getAtomic() == S_DONE; }
// --------------------------------------------------------------------
/** Returns if this request is being prepared. */
bool isPreparing() const { return m_state.getAtomic() == S_PREPARING; }
// --------------------------------------------------------------------
/** Returns if this request is busy. */
bool isBusy() const { return m_state.getAtomic() == S_BUSY; }
// --------------------------------------------------------------------
/** Checks if the request has completed or done (i.e. callbacks were
* executed).
@ -204,8 +221,9 @@ namespace Online
bool hasBeenExecuted() const
{
State s = m_state.getAtomic();
return s==S_EXECUTED || s==S_DONE;
return s == S_EXECUTED || s == S_DONE;
} // hasBeenExecuted
// --------------------------------------------------------------------
/** Virtual method to check if a request has initialized all needed
* members to a valid value. */
@ -226,9 +244,5 @@ namespace Online
}
}; // class Compare
}; // class Request
} //namespace Online
#endif
#endif // HEADER_ONLINE_REQUEST_HPP

35
src/online/request_manager.cpp
View File

@ -111,6 +111,7 @@ namespace Online
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
// Should be the default, but just in case:
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
//pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
@ -118,7 +119,7 @@ namespace Online
m_thread_id.setAtomic(new pthread_t());
int error = pthread_create(m_thread_id.getData(), &attr,
&RequestManager::mainLoop, this);
if(error)
if (error)
{
m_thread_id.lock();
delete m_thread_id.getData();
@ -128,10 +129,11 @@ namespace Online
errno);
}
pthread_attr_destroy(&attr);
// In case that login id was not saved (or first start of stk),
// current player would not be defined at this stage.
PlayerProfile *player = PlayerManager::getCurrentPlayer();
if(player && player->wasOnlineLastTime() &&
if (player && player->wasOnlineLastTime() &&
!UserConfigParams::m_always_show_login_screen)
{
PlayerManager::resumeSavedSession();
@ -178,6 +180,7 @@ namespace Online
request->setBusy();
m_request_queue.lock();
m_request_queue.getData().push(request);
// Wake up the network http thread
pthread_cond_signal(&m_cond_request);
m_request_queue.unlock();
@ -197,27 +200,30 @@ namespace Online
me->m_current_request = NULL;
me->m_request_queue.lock();
while( me->m_request_queue.getData().empty() ||
while (me->m_request_queue.getData().empty() ||
me->m_request_queue.getData().top()->getType() != Request::RT_QUIT)
{
bool empty = me->m_request_queue.getData().empty();
// Wait in cond_wait for a request to arrive. The 'while' is necessary
// since "spurious wakeups from the pthread_cond_wait ... may occur"
// (pthread_cond_wait man page)!
while(empty)
while (empty)
{
pthread_cond_wait(&me->m_cond_request, me->m_request_queue.getMutex());
empty = me->m_request_queue.getData().empty();
}
me->m_current_request = me->m_request_queue.getData().top();
me->m_request_queue.getData().pop();
if(me->m_current_request->getType()==Request::RT_QUIT)
if (me->m_current_request->getType() == Request::RT_QUIT)
break;
me->m_request_queue.unlock();
me->m_current_request->execute();
me->addResult(me->m_current_request);
me->m_request_queue.lock();
} // while
} // while handle all requests
// Signal that the request manager can now be deleted.
// We signal this even before cleaning up memory, since there's no
@ -225,16 +231,18 @@ namespace Online
me->setCanBeDeleted();
// At this stage we have the lock for m_request_queue
while(!me->m_request_queue.getData().empty())
while (!me->m_request_queue.getData().empty())
{
Online::Request * request = me->m_request_queue.getData().top();
Online::Request *request = me->m_request_queue.getData().top();
me->m_request_queue.getData().pop();
// Manage memory can be ignored here, all requests
// need to be freed.
delete request;
}
me->m_request_queue.unlock();
pthread_exit(NULL);
return 0;
} // mainLoop
@ -259,13 +267,13 @@ namespace Online
{
Request * request = NULL;
m_result_queue.lock();
if(!m_result_queue.getData().empty())
if (!m_result_queue.getData().empty())
{
request = m_result_queue.getData().front();
m_result_queue.getData().pop();
}
m_result_queue.unlock();
if(request != NULL)
if (request != NULL)
{
request->callback();
if(request->manageMemory())
@ -298,7 +306,8 @@ namespace Online
float interval = GAME_POLLING_INTERVAL;
if (StateManager::get()->getGameState() == GUIEngine::MENU)
interval = MENU_POLLING_INTERVAL;
if(m_time_since_poll > interval)
if (m_time_since_poll > interval)
{
m_time_since_poll = 0;
PlayerManager::requestOnlinePoll();
@ -306,7 +315,3 @@ namespace Online
} // update
} // namespace Online

20
src/online/request_manager.hpp
View File

@ -39,10 +39,8 @@
#include <queue>
#include <pthread.h>
namespace Online
{
/** A class to execute requests in a separate thread. Typically the
* requests involve a http(s) requests to be sent to the stk server, and
* receive an answer (e.g. to sign in; or to download an addon). The
@ -86,11 +84,14 @@ namespace Online
* grant permission
* IPERM_ALLOWED: STK is allowed to access server.
* IPERM_NOT_ALLOWED: STK must not access external servers. */
enum InternetPermission {IPERM_NOT_ASKED =0,
IPERM_ALLOWED =1,
IPERM_NOT_ALLOWED=2 };
enum InternetPermission
{
IPERM_NOT_ASKED = 0,
IPERM_ALLOWED = 1,
IPERM_NOT_ALLOWED = 2
};
protected:
/** Time passed since the last poll request. */
float m_time_since_poll;
/** The current requested being worked on. */
@ -119,7 +120,7 @@ namespace Online
void addResult(Online::Request *request);
void handleResultQueue();
static void *mainLoop(void *obj);
static void *mainLoop(void *obj);
RequestManager(); //const std::string &url
~RequestManager();
@ -136,12 +137,9 @@ namespace Online
void startNetworkThread();
void stopNetworkThread();
bool getAbort(){ return m_abort.getAtomic(); };
bool getAbort(){ return m_abort.getAtomic(); }
void update(float dt);
}; //class RequestManager
} // namespace Online
#endif // request_manager_HPP
/*EOF*/

8
src/online/server.cpp
View File

@ -24,12 +24,14 @@
#include "utils/constants.hpp"
#include "utils/string_utils.hpp"
namespace Online{
Server::SortOrder Server::m_sort_order=Server::SO_NAME; //FIXME change to some other default
namespace Online
{
Server::SortOrder Server::m_sort_order = Server::SO_NAME;
Server::Server(const XMLNode & xml)
{
assert(xml.getName() == "server");
m_name = "";
m_satisfaction_score = 0;
m_server_id = 0;
@ -45,7 +47,7 @@ namespace Online{
xml.get("max_players", &m_max_players);
xml.get("current_players", &m_current_players);
}; // Server(const XML&)
} // Server(const XML&)
// ----------------------------------------------------------------------------
/**

33
src/online/server.hpp
View File

@ -31,7 +31,8 @@
class XMLNode;
namespace Online{
namespace Online
{
/**
* \ingroup online
*/
@ -40,54 +41,64 @@ namespace Online{
public:
/** Set the sort order used in the comparison function. */
enum SortOrder { SO_SCORE = 1, // Sorted on satisfaction score
SO_NAME = 2, // Sorted alphabetically by name
SO_PLAYERS = 4
enum SortOrder
{
SO_SCORE = 1, // Sorted on satisfaction score
SO_NAME = 2, // Sorted alphabetically by name
SO_PLAYERS = 4
};
protected:
/** The name to be displayed. */
/** The server name to be displayed. */
irr::core::stringw m_name;
std::string m_lower_case_name; //Used for comparison
std::string m_lower_case_name; // Used for comparison
uint32_t m_server_id;
uint32_t m_host_id;
/** The maximum number of players that the server supports */
int m_max_players;
/** The number of players currently on the server */
int m_current_players;
/** The score/rating given */
float m_satisfaction_score;
/** The sort order to be used in the comparison. */
static SortOrder m_sort_order;
Server() {};
Server() {}
public:
/** Initialises the object from an XML node. */
Server(const XMLNode & xml);
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
/** Sets the sort order used in the comparison function. It is static, so
* that each instance can access the sort order. */
static void setSortOrder(SortOrder so) { m_sort_order = so; }
// ------------------------------------------------------------------------
/** Returns the name of the server. */
const irr::core::stringw& getName() const { return m_name; }
const std::string & getLowerCaseName() const { return m_lower_case_name; }
// ------------------------------------------------------------------------
const float getScore() const { return m_satisfaction_score; }
// ------------------------------------------------------------------------
/** Returns the ID of this server. */
const uint32_t getServerId() const { return m_server_id; }
const uint32_t getHostId() const { return m_host_id; }
const int getMaxPlayers() const { return m_max_players; }
const int getCurrentPlayers() const { return m_current_players; }
// ------------------------------------------------------------------------
bool filterByWords(const irr::core::stringw words) const;
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
/** Compares two servers according to the sort order currently defined.
* \param a The addon to compare this addon to.
*/
@ -106,10 +117,10 @@ namespace Online{
return m_current_players < server.getCurrentPlayers();
break;
} // switch
return true;
} // operator<
}; // Server
} // namespace Online
#endif
#endif // HEADER_SERVER_HPP

44
src/online/servers_manager.cpp
View File

@ -16,7 +16,6 @@
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "online/servers_manager.hpp"
#include <string>
@ -28,14 +27,15 @@
#define SERVER_REFRESH_INTERVAL 5.0f
namespace Online{
namespace Online
{
static ServersManager* manager_singleton(NULL);
ServersManager* ServersManager::get()
{
if (manager_singleton == NULL)
manager_singleton = new ServersManager();
return manager_singleton;
}
@ -46,12 +46,14 @@ namespace Online{
} // deallocate
// ============================================================================
ServersManager::ServersManager(){
ServersManager::ServersManager()
{
m_last_load_time.setAtomic(0.0f);
m_joined_server.setAtomic(NULL);
}
ServersManager::~ServersManager(){
ServersManager::~ServersManager()
{
cleanUpServers();
MutexLocker(m_joined_server);
delete m_joined_server.getData();
@ -75,27 +77,30 @@ namespace Online{
if(StkTime::getRealTime() - m_last_load_time.getAtomic() > SERVER_REFRESH_INTERVAL)
{
request = new RefreshRequest();
request->setServerURL("client-user.php");
request->addParameter("action","get_server_list");
request->setApiURL(API::SERVER_PATH, "get-all");
if (request_now)
RequestManager::get()->addRequest(request);
}
return request;
}
void ServersManager::refresh(bool success, const XMLNode * input)
{
if (success)
if (!success)
{
const XMLNode * servers_xml = input->getNode("servers");
cleanUpServers();
for (unsigned int i = 0; i < servers_xml->getNumNodes(); i++)
{
addServer(new Server(*servers_xml->getNode(i)));
}
m_last_load_time.setAtomic((float)StkTime::getRealTime());
Log::error("Server Manager", "Could not refresh server list");
return;
}
//FIXME error message
const XMLNode * servers_xml = input->getNode("servers");
cleanUpServers();
for (unsigned int i = 0; i < servers_xml->getNumNodes(); i++)
{
addServer(new Server(*servers_xml->getNode(i)));
}
m_last_load_time.setAtomic((float)StkTime::getRealTime());
}
void ServersManager::RefreshRequest::callback()
@ -117,7 +122,8 @@ namespace Online{
{
MutexLocker(m_joined_server);
delete m_joined_server.getData();
//It's a copy!
// It's a copy!
m_joined_server.getData() = new Server(*getServerByID(id));
}
@ -135,6 +141,7 @@ namespace Online{
m_sorted_servers.lock();
m_sorted_servers.getData().push_back(server);
m_sorted_servers.unlock();
m_mapped_servers.lock();
m_mapped_servers.getData()[server->getServerId()] = server;
m_mapped_servers.unlock();
@ -168,7 +175,8 @@ namespace Online{
}
// ============================================================================
void ServersManager::sort(bool sort_desc){
void ServersManager::sort(bool sort_desc)
{
MutexLocker(m_sorted_servers);
m_sorted_servers.getData().insertionSort(0, sort_desc);
}

21
src/online/servers_manager.hpp
View File

@ -26,11 +26,8 @@
#include "online/xml_request.hpp"
#include "utils/synchronised.hpp"
namespace Online {
namespace Online
{
/**
* \brief
* \ingroup online
@ -51,8 +48,10 @@ namespace Online {
~ServersManager();
/** Sorted vector of servers */
Synchronised<PtrVector<Server> > m_sorted_servers;
/** Maps server id's to the same servers*/
Synchronised<std::map<uint32_t, Server*> > m_mapped_servers;
/** This is a pointer to a copy of the server, the moment it got joined */
Synchronised<Server *> m_joined_server;
@ -74,14 +73,10 @@ namespace Online {
const Server * getServerBySort (int index) const;
void sort(bool sort_desc);
Server * getJoinedServer() const;
//Returns the best server to join
// Returns the best server to join
const Server * getQuickPlay() const;
}; // class ServersManager
} // namespace Online
#endif
/*EOF*/
#endif // HEADER_SERVERS_MANAGER_HPP

15
src/online/xml_request.cpp
View File

@ -24,15 +24,12 @@
#ifdef WIN32
# include <winsock2.h>
#endif
#include <curl/curl.h>
#include <assert.h>
namespace Online
{
/** Creates a HTTP(S) request that will automatically parse the answer into
* a XML structure.
* \param manage_memory whether or not the RequestManager should take care of
@ -61,22 +58,26 @@ namespace Online
void XMLRequest::afterOperation()
{
m_xml_data = file_manager->createXMLTreeFromString(getData());
if(hadDownloadError())
if (hadDownloadError())
{
Log::error("XMLRequest::afterOperation",
"curl_easy_perform() failed: %s",
getDownloadErrorMessage());
}
m_success = false;
std::string rec_success;
if(m_xml_data->get("success", &rec_success))
if (m_xml_data->get("success", &rec_success))
{
m_success = rec_success =="yes";
m_success = (rec_success == "yes");
m_xml_data->get("info", &m_info);
}
else
{
m_info = _("Unable to connect to the server. Check your internet "
"connection or try again later.");
}
HTTPRequest::afterOperation();
} // afterOperation
} // namespace Online

9
src/online/xml_request.hpp
View File

@ -53,7 +53,7 @@ namespace Online
virtual void afterOperation() OVERRIDE;
public :
XMLRequest(bool manage_memory = false, int priority = 1);
XMLRequest(bool manage_memory = false, int priority = 1);
virtual ~XMLRequest();
// ------------------------------------------------------------------------
@ -73,7 +73,7 @@ namespace Online
* \pre request had to be executed.
* \return get the info from the request reply
*/
const irr::core::stringw & getInfo() const
const irr::core::stringw & getInfo() const
{
assert(hasBeenExecuted());
return m_info;
@ -90,8 +90,5 @@ namespace Online
} // isSuccess
}; // class XMLRequest
} //namespace Online
#endif
#endif // HEADER_XML_REQUEST_HPP

66
src/patch Normal file
View File

@ -0,0 +1,66 @@
diff --git a/src/karts/kart.cpp b/src/karts/kart.cpp
index f9d6cd9..f243d2a 100644
--- a/src/karts/kart.cpp
+++ b/src/karts/kart.cpp
@@ -1098,7 +1098,7 @@ void Kart::update(float dt)
// TODO: hiker said this probably will be moved to btKart or so when updating bullet engine.
// Neutralize any yaw change if the kart leaves the ground, so the kart falls more or less
- // straight after jumping, but still allowing some "boat shake" (roll and pitch).
+ // straight after jumping, but still allowing some "boat shake" (roIll and pitch).
// Otherwise many non perfect jumps end in a total roll over or a serious change of
// direction, sometimes 90 or even full U turn (real but less fun for a karting game).
// As side effect steering becames a bit less responsive (any wheel on air), but not too bad.
@@ -2023,30 +2023,6 @@ void Kart::updatePhysics(float dt)
m_max_speed->setMinSpeed(min_speed);
m_max_speed->update(dt);
- // If the kart is flying, keep its up-axis aligned to gravity (which in
- // turn typically means the kart is parallel to the ground). This avoids
- // that the kart rotates in mid-air and lands on its side.
- if(m_vehicle->getNumWheelsOnGround()==0)
- {
- btVector3 kart_up = getTrans().getBasis().getColumn(1); // up vector
- btVector3 terrain_up = m_body->getGravity();
- float g = World::getWorld()->getTrack()->getGravity();
- // Normalize the gravity, g is the length of the vector
- btVector3 new_up = 0.9f * kart_up + 0.1f * terrain_up/-g;
- // Get the rotation (hpr) based on current heading.
- Vec3 rotation(getHeading(), new_up);
- btMatrix3x3 m;
- m.setEulerZYX(rotation.getX(), rotation.getY(), rotation.getZ());
- // We can't use getXYZ() for the position here, since the position is
- // based on interpolation, while the actual center-of-mass-transform
- // is based on the actual value every 1/60 of a second (using getXYZ()
- // would result in the kart being pushed ahead a bit, making it jump
- // much further, depending on fps)
- btTransform new_trans(m, m_body->getCenterOfMassTransform().getOrigin());
- //setTrans(new_trans);
- m_body->setCenterOfMassTransform(new_trans);
- }
-
// To avoid tunneling (which can happen on long falls), clamp the
// velocity in Y direction. Tunneling can happen if the Y velocity
// is larger than the maximum suspension travel (per frame), since then
diff --git a/src/physics/btKart.cpp b/src/physics/btKart.cpp
index bdb8f55..2aa0096 100644
--- a/src/physics/btKart.cpp
+++ b/src/physics/btKart.cpp
@@ -387,6 +387,17 @@ void btKart::updateVehicle( btScalar step )
if(m_wheelInfo[i].m_raycastInfo.m_isInContact)
m_num_wheels_on_ground++;
}
+
+ // If the kart is flying, try to keep it parallel to the ground.
+ if(m_num_wheels_on_ground==0)
+ {
+ btVector3 kart_up = getChassisWorldTransform().getBasis().getColumn(1);
+ btVector3 terrain_up(0,1,0);
+ btVector3 axis = kart_up.cross(terrain_up);
+ // Times 10 gives a nicely balanced feeling.
+ m_chassisBody->applyTorqueImpulse(axis * 10);
+ }
+
// Work around: make sure that either both wheels on one axis
// are on ground, or none of them. This avoids the problem of
// the kart suddenly getting additional angular velocity because

11
src/physics/btKart.cpp
View File

@ -387,6 +387,17 @@ void btKart::updateVehicle( btScalar step )
if(m_wheelInfo[i].m_raycastInfo.m_isInContact)
m_num_wheels_on_ground++;
}
// If the kart is flying, try to keep it parallel to the ground.
if(m_num_wheels_on_ground==0)
{
btVector3 kart_up = getChassisWorldTransform().getBasis().getColumn(1);
btVector3 terrain_up(0,1,0);
btVector3 axis = kart_up.cross(terrain_up);
// Give a nicely balanced feeling for rebalancing the kart
m_chassisBody->applyTorqueImpulse(axis * m_kart->getKartProperties()->getSmoothFlyingImpulse());
}
// Work around: make sure that either both wheels on one axis
// are on ground, or none of them. This avoids the problem of
// the kart suddenly getting additional angular velocity because

2
src/physics/physical_object.cpp
View File

@ -601,7 +601,7 @@ void PhysicalObject::hit(const Material *m, const Vec3 &normal)
if(isSoccerBall() && m != NULL &&
m->getCollisionReaction() == Material::PUSH_SOCCER_BALL)
{
m_body->applyCentralImpulse(normal * 100.0f);
m_body->applyCentralImpulse(normal * m_mass * 5.0f);
}
} // hit

2
src/states_screens/create_server_screen.cpp
View File

@ -139,7 +139,7 @@ void CreateServerScreen::serverCreationRequest()
{
m_server_creation_request = new ServerCreationRequest();
PlayerManager::setUserDetails(m_server_creation_request,"create_server");
PlayerManager::setUserDetails(m_server_creation_request, "create", Online::API::SERVER_PATH);
m_server_creation_request->addParameter("name", name);
m_server_creation_request->addParameter("max_players", max_players);
m_server_creation_request->queue();

34
src/states_screens/dialogs/change_password_dialog.cpp
View File

@ -38,8 +38,7 @@ using namespace Online;
/** Creates a modal dialog with given percentage of screen width and height
*/
ChangePasswordDialog::ChangePasswordDialog()
: ModalDialog(0.8f,0.7f)
ChangePasswordDialog::ChangePasswordDialog() : ModalDialog(0.8f, 0.7f)
{
m_self_destroy = false;
m_success = false;
@ -49,15 +48,15 @@ ChangePasswordDialog::ChangePasswordDialog()
m_current_password_widget = getWidget<TextBoxWidget>("current_password");
assert(m_current_password_widget != NULL);
m_current_password_widget->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
m_current_password_widget->setPasswordBox(true,L'*');
m_current_password_widget->setPasswordBox(true, L'*');
m_new_password1_widget = getWidget<TextBoxWidget>("new_password1");
assert(m_new_password1_widget != NULL);
m_new_password1_widget->setPasswordBox(true,L'*');
m_new_password1_widget->setPasswordBox(true, L'*');
m_new_password2_widget = getWidget<TextBoxWidget>("new_password2");
assert(m_new_password2_widget != NULL);
m_new_password2_widget->setPasswordBox(true,L'*');
m_new_password2_widget->setPasswordBox(true, L'*');
m_info_widget = getWidget<LabelWidget>("info");
assert(m_info_widget != NULL);
@ -71,7 +70,6 @@ ChangePasswordDialog::ChangePasswordDialog()
} // ChangePasswordDialog
// ----------------------------------------------------------------------------
ChangePasswordDialog::~ChangePasswordDialog()
{
} // ~ChangePasswordDialog
@ -93,6 +91,7 @@ void ChangePasswordDialog::changePassword(const stringw &current_password,
virtual void callback()
{
if (!GUIEngine::ModalDialog::isADialogActive()) return;
ChangePasswordDialog * dialog =
dynamic_cast<ChangePasswordDialog*>(GUIEngine::ModalDialog
::getCurrent());
@ -111,8 +110,9 @@ void ChangePasswordDialog::changePassword(const stringw &current_password,
// ------------------------------------------------------------------------
ChangePasswordRequest * request = new ChangePasswordRequest();
PlayerManager::setUserDetails(request, "change_password");
PlayerManager::setUserDetails(request, "change-password");
request->addParameter("current", current_password);
// The server code expects two passwords (and verifies again that they
// are identical), so send the passwod twice.
request->addParameter("new1", new_password);
@ -126,6 +126,7 @@ void ChangePasswordDialog::submit()
const stringw current_password = m_current_password_widget->getText().trim();
const stringw new_password1 = m_new_password1_widget->getText().trim();
const stringw new_password2 = m_new_password2_widget->getText().trim();
if (current_password.size() < 8 || current_password.size() > 30)
{
sfx_manager->quickSound("anvil");
@ -149,6 +150,7 @@ void ChangePasswordDialog::submit()
{
m_options_widget->setDeactivated();
m_info_widget->setDefaultColor();
// We don't need to use password 2 anymore, it was already confirmed
// that both passwords are identical.
changePassword(current_password, new_password1);
@ -159,42 +161,45 @@ void ChangePasswordDialog::submit()
GUIEngine::EventPropagation
ChangePasswordDialog::processEvent(const std::string& eventSource)
{
if (eventSource == m_options_widget->m_properties[PROP_ID])
{
const std::string& selection =
m_options_widget->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (selection == m_cancel_widget->m_properties[PROP_ID])
{
m_self_destroy = true;
return GUIEngine::EVENT_BLOCK;
}
else if(selection == m_submit_widget->m_properties[PROP_ID])
{
submit();
return GUIEngine::EVENT_BLOCK;
}
}
return GUIEngine::EVENT_LET;
} // processEvent
// ----------------------------------------------------------------------------
void ChangePasswordDialog::onEnterPressedInternal()
{
const int playerID = PLAYER_ID_GAME_MASTER;
if (GUIEngine::isFocusedForPlayer(m_options_widget, playerID))
return;
if (m_submit_widget->isActivated())
submit();
} // onEnterPressedInternal
// ----------------------------------------------------------------------------
bool ChangePasswordDialog::onEscapePressed()
{
if (m_cancel_widget->isActivated())
m_self_destroy = true;
return false;
} // onEscapePressed
@ -222,12 +227,15 @@ void ChangePasswordDialog::error(const irr::core::stringw & error)
} // error
// -----------------------------------------------------------------------------
void ChangePasswordDialog::onUpdate(float dt)
{
if(!m_options_widget->isActivated())
m_info_widget->setText(StringUtils::loadingDots(_("Validating info")),
false );
{
m_info_widget->setText(
StringUtils::loadingDots(_("Validating info")),
false
);
}
// It's unsafe to delete from inside the event handler so we do it here
if (m_self_destroy)

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

@ -22,6 +22,7 @@
#include "guiengine/widgets/spinner_widget.hpp"
#include "states_screens/options_screen_video.hpp"
#include "utils/translation.hpp"
#include "graphics/irr_driver.hpp"
#include <IGUIEnvironment.h>
@ -51,7 +52,6 @@ void CustomVideoSettingsDialog::beforeAddingWidgets()
{
getWidget<CheckBoxWidget>("anim_gfx")->setState( UserConfigParams::m_graphical_effects );
getWidget<CheckBoxWidget>("weather_gfx")->setState( UserConfigParams::m_weather_effects );
getWidget<CheckBoxWidget>("ubo")->setState(!UserConfigParams::m_ubo_disabled);
getWidget<CheckBoxWidget>("dof")->setState(UserConfigParams::m_dof);
getWidget<CheckBoxWidget>("hd-textures")->setState(UserConfigParams::m_high_definition_textures);
@ -83,7 +83,7 @@ void CustomVideoSettingsDialog::beforeAddingWidgets()
shadows->addLabel( _("Disabled") ); // 0
shadows->addLabel( _("low") ); // 1
shadows->addLabel( _("high") ); // 2
if (!UserConfigParams::m_ubo_disabled)
if (!irr_driver->needUBOWorkaround())
shadows->setValue(UserConfigParams::m_shadows);
else
shadows->setValue(0);
@ -109,11 +109,11 @@ GUIEngine::EventPropagation CustomVideoSettingsDialog::processEvent(const std::s
UserConfigParams::m_dof =
advanced_pipeline && getWidget<CheckBoxWidget>("dof")->getState();
UserConfigParams::m_motionblur =
advanced_pipeline && getWidget<CheckBoxWidget>("motionblur")->getState();
if (advanced_pipeline && getWidget<CheckBoxWidget>("ubo")->getState())
if (advanced_pipeline)
{
UserConfigParams::m_shadows =
getWidget<SpinnerWidget>("shadows")->getValue();
@ -150,9 +150,6 @@ GUIEngine::EventPropagation CustomVideoSettingsDialog::processEvent(const std::s
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();

45
src/states_screens/dialogs/debug_slider.cpp
View File

@ -32,30 +32,19 @@ using namespace GUIEngine;
// ------------------------------------------------------------------------------------------------------
DebugSliderDialog::DebugSliderDialog(std::string id, irr::core::stringw msg) :
ModalDialog(0.85f, 0.25f, MODAL_DIALOG_LOCATION_BOTTOM)
DebugSliderDialog::DebugSliderDialog() : ModalDialog(0.85f, 0.25f, MODAL_DIALOG_LOCATION_BOTTOM)
{
//if (StateManager::get()->getGameState() == GUIEngine::GAME)
//{
// World::getWorld()->schedulePause(World::IN_GAME_MENU_PHASE);
//}
m_id = id;
m_fade_background = false;
loadFromFile("debug_slider.stkgui");
}
LabelWidget* message = getWidget<LabelWidget>("title");
message->setText( msg.c_str(), false );
float val;
if (m_id == "lwhite")
val = irr_driver->getLwhite() * 10.f;
if (m_id == "exposure")
val = irr_driver->getExposure() * 100.f;
getWidget<SpinnerWidget>("value_slider")->setValue(int(val));
void DebugSliderDialog::setSliderHook(std::string id, unsigned min, unsigned max, std::function<int()> G, std::function<void(int)> S)
{
getWidget<SpinnerWidget>(id.c_str())->setValue(G());
getWidget<SpinnerWidget>(id.c_str())->setMin(min);
getWidget<SpinnerWidget>(id.c_str())->setMax(max);
Setters[id] = S;
}
// ------------------------------------------------------------------------------------------------------
@ -78,18 +67,12 @@ void DebugSliderDialog::onEnterPressedInternal()
GUIEngine::EventPropagation DebugSliderDialog::processEvent(const std::string& eventSource)
{
if (eventSource == "value_slider")
{
int value = getWidget<SpinnerWidget>("value_slider")->getValue();
Log::info("DebugSlider", "Value for <%s> : %i", m_id.c_str(), value);
if (m_id == "lwhite")
irr_driver->setLwhite(value / 10.f);
if (m_id == "exposure")
irr_driver->setExposure(value / 100.f);
return GUIEngine::EVENT_BLOCK;
}
return GUIEngine::EVENT_LET;
if (Setters.find(eventSource) == Setters.end())
return GUIEngine::EVENT_LET;
int value = getWidget<SpinnerWidget>(eventSource.c_str())->getValue();
Log::info("DebugSlider", "Value for <%s> : %i", eventSource.c_str(), value);
Setters[eventSource](value);
return GUIEngine::EVENT_BLOCK;
}
// ------------------------------------------------------------------------------------------------------

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

@ -22,6 +22,7 @@
#include "guiengine/modaldialog.hpp"
#include "utils/cpp2011.hpp"
#include "utils/leak_check.hpp"
#include <functional>
/**
* \brief For internal value tweaking
@ -32,18 +33,18 @@ class DebugSliderDialog : public GUIEngine::ModalDialog
private:
std::string m_id;
std::map<std::string, std::function<void(int)> >Setters;
public:
DebugSliderDialog();
DebugSliderDialog(std::string id, ::core::stringw msg);
~DebugSliderDialog();
void setSliderHook(std::string id, unsigned min, unsigned max, std::function<int()> G, std::function<void(int)> S);
virtual void onEnterPressedInternal() OVERRIDE;
virtual void onUpdate(float dt) OVERRIDE;
GUIEngine::EventPropagation processEvent(const std::string& eventSource);
};

21
src/states_screens/dialogs/recovery_dialog.cpp
View File

@ -125,9 +125,11 @@ void RecoveryDialog::processInput()
{
m_info_widget->setDefaultColor();
m_options_widget->setDeactivated();
m_recovery_request = new XMLRequest();
// This function also works when the current user is not logged in
PlayerManager::setUserDetails(m_recovery_request, "recovery");
PlayerManager::setUserDetails(m_recovery_request, "recover");
m_recovery_request->addParameter("username", username);
m_recovery_request->addParameter("email", email );
m_recovery_request->queue();
@ -142,10 +144,13 @@ GUIEngine::EventPropagation
{
std::string selection;
if (eventSource == m_options_widget->m_properties[PROP_ID])
selection =
m_options_widget->getSelectionIDString(PLAYER_ID_GAME_MASTER);
{
selection = m_options_widget->getSelectionIDString(PLAYER_ID_GAME_MASTER);
}
else
{
selection = eventSource;
}
if (selection == m_cancel_widget->m_properties[PROP_ID])
{
@ -165,9 +170,9 @@ GUIEngine::EventPropagation
*/
void RecoveryDialog::onEnterPressedInternal()
{
if (GUIEngine::isFocusedForPlayer(m_options_widget, PLAYER_ID_GAME_MASTER))
return;
if (m_submit_widget->isActivated())
processInput();
}
@ -194,15 +199,19 @@ void RecoveryDialog::onUpdate(float dt)
m_info_widget->setText(m_recovery_request->getInfo(), false);
m_options_widget->setActivated();
}
delete m_recovery_request;
m_recovery_request = NULL;
}
else
{
m_info_widget->setText(StringUtils::loadingDots(_("Validating info")),
false);
m_info_widget->setText(
StringUtils::loadingDots(_("Validating info")),
false
);
}
}
// It's unsafe to delete from inside the event handler so we do it here
if (m_self_destroy)
ModalDialog::dismiss();

1
src/states_screens/dialogs/registration_dialog.cpp
View File

@ -78,6 +78,7 @@ EventPropagation RegistrationDialog::processEvent(const std::string& event_sourc
assert(r);
r->acceptTerms();
}
// If it's not accept, it's cancel - anyway, close dialog
ModalDialog::dismiss();
return EVENT_BLOCK;

3
src/states_screens/dialogs/track_info_dialog.cpp
View File

@ -99,7 +99,7 @@ TrackInfoDialog::TrackInfoDialog(const std::string& ribbonItem, const std::strin
if (UserConfigParams::m_artist_debug_mode)
m_spinner->setMin(0);
m_spinner->setValue(track->getDefaultNumberOfLaps());
m_spinner->setValue(track->getActualNumberOfLap());
race_manager->setNumLaps(m_spinner->getValue());
}
else
@ -236,6 +236,7 @@ void TrackInfoDialog::onEnterPressedInternal()
const int num_laps = (m_spinner == NULL ? -1 : m_spinner->getValue());
const bool reverse_track = m_checkbox == NULL ? false
: m_checkbox->getState();
track_manager->getTrack(m_track_ident)->setActualNumberOfLaps(num_laps);
race_manager->setReverseTrack(reverse_track);
std::string track_ident = m_track_ident;
// Disable accidentally unlocking of a challenge

29
src/states_screens/dialogs/user_info_dialog.cpp
View File

@ -144,9 +144,10 @@ void UserInfoDialog::sendFriendRequest()
*/
virtual void callback()
{
core::stringw info_text("");
uint32_t id(0);
getXMLData()->get("friendid", &id);
core::stringw info_text("");
if (isSuccess())
{
PlayerManager::getCurrentOnlineProfile()->addFriend(id);
@ -158,7 +159,10 @@ void UserInfoDialog::sendFriendRequest()
info_text = _("Friend request send!");
}
else
{
info_text = getInfo();
}
UserInfoDialog *dialog = new UserInfoDialog(id, info_text,
!isSuccess(), true);
GUIEngine::DialogQueue::get()->pushDialog(dialog, true);
@ -196,8 +200,9 @@ void UserInfoDialog::acceptFriendRequest()
virtual void callback()
{
uint32_t id(0);
getXMLData()->get("friendid", &id);
core::stringw info_text("");
getXMLData()->get("friendid", &id);
if (isSuccess())
{
OnlineProfile * profile =
@ -211,7 +216,10 @@ void UserInfoDialog::acceptFriendRequest()
info_text = _("Friend request accepted!");
}
else
{
info_text = getInfo();
}
GUIEngine::DialogQueue::get()->pushDialog(
new UserInfoDialog(id, info_text, !isSuccess(), true), true);
@ -225,6 +233,7 @@ void UserInfoDialog::acceptFriendRequest()
PlayerManager::setUserDetails(request, "accept-friend-request");
request->addParameter("friendid", m_online_profile->getID());
request->queue();
m_processing = true;
m_options_widget->setDeactivated();
} // acceptFriendRequest
@ -246,8 +255,9 @@ void UserInfoDialog::declineFriendRequest()
virtual void callback()
{
uint32_t id(0);
getXMLData()->get("friendid", &id);
core::stringw info_text("");
getXMLData()->get("friendid", &id);
if (isSuccess())
{
PlayerManager::getCurrentOnlineProfile()->removeFriend(id);
@ -258,7 +268,10 @@ void UserInfoDialog::declineFriendRequest()
info_text = _("Friend request declined!");
}
else
{
info_text = getInfo();
}
GUIEngine::DialogQueue::get()->pushDialog(
new UserInfoDialog(id, info_text, !isSuccess(),
true), true);
@ -286,9 +299,11 @@ void UserInfoDialog::removeExistingFriend()
class RemoveFriendRequest : public XMLRequest
{
unsigned int m_id;
virtual void callback()
{
core::stringw info_text("");
if (isSuccess())
{
PlayerManager::getCurrentOnlineProfile()->removeFriend(m_id);
@ -299,7 +314,9 @@ void UserInfoDialog::removeExistingFriend()
info_text = _("Friend removed!");
}
else
{
info_text = getInfo();
}
UserInfoDialog *info = new UserInfoDialog(m_id, info_text,
!isSuccess(), true);
@ -335,8 +352,9 @@ void UserInfoDialog::removePendingFriend()
virtual void callback()
{
uint32_t id(0);
getXMLData()->get("friendid", &id);
core::stringw info_text("");
getXMLData()->get("friendid", &id);
if (isSuccess())
{
PlayerManager::getCurrentOnlineProfile()->removeFriend(id);
@ -347,8 +365,9 @@ void UserInfoDialog::removePendingFriend()
info_text = _("Friend request cancelled!");
}
else
{
info_text = getInfo();
}
UserInfoDialog *dia = new UserInfoDialog(id, info_text,
!isSuccess(), true);
GUIEngine::DialogQueue::get()->pushDialog(dia, true);

23
src/states_screens/dialogs/vote_dialog.cpp
View File

@ -48,14 +48,16 @@ VoteDialog::VoteDialog(const std::string & addon_id)
m_rating_widget = getWidget<RatingBarWidget>("rating");
assert(m_rating_widget != NULL);
m_rating_widget->setRating(0);
m_rating_widget->allowVoting();
m_options_widget = getWidget<RibbonWidget>("options");
assert(m_options_widget != NULL);
m_cancel_widget = getWidget<IconButtonWidget>("cancel");
assert(m_cancel_widget != NULL);
m_options_widget->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
m_options_widget->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
m_fetch_vote_request = new XMLRequest();
PlayerManager::setUserDetails(m_fetch_vote_request, "get-addon-vote");
@ -102,8 +104,9 @@ void VoteDialog::sendVote()
if (isSuccess())
{
std::string addon_id;
getXMLData()->get("addon-id", &addon_id);
float average;
getXMLData()->get("addon-id", &addon_id);
getXMLData()->get("new-average", &average);
addons_manager->getAddon(Addon::createAddonId(addon_id))
->setRating(average);
@ -112,10 +115,8 @@ void VoteDialog::sendVote()
public:
SetAddonVoteRequest() : XMLRequest() {}
}; // SetAddonVoteRequest
// ------------------------------------------------------------------------
m_perform_vote_request = new SetAddonVoteRequest();
PlayerManager::setUserDetails(m_perform_vote_request, "set-addon-vote");
m_perform_vote_request->addParameter("addonid", m_addon_id.substr(6));
@ -144,12 +145,15 @@ GUIEngine::EventPropagation VoteDialog::processEvent(const std::string& event)
{
const std::string& selection =
m_options_widget->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (selection == m_cancel_widget->m_properties[PROP_ID])
{
m_self_destroy = true;
return GUIEngine::EVENT_BLOCK;
}
}
return GUIEngine::EVENT_LET;
} // processEvent
@ -163,16 +167,21 @@ void VoteDialog::updateFetchVote()
if (!m_fetch_vote_request->isDone())
{
// request still pending
m_info_widget->setText(StringUtils::loadingDots(_("Fetching last vote")),
false );
m_info_widget->setText(
StringUtils::loadingDots(_("Fetching last vote")),
false
);
return;
} // !isDone
if (m_fetch_vote_request->isSuccess())
{
m_info_widget->setDefaultColor();
std::string voted("");
m_info_widget->setDefaultColor();
m_fetch_vote_request->getXMLData()->get("voted", &voted);
if (voted == "yes")
{
float rating;

28
src/states_screens/online_screen.cpp
View File

@ -168,36 +168,36 @@ void OnlineScreen::onUpdate(float delta)
void OnlineScreen::doQuickPlay()
{
// Refresh server list.
HTTPRequest* request = ServersManager::get()->refreshRequest(false);
if (request != NULL) // consider request done
HTTPRequest* refresh_request = ServersManager::get()->refreshRequest(false);
if (refresh_request != NULL) // consider request done
{
request->executeNow();
delete request;
refresh_request->executeNow();
delete refresh_request;
}
else
{
Log::error("OnlineScreen", "Could not get the server list.");
return;
}
// select first one
const Server * server = ServersManager::get()->getQuickPlay();
const Server *server = ServersManager::get()->getQuickPlay();
XMLRequest *request2 = new RequestConnection::ServerJoinRequest();
if (!request2)
// do a join request
XMLRequest *join_request = new RequestConnection::ServerJoinRequest();
if (!join_request)
{
sfx_manager->quickSound("anvil");
return;
}
PlayerManager::setUserDetails(request2, "request-connection");
request2->setServerURL("address-management.php");
request2->addParameter("server_id", server->getServerId());
PlayerManager::setUserDetails(join_request, "request-connection", Online::API::SERVER_PATH);
join_request->addParameter("server_id", server->getServerId());
request2->executeNow();
if (request2->isSuccess())
join_request->executeNow();
if (join_request->isSuccess())
{
delete request2;
delete join_request;
StateManager::get()->pushScreen(NetworkingLobby::getInstance());
ConnectToServer *cts = new ConnectToServer(server->getServerId(),
server->getHostId());

16
src/states_screens/online_user_search.cpp
View File

@ -139,25 +139,30 @@ void OnlineUserSearch::parseResult(const XMLNode * input)
{
m_users.clear();
const XMLNode * users_xml = input->getNode("users");
// Try to reserve enough cache space for all found entries.
unsigned int n = ProfileManager::get()
->guaranteeCacheSize(users_xml->getNumNodes());
if (n >= users_xml->getNumNodes())
{
n = users_xml->getNumNodes();
}
else
{
Log::warn("OnlineSearch",
"Too many results found, only %d will be displayed.", n);
}
for (unsigned int i = 0; i < n; i++)
{
OnlineProfile * profile = new OnlineProfile(users_xml->getNode(i));
// The id must be pushed before adding it to the cache, since
// the cache might merge the new data with an existing entry
m_users.push_back(profile->getID());
ProfileManager::get()->addToCache(profile);
}
} // for i = 0 ... number of display users
} // parseResult
// ----------------------------------------------------------------------------
@ -166,17 +171,19 @@ void OnlineUserSearch::parseResult(const XMLNode * input)
void OnlineUserSearch::showList()
{
m_user_list_widget->clear();
for (unsigned int i=0; i < m_users.size(); i++)
for (unsigned int i = 0; i < m_users.size(); i++)
{
std::vector<GUIEngine::ListWidget::ListCell> row;
OnlineProfile * profile = ProfileManager::get()->getProfileByID(m_users[i]);
// This could still happen if something pushed results out of the cache.
if (!profile)
{
Log::warn("OnlineSearch", "User %d not in cache anymore, ignored.",
m_users[i]);
Log::warn("OnlineSearch", "User %d not in cache anymore, ignored.", m_users[i]);
continue;
}
row.push_back(GUIEngine::ListWidget::ListCell(profile->getUserName(),-1,3));
m_user_list_widget->addItem("user", row);
}
@ -267,6 +274,7 @@ void OnlineUserSearch::onUpdate(float dt)
sfx_manager->quickSound( "anvil" );
new MessageDialog(m_search_request->getInfo());
}
delete m_search_request;
m_search_request = NULL;
m_back_widget->setActivated();

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