mirror/Aquaria
1
0
Fork 0
mirror of https://github.com/AquariaOSE/Aquaria.git synced 2024-12-25 14:15:46 +00:00
Code Issues Releases Wiki Activity
Aquaria/BBGE/Core.h
fgenesis d903e74bf6 Core: tgaSave() should free memory passed in. SceneEditor: Add support for grid map dumping (in TGA format). 
This allows reconstructing the map templates, which were never shipped with the game.
This patch also fixes insane memory leaking when taking screenshots, or dumping screen frames.
2011-11-20 22:58:36 +01:00

1411 lines
31 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 "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 <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:
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 resize3D();
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 enable3D();
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::vector<Resource*>resources;
std::vector<std::string> resourceNames;
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;
int mode;
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;
std::vector<Light> lights;
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<ScreenMode> 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<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;
//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
Reference in a new issue View git blame Copy permalink