mirror/Aquaria
1
0
Fork 0
mirror of https://github.com/AquariaOSE/Aquaria.git synced 2024-11-25 17:53:47 +00:00
Code Issues Releases Wiki Activity
Aquaria/BBGE/Core.h

1409 lines
30 KiB
C++
Raw Blame History

/*
Copyright (C) 2007, 2010 - Bit-Blot
This file is part of Aquaria.
Aquaria 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 2
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 __core__
#define __core__
/*
valid BUILD_ flags
WIN32/BUILD_WIN32
BUILD_MACOSX
BUILD_X360
BUILD_LINUX
*/
#include "Base.h"
#include "RenderObject.h"
#include "SoundManager.h"
#include "ActionMapper.h"
#include "Event.h"
#include "StateManager.h"
#include "Light.h"
#include "Flags.h"
//#include "Scripting.h"
#include "Effects.h"
#include "Localization.h"
#include "DarkLayer.h"
/*
#ifdef BBGE_BUILD_WINDOWS
#include "Joystick.h"
#endif
*/
#include "FrameBuffer.h"
#include "Shader.h"
class ParticleEffect;
class ParticleManager;
void initInputCodeMap();
void clearInputCodeMap();
std::string getInputCodeToString(int key);
std::string getInputCodeToUserString(int key);
int getStringToInputCode(const std::string &string);
enum TimeUpdateType
{
TIMEUPDATE_DYNAMIC = 0,
TIMEUPDATE_FIXED = 1
};
struct ScreenMode
{
ScreenMode() { idx = x = y = 0; }
ScreenMode(int i, int x, int y) : idx(i), x(x), y(y) {}
int idx, x, y;
};
struct CoreSettings
{
CoreSettings() { renderOn = true; updateOn = true; runInBackground = false; prebufferSounds = false; }
bool renderOn;
bool runInBackground;
bool updateOn; // NOT IMPLEMENTED YET
bool prebufferSounds;
};
enum CoreFlags
{
CF_CLEARBUFFERS = 0x00000001,
CF_SORTENABLED = 0x00000010
};
enum CoreLayers
{
LR_NONE = -1
};
const int NO_FOLLOW_CAMERA = -999;
class AfterEffectManager;
class Texture;
const int baseVirtualWidth = 800;
const int baseVirtualHeight = 600;
#if (defined(BBGE_BUILD_WINDOWS)) && !defined(BBGE_BUILD_SDL)
enum GameKeys
{
KEY_BACKSPACE = DIK_BACKSPACE,
KEY_CAPSLOCK = DIK_CAPSLOCK,
KEY_CIRCUMFLEX = DIK_CIRCUMFLEX,
KEY_DOWNARROW = DIK_DOWNARROW,
KEY_LALT = DIK_LALT,
KEY_LEFTARROW = DIK_LEFTARROW,
KEY_NUMPADMINUS = DIK_NUMPADMINUS,
KEY_NUMPADPERIOD = DIK_NUMPADPERIOD,
KEY_NUMPADPLUS = DIK_NUMPADPLUS,
KEY_NUMPADSLASH = DIK_NUMPADSLASH,
KEY_NUMPADSTAR = DIK_NUMPADSTAR,
KEY_PGDN = DIK_PGDN,
KEY_PGUP = DIK_PGUP,
KEY_RALT = DIK_RALT,
KEY_RIGHTARROW = DIK_RIGHTARROW,
KEY_UPARROW = DIK_UPARROW,
KEY_TILDE = DIK_GRAVE,
KEY_0 = DIK_0,
KEY_1 = DIK_1,
KEY_2 = DIK_2,
KEY_3 = DIK_3,
KEY_4 = DIK_4,
KEY_5 = DIK_5,
KEY_6 = DIK_6,
KEY_7 = DIK_7,
KEY_8 = DIK_8,
KEY_9 = DIK_9,
KEY_A = DIK_A,
KEY_ABNT_C1 = DIK_ABNT_C1,
KEY_ABNT_C2 = DIK_ABNT_C2,
KEY_ADD = DIK_ADD,
KEY_APOSTROPHE = DIK_APOSTROPHE,
KEY_APPS = DIK_APPS,
KEY_AT = DIK_AT,
KEY_AX = DIK_AX,
KEY_B = DIK_B,
KEY_BACK = DIK_BACK,
KEY_BACKSLASH = DIK_BACKSLASH,
KEY_C = DIK_C,
KEY_CALCULATOR = DIK_CALCULATOR,
KEY_CAPITAL = DIK_CAPITAL,
KEY_COLON = DIK_COLON,
KEY_COMMA = DIK_COMMA,
KEY_CONVERT = DIK_CONVERT,
KEY_D = DIK_D,
KEY_DECIMAL = DIK_DECIMAL,
KEY_DELETE = DIK_DELETE,
KEY_DIVIDE = DIK_DIVIDE,
KEY_DOWN = DIK_DOWN,
KEY_E = DIK_E,
KEY_END = DIK_END,
KEY_EQUALS = DIK_EQUALS,
KEY_ESCAPE = DIK_ESCAPE,
KEY_F = DIK_F,
KEY_F1 = DIK_F1,
KEY_F2 = DIK_F2,
KEY_F3 = DIK_F3,
KEY_F4 = DIK_F4,
KEY_F5 = DIK_F5,
KEY_F6 = DIK_F6,
KEY_F7 = DIK_F7,
KEY_F8 = DIK_F8,
KEY_F9 = DIK_F9,
KEY_F10 = DIK_F10,
KEY_F11 = DIK_F11,
KEY_F12 = DIK_F12,
KEY_F13 = DIK_F13,
KEY_F14 = DIK_F14,
KEY_F15 = DIK_F15,
KEY_G = DIK_G,
KEY_GRAVE = DIK_GRAVE,
KEY_H = DIK_H,
KEY_HOME = DIK_HOME,
KEY_I = DIK_I,
KEY_INSERT = DIK_INSERT,
KEY_J = DIK_J,
KEY_K = DIK_K,
KEY_KANA = DIK_KANA,
KEY_KANJI = DIK_KANJI,
KEY_L = DIK_L,
KEY_LBRACKET = DIK_LBRACKET,
KEY_LCONTROL = DIK_LCONTROL,
KEY_LEFT = DIK_LEFT,
KEY_LMENU = DIK_LMENU,
KEY_LSHIFT = DIK_LSHIFT,
KEY_LMETA = DIK_LWIN,
KEY_M = DIK_M,
KEY_MAIL = DIK_MAIL,
KEY_MEDIASELECT = DIK_MEDIASELECT,
KEY_MEDIASTOP = DIK_MEDIASTOP,
KEY_MINUS = DIK_MINUS,
KEY_MULTIPLY = DIK_MULTIPLY,
KEY_MUTE = DIK_MUTE,
KEY_MYCOMPUTER = DIK_MYCOMPUTER,
KEY_N = DIK_N,
KEY_NEXT = DIK_NEXT,
KEY_NEXTTRACK = DIK_NEXTTRACK,
KEY_NOCONVERT = DIK_NOCONVERT,
KEY_NUMLOCK = DIK_NUMLOCK,
KEY_NUMPAD0 = DIK_NUMPAD0,
KEY_NUMPAD1 = DIK_NUMPAD1,
KEY_NUMPAD2 = DIK_NUMPAD2,
KEY_NUMPAD3 = DIK_NUMPAD3,
KEY_NUMPAD4 = DIK_NUMPAD4,
KEY_NUMPAD5 = DIK_NUMPAD5,
KEY_NUMPAD6 = DIK_NUMPAD6,
KEY_NUMPAD7 = DIK_NUMPAD7,
KEY_NUMPAD8 = DIK_NUMPAD8,
KEY_NUMPAD9 = DIK_NUMPAD9,
KEY_NUMPADCOMMA = DIK_NUMPADCOMMA,
KEY_NUMPADENTER = DIK_NUMPADENTER,
KEY_NUMPADEQUALS = DIK_NUMPADEQUALS,
KEY_O = DIK_O,
KEY_OEM_102 = DIK_OEM_102,
KEY_P = DIK_P,
KEY_PAUSE = DIK_PAUSE,
KEY_PERIOD = DIK_PERIOD,
KEY_PLAYPAUSE = DIK_PLAYPAUSE,
KEY_POWER = DIK_POWER,
KEY_PREVTRACK = DIK_PREVTRACK,
KEY_PRIOR = DIK_PRIOR,
KEY_Q = DIK_Q,
KEY_R = DIK_R,
KEY_RBRACKET = DIK_RBRACKET,
KEY_RCONTROL = DIK_RCONTROL,
KEY_RETURN = DIK_RETURN,
KEY_RIGHT = DIK_RIGHT,
KEY_RMENU = DIK_RMENU,
KEY_RSHIFT = DIK_RSHIFT,
KEY_RMETA = DIK_RWIN,
KEY_S = DIK_S,
KEY_SCROLL = DIK_SCROLL,
KEY_SEMICOLON = DIK_SEMICOLON,
KEY_SLASH = DIK_SLASH,
KEY_SLEEP = DIK_SLEEP,
KEY_SPACE = DIK_SPACE,
KEY_STOP = DIK_STOP,
KEY_SUBTRACT = DIK_SUBTRACT,
KEY_SYSRQ = DIK_SYSRQ,
KEY_T = DIK_T,
KEY_TAB = DIK_TAB,
KEY_U = DIK_U,
KEY_UNDERLINE = DIK_UNDERLINE,
KEY_UNLABELED = DIK_UNLABELED,
KEY_UP = DIK_UP,
KEY_V = DIK_V,
KEY_VOLUMEDOWN = DIK_VOLUMEDOWN,
KEY_VOLUMEUP = DIK_VOLUMEUP,
KEY_W = DIK_W,
KEY_WAKE = DIK_WAKE,
KEY_WEBBACK = DIK_WEBBACK,
KEY_WEBFAVORITES = DIK_WEBFAVORITES,
KEY_WEBFORWARD = DIK_WEBFORWARD,
KEY_WEBHOME = DIK_WEBHOME,
KEY_WEBREFRESH = DIK_WEBREFRESH,
KEY_WEBSEARCH = DIK_WEBSEARCH,
KEY_WEBSTOP = DIK_WEBSTOP,
KEY_X = DIK_X,
KEY_Y = DIK_Y,
KEY_YEN = DIK_YEN,
KEY_Z = DIK_Z,
KEY_ANYKEY = 4059,
KEY_MAXARRAY = 256
};
#elif defined(BBGE_BUILD_SDL)
enum GameKeys
{
// replace with GLFW equivalent
/*
KEY_DOWNARROW = GLFW_KEY_DOWN,
KEY_RIGHTARROW = GLFW_KEY_RIGHT,
KEY_UPARROW = GLFW_KEY_UP,
KEY_LEFTARROW = GLFW_KEY_LEFT,
*/
KEY_LSUPER,
KEY_RSUPER,
KEY_LMETA,
KEY_RMETA,
KEY_BACKSPACE,
KEY_PRINTSCREEN,
//KEY_CAPSLOCK,
//KEY_CIRCUMFLEX,
KEY_LALT,
KEY_RALT,
KEY_LSHIFT,
KEY_RSHIFT,
KEY_LCONTROL,
KEY_RCONTROL,
KEY_NUMPADMINUS,
KEY_NUMPADPERIOD,
KEY_NUMPADPLUS,
KEY_NUMPADSLASH,
KEY_NUMPADSTAR,
KEY_PGDN,
KEY_PGUP,
KEY_APOSTROPHE,
KEY_EQUALS,
KEY_SEMICOLON,
KEY_LBRACKET,
KEY_RBRACKET,
//KEY_RALT,
KEY_TILDE,
KEY_0,
KEY_1,
KEY_2,
KEY_3,
KEY_4,
KEY_5,
KEY_6,
KEY_7,
KEY_8,
KEY_9,
KEY_A,
KEY_B,
KEY_C,
KEY_D,
KEY_E,
KEY_F,
KEY_G,
KEY_H,
KEY_I,
KEY_J,
KEY_K,
KEY_L,
KEY_M,
KEY_N,
KEY_O,
KEY_P,
KEY_Q,
KEY_R,
KEY_S,
KEY_T,
KEY_U,
KEY_V,
KEY_W,
KEY_X,
KEY_Y,
KEY_Z,
KEY_LEFT,
KEY_RIGHT,
KEY_UP,
KEY_DOWN,
KEY_NUMPAD1,
KEY_NUMPAD2,
KEY_NUMPAD3,
KEY_NUMPAD4,
KEY_NUMPAD5,
KEY_NUMPAD6,
KEY_NUMPAD7,
KEY_NUMPAD8,
KEY_NUMPAD9,
KEY_NUMPAD0,
KEY_DELETE,
KEY_SPACE,
KEY_RETURN,
KEY_PERIOD,
KEY_MINUS,
KEY_CAPSLOCK,
KEY_SYSRQ,
KEY_TAB,
KEY_HOME,
KEY_END,
KEY_COMMA,
KEY_SLASH,
KEY_F1,
KEY_F2,
KEY_F3,
KEY_F4,
KEY_F5,
KEY_F6,
KEY_F7,
KEY_F8,
KEY_F9,
KEY_F10,
KEY_F11,
KEY_F12,
KEY_F13,
KEY_F14,
KEY_F15,
KEY_ESCAPE,
KEY_ANYKEY,
KEY_MAXARRAY
};
#elif defined(BBGE_BUILD_XINPUT)
enum GameKeys
{
KEY_LSUPER = 0,
KEY_RSUPER = 0,
KEY_LMETA = 0,
KEY_RMETA = 0,
KEY_BACKSPACE = 0,
KEY_PRINTSCREEN = 0,
KEY_LALT = 0,
KEY_RALT = 0,
KEY_LSHIFT = 0,
KEY_RSHIFT = 0,
KEY_LCONTROL = 0,
KEY_RCONTROL = 0,
KEY_NUMPADMINUS = 0,
KEY_NUMPADPERIOD = 0,
KEY_NUMPADPLUS = 0,
KEY_NUMPADSLASH = 0,
KEY_NUMPADSTAR = 0,
KEY_PGDN = 0,
KEY_PGUP = 0,
KEY_TILDE = 0,
KEY_0 = 0,
KEY_1 = 0,
KEY_2 = 0,
KEY_3 = 0,
KEY_4 = 0,
KEY_5 = 0,
KEY_6 = 0,
KEY_7 = 0,
KEY_8 = 0,
KEY_9 = 0,
KEY_A = 0,
KEY_B = 0,
KEY_C = 0,
KEY_D = 0,
KEY_E = 0,
KEY_F = 0,
KEY_G = 0,
KEY_H = 0,
KEY_I = 0,
KEY_J = 0,
KEY_K = 0,
KEY_L = 0,
KEY_M = 0,
KEY_N = 0,
KEY_O = 0,
KEY_P = 0,
KEY_Q = 0,
KEY_R = 0,
KEY_S = 0,
KEY_T = 0,
KEY_U = 0,
KEY_V = 0,
KEY_W = 0,
KEY_X = 0,
KEY_Y = 0,
KEY_Z = 0,
KEY_LEFT = 0,
KEY_RIGHT = 0,
KEY_UP = 0,
KEY_DOWN = 0,
KEY_NUMPAD1 = 0,
KEY_NUMPAD2 = 0,
KEY_NUMPAD3 = 0,
KEY_NUMPAD4 = 0,
KEY_NUMPAD5 = 0,
KEY_NUMPAD6 = 0,
KEY_NUMPAD7 = 0,
KEY_NUMPAD8 = 0,
KEY_NUMPAD9 = 0,
KEY_NUMPAD0 = 0,
KEY_DELETE = 0,
KEY_SPACE = 0,
KEY_RETURN = 0,
KEY_PERIOD = 0,
KEY_MINUS = 0,
KEY_CAPSLOCK = 0,
KEY_SYSRQ = 0,
KEY_TAB = 0,
KEY_HOME = 0,
KEY_END = 0,
KEY_COMMA = 0,
KEY_SLASH = 0,
KEY_F1 = 0,
KEY_F2 = 0,
KEY_F3 = 0,
KEY_F4 = 0,
KEY_F5 = 0,
KEY_F6 = 0,
KEY_F7 = 0,
KEY_F8 = 0,
KEY_F9 = 0,
KEY_F10 = 0,
KEY_F11 = 0,
KEY_F12 = 0,
KEY_F13 = 0,
KEY_F14 = 0,
KEY_F15 = 0,
KEY_ESCAPE = 0,
KEY_ANYKEY = 4059,
KEY_MAXARRAY = 256
};
#elif defined(BBGE_BUILD_GLFW)
enum GameKeys
{
// replace with GLFW equivalent
/*
KEY_DOWNARROW = GLFW_KEY_DOWN,
KEY_RIGHTARROW = GLFW_KEY_RIGHT,
KEY_UPARROW = GLFW_KEY_UP,
KEY_LEFTARROW = GLFW_KEY_LEFT,
*/
KEY_BACKSPACE = GLFW_KEY_BACKSPACE,
//KEY_CAPSLOCK = DIK_CAPSLOCK,
//KEY_CIRCUMFLEX = DIK_CIRCUMFLEX,
KEY_LALT = GLFW_KEY_LALT,
KEY_RALT = GLFW_KEY_RALT,
KEY_LSHIFT = GLFW_KEY_LSHIFT,
KEY_RSHIFT = GLFW_KEY_RSHIFT,
KEY_LCONTROL = GLFW_KEY_LCTRL,
KEY_RCONTROL = GLFW_KEY_RCTRL,
KEY_NUMPADMINUS = GLFW_KEY_KP_SUBTRACT,
KEY_NUMPADPERIOD = GLFW_KEY_KP_DECIMAL,
KEY_NUMPADPLUS = GLFW_KEY_KP_ADD,
KEY_NUMPADSLASH = GLFW_KEY_KP_DIVIDE,
KEY_NUMPADSTAR = GLFW_KEY_KP_MULTIPLY,
KEY_PGDN = GLFW_KEY_PAGEDOWN,
KEY_PGUP = GLFW_KEY_PAGEUP,
//KEY_RALT = GLFW_KEY_RALT,
KEY_TILDE = '`',
KEY_0 = '0',
KEY_1 = '1',
KEY_2 = '2',
KEY_3 = '3',
KEY_4 = '4',
KEY_5 = '5',
KEY_6 = '6',
KEY_7 = '7',
KEY_8 = '8',
KEY_9 = '9',
KEY_A = 'A',
KEY_B = 'B',
KEY_C = 'C',
KEY_D = 'D',
KEY_E = 'E',
KEY_F = 'F',
KEY_G = 'G',
KEY_H = 'H',
KEY_I = 'I',
KEY_J = 'J',
KEY_K = 'K',
KEY_L = 'L',
KEY_M = 'M',
KEY_N = 'N',
KEY_O = 'O',
KEY_P = 'P',
KEY_Q = 'Q',
KEY_R = 'R',
KEY_S = 'S',
KEY_T = 'T',
KEY_U = 'U',
KEY_V = 'V',
KEY_W = 'W',
KEY_X = 'X',
KEY_Y = 'Y',
KEY_Z = 'Z',
KEY_LEFT = GLFW_KEY_LEFT,
KEY_RIGHT = GLFW_KEY_RIGHT,
KEY_UP = GLFW_KEY_UP,
KEY_DOWN = GLFW_KEY_DOWN,
KEY_NUMPAD1 = GLFW_KEY_KP_1,
KEY_NUMPAD2 = GLFW_KEY_KP_2,
KEY_NUMPAD3 = GLFW_KEY_KP_3,
KEY_NUMPAD4 = GLFW_KEY_KP_4,
KEY_NUMPAD5 = GLFW_KEY_KP_5,
KEY_NUMPAD6 = GLFW_KEY_KP_6,
KEY_NUMPAD7 = GLFW_KEY_KP_7,
KEY_NUMPAD8 = GLFW_KEY_KP_8,
KEY_NUMPAD9 = GLFW_KEY_KP_9,
KEY_NUMPAD0 = GLFW_KEY_KP_0,
KEY_DELETE = GLFW_KEY_DEL,
KEY_SPACE = GLFW_KEY_SPACE,
// mac os x
KEY_RETURN = 13,
KEY_PERIOD = '.',
KEY_MINUS = '-',
KEY_CAPSLOCK = -1,
KEY_SYSRQ = '`',
KEY_TAB = GLFW_KEY_TAB,
KEY_HOME = GLFW_KEY_HOME,
KEY_END = GLFW_KEY_END,
KEY_COMMA = ',',
KEY_SLASH = '/',
//KEY_ABNT_C1 = DIK_ABNT_C1,
//KEY_ABNT_C2 = DIK_ABNT_C2,
/*
KEY_ADD = DIK_ADD,
KEY_APOSTROPHE = DIK_APOSTROPHE,
KEY_APPS = DIK_APPS,
KEY_AT = DIK_AT,
KEY_AX = DIK_AX,
*/
/*
KEY_B = 'B',
KEY_BACK = DIK_BACK,
KEY_BACKSLASH = DIK_BACKSLASH,
KEY_C = DIK_C,
KEY_CALCULATOR = DIK_CALCULATOR,
KEY_CAPITAL = DIK_CAPITAL,
KEY_COLON = DIK_COLON,
KEY_COMMA = DIK_COMMA,
KEY_CONVERT = DIK_CONVERT,
KEY_D = DIK_D,
KEY_DECIMAL = DIK_DECIMAL,
KEY_DELETE = DIK_DELETE,
KEY_DIVIDE = DIK_DIVIDE,
KEY_DOWN = DIK_DOWN,
KEY_E = DIK_E,
KEY_END = DIK_END,
KEY_EQUALS = DIK_EQUALS,
KEY_ESCAPE = DIK_ESCAPE,
KEY_F = DIK_F,
*/
KEY_F1 = GLFW_KEY_F1,
KEY_F2 = GLFW_KEY_F2,
KEY_F3 = GLFW_KEY_F3,
KEY_F4 = GLFW_KEY_F4,
KEY_F5 = GLFW_KEY_F5,
KEY_F6 = GLFW_KEY_F6,
KEY_F7 = GLFW_KEY_F7,
KEY_F8 = GLFW_KEY_F8,
KEY_F9 = GLFW_KEY_F9,
KEY_F10 = GLFW_KEY_F10,
KEY_F11 = GLFW_KEY_F11,
KEY_F12 = GLFW_KEY_F12,
KEY_F13 = GLFW_KEY_F13,
KEY_F14 = GLFW_KEY_F14,
KEY_F15 = GLFW_KEY_F15,
/*
KEY_G = DIK_G,
KEY_GRAVE = DIK_GRAVE,
KEY_H = DIK_H,
KEY_HOME = DIK_HOME,
KEY_I = DIK_I,
KEY_INSERT = DIK_INSERT,
KEY_J = DIK_J,
KEY_K = DIK_K,
KEY_KANA = DIK_KANA,
KEY_KANJI = DIK_KANJI,
KEY_L = DIK_L,
KEY_LBRACKET = DIK_LBRACKET,
KEY_LCONTROL = DIK_LCONTROL,
KEY_LEFT = DIK_LEFT,
KEY_LMENU = DIK_LMENU,
KEY_LWIN = DIK_LWIN,
KEY_M = DIK_M,
KEY_MAIL = DIK_MAIL,
KEY_MEDIASELECT = DIK_MEDIASELECT,
KEY_MEDIASTOP = DIK_MEDIASTOP,
KEY_MINUS = DIK_MINUS,
KEY_MULTIPLY = DIK_MULTIPLY,
KEY_MUTE = DIK_MUTE,
KEY_MYCOMPUTER = DIK_MYCOMPUTER,
KEY_N = DIK_N,
KEY_NEXT = DIK_NEXT,
KEY_NEXTTRACK = DIK_NEXTTRACK,
KEY_NOCONVERT = DIK_NOCONVERT,
KEY_NUMLOCK = DIK_NUMLOCK,
KEY_NUMPAD0 = DIK_NUMPAD0,
KEY_NUMPAD1 = DIK_NUMPAD1,
KEY_NUMPAD2 = DIK_NUMPAD2,
KEY_NUMPAD3 = DIK_NUMPAD3,
KEY_NUMPAD4 = DIK_NUMPAD4,
KEY_NUMPAD5 = DIK_NUMPAD5,
KEY_NUMPAD6 = DIK_NUMPAD6,
KEY_NUMPAD7 = DIK_NUMPAD7,
KEY_NUMPAD8 = DIK_NUMPAD8,
KEY_NUMPAD9 = DIK_NUMPAD9,
KEY_NUMPADCOMMA = DIK_NUMPADCOMMA,
KEY_NUMPADENTER = DIK_NUMPADENTER,
KEY_NUMPADEQUALS = DIK_NUMPADEQUALS,
KEY_O = DIK_O,
KEY_OEM_102 = DIK_OEM_102,
KEY_P = DIK_P,
KEY_PAUSE = DIK_PAUSE,
KEY_PERIOD = DIK_PERIOD,
KEY_PLAYPAUSE = DIK_PLAYPAUSE,
KEY_POWER = DIK_POWER,
KEY_PREVTRACK = DIK_PREVTRACK,
KEY_PRIOR = DIK_PRIOR,
KEY_Q = DIK_Q,
KEY_R = DIK_R,
KEY_RBRACKET = DIK_RBRACKET,
KEY_RCONTROL = DIK_RCONTROL,
KEY_RETURN = DIK_RETURN,
KEY_RIGHT = DIK_RIGHT,
KEY_RMENU = DIK_RMENU,
KEY_RWIN = DIK_RWIN,
KEY_S = DIK_S,
KEY_SCROLL = DIK_SCROLL,
KEY_SEMICOLON = DIK_SEMICOLON,
KEY_SLASH = DIK_SLASH,
KEY_SLEEP = DIK_SLEEP,
KEY_SPACE = DIK_SPACE,
KEY_STOP = DIK_STOP,
KEY_SUBTRACT = DIK_SUBTRACT,
KEY_SYSRQ = DIK_SYSRQ,
KEY_T = DIK_T,
KEY_TAB = DIK_TAB,
KEY_U = DIK_U,
KEY_UNDERLINE = DIK_UNDERLINE,
KEY_UNLABELED = DIK_UNLABELED,
KEY_UP = DIK_UP,
KEY_V = DIK_V,
KEY_VOLUMEDOWN = DIK_VOLUMEDOWN,
KEY_VOLUMEUP = DIK_VOLUMEUP,
KEY_W = DIK_W,
KEY_WAKE = DIK_WAKE,
KEY_WEBBACK = DIK_WEBBACK,
KEY_WEBFAVORITES = DIK_WEBFAVORITES,
KEY_WEBFORWARD = DIK_WEBFORWARD,
KEY_WEBHOME = DIK_WEBHOME,
KEY_WEBREFRESH = DIK_WEBREFRESH,
KEY_WEBSEARCH = DIK_WEBSEARCH,
KEY_WEBSTOP = DIK_WEBSTOP,
KEY_X = DIK_X,
KEY_Y = DIK_Y,
KEY_YEN = DIK_YEN,
KEY_Z = DIK_Z,
*/
KEY_ESCAPE = GLFW_KEY_ESC,
KEY_ANYKEY = 4059
};
#endif
enum ButtonState { UP = 0, DOWN };
struct MouseButtons
{
MouseButtons ()
{
left = UP;
right = UP;
middle = UP;
}
ButtonState left, right, middle;
};
struct Mouse
{
Mouse()
{
scrollWheel = scrollWheelChange = lastScrollWheel = 0;
buttonsEnabled = true;
movementEnabled = true;
}
Vector position, lastPosition;
MouseButtons buttons;
MouseButtons pure_buttons;
Vector change;
// movementEnabled is not implemented yet
bool buttonsEnabled, movementEnabled;
int scrollWheel, scrollWheelChange, lastScrollWheel;
};
const int maxJoyBtns = 64;
class Joystick
{
public:
Joystick();
void init(int stick=0);
void shutdown();
//Ranges from 0 to 65535 (full speed).
void rumble(float leftMotor, float rightMotor, float time);
void update(float dt);
Vector position, lastPosition;
ButtonState buttons[maxJoyBtns];
float deadZone1, deadZone2;
float clearRumbleTime;
void callibrate(Vector &vec, float dead);
float leftTrigger, rightTrigger;
bool leftThumb, rightThumb, leftShoulder, rightShoulder, dpadLeft, dpadRight, dpadUp, dpadDown;
bool btnStart, btnSelect;
Vector rightStick;
bool inited, xinited;
bool anyButton();
#ifdef BBGE_BUILD_SDL
# ifdef BBGE_BUILD_SDL2
SDL_GameController *sdl_controller;
SDL_Haptic *sdl_haptic;
# endif
SDL_Joystick *sdl_joy;
#endif
#if defined(__LINUX__) && !defined(BBGE_BUILD_SDL2)
int eventfd;
int16_t effectid;
#endif
int stickIndex;
int s1ax, s1ay, s2ax, s2ay;
};
enum FollowCameraLock
{
FCL_NONE = 0,
FCL_HORZ = 1,
FCL_VERT = 2
};
//RenderObject Layer Type (enable only one)
//#define RLT_DYNAMIC // Dynamic list
#define RLT_FIXED // Static array
//#define RLT_MAP // Mapping
typedef std::vector <RenderObject*> RenderObjects;
typedef std::list <RenderObject*> RenderObjectList;
typedef std::map <intptr_t, RenderObject*> RenderObjectMap;
class RenderObjectLayer
{
public:
RenderObjectLayer();
~RenderObjectLayer();
void add(RenderObject* r);
void remove(RenderObject* r);
void moveToFront(RenderObject *r);
void moveToBack(RenderObject *r);
void setCull(bool cull);
void setOptimizeStatic(bool opt);
void sort();
void renderPass(int pass);
void reloadDevice();
inline bool empty()
{
#ifdef RLT_FIXED
return objectCount == 0;
#endif
#ifdef RLT_DYNAMIC
return renderObjectList.empty();
#endif
return false;
}
inline RenderObject *getFirst()
{
#ifdef RLT_DYNAMIC
if (renderObjectList.empty()) return 0;
iter = renderObjectList.begin();
return *iter;
#endif
#ifdef RLT_MAP
if (renderObjectMap.empty()) return 0;
iter = renderObjectMap.begin();
return (*iter).second;
#endif
#ifdef RLT_FIXED
iter = 0;
return getNext();
#endif
}
RenderObject *getNext()
{
#ifdef RLT_DYNAMIC
if (iter == renderObjectList.end()) return 0;
iter++;
if (iter == renderObjectList.end()) return 0;
return *iter;
#endif
#ifdef RLT_MAP
if (iter == renderObjectMap.end()) return 0;
iter++;
if (iter == renderObjectMap.end()) return 0;
return (*iter).second;
#endif
#ifdef RLT_FIXED
const int size = renderObjects.size();
int i;
for (i = iter; i < size; i++)
{
if (renderObjects[i] != 0)
break;
}
if (i < size)
{
iter = i+1;
return renderObjects[i];
}
else
{
iter = i;
return 0;
}
#endif
return 0;
}
//inclusive
int startPass, endPass;
bool visible;
float followCamera;
int followCameraLock;
bool cull;
bool update;
int mode;
Vector color;
protected:
void clearDisplayList();
void generateDisplayList();
inline void renderOneObject(RenderObject *robj);
bool optimizeStatic;
bool displayListValid;
int displayListGeneration;
struct DisplayListElement {
DisplayListElement() {isList = false; u.robj = 0;}
bool isList; // True if this is a GL display list
union {
RenderObject *robj;
GLuint listID;
} u;
};
std::vector<DisplayListElement> displayList;
#ifdef RLT_DYNAMIC
RenderObjectList renderObjectList;
RenderObjectList::iterator iter;
#endif
#ifdef RLT_MAP
RenderObjectMap renderObjectMap;
RenderObjectMap::iterator iter;
#endif
#ifdef RLT_FIXED
RenderObjects renderObjects;
int objectCount;
int firstFreeIdx;
int iter;
#endif
};
class Core : public ActionMapper, public StateManager
{
public:
// init
Core(const std::string &filesystem, const std::string& extraDataDir, int numRenderLayers, const std::string &appName="BBGE", int particleSize=1024, std::string userDataSubFolder="");
void initPlatform(const std::string &filesystem);
~Core();
virtual void init();
void initRenderObjectLayers(int num);
void applyState(const std::string &state);
//bool createGlWindow(char* title, int width, int height, int bits, bool fullscreenflag);
bool createWindow(int width, int height, int bits, bool fullscreen, std::string windowTitle="");
//void setWindowTitle(const std::string &title); // func not yet written
void clearBuffers();
void render(int startLayer=-1, int endLayer=-1, bool useFrameBufferIfAvail=true);
void showBuffer();
void quit();
bool isShuttingDown();
bool isWindowFocus();
void instantQuit();
void cacheRender();
void setSDLGLAttributes();
void reloadResources();
void unloadResources();
std::string getPreferencesFolder();
std::string getUserDataFolder();
std::string adjustFilenameCase(const char *buf);
std::string adjustFilenameCase(const std::string &str) { return adjustFilenameCase(str.c_str()); };
void resetCamera();
virtual void shutdown();
void main(float runTime = -1); // can use main
//void adjustWindowPosition(int x, int y);
// state functions
std::string getTextureLoadName(const std::string &texture);
void setMousePosition(const Vector &p);
void toggleScreenMode(int t=0);
void enable2D(int pixelScaleX=0, int pixelScaleY=0, bool forcePixelScale=false);
void addRenderObject(RenderObject *o, int layer=0);
void switchRenderObjectLayer(RenderObject *o, int toLayer);
void addTexture(Texture *r);
CountedPtr<Texture> findTexture(const std::string &name);
void removeTexture(Texture *res);
void clearResources();
CountedPtr<Texture> addTexture(const std::string &texture, TextureLoadResult *pLoadResult = 0);
PostProcessingFX postProcessingFx;
enum RemoveRenderObjectFlag { DESTROY_RENDER_OBJECT=0, DO_NOT_DESTROY_RENDER_OBJECT };
void removeRenderObject(RenderObject *r, RemoveRenderObjectFlag flag = DESTROY_RENDER_OBJECT);
void setMouseConstraint(bool on);
void setMouseConstraintCircle(const Vector& pos, float mouseCircle);
void setReentryInputGrab(int on);
void action(int id, int state){}
bool exists(const std::string &file);
void enqueueRenderObjectDeletion(RenderObject *object);
void clearGarbage();
bool isNested() { return nestedMains > 1; }
int getNestedMains() { return nestedMains; }
void quitNestedMain();
int getWindowWidth() { return width; }
int getWindowHeight() { return height; }
void updateCursorFromJoystick(float dt, int spd);
uint32 getTicks();
float stopWatch(int d);
float stopWatchStartTime;
void resetGraphics(int w, int h, int fullscreen=-1, int vsync=-1, int bpp=-1);
/*
#ifdef BBGE_BUILD_OPENGL
void getWindowHeight(int *height)
{glfwGetWindowSize(0, height);}
void getWindowWidth(int *width)
{glfwGetWindowSize(width, 0);}
#endif
*/
void setDockIcon(const std::string &ident);
Vector getGameCursorPosition();
Vector getGamePosition(const Vector &v);
Vector joystickPosition;
bool coreVerboseDebug;
Vector screenCenter;
void sort();
void sortLayer(int layer);
void print(int x, int y, const char *str, float sz=1);
// windows variables
#ifdef BBGE_BUILD_WINDOWS
HDC hDC; // Private GDI Device Context
HGLRC hRC; // Permanent Rendering Context
HWND hWnd; // Holds Our Window Handle
HINSTANCE hInstance; // Holds The Instance Of The Application
#endif
std::vector<Texture*> resources;
RenderObjectLayer *getRenderObjectLayer(int i);
std::vector <int> renderObjectLayerOrder;
//typedef std::list<RenderObject*> RenderObjects;
typedef std::vector<RenderObjectLayer> RenderObjectLayers;
RenderObjectLayers renderObjectLayers;
RenderObjectList garbage;
SoundManager *sound;
float aspect;
int width, height;
enum Modes { MODE_NONE=-1, MODE_3D=0, MODE_2D };
InterpolatedVector globalScale;
Vector globalResolutionScale;
Vector screenCapScale;
virtual void onResetScene(){}
virtual void onPlayedVoice(const std::string &name){}
Vector cameraPos;
int fps;
bool loopDone;
Mouse mouse;
AfterEffectManager *afterEffectManager;
ParticleManager *particleManager;
//Scripting::Script script;
void setBaseTextureDirectory(const std::string &baseTextureDirectory)
{ this->baseTextureDirectory = baseTextureDirectory; }
std::string getBaseTextureDirectory()
{
return baseTextureDirectory;
}
virtual bool canChangeState();
void resetTimer();
inline int getVirtualWidth()
{
return virtualWidth;
}
inline int getVirtualHeight()
{
return virtualHeight;
}
unsigned char *grabScreenshot(int x, int y, int w, int h);
unsigned char *grabCenteredScreenshot(int w, int h);
int saveScreenshotTGA(const std::string &filename);
void save64x64ScreenshotTGA(const std::string &filename);
void saveSizedScreenshotTGA(const std::string &filename, int sz, int crop34);
void saveCenteredScreenshotTGA(const std::string &filename, int sz);
bool minimized;
std::string getEnqueuedJumpState();
float cullRadius;
float cullRadiusSqr;
Vector cullCenter;
unsigned int renderObjectCount, processedRenderObjectCount, totalRenderObjectCount;
float invGlobalScale, invGlobalScaleSqr;
void globalScaleChanged();
void screenshot();
void clearRenderObjects();
void applyMatrixStackToWorld();
void translateMatrixStack(float x, float y, float z=0);
//void translateMatrixStackRelative(float x, float y, float z=0);
void rotateMatrixStack(float x, float y, float z);
void scaleMatrixStack(float x, float y, float z=1);
void rotateMatrixStack(float z);
void setColor(float r, float g, float b, float a);
void bindTexture(int stage, unsigned int handle);
#ifdef BBGE_BUILD_DIRECTX
void blitD3DVerts(IDirect3DTexture9 *texture, float v1x, float v1y, float v2x, float v2y, float v3x, float v3y, float v4x, float v4y);
void blitD3D (IDirect3DTexture9 *texture, int width, int height);
void blitD3DPreTrans (IDirect3DTexture9 *texture, float x, float y, int absWidth, int absHeight);
void blitD3DEx (IDirect3DTexture9 *texture, int width, int height, float u1=0, float v1=0, float u2=1, float v2=1);
void blitD3DGradient(D3DCOLOR ulc0, D3DCOLOR ulc1, D3DCOLOR ulc2, D3DCOLOR ulc3);
LPDIRECT3DDEVICE9 getD3DDevice();
LPD3DXSPRITE getD3DSprite();
LPD3DXMATRIXSTACK getD3DMatrixStack();
#endif
bool getKeyState(int k);
bool getMouseButtonState(int m);
int currentLayerPass;
int keys[KEY_MAXARRAY];
Flags flags;
virtual void debugLog(const std::string &s);
virtual void errorLog(const std::string &s);
void messageBox(const std::string &title, const std::string &msg);
bool getShiftState();
bool getAltState();
bool getCtrlState();
bool getMetaState();
virtual void generateCollisionMask(RenderObject *r){}
DarkLayer darkLayer;
int redBits, greenBits, blueBits, alphaBits;
void setupRenderPositionAndScale();
void setupGlobalResolutionScale();
int particlesPaused;
//JoystickData joystickData[4];
bool joystickEnabled;
bool joystickOverrideMouse;
/*
int numJoysticks;
DIJOYSTATE2 joystate;
Joystick* joysticks[4];
*/
bool debugLogTextures;
Joystick joystick;
void setClearColor(const Vector &c);
Vector getClearColor();
int flipMouseButtons;
void initFrameBuffer();
FrameBuffer frameBuffer;
void updateRenderObjects(float dt);
bool joystickAsMouse;
virtual void prepScreen(bool t){}
bool updateMouse;
bool frameOutputMode;
int overrideStartLayer, overrideEndLayer;
void setWindowCaption(const std::string &caption, const std::string &icon);
ParticleEffect* createParticleEffect(const std::string &name, const Vector &position, int layer, float rotz=0);
std::string secondaryTexturePath;
bool hasFocus();
EventQueue eventQueue;
float aspectX, aspectY;
float get_old_dt() { return old_dt; }
float get_current_dt() { return current_dt; }
bool debugLogActive;
void setInputGrab(bool on);
bool isFullscreen();
int viewOffX, viewOffY;
int getVirtualOffX();
int getVirtualOffY();
void centerMouse();
int vw2, vh2;
Vector center;
void enable2DWide(int rx, int ry);
void enumerateScreenModes();
std::vector<ScreenMode> screenModes;
void pollEvents();
CoreSettings settings;
int tgaSave(const char *filename, short int width, short int height, unsigned char pixelDepth, unsigned char *imageData);
int zgaSave(const char *filename, short int width, short int height, unsigned char pixelDepth, unsigned char *imageData);
volatile int dbg_numThreadDecoders;
static unsigned int dbg_numRenderCalls;
virtual void onBackgroundUpdate();
void initLocalization();
protected:
std::string fpsDebugString;
TimeUpdateType timeUpdateType;
int fixedFPS;
void updateCullData();
std::string userDataFolder;
int grabInputOnReentry;
int virtualOffX, virtualOffY;
void initIcon();
float old_dt;
float current_dt;
std::string debugLogPath;
virtual void onReloadResources();
std::pair<CountedPtr<Texture>, TextureLoadResult> doTextureAdd(const std::string &texture, const std::string &name, std::string internalTextureName);
void deleteRenderObjectMemory(RenderObject *r);
bool _hasFocus;
bool lib_graphics, lib_sound, lib_input;
Vector clearColor;
bool updateCursorFromMouse;
virtual void unloadDevice();
virtual void reloadDevice();
std::string appName;
bool mouseConstraint;
float mouseCircle;
Vector mouseConstraintCenter;
bool doMouseConstraint();
virtual void onMouseInput(){}
bool doScreenshot;
float baseCullRadius;
bool initSoundLibrary(const std::string &defaultDevice);
bool initInputLibrary();
bool initJoystickLibrary(int numSticks=1);
bool initGraphicsLibrary(int w, int h, bool fullscreen, int vsync, int bpp, bool recreate=true);
void shutdownInputLibrary();
void shutdownJoystickLibrary();
void shutdownGraphicsLibrary(bool kill=true);
void shutdownSoundLibrary();
int afterEffectManagerLayer;
bool sortEnabled;
Vector cameraOffset;
std::vector<float> avgFPS;
float sortTimer;
bool sortFlag;
virtual void modifyDt(float &dt){}
void setPixelScale(int pixelScaleX, int pixelScaleY);
int virtualHeight, virtualWidth;
bool shuttingDown;
bool quitNestedMainFlag;
bool clearedGarbageFlag;
int nestedMains;
std::string baseTextureDirectory;
#ifdef BBGE_BUILD_WINDOWS
__int64 lastTime, curTime, freq;
#endif
std::ofstream _logOut;
#ifdef BBGE_BUILD_SDL
int nowTicks, thenTicks;
#endif
int _vsync, _bpp;
bool _fullscreen;
int numSavedScreenshots;
CountedPtr<Texture> texError;
//unsigned int windowWidth, windowHeight;
int tgaSaveSeries(char *filename, short int width, short int height, unsigned char pixelDepth, unsigned char *imageData);
virtual void onUpdate(float dt);
virtual void onRender(){}
void setupFileAccess();
std::string _extraDataDir;
};
extern Core *core;
#include "RenderObject_inline.h"
#endif
Reference in a new issue View git blame Copy permalink