/* 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 "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; } bool renderOn; bool runInBackground; bool updateOn; // NOT IMPLEMENTED YET }; 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 = SDLK_LSUPER, KEY_RSUPER = SDLK_RSUPER, KEY_LMETA = SDLK_LMETA, KEY_RMETA = SDLK_RMETA, KEY_BACKSPACE = SDLK_BACKSPACE, KEY_PRINTSCREEN = SDLK_PRINT, //KEY_CAPSLOCK = DIK_CAPSLOCK, //KEY_CIRCUMFLEX = DIK_CIRCUMFLEX, KEY_LALT = SDLK_LALT, KEY_RALT = SDLK_RALT, KEY_LSHIFT = SDLK_LSHIFT, KEY_RSHIFT = SDLK_RSHIFT, KEY_LCONTROL = SDLK_LCTRL, KEY_RCONTROL = SDLK_RCTRL, KEY_NUMPADMINUS = SDLK_KP_MINUS, KEY_NUMPADPERIOD = SDLK_KP_PERIOD, KEY_NUMPADPLUS = SDLK_KP_PLUS, KEY_NUMPADSLASH = SDLK_KP_DIVIDE, KEY_NUMPADSTAR = SDLK_KP_MULTIPLY, KEY_PGDN = SDLK_PAGEDOWN, KEY_PGUP = SDLK_PAGEUP, KEY_APOSTROPHE = SDLK_QUOTE, KEY_EQUALS = SDLK_EQUALS, KEY_SEMICOLON = SDLK_SEMICOLON, KEY_LBRACKET = SDLK_LEFTBRACKET, KEY_RBRACKET = SDLK_RIGHTBRACKET, //KEY_RALT = GLFW_KEY_RALT, KEY_TILDE = SDLK_BACKQUOTE, KEY_0 = SDLK_0, KEY_1 = SDLK_1, KEY_2 = SDLK_2, KEY_3 = SDLK_3, KEY_4 = SDLK_4, KEY_5 = SDLK_5, KEY_6 = SDLK_6, KEY_7 = SDLK_7, KEY_8 = SDLK_8, KEY_9 = SDLK_9, KEY_A = SDLK_a, KEY_B = SDLK_b, KEY_C = SDLK_c, KEY_D = SDLK_d, KEY_E = SDLK_e, KEY_F = SDLK_f, KEY_G = SDLK_g, KEY_H = SDLK_h, KEY_I = SDLK_i, KEY_J = SDLK_j, KEY_K = SDLK_k, KEY_L = SDLK_l, KEY_M = SDLK_m, KEY_N = SDLK_n, KEY_O = SDLK_o, KEY_P = SDLK_p, KEY_Q = SDLK_q, KEY_R = SDLK_r, KEY_S = SDLK_s, KEY_T = SDLK_t, KEY_U = SDLK_u, KEY_V = SDLK_v, KEY_W = SDLK_w, KEY_X = SDLK_x, KEY_Y = SDLK_y, KEY_Z = SDLK_z, KEY_LEFT = SDLK_LEFT, KEY_RIGHT = SDLK_RIGHT, KEY_UP = SDLK_UP, KEY_DOWN = SDLK_DOWN, KEY_NUMPAD1 = SDLK_KP1, KEY_NUMPAD2 = SDLK_KP2, KEY_NUMPAD3 = SDLK_KP3, KEY_NUMPAD4 = SDLK_KP4, KEY_NUMPAD5 = SDLK_KP5, KEY_NUMPAD6 = SDLK_KP6, KEY_NUMPAD7 = SDLK_KP7, KEY_NUMPAD8 = SDLK_KP8, KEY_NUMPAD9 = SDLK_KP9, KEY_NUMPAD0 = SDLK_KP0, KEY_DELETE = SDLK_DELETE, KEY_SPACE = SDLK_SPACE, KEY_RETURN = SDLK_RETURN, KEY_PERIOD = SDLK_PERIOD, KEY_MINUS = SDLK_MINUS, KEY_CAPSLOCK = SDLK_CAPSLOCK, KEY_SYSRQ = SDLK_SYSREQ, KEY_TAB = SDLK_TAB, KEY_HOME = SDLK_HOME, KEY_END = SDLK_END, KEY_COMMA = SDLK_COMMA, KEY_SLASH = SDLK_SLASH, KEY_F1 = SDLK_F1, KEY_F2 = SDLK_F2, KEY_F3 = SDLK_F3, KEY_F4 = SDLK_F4, KEY_F5 = SDLK_F5, KEY_F6 = SDLK_F6, KEY_F7 = SDLK_F7, KEY_F8 = SDLK_F8, KEY_F9 = SDLK_F9, KEY_F10 = SDLK_F10, KEY_F11 = SDLK_F11, KEY_F12 = SDLK_F12, KEY_F13 = SDLK_F13, KEY_F14 = SDLK_F14, KEY_F15 = SDLK_F15, KEY_ESCAPE = SDLK_ESCAPE, KEY_ANYKEY = 4059, KEY_MAXARRAY = SDLK_LAST+1 }; #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 SDL_Joystick *sdl_joy; #endif #ifdef __LINUX__ 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 RenderObjects; typedef std::list RenderObjectList; typedef std::map 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 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: enum RemoveResource { DESTROY = 0, NO_DESTROY }; // init Core(const std::string &filesystem, 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 addResource(Resource *r); Resource *findResource(const std::string &name); Texture *findTexture(const std::string &name); void removeResource(std::string name, RemoveResource removeFlag); Texture *addTexture(const std::string &texture); void removeTexture(std::string texture); 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(int mouseCircle); void setReentryInputGrab(int on); void action(int id, int state){} bool exists(const std::string &file); void enqueueRenderObjectDeletion(RenderObject *object); void clearGarbage(); void clearResources(); 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::vectorresources; std::vector resourceNames; RenderObjectLayer *getRenderObjectLayer(int i); std::vector renderObjectLayerOrder; //typedef std::list RenderObjects; typedef std::vector 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){} InterpolatedVector cameraPos, cameraRot; 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); virtual void msg(const std::string &message); bool minimized; std::string getEnqueuedJumpState(); int cullRadius; float cullRadiusSqr; Vector cullCenter; int screenCullX1, screenCullY1, screenCullX2, screenCullY2; unsigned int renderObjectCount, processedRenderObjectCount, totalRenderObjectCount; float invGlobalScale, invGlobalScaleSqr; 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; std::string getInternalTextureName(const std::string &name); 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; } 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 screenModes; void pollEvents(); CoreSettings settings; int tgaSave(const char *filename, short int width, short int height, unsigned char pixelDepth, unsigned char *imageData); protected: std::string fpsDebugString; TimeUpdateType timeUpdateType; int fixedFPS; void updateCullData(); std::string userDataFolder; int grabInputOnReentry; int virtualOffX, virtualOffY; void initIcon(); float old_dt; std::string debugLogPath; virtual void onReloadResources(); Texture* 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; int mouseCircle; bool doMouseConstraint(); virtual void onMouseInput(){} bool doScreenshot; int 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 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; //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(){} }; extern Core *core; #include "RenderObject_inline.h" #endif