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

Merge remote-tracking branch 'origin/master' into game_protocol

Browse Source
This commit is contained in:
hiker 2018-03-08 09:51:00 +11:00
commit 8cf885652f
29 changed files with 1863 additions and 1100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
android/generate_assets.sh
View File

@ -43,7 +43,8 @@ export RUN_OPTIMIZE_SCRIPT=0
export DECREASE_QUALITY=1
export CONVERT_TO_JPG=1
export CONVERT_TO_JPG_BLACKLIST="data/karts/hexley/hexley_kart_diffuse.png"
export CONVERT_TO_JPG_BLACKLIST="data/karts/hexley/hexley_kart_diffuse.png \
data/models/traffic_light.png"
export BLACKLIST_FILES="data/music/cocoa_river_fast.ogg2"

26
data/gui/init_android.stkgui Normal file
View File

@ -0,0 +1,26 @@
<?xml version="1.0" encoding="UTF-8"?>
<stkgui>
<div x="2%" y="2%" width="96%" height="96%" layout="vertical-row" >
<spacer height="2%" width="25"/>
<box width="100%" height="fit" padding="10" layout="vertical-row">
<bright width="100%" text="Select a type of control that you prefer" align="center" text_align="left" />
<spacer height="15%" width="10"/>
<ribbon id="control_type" height="135" width="100%" align="center">
<icon-button id="accelerometer" width="128" height="128" icon="gui/difficulty_medium.png"
I18N="Control type" text="Accelerometer"/>
<icon-button id="steering_wheel" width="128" height="128" icon="gui/difficulty_hard.png"
I18N="Control type" text="Steering wheel"/>
</ribbon>
</box>
<spacer height="7%" width="10"/>
<div width="25%" height="10%" layout="horizontal-row" align="center">
<button id="close" text="Apply" width="100%" height="100%" align="center"/>
</div>
</div>
</stkgui>

2
data/gui/multitouch_settings.stkgui
View File

@ -35,7 +35,7 @@
<label proportion="1" align="center" text_align="right" I18N="In the multitouch settings screen" text="Accelerometer"/>
<div proportion="1" align="center" height="fit" layout="horizontal-row" >
<spacer width="40" height="10" />
<spinner id="accelerometer" proportion="1"/>
<checkbox id="accelerometer"/>
</div>
</div>

56
data/shaders/sp_dynamic_night_bloom.frag Normal file
View File

@ -0,0 +1,56 @@
in vec3 bitangent;
in vec4 color;
in float hue_change;
in vec3 normal;
in vec3 tangent;
in vec2 uv;
uniform int is_during_day;
layout(location = 0) out vec4 o_diffuse_color;
layout(location = 1) out vec4 o_normal_color;
#stk_include "utils/encode_normal.frag"
#stk_include "utils/rgb_conversion.frag"
#stk_include "utils/sp_texture_sampling.frag"
void main()
{
vec4 col = sampleTextureLayer0(uv);
if (hue_change > 0.0)
{
float mask = col.a;
vec3 old_hsv = rgbToHsv(col.rgb);
float mask_step = step(mask, 0.5);
#if !defined(Advanced_Lighting_Enabled)
// For similar color
float saturation = mask * 1.825; // 2.5 * 0.5 ^ (1. / 2.2)
#else
float saturation = mask * 2.5;
#endif
vec2 new_xy = mix(vec2(old_hsv.x, old_hsv.y), vec2(hue_change,
max(old_hsv.y, saturation)), vec2(mask_step, mask_step));
vec3 new_color = hsvToRgb(vec3(new_xy.x, new_xy.y, old_hsv.z));
col = vec4(new_color.r, new_color.g, new_color.b, 1.0);
}
vec3 final_color = col.xyz * color.xyz;
#if defined(Advanced_Lighting_Enabled)
vec4 layer_2 = sampleTextureLayer2(uv);
vec4 layer_3 = sampleTextureLayer3(uv);
o_diffuse_color = vec4(final_color, layer_2.z * (1.0f - float(is_during_day)));
vec3 tangent_space_normal = 2.0 * layer_3.xyz - 1.0;
vec3 frag_tangent = normalize(tangent);
vec3 frag_bitangent = normalize(bitangent);
vec3 frag_normal = normalize(normal);
mat3 t_b_n = mat3(frag_tangent, frag_bitangent, frag_normal);
vec3 world_normal = t_b_n * tangent_space_normal;
o_normal_color.xy = 0.5 * EncodeNormal(normalize(world_normal)) + 0.5;
o_normal_color.zw = layer_2.xy;
#else
o_diffuse_color = vec4(final_color, 1.0);
#endif
}

20
data/shaders/sps_9_dynamicNightBloom.xml Normal file
View File

@ -0,0 +1,20 @@
<!--
Shader used to enable bloom only at night time (to emulate neons, lamps, etc)
-->
<spshader>
<shader-info name="dynamicnightbloom" fallback-shader="solid" use-tangents="Y"/>
<first-pass vertex-shader="sp_pass.vert"
fragment-shader="sp_dynamic_night_bloom.frag"
skinned-mesh-shader="sp_skinning.vert">
</first-pass>
<shadow-pass vertex-shader="sp_shadow.vert"
fragment-shader="white.frag"
skinned-mesh-shader="sp_skinning_shadow.vert">
</shadow-pass>
<uniform-assigners>
<uniform-assigner name="layer"
function="shadowCascadeUniformAssigner"/>
<uniform-assigner name="is_during_day"
function="isDuringDayUniformAssigner"/>
</uniform-assigners>
</spshader>

22
lib/irrlicht/include/Keycodes.h
View File

@ -179,7 +179,27 @@ namespace irr
IRR_KEY_PA1 = 0xFD, // PA1 key
IRR_KEY_OEM_CLEAR = 0xFE, // Clear key
IRR_KEY_CODES_COUNT = 0xFF // this is not a key, but the amount of keycodes there are.
IRR_KEY_BUTTON_LEFT = 0x100,
IRR_KEY_BUTTON_RIGHT = 0x101,
IRR_KEY_BUTTON_UP = 0x102,
IRR_KEY_BUTTON_DOWN = 0x103,
IRR_KEY_BUTTON_A = 0x104,
IRR_KEY_BUTTON_B = 0x105,
IRR_KEY_BUTTON_C = 0x106,
IRR_KEY_BUTTON_X = 0x107,
IRR_KEY_BUTTON_Y = 0x108,
IRR_KEY_BUTTON_Z = 0x109,
IRR_KEY_BUTTON_L1 = 0x10A,
IRR_KEY_BUTTON_R1 = 0x10B,
IRR_KEY_BUTTON_L2 = 0x10C,
IRR_KEY_BUTTON_R2 = 0x10D,
IRR_KEY_BUTTON_THUMBL = 0x10E,
IRR_KEY_BUTTON_THUMBR = 0x10F,
IRR_KEY_BUTTON_START = 0x110,
IRR_KEY_BUTTON_SELECT = 0x111,
IRR_KEY_BUTTON_MODE = 0x112,
IRR_KEY_CODES_COUNT = 0x113 // this is not a key, but the amount of keycodes there are.
};
} // end namespace irr

138
lib/irrlicht/source/Irrlicht/CIrrDeviceAndroid.cpp
View File

@ -50,7 +50,8 @@ CIrrDeviceAndroid::CIrrDeviceAndroid(const SIrrlichtCreationParameters& param)
Gyroscope(0),
IsMousePressed(false),
GamepadAxisX(0),
GamepadAxisY(0)
GamepadAxisY(0),
DefaultOrientation(ORIENTATION_UNKNOWN)
{
#ifdef _DEBUG
setDebugName("CIrrDeviceAndroid");
@ -234,10 +235,26 @@ bool CIrrDeviceAndroid::run()
case ASENSOR_TYPE_ACCELEROMETER:
SEvent accEvent;
accEvent.EventType = EET_ACCELEROMETER_EVENT;
if (DefaultOrientation == ORIENTATION_LANDSCAPE)
{
accEvent.AccelerometerEvent.X = event.acceleration.y;
accEvent.AccelerometerEvent.Y = -event.acceleration.x;
}
else
{
accEvent.AccelerometerEvent.X = event.acceleration.x;
accEvent.AccelerometerEvent.Y = event.acceleration.y;
}
accEvent.AccelerometerEvent.Z = event.acceleration.z;
if (accEvent.AccelerometerEvent.X < 0)
{
accEvent.AccelerometerEvent.X *= -1;
accEvent.AccelerometerEvent.Y *= -1;
accEvent.AccelerometerEvent.Z *= -1;
}
postEventFromUser(accEvent);
break;
@ -417,6 +434,7 @@ void CIrrDeviceAndroid::handleAndroidCommand(android_app* app, int32_t cmd)
os::Printer::log("Android command APP_CMD_LOW_MEMORY", ELL_DEBUG);
break;
default:
os::Printer::log("Android command: ", core::stringc(cmd).c_str(), ELL_DEBUG);
break;
}
@ -742,15 +760,16 @@ s32 CIrrDeviceAndroid::handleGamepad(AInputEvent* androidEvent)
if (GamepadAxisX != 0)
{
event.KeyInput.PressedDown = false;
event.KeyInput.Key = GamepadAxisX < 0 ? IRR_KEY_LEFT
: IRR_KEY_RIGHT;
event.KeyInput.Key = GamepadAxisX < 0 ? IRR_KEY_BUTTON_LEFT
: IRR_KEY_BUTTON_RIGHT;
postEventFromUser(event);
}
if (axis_x != 0)
{
event.KeyInput.PressedDown = true;
event.KeyInput.Key = axis_x < 0 ? IRR_KEY_LEFT : IRR_KEY_RIGHT;
event.KeyInput.Key = axis_x < 0 ? IRR_KEY_BUTTON_LEFT
: IRR_KEY_BUTTON_RIGHT;
postEventFromUser(event);
}
@ -762,15 +781,16 @@ s32 CIrrDeviceAndroid::handleGamepad(AInputEvent* androidEvent)
if (GamepadAxisY != 0)
{
event.KeyInput.PressedDown = false;
event.KeyInput.Key = GamepadAxisY < 0 ? IRR_KEY_UP
: IRR_KEY_DOWN;
event.KeyInput.Key = GamepadAxisY < 0 ? IRR_KEY_BUTTON_UP
: IRR_KEY_BUTTON_DOWN;
postEventFromUser(event);
}
if (axis_y != 0)
{
event.KeyInput.PressedDown = true;
event.KeyInput.Key = axis_y < 0 ? IRR_KEY_UP : IRR_KEY_DOWN;
event.KeyInput.Key = axis_y < 0 ? IRR_KEY_BUTTON_UP
: IRR_KEY_BUTTON_DOWN;
postEventFromUser(event);
}
@ -926,21 +946,21 @@ void CIrrDeviceAndroid::createKeyMap()
KeyMap[AKEYCODE_SWITCH_CHARSET] = IRR_KEY_UNKNOWN;
// following look like controller inputs
KeyMap[AKEYCODE_BUTTON_A] = IRR_KEY_RETURN;
KeyMap[AKEYCODE_BUTTON_B] = IRR_KEY_ESCAPE;
KeyMap[AKEYCODE_BUTTON_C] = IRR_KEY_2;
KeyMap[AKEYCODE_BUTTON_X] = IRR_KEY_3;
KeyMap[AKEYCODE_BUTTON_Y] = IRR_KEY_4;
KeyMap[AKEYCODE_BUTTON_Z] = IRR_KEY_5;
KeyMap[AKEYCODE_BUTTON_L1] = IRR_KEY_6;
KeyMap[AKEYCODE_BUTTON_R1] = IRR_KEY_7;
KeyMap[AKEYCODE_BUTTON_L2] = IRR_KEY_8;
KeyMap[AKEYCODE_BUTTON_R2] = IRR_KEY_9;
KeyMap[AKEYCODE_BUTTON_THUMBL] = IRR_KEY_RETURN;
KeyMap[AKEYCODE_BUTTON_THUMBR] = IRR_KEY_RETURN;
KeyMap[AKEYCODE_BUTTON_START] = IRR_KEY_RETURN;
KeyMap[AKEYCODE_BUTTON_SELECT] = IRR_KEY_ESCAPE;
KeyMap[AKEYCODE_BUTTON_MODE] = IRR_KEY_MENU;
KeyMap[AKEYCODE_BUTTON_A] = IRR_KEY_BUTTON_A;
KeyMap[AKEYCODE_BUTTON_B] = IRR_KEY_BUTTON_B;
KeyMap[AKEYCODE_BUTTON_C] = IRR_KEY_BUTTON_C;
KeyMap[AKEYCODE_BUTTON_X] = IRR_KEY_BUTTON_X;
KeyMap[AKEYCODE_BUTTON_Y] = IRR_KEY_BUTTON_Y;
KeyMap[AKEYCODE_BUTTON_Z] = IRR_KEY_BUTTON_Z;
KeyMap[AKEYCODE_BUTTON_L1] = IRR_KEY_BUTTON_L1;
KeyMap[AKEYCODE_BUTTON_R1] = IRR_KEY_BUTTON_R1;
KeyMap[AKEYCODE_BUTTON_L2] = IRR_KEY_BUTTON_L2;
KeyMap[AKEYCODE_BUTTON_R2] = IRR_KEY_BUTTON_R2;
KeyMap[AKEYCODE_BUTTON_THUMBL] = IRR_KEY_BUTTON_THUMBL;
KeyMap[AKEYCODE_BUTTON_THUMBR] = IRR_KEY_BUTTON_THUMBR;
KeyMap[AKEYCODE_BUTTON_START] = IRR_KEY_BUTTON_START;
KeyMap[AKEYCODE_BUTTON_SELECT] = IRR_KEY_BUTTON_SELECT;
KeyMap[AKEYCODE_BUTTON_MODE] = IRR_KEY_BUTTON_MODE;
KeyMap[AKEYCODE_ESCAPE] = IRR_KEY_ESCAPE;
KeyMap[AKEYCODE_FORWARD_DEL] = IRR_KEY_DELETE;
@ -1111,11 +1131,85 @@ void CIrrDeviceAndroid::getKeyChar(SEvent& event)
}
}
int CIrrDeviceAndroid::getRotation()
{
JavaVMAttachArgs args;
args.version = JNI_VERSION_1_6;
args.name = "NativeThread";
args.group = NULL;
JNIEnv* env;
if (Android->activity->vm->AttachCurrentThread(&env, &args) != JNI_OK)
{
os::Printer::log("Cannot find rotation.", ELL_DEBUG);
return 0;
}
jobject activity_obj = Android->activity->clazz;
jclass activity = env->GetObjectClass(activity_obj);
jclass context = env->FindClass("android/content/Context");
jclass window_manager = env->FindClass("android/view/WindowManager");
jclass display = env->FindClass("android/view/Display");
jmethodID get_system_service = env->GetMethodID(activity, "getSystemService",
"(Ljava/lang/String;)Ljava/lang/Object;");
jmethodID get_default_display = env->GetMethodID(window_manager,
"getDefaultDisplay",
"()Landroid/view/Display;");
jmethodID get_rotation = env->GetMethodID(display, "getRotation", "()I");
jfieldID window_service = env->GetStaticFieldID(context, "WINDOW_SERVICE",
"Ljava/lang/String;");
jobject window_service_obj = env->GetStaticObjectField(context, window_service);
jobject window_manager_obj = env->CallObjectMethod(activity_obj, get_system_service,
window_service_obj);
jobject display_obj = env->CallObjectMethod(window_manager_obj, get_default_display);
int rotation = env->CallIntMethod(display_obj, get_rotation);
env->DeleteLocalRef(activity);
env->DeleteLocalRef(context);
env->DeleteLocalRef(window_manager);
env->DeleteLocalRef(display);
Android->activity->vm->DetachCurrentThread();
return rotation;
}
DeviceOrientation CIrrDeviceAndroid::getDefaultOrientation()
{
int rotation = getRotation();
int32_t orientation = AConfiguration_getOrientation(Android->config);
if (((rotation == 0 || rotation == 2) &&
orientation == ACONFIGURATION_ORIENTATION_LAND) ||
((rotation == 1 || rotation == 3) &&
orientation == ACONFIGURATION_ORIENTATION_PORT))
{
return ORIENTATION_LANDSCAPE;
}
else
{
return ORIENTATION_PORTRAIT;
}
}
bool CIrrDeviceAndroid::activateAccelerometer(float updateInterval)
{
if (!isAccelerometerAvailable())
return false;
if (DefaultOrientation == ORIENTATION_UNKNOWN)
{
DefaultOrientation = getDefaultOrientation();
}
ASensorEventQueue_enableSensor(SensorEventQueue, Accelerometer);
ASensorEventQueue_setEventRate(SensorEventQueue, Accelerometer,
(int32_t)(updateInterval*1000.f*1000.f)); // in microseconds

9
lib/irrlicht/source/Irrlicht/CIrrDeviceAndroid.h
View File

@ -23,6 +23,12 @@
namespace irr
{
enum DeviceOrientation
{
ORIENTATION_UNKNOWN,
ORIENTATION_PORTRAIT,
ORIENTATION_LANDSCAPE
};
class CIrrDeviceAndroid : public CIrrDeviceStub, video::IImagePresenter
{
@ -123,6 +129,7 @@ namespace irr
bool IsMousePressed;
float GamepadAxisX;
float GamepadAxisY;
DeviceOrientation DefaultOrientation;
video::SExposedVideoData ExposedVideoData;
@ -133,6 +140,8 @@ namespace irr
void createKeyMap();
void createVideoModeList();
void getKeyChar(SEvent& event);
int getRotation();
DeviceOrientation getDefaultOrientation();
video::SExposedVideoData& getExposedVideoData();
static void handleAndroidCommand(android_app* app, int32_t cmd);

6
src/config/user_config.hpp
View File

@ -468,10 +468,10 @@ namespace UserConfigParams
&m_multitouch_group,
"Draw steering wheel on right side.") );
PARAM_PREFIX IntUserConfigParam m_multitouch_accelerometer
PARAM_DEFAULT( IntUserConfigParam(0, "multitouch_accelerometer",
PARAM_PREFIX IntUserConfigParam m_multitouch_controls
PARAM_DEFAULT( IntUserConfigParam(0, "multitouch_controls",
&m_multitouch_group,
"Accelerometer mode: 0 = off, 1 = tablet, 2 = phone"));
"Multitouch mode: 0 = undefined, 1 = steering wheel, 2 = accelerometer"));
PARAM_PREFIX FloatUserConfigParam m_multitouch_deadzone_center
PARAM_DEFAULT( FloatUserConfigParam(0.1f, "multitouch_deadzone_center",

5
src/graphics/graphics_restrictions.cpp
View File

@ -200,6 +200,11 @@ public:
convertVersionString(s[2]);
return;
}
else if (s.size() == 5)
{
convertVersionString(s[4]);
return;
}
}

7
src/graphics/sp/sp_shader_manager.cpp
View File

@ -60,6 +60,13 @@ SPShaderManager::SPShaderManager()
ua->setValue(sp_wind_dir);
}
},
{ "isDuringDayUniformAssigner", [](SPUniformAssigner* ua)
{
int is_during_day = Track::getCurrentTrack() ?
Track::getCurrentTrack()->getIsDuringDay() ? 1 : 0 : 0;
ua->setValue(is_during_day);
}
},
{ "zeroAlphaUniformAssigner", [](SPUniformAssigner* ua)
{
ua->setValue(0.0f);

18
src/guiengine/widgets/CGUIEditBox.cpp
View File

@ -23,6 +23,10 @@
#include "../../../lib/irrlicht/include/IrrCompileConfig.h"
#include "../../../lib/irrlicht/source/Irrlicht/CIrrDeviceLinux.h"
#ifdef ANDROID
#include "../../../lib/irrlicht/source/Irrlicht/CIrrDeviceAndroid.h"
#endif
/*
todo:
optional scrollbars
@ -1255,12 +1259,24 @@ bool CGUIEditBox::processMouse(const SEvent& event)
}
else if (!m_rtl)
{
bool use_screen_keyboard = UserConfigParams::m_screen_keyboard;
#ifdef ANDROID
int32_t keyboard = AConfiguration_getKeyboard(
global_android_app->config);
if (keyboard == ACONFIGURATION_KEYBOARD_QWERTY)
{
use_screen_keyboard = false;
}
#endif
if (!AbsoluteClippingRect.isPointInside(
core::position2d<s32>(event.MouseInput.X, event.MouseInput.Y)))
{
return false;
}
else if (UserConfigParams::m_screen_keyboard)
else if (use_screen_keyboard)
{
CursorPos = Text.size();
setTextMarkers(CursorPos, CursorPos);

5
src/input/device_config.cpp
View File

@ -20,6 +20,7 @@
#include "input/device_config.hpp"
#include "input/gamepad_config.hpp"
#include "input/gamepad_android_config.hpp"
#include "input/keyboard_config.hpp"
#include "io/xml_node.hpp"
#include "utils/log.hpp"
@ -47,6 +48,10 @@ DeviceConfig* DeviceConfig::create(const XMLNode *config)
{
device_config = new GamepadConfig();
}
else if(config->getName()=="gamepad_android")
{
device_config = new GamepadAndroidConfig();
}
else
{
Log::error("DeviceConfig", "Incorrect type: '%s'.",

1
src/input/device_config.hpp
View File

@ -95,6 +95,7 @@ public:
irr::core::stringw getMappingIdString (const PlayerAction action) const;
virtual irr::core::stringw getBindingAsString(const PlayerAction action) const;
virtual bool isGamePad() const = 0;
virtual bool isGamePadAndroid() const = 0;
virtual bool isKeyboard() const = 0;
virtual void save(std::ofstream& stream);

23
src/input/device_manager.cpp
View File

@ -23,6 +23,7 @@
#include "config/user_config.hpp"
#include "graphics/irr_driver.hpp"
#include "input/gamepad_android_config.hpp"
#include "input/gamepad_device.hpp"
#include "input/keyboard_device.hpp"
#include "input/multitouch_device.hpp"
@ -80,9 +81,28 @@ bool DeviceManager::initialize()
if(UserConfigParams::logMisc())
Log::info("Device manager","No keyboard configuration exists, creating one.");
m_keyboard_configs.push_back(new KeyboardConfig());
created = true;
}
#ifdef ANDROID
bool has_gamepad_android_config = false;
for (unsigned int i = 0; i < m_keyboard_configs.size(); i++)
{
if (m_keyboard_configs[i].isGamePadAndroid())
{
has_gamepad_android_config = true;
}
}
if (!has_gamepad_android_config)
{
m_keyboard_configs.push_back(new GamepadAndroidConfig());
created = true;
}
#endif
const int keyboard_amount = m_keyboard_configs.size();
for (int n = 0; n < keyboard_amount; n++)
{
@ -568,7 +588,8 @@ bool DeviceManager::load()
config->getName().c_str());
continue;
}
if(config->getName()=="keyboard")
if (config->getName() == "keyboard" ||
config->getName() == "gamepad_android")
{
KeyboardConfig *kc = static_cast<KeyboardConfig*>(device_config);
m_keyboard_configs.push_back(kc);

145
src/input/gamepad_android_config.cpp Normal file
View File

@ -0,0 +1,145 @@
//
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2010-2015 SuperTuxKart-Team
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 3
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "input/gamepad_android_config.hpp"
#include "utils/translation.hpp"
#include <SKeyMap.h>
using namespace irr;
GamepadAndroidConfig::GamepadAndroidConfig()
{
setDefaultBinds();
}
// ----------------------------------------------------------------------------
/** Saves the configuration to a file. It writes the name for a gamepad
* config, saves the device specific parameters, and calls
* DeviceConfig::save() to save the rest.
* \param stream The stream to save to.
*/
void GamepadAndroidConfig::save(std::ofstream& stream)
{
stream << "<gamepad_android ";
DeviceConfig::save(stream);
stream << "</gamepad_android>\n\n";
} // save
// ----------------------------------------------------------------------------
irr::core::stringw GamepadAndroidConfig::getBindingAsString(const PlayerAction action) const
{
const Binding &b = getBinding(action);
int id = b.getId();
irr::core::stringw button_name;
switch (id)
{
case IRR_KEY_BUTTON_LEFT:
button_name = _C("input_key", "Left");
break;
case IRR_KEY_BUTTON_RIGHT:
button_name = _C("input_key", "Right");
break;
case IRR_KEY_BUTTON_UP:
button_name = _C("input_key", "Up");
break;
case IRR_KEY_BUTTON_DOWN:
button_name = _C("input_key", "Down");
break;
case IRR_KEY_BUTTON_A:
button_name = "A";
break;
case IRR_KEY_BUTTON_B:
button_name = "B";
break;
case IRR_KEY_BUTTON_C:
button_name = "C";
break;
case IRR_KEY_BUTTON_X:
button_name = "X";
break;
case IRR_KEY_BUTTON_Y:
button_name = "Y";
break;
case IRR_KEY_BUTTON_Z:
button_name = "Z";
break;
case IRR_KEY_BUTTON_L1:
button_name = "L1";
break;
case IRR_KEY_BUTTON_R1:
button_name = "R1";
break;
case IRR_KEY_BUTTON_L2:
button_name = "L2";
break;
case IRR_KEY_BUTTON_R2:
button_name = "R2";
break;
case IRR_KEY_BUTTON_THUMBL:
button_name = _C("input_key", "Thumb Left");
break;
case IRR_KEY_BUTTON_THUMBR:
button_name = _C("input_key", "Thumb Right");
break;
case IRR_KEY_BUTTON_START:
button_name = _C("input_key", "Start");
break;
case IRR_KEY_BUTTON_SELECT:
button_name = _C("input_key", "Select");
break;
case IRR_KEY_BUTTON_MODE:
button_name = _C("input_key", "Mode");
break;
default:
button_name = DeviceConfig::getBindingAsString(action);
break;
}
return button_name;
}
// ----------------------------------------------------------------------------
void GamepadAndroidConfig::setDefaultBinds()
{
setBinding(PA_NITRO, Input::IT_KEYBOARD, IRR_KEY_BUTTON_X);
setBinding(PA_ACCEL, Input::IT_KEYBOARD, IRR_KEY_BUTTON_UP);
setBinding(PA_BRAKE, Input::IT_KEYBOARD, IRR_KEY_BUTTON_DOWN);
setBinding(PA_STEER_LEFT, Input::IT_KEYBOARD, IRR_KEY_BUTTON_LEFT);
setBinding(PA_STEER_RIGHT, Input::IT_KEYBOARD, IRR_KEY_BUTTON_RIGHT);
setBinding(PA_DRIFT, Input::IT_KEYBOARD, IRR_KEY_BUTTON_Y);
setBinding(PA_RESCUE, Input::IT_KEYBOARD, IRR_KEY_BUTTON_L1);
setBinding(PA_FIRE, Input::IT_KEYBOARD, IRR_KEY_BUTTON_A);
setBinding(PA_LOOK_BACK, Input::IT_KEYBOARD, IRR_KEY_BUTTON_R1);
setBinding(PA_PAUSE_RACE, Input::IT_KEYBOARD, IRR_KEY_BUTTON_B);
setBinding(PA_MENU_UP, Input::IT_KEYBOARD, IRR_KEY_BUTTON_UP);
setBinding(PA_MENU_DOWN, Input::IT_KEYBOARD, IRR_KEY_BUTTON_DOWN);
setBinding(PA_MENU_LEFT, Input::IT_KEYBOARD, IRR_KEY_BUTTON_LEFT);
setBinding(PA_MENU_RIGHT, Input::IT_KEYBOARD, IRR_KEY_BUTTON_RIGHT);
setBinding(PA_MENU_SELECT, Input::IT_KEYBOARD, IRR_KEY_BUTTON_A);
setBinding(PA_MENU_CANCEL, Input::IT_KEYBOARD, IRR_KEY_BUTTON_B);
}
//------------------------------------------------------------------------------

55
src/input/gamepad_android_config.hpp Normal file
View File

@ -0,0 +1,55 @@
//
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2010-2015 SuperTuxKart-Team
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 3
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#ifndef HEADER_GAMEPAD_ANDROID_CONFIG_HPP
#define HEADER_GAMEPAD_ANDROID_CONFIG_HPP
#include "input/binding.hpp"
#include "input/keyboard_config.hpp"
#include "input/input.hpp"
#include "utils/no_copy.hpp"
#include "utils/cpp2011.hpp"
#include <iosfwd>
/**
* \brief specialisation of DeviceConfig for android gamepad devices
* \ingroup config
*/
class GamepadAndroidConfig : public KeyboardConfig
{
public:
GamepadAndroidConfig();
virtual ~GamepadAndroidConfig() {}
virtual void setDefaultBinds();
virtual void save(std::ofstream& stream);
virtual irr::core::stringw getBindingAsString(const PlayerAction action) const;
// ------------------------------------------------------------------------
virtual bool isGamePad() const { return false; }
// ------------------------------------------------------------------------
virtual bool isGamePadAndroid() const { return true; }
// ------------------------------------------------------------------------
virtual bool isKeyboard() const { return true; }
}; // class GamepadAndroidConfig
#endif

2
src/input/gamepad_config.hpp
View File

@ -105,6 +105,8 @@ public:
// ------------------------------------------------------------------------
virtual bool isGamePad() const OVERRIDE { return true; }
// ------------------------------------------------------------------------
virtual bool isGamePadAndroid() const OVERRIDE { return false; }
// ------------------------------------------------------------------------
virtual bool isKeyboard() const OVERRIDE { return false; }
}; // class GamepadConfig

20
src/input/input_manager.cpp
View File

@ -109,7 +109,8 @@ void InputManager::handleStaticAction(int key, int value)
// When no players... a cutscene
if (race_manager->getNumPlayers() == 0 && world != NULL && value > 0 &&
(key == IRR_KEY_SPACE || key == IRR_KEY_RETURN))
(key == IRR_KEY_SPACE || key == IRR_KEY_RETURN ||
key == IRR_KEY_BUTTON_A))
{
world->onFirePressed(NULL);
}
@ -664,6 +665,11 @@ void InputManager::dispatchInput(Input::InputType type, int deviceID,
else if (button == IRR_KEY_RIGHT) action = PA_MENU_RIGHT;
else if (button == IRR_KEY_SPACE) action = PA_MENU_SELECT;
else if (button == IRR_KEY_RETURN) action = PA_MENU_SELECT;
else if (button == IRR_KEY_BUTTON_UP) action = PA_MENU_DOWN;
else if (button == IRR_KEY_BUTTON_DOWN) action = PA_MENU_UP;
else if (button == IRR_KEY_BUTTON_LEFT) action = PA_MENU_LEFT;
else if (button == IRR_KEY_BUTTON_RIGHT) action = PA_MENU_RIGHT;
else if (button == IRR_KEY_BUTTON_A) action = PA_MENU_SELECT;
else if (button == IRR_KEY_TAB)
{
if (shift_mask)
@ -676,7 +682,7 @@ void InputManager::dispatchInput(Input::InputType type, int deviceID,
}
}
if (button == IRR_KEY_RETURN)
if (button == IRR_KEY_RETURN || button == IRR_KEY_BUTTON_A)
{
if (GUIEngine::ModalDialog::isADialogActive() &&
!GUIEngine::ScreenKeyboard::isActive())
@ -1196,20 +1202,12 @@ EventPropagation InputManager::input(const SEvent& event)
float factor = UserConfigParams::m_multitouch_tilt_factor;
factor = std::max(factor, 0.1f);
if (UserConfigParams::m_multitouch_accelerometer == 1)
{
button->axis_x = (float)-event.AccelerometerEvent.X / factor;
device->handleControls(button);
}
else if (UserConfigParams::m_multitouch_accelerometer == 2)
{
button->axis_x = (float)event.AccelerometerEvent.Y / factor;
device->handleControls(button);
}
}
}
}
// block events in all modes but initial menus (except in text boxes to
// allow typing, and except in modal dialogs in-game)

4
src/input/keyboard_config.hpp
View File

@ -39,12 +39,14 @@ public:
KeyboardConfig();
virtual ~KeyboardConfig() {}
void setDefaultBinds ();
virtual void setDefaultBinds();
virtual void save(std::ofstream& stream);
// ------------------------------------------------------------------------
virtual bool isGamePad() const { return false; }
// ------------------------------------------------------------------------
virtual bool isGamePadAndroid() const { return false; }
// ------------------------------------------------------------------------
virtual bool isKeyboard() const { return true; }
}; // class KeyboardConfig

2
src/input/multitouch_device.cpp
View File

@ -140,7 +140,7 @@ void MultitouchDevice::addButton(MultitouchButtonType type, int x, int y,
#ifdef ANDROID
if (button->type == MultitouchButtonType::BUTTON_STEERING)
{
if (UserConfigParams::m_multitouch_accelerometer > 0 &&
if (UserConfigParams::m_multitouch_controls == 2 &&
!m_android_device->isAccelerometerActive())
{
m_android_device->activateAccelerometer(1.0f / 30);

18
src/main.cpp
View File

@ -228,6 +228,7 @@
#include "states_screens/register_screen.hpp"
#include "states_screens/state_manager.hpp"
#include "states_screens/user_screen.hpp"
#include "states_screens/dialogs/init_android_dialog.hpp"
#include "states_screens/dialogs/message_dialog.hpp"
#include "tracks/arena_graph.hpp"
#include "tracks/track.hpp"
@ -1686,6 +1687,21 @@ int main(int argc, char *argv[] )
Log::warn("main", "Screen size is too small!");
}
#ifdef ANDROID
if (UserConfigParams::m_multitouch_controls == 0)
{
int32_t touch = AConfiguration_getTouchscreen(
global_android_app->config);
if (touch != ACONFIGURATION_TOUCHSCREEN_NOTOUCH)
{
InitAndroidDialog* init_android = new InitAndroidDialog(
0.6f, 0.6f);
GUIEngine::DialogQueue::get()->pushDialog(init_android);
}
}
#endif
if (GraphicsRestrictions::isDisabled(
GraphicsRestrictions::GR_DRIVER_RECENT_ENOUGH))
{
@ -1701,6 +1717,7 @@ int main(int argc, char *argv[] )
}
else if (!CVS->isGLSL())
{
#if !defined(ANDROID)
if (UserConfigParams::m_old_driver_popup)
{
#ifdef USE_GLES2
@ -1717,6 +1734,7 @@ int main(int argc, char *argv[] )
/*from queue*/ true);
GUIEngine::DialogQueue::get()->pushDialog(dialog);
}
#endif
Log::warn("OpenGL", "OpenGL version is too old!");
}
}

3
src/modes/linear_world.cpp
View File

@ -283,9 +283,12 @@ void LinearWorld::newLap(unsigned int kart_index)
}
// Last lap message (kart_index's assert in previous block already)
if (raceHasLaps() && kart_info.m_race_lap+1 == lap_count)
{
if (lap_count > 1)
{
m_race_gui->addMessage(_("Final lap!"), kart,
3.0f, GUIEngine::getSkin()->getColor("font::normal"), true);
}
if(!m_last_lap_sfx_played && lap_count > 1)
{
if (UserConfigParams::m_music)

158
src/states_screens/dialogs/init_android_dialog.cpp Normal file
View File

@ -0,0 +1,158 @@
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2014-2015 SuperTuxKart-Team
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 3
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "states_screens/dialogs/init_android_dialog.hpp"
#include "config/user_config.hpp"
#include "graphics/irr_driver.hpp"
#include "guiengine/widgets/check_box_widget.hpp"
#include "guiengine/widgets/spinner_widget.hpp"
#include "guiengine/widgets/ribbon_widget.hpp"
#include "input/device_manager.hpp"
#include "input/input_manager.hpp"
#include "input/multitouch_device.hpp"
#include "utils/translation.hpp"
#ifdef ANDROID
#include "../../../lib/irrlicht/source/Irrlicht/CIrrDeviceAndroid.h"
#endif
#include <IGUIEnvironment.h>
using namespace GUIEngine;
using namespace irr;
using namespace irr::core;
using namespace irr::gui;
// -----------------------------------------------------------------------------
InitAndroidDialog::InitAndroidDialog(const float w, const float h)
: ModalDialog(w, h)
{
}
// -----------------------------------------------------------------------------
InitAndroidDialog::~InitAndroidDialog()
{
}
// -----------------------------------------------------------------------------
void InitAndroidDialog::load()
{
loadFromFile("init_android.stkgui");
}
// -----------------------------------------------------------------------------
void InitAndroidDialog::beforeAddingWidgets()
{
bool accelerometer_available = false;
#ifdef ANDROID
CIrrDeviceAndroid* android_device = dynamic_cast<CIrrDeviceAndroid*>(
irr_driver->getDevice());
assert(android_device != NULL);
accelerometer_available = android_device->isAccelerometerAvailable();
#endif
if (!accelerometer_available)
{
RibbonWidget* control_type = getWidget<RibbonWidget>("control_type");
assert(control_type != NULL);
int index = control_type->findItemNamed("accelerometer");
Widget* accelerometer = &control_type->getChildren()[index];
accelerometer->setActive(false);
if (UserConfigParams::m_multitouch_controls = 2)
{
UserConfigParams::m_multitouch_controls = 1;
}
}
updateValues();
}
// -----------------------------------------------------------------------------
GUIEngine::EventPropagation InitAndroidDialog::processEvent(
const std::string& eventSource)
{
if (eventSource == "close")
{
RibbonWidget* control_type = getWidget<RibbonWidget>("control_type");
assert(control_type != NULL);
const std::string& selected = control_type->getSelectionIDString(
PLAYER_ID_GAME_MASTER);
int index = control_type->getSelection(PLAYER_ID_GAME_MASTER);
Widget* selected_widget = &control_type->getChildren()[index];
if (!selected_widget->isActivated())
return GUIEngine::EVENT_BLOCK;
if (selected == "steering_wheel")
{
UserConfigParams::m_multitouch_controls = 1;
}
else if (selected == "accelerometer")
{
UserConfigParams::m_multitouch_controls = 2;
}
user_config->saveConfig();
ModalDialog::dismiss();
return GUIEngine::EVENT_BLOCK;
}
return GUIEngine::EVENT_LET;
} // processEvent
// -----------------------------------------------------------------------------
void InitAndroidDialog::updateValues()
{
RibbonWidget* control_type = getWidget<RibbonWidget>("control_type");
assert(control_type != NULL);
if (UserConfigParams::m_multitouch_controls == 2)
{
int id = control_type->findItemNamed("accelerometer");
control_type->setSelection(id, PLAYER_ID_GAME_MASTER);
}
else
{
int id = control_type->findItemNamed("steering_wheel");
control_type->setSelection(id, PLAYER_ID_GAME_MASTER);
}
}
// -----------------------------------------------------------------------------
bool InitAndroidDialog::onEscapePressed()
{
UserConfigParams::m_multitouch_controls = 1;
user_config->saveConfig();
ModalDialog::dismiss();
return true;
} // onEscapePressed
// -----------------------------------------------------------------------------

48
src/states_screens/dialogs/init_android_dialog.hpp Normal file
View File

@ -0,0 +1,48 @@
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2014-2015 SuperTuxKart-Team
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 3
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#ifndef HEADER_INIT_ANDROID_DIALOG_HPP
#define HEADER_INIT_ANDROID_DIALOG_HPP
#include "guiengine/modaldialog.hpp"
/**
* \brief Dialog that allows the player to adjust multitouch steering settings
* \ingroup states_screens
*/
class InitAndroidDialog : public GUIEngine::ModalDialog
{
private:
void updateValues();
public:
/**
* Creates a modal dialog with given percentage of screen width and height
*/
InitAndroidDialog(const float percentWidth, const float percentHeight);
~InitAndroidDialog();
virtual void beforeAddingWidgets();
virtual void load();
virtual bool onEscapePressed();
GUIEngine::EventPropagation processEvent(const std::string& eventSource);
};
#endif

39
src/states_screens/dialogs/multitouch_settings_dialog.cpp
View File

@ -18,6 +18,7 @@
#include "states_screens/dialogs/multitouch_settings_dialog.hpp"
#include "config/user_config.hpp"
#include "graphics/irr_driver.hpp"
#include "guiengine/widgets/check_box_widget.hpp"
#include "guiengine/widgets/spinner_widget.hpp"
#include "input/device_manager.hpp"
@ -25,6 +26,10 @@
#include "input/multitouch_device.hpp"
#include "utils/translation.hpp"
#ifdef ANDROID
#include "../../../lib/irrlicht/source/Irrlicht/CIrrDeviceAndroid.h"
#endif
#include <IGUIEnvironment.h>
@ -51,16 +56,21 @@ MultitouchSettingsDialog::~MultitouchSettingsDialog()
void MultitouchSettingsDialog::beforeAddingWidgets()
{
SpinnerWidget* accelerometer = getWidget<SpinnerWidget>("accelerometer");
assert(accelerometer != NULL);
bool accelerometer_available = false;
accelerometer->m_properties[PROP_WRAP_AROUND] = "true";
accelerometer->clearLabels();
accelerometer->addLabel(_("Disabled"));
accelerometer->addLabel(_("Tablet"));
accelerometer->addLabel(_("Phone"));
accelerometer->m_properties[GUIEngine::PROP_MIN_VALUE] = "0";
accelerometer->m_properties[GUIEngine::PROP_MAX_VALUE] = "2";
#ifdef ANDROID
CIrrDeviceAndroid* android_device = dynamic_cast<CIrrDeviceAndroid*>(
irr_driver->getDevice());
assert(android_device != NULL);
accelerometer_available = android_device->isAccelerometerAvailable();
#endif
if (!accelerometer_available)
{
CheckBoxWidget* accelerometer = getWidget<CheckBoxWidget>("accelerometer");
assert(accelerometer != NULL);
accelerometer->setActive(false);
}
updateValues();
}
@ -94,10 +104,11 @@ GUIEngine::EventPropagation MultitouchSettingsDialog::processEvent(
assert(buttons_inv != NULL);
UserConfigParams::m_multitouch_inverted = buttons_inv->getState();
SpinnerWidget* accelerometer = getWidget<SpinnerWidget>("accelerometer");
CheckBoxWidget* accelerometer = getWidget<CheckBoxWidget>("accelerometer");
assert(accelerometer != NULL);
UserConfigParams::m_multitouch_accelerometer = accelerometer->getValue();
UserConfigParams::m_multitouch_controls = accelerometer->
getState() ? 2 : 1;
MultitouchDevice* touch_device = input_manager->getDeviceManager()->
getMultitouchDevice();
@ -118,7 +129,7 @@ GUIEngine::EventPropagation MultitouchSettingsDialog::processEvent(
UserConfigParams::m_multitouch_deadzone_edge.revertToDefaults();
UserConfigParams::m_multitouch_deadzone_center.revertToDefaults();
UserConfigParams::m_multitouch_mode.revertToDefaults();
UserConfigParams::m_multitouch_accelerometer.revertToDefaults();
UserConfigParams::m_multitouch_controls.revertToDefaults();
updateValues();
@ -154,9 +165,9 @@ void MultitouchSettingsDialog::updateValues()
assert(buttons_inv != NULL);
buttons_inv->setState(UserConfigParams::m_multitouch_inverted);
SpinnerWidget* accelerometer = getWidget<SpinnerWidget>("accelerometer");
CheckBoxWidget* accelerometer = getWidget<CheckBoxWidget>("accelerometer");
assert(accelerometer != NULL);
accelerometer->setValue(UserConfigParams::m_multitouch_accelerometer);
accelerometer->setState(UserConfigParams::m_multitouch_controls == 2);
}
// -----------------------------------------------------------------------------

11
src/states_screens/options_screen_device.cpp
View File

@ -106,6 +106,11 @@ void OptionsScreenDevice::init()
delete_button->setLabel(label);
}
else if (m_config->isGamePadAndroid())
{
delete_button->setLabel(_("Delete Configuration"));
delete_button->setActive(false);
}
else
{
delete_button->setLabel(_("Delete Configuration"));
@ -160,7 +165,11 @@ void OptionsScreenDevice::init()
// Disable deletion keyboard configurations
bool in_game = StateManager::get()->getGameState() == GUIEngine::INGAME_MENU;
getWidget<ButtonWidget>("delete")->setActive(!in_game);
if (in_game)
{
getWidget<ButtonWidget>("delete")->setActive(false);
}
} // init
// -----------------------------------------------------------------------------

15
src/states_screens/options_screen_input.cpp
View File

@ -89,15 +89,26 @@ void OptionsScreenInput::buildDeviceList()
for (int i=0; i<keyboard_config_count; i++)
{
//KeyboardConfig *config = input_manager->getDeviceList()->getKeyboardConfig(i);
KeyboardConfig *config = device_manager->getKeyboardConfig(i);
std::ostringstream kbname;
kbname << "keyboard" << i;
const std::string internal_name = kbname.str();
if (config->isGamePadAndroid())
{
// since irrLicht's list widget has the nasty tendency to put the
// icons very close to the text, I'm adding spaces to compensate.
devices->addItem(internal_name, (core::stringw(" ") + _("Keyboard %i", i)).c_str(), 0 /* icon */);
devices->addItem(internal_name, (core::stringw(" ") +
_("Gamepad")).c_str(), 1 /* icon */);
}
else
{
// since irrLicht's list widget has the nasty tendency to put the
// icons very close to the text, I'm adding spaces to compensate.
devices->addItem(internal_name, (core::stringw(" ") +
_("Keyboard %i", i)).c_str(), 0 /* icon */);
}
}
const int gpad_config_count = device_manager->getGamePadConfigAmount();

22
src/utils/translation.cpp
View File

@ -45,6 +45,10 @@
#include "utils/constants.hpp"
#include "utils/log.hpp"
#ifdef ANDROID
#include "main_android.hpp"
#endif
// set to 1 to debug i18n
#define TRANSLATE_VERBOSE 0
@ -301,6 +305,24 @@ Translations::Translations() //: m_dictionary_manager("UTF-16")
"GetLocaleInfo tryname returns '%s'.", c);
if(c[0]) language += std::string("_")+c;
} // if c[0]
#elif defined(ANDROID)
char p_language[3] = {};
AConfiguration_getLanguage(global_android_app->config, p_language);
if (p_language != NULL)
{
language += p_language;
char p_country[3] = {};
AConfiguration_getCountry(global_android_app->config, p_country);
if (p_country)
{
language += "_";
language += p_country;
}
}
#endif
} // neither LANGUAGE nor LANG defined