void init() {
Scene<BLINN_PHONG> scene;
auto texIds = scene.textures.createTextures<6>(
{gli::load_dds("textures/tex1.dds"),
gli::load_dds("textures/tex2.dds"),
gli::load_dds("textures/tex3.dds"),
gli::load_dds("textures/bricks.dds"),
gli::load_dds("textures/bricks_normals.dds"),
gli::load_dds("textures/tex4.dds")});
auto texId = scene.textures.createTexture(gli::load_dds("textures/bricks.dds"));
// TiledMirrorBox::buildTiledMirrorBox<BLINN_PHONG>(scene,
// glm::vec3(10.0, 10.0, 10.0), glm::ivec2(0, 0),
// {{texIds[0], texIds[1], texIds[2],
// texIds[3], texIds[4], texIds[5]}});
Kaleidescope::buildKaleidescope<BLINN_PHONG>(scene, std::array<unsigned, 3>{{6, 3, 2}}, 7.0f, 5.0f, texId);
rndr = new Renderer<CL_DEVICE_TYPE_GPU, BLINN_PHONG>(
scene, width, height,
numReflectivePasses, maxViewDistance);
arrow = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
hand = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZEALL);
initGL();
}
bool RWindow::initializeSDL()
{
SDL_DisplayMode current;
if(SDL_Init(SDL_INIT_EVERYTHING) < 0)
{
std::cerr << "Could not initialize SDL: " << SDL_GetError();
std::cerr << std::endl;
std::exit(1);
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
if(SDL_GetCurrentDisplayMode(0, ¤t) != 0)
{
// In case of error...
std::cerr << "Could not get display mode for video display: ";
std::cerr << SDL_GetError() << std::endl;
return false;
}
else
{
// Everything is normal
m_width = current.w;
m_height = current.h;
}
m_window = SDL_CreateWindow(
m_title.data(),
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
m_width, m_height,
SDL_WINDOW_OPENGL |
SDL_WINDOW_FULLSCREEN_DESKTOP |
SDL_WINDOW_HIDDEN);
if(m_window == nullptr)
{
std::cerr << "Could not iniialize SDL Window: " << SDL_GetError();
std::cerr << std::endl;
return false;
}
m_surface = SDL_GetWindowSurface(m_window);
m_context = SDL_GL_CreateContext(m_window);
//Init cursors
m_systemCursors[0] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
m_systemCursors[1] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_IBEAM);
m_systemCursors[2] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_WAIT);
m_systemCursors[3] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_NO);
m_systemCursors[4] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_HAND);
for(unsigned i = 0; i < 4; ++i)
m_customCursors[i] = nullptr;
return true;
}
void PPDisplayDevice::initMousePointers()
{
cursorStandard = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
cursorResizeHoriz = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZEWE);
cursorEggtimer = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_WAIT);
cursorHand = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_HAND);
}
void Runtime::construct(const char *font, const char *boldFont) {
logEntered();
_state = kClosingState;
_graphics = new Graphics(_window);
_cursorHand = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_HAND);
_cursorArrow = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
_cursorIBeam = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_IBEAM);
if (_graphics && _graphics->construct(font, boldFont)) {
int w, h;
SDL_GetWindowSize(_window, &w, &h);
_output = new AnsiWidget(w, h);
if (_output && _output->construct()) {
_eventQueue = new Stack<MAEvent *>();
if (_eventQueue) {
_state = kActiveState;
}
}
} else {
alert("Unable to start", "Font resource not loaded");
fprintf(stderr, "failed to load: [%s] [%s]\n", font, boldFont);
exit(1);
}
}
void display_result_text(SDL_Renderer *pRenderer, Text *text, int *sleep, int16_t *counter) {
/** Display the round winner by blinking the the text during a short time. **/
if (*counter == 0) {
/** First time this function is called:
* So we initialize the setting for an animation.
*************************************************/
game_control->is_animation_running=true ;
game_control->cursor_type = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_WAITARROW) ;
SDL_SetCursor(game_control->cursor_type) ;
*sleep=1500000/3 ; /** Mainloop pausing time high value needed for blinking. **/
/** Setting up the text to display in relationship to the round result.
* Sea \file ./Utilities/text_utils.c
**********************************************************************/
configure_result_text(pRenderer, text, game_control->round_winner) ;
(*counter) += 2 ;
}
if ((*counter) % 2 == 0 && game_control->is_animation_running && (*counter) < 11) {
render_text(pRenderer, text) ; /** Render text sea: \file ./Utilities/text_utils.c **/
}
(*counter)++ ;
if (*counter == 13) {
/** End of the animation: we reset settings. **/
*sleep=10000 ;
*counter=0 ;
game_control->cursor_type = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW) ;
SDL_SetCursor(game_control->cursor_type) ;
game_control->is_animation_running = false ;
game_control->GAME_STATUS = UPDATE_SCORE ;
return ;
}
return ;
}
static bool ImGui_ImplSDL2_Init(SDL_Window* window)
{
g_Window = window;
// Setup back-end capabilities flags
ImGuiIO& io = ImGui::GetIO();
io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors; // We can honor GetMouseCursor() values (optional)
#if SDL_HAS_WARP_MOUSE_GLOBAL
io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos; // We can honor io.WantSetMousePos requests (optional, rarely used)
#endif
// Keyboard mapping. ImGui will use those indices to peek into the io.KeysDown[] array.
io.KeyMap[ImGuiKey_Tab] = SDL_SCANCODE_TAB;
io.KeyMap[ImGuiKey_LeftArrow] = SDL_SCANCODE_LEFT;
io.KeyMap[ImGuiKey_RightArrow] = SDL_SCANCODE_RIGHT;
io.KeyMap[ImGuiKey_UpArrow] = SDL_SCANCODE_UP;
io.KeyMap[ImGuiKey_DownArrow] = SDL_SCANCODE_DOWN;
io.KeyMap[ImGuiKey_PageUp] = SDL_SCANCODE_PAGEUP;
io.KeyMap[ImGuiKey_PageDown] = SDL_SCANCODE_PAGEDOWN;
io.KeyMap[ImGuiKey_Home] = SDL_SCANCODE_HOME;
io.KeyMap[ImGuiKey_End] = SDL_SCANCODE_END;
io.KeyMap[ImGuiKey_Insert] = SDL_SCANCODE_INSERT;
io.KeyMap[ImGuiKey_Delete] = SDL_SCANCODE_DELETE;
io.KeyMap[ImGuiKey_Backspace] = SDL_SCANCODE_BACKSPACE;
io.KeyMap[ImGuiKey_Space] = SDL_SCANCODE_SPACE;
io.KeyMap[ImGuiKey_Enter] = SDL_SCANCODE_RETURN;
io.KeyMap[ImGuiKey_Escape] = SDL_SCANCODE_ESCAPE;
io.KeyMap[ImGuiKey_A] = SDL_SCANCODE_A;
io.KeyMap[ImGuiKey_C] = SDL_SCANCODE_C;
io.KeyMap[ImGuiKey_V] = SDL_SCANCODE_V;
io.KeyMap[ImGuiKey_X] = SDL_SCANCODE_X;
io.KeyMap[ImGuiKey_Y] = SDL_SCANCODE_Y;
io.KeyMap[ImGuiKey_Z] = SDL_SCANCODE_Z;
io.SetClipboardTextFn = ImGui_ImplSDL2_SetClipboardText;
io.GetClipboardTextFn = ImGui_ImplSDL2_GetClipboardText;
io.ClipboardUserData = NULL;
g_MouseCursors[ImGuiMouseCursor_Arrow] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
g_MouseCursors[ImGuiMouseCursor_TextInput] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_IBEAM);
g_MouseCursors[ImGuiMouseCursor_ResizeAll] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZEALL);
g_MouseCursors[ImGuiMouseCursor_ResizeNS] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENS);
g_MouseCursors[ImGuiMouseCursor_ResizeEW] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZEWE);
g_MouseCursors[ImGuiMouseCursor_ResizeNESW] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENESW);
g_MouseCursors[ImGuiMouseCursor_ResizeNWSE] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENWSE);
g_MouseCursors[ImGuiMouseCursor_Hand] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_HAND);
#ifdef _WIN32
SDL_SysWMinfo wmInfo;
SDL_VERSION(&wmInfo.version);
SDL_GetWindowWMInfo(window, &wmInfo);
io.ImeWindowHandle = wmInfo.info.win.window;
#else
(void)window;
#endif
return true;
}
static SDL_Cursor * GetLoadCursor( const EE_SYSTEM_CURSOR& cursor ) {
if ( 0 == SDL_SYS_CURSORS[ cursor ] ) {
SDL_SYS_CURSORS[ cursor ] = SDL_CreateSystemCursor( (SDL_SystemCursor)cursor );
}
return SDL_SYS_CURSORS[ cursor ];
}
void
loop()
{
SDL_Event event;
/* Check for events */
while (SDL_PollEvent(&event)) {
SDLTest_CommonEvent(state, &event, &done);
if (event.type == SDL_WINDOWEVENT) {
if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
SDL_Window *window = SDL_GetWindowFromID(event.window.windowID);
if (window) {
SDL_Log("Window %d resized to %dx%d\n",
event.window.windowID,
event.window.data1,
event.window.data2);
}
}
if (event.window.event == SDL_WINDOWEVENT_MOVED) {
SDL_Window *window = SDL_GetWindowFromID(event.window.windowID);
if (window) {
SDL_Log("Window %d moved to %d,%d (display %s)\n",
event.window.windowID,
event.window.data1,
event.window.data2,
SDL_GetDisplayName(SDL_GetWindowDisplayIndex(window)));
}
}
}
if (event.type == SDL_KEYUP) {
SDL_bool updateCursor = SDL_FALSE;
if (event.key.keysym.sym == SDLK_LEFT) {
--system_cursor;
if (system_cursor < 0) {
system_cursor = SDL_NUM_SYSTEM_CURSORS - 1;
}
updateCursor = SDL_TRUE;
} else if (event.key.keysym.sym == SDLK_RIGHT) {
++system_cursor;
if (system_cursor >= SDL_NUM_SYSTEM_CURSORS) {
system_cursor = 0;
}
updateCursor = SDL_TRUE;
}
if (updateCursor) {
SDL_Log("Changing cursor to \"%s\"", cursorNames[system_cursor]);
SDL_FreeCursor(cursor);
cursor = SDL_CreateSystemCursor((SDL_SystemCursor)system_cursor);
SDL_SetCursor(cursor);
}
}
}
#ifdef __EMSCRIPTEN__
if (done) {
emscripten_cancel_main_loop();
}
#endif
}
void settingsScreen::load(screenManager* manager) {
printf("The settings screen has loaded!\n");
this->manager = manager;
// Challenge puzzles button
buttons.push_back(rectangle(5, 20, 90, 40));
// Custom puzzles button
buttons.push_back(rectangle(5, 80, 90, 40));
// Settings button
buttons.push_back(rectangle(5, 140, 90, 40));
arrowCursor = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
pointerCursor = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_HAND);
}
int Init () {
if (SDL_Init(SDL_INIT_TIMER | SDL_INIT_VIDEO | SDL_INIT_EVENTS) < 0) {
return 1;
}
if ((window = SDL_CreateWindow("PID Demo", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_FULLSCREEN)) == NULL) {
return 2;
}
if ((renderer = SDL_CreateRenderer(window, -1, 0)) == NULL) {
return 3;
}
SDL_Surface* policeBMP;
if ((policeBMP = SDL_LoadBMP("./police.bmp")) == NULL) {
return 4;
}
if ((police = SDL_CreateTextureFromSurface(renderer, policeBMP)) == NULL) {
return 5;
}
SDL_FreeSurface(policeBMP);
SDL_Cursor* cursor;
if ((cursor = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_CROSSHAIR)) == NULL) {
return 6;
}
SDL_SetCursor(cursor);
policeDest.w = POLICE_WIDTH;
policeDest.h = POLICE_HEIGHT;
gains.p = 10;
gains.i = 1;
gains.d = 5;
frameX.p = (SCREEN_WIDTH / 2) - (POLICE_WIDTH / 2);
frameX.v = 0;
frameX.a = 0;
frameY.p = (SCREEN_HEIGHT / 2) - (POLICE_HEIGHT / 2);
frameY.v = 0;
frameY.a = 0;
stateX.error = 0;
stateX.integral = 0;
stateY.error = 0;
stateY.integral = 0;
return 0;
}
void Initialise()
{
Guard::Assert(!_initialised, "Cursors have already been initialised.");
_initialised = true;
// Using system cursors
_loadedCursors[CURSOR_ARROW] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
_loadedCursors[CURSOR_HAND_POINT] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_HAND);
// Using custom cursors
for (size_t i = 0; i < CURSOR_COUNT; i++)
{
const CursorData * cursorData = GetCursorData((CURSOR_ID)i);
if (cursorData != nullptr)
{
_loadedCursors[i] = Create(cursorData);
}
}
_currentCursor = CURSOR_UNDEFINED;
SetCurrentCursor(CURSOR_ARROW);
}
bool Cursor::createFromSystem(Type type)
{
SDL_Cursor *created = SDL_CreateSystemCursor(type);
if (!created)
{
Error() << "creating cursor from system: " << SDL_GetError();
}
else
{
load(created);
}
return created;
}
//------------------------------------------------------------------------------------------------------
//setter function that creates a system mouse cursor
//------------------------------------------------------------------------------------------------------
void InputManager::SetMouseCursorType(CursorType cursorType)
{
//first destroy old cursor object from memory
SDL_FreeCursor(m_cursor);
//based on type of cursor value passed, create mouse cursor using SDL ID flag value
m_cursor = SDL_CreateSystemCursor(SDL_SystemCursor(cursorType));
//use cursor pointer to assign cursor to SDL
SDL_SetCursor(m_cursor);
}
void break_computer_throw_cards_animation(void) {
/** Computer throw cards animation end function. **/
game_control->GAME_STATUS = CARDS_THROW ;
game_control->SAVED_GAME_STATUS = CARDS_THROW ;
game_control->is_animation_running = false ;
game_control->cursor_type = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW) ;
SDL_SetCursor(game_control->cursor_type) ;
return ;
}
InputDeviceSDL2::InputDeviceSDL2(OInput* pInput)
: InputDevice(pInput)
{
m_mouseState[0] = 0;
m_mouseState[1] = 1;
m_mouseState[2] = 2;
m_previousMouseState[0] = 0;
m_previousMouseState[1] = 1;
m_previousMouseState[2] = 2;
SDL_Init(SDL_INIT_GAMECONTROLLER);
m_pArrowCursor = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
}
void Cursor::ApplyOSCursorShape()
{
// Mobile platforms do not support applying OS cursor shapes: comment out to avoid log error messages
#if !defined(ANDROID) && !defined(IOS)
if (!osShapeDirty_ || !GetSubsystem<Input>()->IsMouseVisible() || GetSubsystem<SystemUI>()->GetCursor() != this)
return;
CursorShapeInfo& info = shapeInfos_[shape_];
// Remove existing SDL cursor if is not a system shape while we should be using those, or vice versa
if (info.osCursor_ && info.systemDefined_ != useSystemShapes_)
{
SDL_FreeCursor(info.osCursor_);
info.osCursor_ = 0;
}
// Create SDL cursor now if necessary
if (!info.osCursor_)
{
// Create a system default shape
if (useSystemShapes_ && info.systemCursor_ >= 0 && info.systemCursor_ < CS_MAX_SHAPES)
{
info.osCursor_ = SDL_CreateSystemCursor((SDL_SystemCursor)osCursorLookup[info.systemCursor_]);
info.systemDefined_ = true;
if (!info.osCursor_)
ATOMIC_LOGERROR("Could not create system cursor");
}
// Create from image
else if (info.image_)
{
SDL_Surface* surface = info.image_->GetSDLSurface(info.imageRect_);
if (surface)
{
info.osCursor_ = SDL_CreateColorCursor(surface, info.hotSpot_.x_, info.hotSpot_.y_);
info.systemDefined_ = false;
if (!info.osCursor_)
ATOMIC_LOGERROR("Could not create cursor from image " + info.image_->GetName());
SDL_FreeSurface(surface);
}
}
}
if (info.osCursor_)
SDL_SetCursor(info.osCursor_);
osShapeDirty_ = false;
#endif
}
void Cursor::ApplyShape()
{
CursorShapeInfo& info = shapeInfos_[shape_];
texture_ = info.texture_;
imageRect_ = info.imageRect_;
SetSize(info.imageRect_.Size());
// If the OS cursor is being shown, define/set SDL cursor shape if necessary
// Only do this when we are the active UI cursor
if (GetSubsystem<Input>()->IsMouseVisible() && GetSubsystem<UI>()->GetCursor() == this)
{
// Remove existing SDL cursor if is not a system shape while we should be using those, or vice versa
if (info.osCursor_ && info.systemDefined_ != useSystemShapes_)
{
SDL_FreeCursor(info.osCursor_);
info.osCursor_ = 0;
}
// Create SDL cursor now if necessary
if (!info.osCursor_)
{
// Create a system default shape
if (useSystemShapes_)
{
info.osCursor_ = SDL_CreateSystemCursor((SDL_SystemCursor)osCursorLookup[shape_]);
info.systemDefined_ = true;
if (!info.osCursor_)
LOGERROR("Could not create system cursor");
}
// Create from image
else if (info.image_)
{
SDL_Surface* surface = info.image_->GetSDLSurface(info.imageRect_);
if (surface)
{
info.osCursor_ = SDL_CreateColorCursor(surface, info.hotSpot_.x_, info.hotSpot_.y_);
info.systemDefined_ = false;
if (!info.osCursor_)
LOGERROR("Could not create cursor from image " + info.image_->GetName());
SDL_FreeSurface(surface);
}
}
}
if (info.osCursor_)
SDL_SetCursor(info.osCursor_);
}
}
Cursor::Cursor(mouse::Cursor::SystemCursor cursortype)
: cursor(nullptr)
, type(CURSORTYPE_SYSTEM)
, systemType(cursortype)
{
SDL_SystemCursor sdlcursortype;
if (systemCursors.find(cursortype, sdlcursortype))
cursor = SDL_CreateSystemCursor(sdlcursortype);
else
throw love::Exception("Cannot create system cursor: invalid type.");
if (!cursor)
throw love::Exception("Cannot create system cursor: %s", SDL_GetError());
}
bool ImGui_ImplSdlGL2_Init(SDL_Window* window)
{
// Keyboard mapping. ImGui will use those indices to peek into the io.KeyDown[] array.
ImGuiIO& io = ImGui::GetIO();
io.KeyMap[ImGuiKey_Tab] = SDL_SCANCODE_TAB;
io.KeyMap[ImGuiKey_LeftArrow] = SDL_SCANCODE_LEFT;
io.KeyMap[ImGuiKey_RightArrow] = SDL_SCANCODE_RIGHT;
io.KeyMap[ImGuiKey_UpArrow] = SDL_SCANCODE_UP;
io.KeyMap[ImGuiKey_DownArrow] = SDL_SCANCODE_DOWN;
io.KeyMap[ImGuiKey_PageUp] = SDL_SCANCODE_PAGEUP;
io.KeyMap[ImGuiKey_PageDown] = SDL_SCANCODE_PAGEDOWN;
io.KeyMap[ImGuiKey_Home] = SDL_SCANCODE_HOME;
io.KeyMap[ImGuiKey_End] = SDL_SCANCODE_END;
io.KeyMap[ImGuiKey_Insert] = SDL_SCANCODE_INSERT;
io.KeyMap[ImGuiKey_Delete] = SDL_SCANCODE_DELETE;
io.KeyMap[ImGuiKey_Backspace] = SDL_SCANCODE_BACKSPACE;
io.KeyMap[ImGuiKey_Space] = SDL_SCANCODE_SPACE;
io.KeyMap[ImGuiKey_Enter] = SDL_SCANCODE_RETURN;
io.KeyMap[ImGuiKey_Escape] = SDL_SCANCODE_ESCAPE;
io.KeyMap[ImGuiKey_A] = SDL_SCANCODE_A;
io.KeyMap[ImGuiKey_C] = SDL_SCANCODE_C;
io.KeyMap[ImGuiKey_V] = SDL_SCANCODE_V;
io.KeyMap[ImGuiKey_X] = SDL_SCANCODE_X;
io.KeyMap[ImGuiKey_Y] = SDL_SCANCODE_Y;
io.KeyMap[ImGuiKey_Z] = SDL_SCANCODE_Z;
io.SetClipboardTextFn = ImGui_ImplSdlGL2_SetClipboardText;
io.GetClipboardTextFn = ImGui_ImplSdlGL2_GetClipboardText;
io.ClipboardUserData = NULL;
g_MouseCursors[ImGuiMouseCursor_Arrow] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
g_MouseCursors[ImGuiMouseCursor_TextInput] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_IBEAM);
g_MouseCursors[ImGuiMouseCursor_ResizeAll] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZEALL);
g_MouseCursors[ImGuiMouseCursor_ResizeNS] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENS);
g_MouseCursors[ImGuiMouseCursor_ResizeEW] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZEWE);
g_MouseCursors[ImGuiMouseCursor_ResizeNESW] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENESW);
g_MouseCursors[ImGuiMouseCursor_ResizeNWSE] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENWSE);
#ifdef _WIN32
SDL_SysWMinfo wmInfo;
SDL_VERSION(&wmInfo.version);
SDL_GetWindowWMInfo(window, &wmInfo);
io.ImeWindowHandle = wmInfo.info.win.window;
#else
(void)window;
#endif
return true;
}
void sdl_window::set_mouse_cursor(mouse_system_cursor aSystemCursor)
{
SDL_SystemCursor sdlCursor = SDL_SYSTEM_CURSOR_ARROW;
switch (aSystemCursor)
{
case mouse_system_cursor::Arrow:
sdlCursor = SDL_SYSTEM_CURSOR_ARROW;
break;
case mouse_system_cursor::Ibeam:
sdlCursor = SDL_SYSTEM_CURSOR_IBEAM;
break;
case mouse_system_cursor::Wait:
sdlCursor = SDL_SYSTEM_CURSOR_WAIT;
break;
case mouse_system_cursor::Crosshair:
sdlCursor = SDL_SYSTEM_CURSOR_CROSSHAIR;
break;
case mouse_system_cursor::WaitArrow:
sdlCursor = SDL_SYSTEM_CURSOR_WAITARROW;
break;
case mouse_system_cursor::SizeNWSE:
sdlCursor = SDL_SYSTEM_CURSOR_SIZENWSE;
break;
case mouse_system_cursor::SizeNESW:
sdlCursor = SDL_SYSTEM_CURSOR_SIZENESW;
break;
case mouse_system_cursor::SizeWE:
sdlCursor = SDL_SYSTEM_CURSOR_SIZEWE;
break;
case mouse_system_cursor::SizeNS:
sdlCursor = SDL_SYSTEM_CURSOR_SIZENS;
break;
case mouse_system_cursor::SizeAll:
sdlCursor = SDL_SYSTEM_CURSOR_SIZEALL;
break;
case mouse_system_cursor::No:
sdlCursor = SDL_SYSTEM_CURSOR_NO;
break;
case mouse_system_cursor::Hand:
sdlCursor = SDL_SYSTEM_CURSOR_HAND;
break;
}
iCurrentCursor = cursor_pointer(cursor_pointer(), SDL_CreateSystemCursor(sdlCursor));
SDL_SetCursor(&*iCurrentCursor);
}
void BuyState::update(const float deltaTime)
{
#ifndef ANDROID_BUILD
SDL_Point mousePosRunning;
SDL_GetMouseState(&mousePosRunning.x, &mousePosRunning.y);
SDL_Rect turretRect = getRect(turret_);
if (!SDL_EnclosePoints(&mousePosRunning, 1, &turretRect, NULL))
{
SDL_Cursor* cursor = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
SDL_SetCursor(cursor);
Game::getInstance().toPop_ = name();
}
#else
#endif
}
void break_give_new_cards_animation(void) {
if (! game_control->distribute && ! give_order) {
give_order=true ;
return ;
}
else if (game_control->distribute && give_order) {
give_order=false ;
return ;
}
game_control->GAME_STATUS = NEW_CARDS_GIVEN ;
game_control->cursor_type = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW) ;
SDL_SetCursor(game_control->cursor_type) ;
game_control->is_animation_running = false ;
return ;
}
void init_ui(bool fullscreen) {
int width = 640, height = 480;
SDL_Init(SDL_INIT_EVERYTHING);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 2);
screen = SDL_CreateWindow("putkijuoksu",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
width, height,
(fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0) |
SDL_WINDOW_OPENGL);
if(screen == NULL)
throw "could not init SDL / opengl";
SDL_GetWindowSize(screen, &width, &height);
SDL_GL_CreateContext(screen);
SDL_SetRelativeMouseMode(SDL_TRUE);
SDL_SetCursor(SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW));
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(40, (double)width/(double)height, 0.1, 100);
glMatrixMode(GL_MODELVIEW);
glClearColor(0, 1, 1, 1);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glEnable(GL_MULTISAMPLE);
glClearColor(0.5f,0.5f,0.5f,1.0f);
glFogi(GL_FOG_MODE, GL_LINEAR);
GLfloat fog_color[] = {0.5, 0.5, 0.5, 1};
glFogfv(GL_FOG_COLOR, fog_color);
glFogf(GL_FOG_DENSITY, 0.35f);
glHint(GL_FOG_HINT, GL_DONT_CARE);
glFogf(GL_FOG_START, VIEWDISTANCE-5);
glFogf(GL_FOG_END, VIEWDISTANCE+5);
glEnable(GL_FOG);
init_resources();
}
Cursor::Cursor(CursorType cursorType) :
m_cursorType(cursorType)
{
FLAT_ASSERT(m_cursorType != INVALID_CURSOR);
m_cursor = SDL_CreateSystemCursor(cursorType);
}
void get_events(int16_t *mouse_x, int16_t *mouse_y) {
SDL_Event event;
while (SDL_PollEvent(&event)) { /** Get user events. **/
switch(event.type) {
case SDL_QUIT:
/** User press the cross to close the application. **/
quit_game=true ;
set_loop(false) ;
break;
case SDL_KEYDOWN :
if (event.key.keysym.scancode == SDL_SCANCODE_ESCAPE) {
/** The user fallback to the previous screen. **/
set_loop(false) ;
break ;
}
case SDL_MOUSEMOTION :
*mouse_x = event.motion.x ; /** We keep the mouse position at everytime in the game. **/
*mouse_y = event.motion.y ; /** We keep the mouse position at everytime in the game. **/
if ( ! game_control->is_animation_running && game_control->GAME_STATUS != DRAG_CARD_ON && game_control->GAME_STATUS != GAME_START ) {
if ( mouse_over_card(event.motion.x,event.motion.y) != -1 && ! game_control->is_animation_running ) {
/** The mouse is over an card. **/
if ( game_control->cursor_type != SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_HAND) ) {
/** We set the cursor to an hand cursor to notify the user that he can return or drag-and-drop the card. **/
game_control->cursor_type = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_HAND) ;
SDL_SetCursor(game_control->cursor_type) ;
game_control->mouse_over_card=true ;
}
}
else {
if ( game_control->cursor_type != SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW) && ! game_control->is_animation_running && ! is_mouse_in_buttons_bboxes(event.motion.x) ) {
/** We reset the cursor to default. **/
game_control->cursor_type = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW) ;
SDL_SetCursor(game_control->cursor_type) ;
game_control->mouse_over_card=false ;
}
}
}
if ( ! game_control->is_animation_running ) {
/** The mouse is over an button. **/
mouse_over_button(event.motion.x,event.motion.y) ;
break ;
}
break ;
case SDL_MOUSEBUTTONDOWN :
if (event.button.button == SDL_BUTTON_LEFT && event.button.state == SDL_PRESSED) {
int8_t ret ;
if ( ! game_control->is_animation_running && ((ret=mouse_over_card(event.button.x,event.button.y)) != -1) ) {
if (game_control->player[ret].is_back_faced) {
/** We process an card returning aniation. **/
current_card = &game_control->player[ret] ;
game_control->GAME_STATUS = RETURN_A_CARD ;
break ;
}
else if (! game_control->player[ret].is_back_faced && game_control->GAME_STATUS != DRAG_CARD_ON) {
/** The user can drag an card. **/
dragging_card->card = &game_control->player[ret] ;
dragging_card->x = event.button.x - game_control->player[ret].x ;
dragging_card->y = event.button.y - game_control->player[ret].y ;
game_control->player[ret].is_moving = true ;
game_control->GAME_STATUS = DRAG_CARD_ON ;
game_control->cursor_type = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZEALL) ;
SDL_SetCursor(game_control->cursor_type) ;
break ;
}
}
else if ( ! game_control->is_animation_running && (ret = press_button(event.button.x,event.button.y)) != -1 ) {
/** The user press an button which is allowed. **/
do_change_game_status(ret) ;
break ;
}
}
case SDL_MOUSEBUTTONUP :
if ( game_control->GAME_STATUS == DRAG_CARD_ON) {
/** The user release an card he is dragging, so we process. **/
game_control->GAME_STATUS = DRAG_CARD_OFF ;
game_control->cursor_type = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW) ;
SDL_SetCursor(game_control->cursor_type) ;
}
break ;
}
}
return ;
}
int
main(int argc, char *argv[])
{
int i;
const char *color_cursor = NULL;
/* Enable standard application logging */
SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
/* Initialize test framework */
state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO);
if (!state) {
return 1;
}
for (i = 1; i < argc;) {
int consumed;
consumed = SDLTest_CommonArg(state, i);
if (consumed == 0) {
color_cursor = argv[i];
break;
}
if (consumed < 0) {
SDL_Log("Usage: %s %s\n", argv[0], SDLTest_CommonUsage(state));
quit(1);
}
i += consumed;
}
if (!SDLTest_CommonInit(state)) {
quit(2);
}
for (i = 0; i < state->num_windows; ++i) {
SDL_Renderer *renderer = state->renderers[i];
SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
SDL_RenderClear(renderer);
}
if (color_cursor) {
cursors[0] = init_color_cursor(color_cursor);
} else {
cursors[0] = init_system_cursor(arrow);
}
if (!cursors[0]) {
SDL_Log("Error, couldn't create cursor\n");
quit(2);
}
for (i = 0; i < SDL_NUM_SYSTEM_CURSORS; ++i) {
cursors[1+i] = SDL_CreateSystemCursor((SDL_SystemCursor)i);
if (!cursors[1+i]) {
SDL_Log("Error, couldn't create system cursor %d\n", i);
quit(2);
}
}
SDL_SetCursor(cursors[0]);
/* Main render loop */
done = 0;
#ifdef __EMSCRIPTEN__
emscripten_set_main_loop(loop, 0, 1);
#else
while (!done) {
loop();
}
#endif
for (i = 0; i < SDL_arraysize(cursors); ++i) {
SDL_FreeCursor(cursors[i]);
}
quit(0);
/* keep the compiler happy ... */
return(0);
}
void gathering_cards_animation(SDL_Renderer *pRenderer,SDL_Texture *card_back_face_texture,Vector distribute_cards[10][50],Anim_Cards *anim_cards_settings, int *sleep, _Bool invert) {
/** Gathering cards animation.
* The function need a Anim_Cards structure to control the animation.
* Each vector represent the current card postion.
* For each card their an Vector array from size depending from the length of the travel to reach the throw card frame.
* ********************************************************************************************************************/
if (game_control->GAME_STATUS == CLEAN_PLAYGROUND) {
if ((anim_cards_settings->step == 0) && (anim_cards_settings->card == 0)) {
/** First time this function is called:
* So we initialize the setting for an animation.
*************************************************/
*sleep=5250 ; /** We set the pausing time from the mainloop. **/
game_control->cursor_type = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_WAITARROW) ;
SDL_SetCursor(game_control->cursor_type) ;
game_control->is_animation_running = true ;
if (! invert) {
/** Case we gather the player card first. **/
game_control->player[0].card_is_throw = true ;
}
else {
/** Case we gather the computer card first. **/
game_control->computer[0].card_is_throw = true ;
}
}
anim_cards_settings->step++ ;
display_a_card_by_animation(pRenderer,card_back_face_texture ,distribute_cards[anim_cards_settings->card][anim_cards_settings->step]) ;
if ((anim_cards_settings->step == 50) && (anim_cards_settings->card == 0 )) {
/** The first card has reach the throw card frame.
* Even from the player or the computer hand first
* depending from the value from the boolean variable invert. **/
if (! bounding_boxes[5].is_frame_empty) {
/** Case the throw card heap was empty before. **/
bounding_boxes[5].is_frame_empty=false ;
}
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
anim_cards_settings->pos_to_fill++ ;
anim_cards_settings->cards_number++ ;
if (! invert) {
/** Case we gather the player card. **/
game_control->computer[0].card_is_throw = true ;
}
else {
/** Case we gather the computer card. **/
game_control->player[0].card_is_throw = true ;
}
}
else if ((anim_cards_settings->step == 50) && (anim_cards_settings->card == 1)) {
/** The first card has reach the throw card frame.
* Even from the player or the computer hand first
* depending from the value from the boolean variable invert. **/
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
*sleep=6375 ; /** We set the pausing time from the mainloop. **/
anim_cards_settings->cards_number++ ;
if (! invert) {
/** Case we gather the player card. **/
game_control->player[1].card_is_throw = true ;
}
else {
/** Case we gather the computer card. **/
game_control->computer[1].card_is_throw = true ;
}
}
else if ((anim_cards_settings->step == 40) && (anim_cards_settings->card == 2 )) {
/** The second card has reach the throw card frame.
* Even from the player or the computer hand first
* depending from the value from the boolean variable invert. **/
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
anim_cards_settings->pos_to_fill++ ;
anim_cards_settings->cards_number++ ;
if (! invert) {
/** Case we gather the player card first. **/
game_control->computer[1].card_is_throw = true ;
}
else {
/** Case we gather the computer card first. **/
game_control->player[1].card_is_throw = true ;
}
}
else if ((anim_cards_settings->step == 40) && (anim_cards_settings->card == 3)) {
/** The second card has reach the throw card frame.
* Even from the player or the computer hand first
* depending from the value from the boolean variable invert. **/
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
*sleep=7500 ; /** We set the pausing time from the mainloop. **/
anim_cards_settings->cards_number++ ;
if (! invert) {
/** Case we gather the player card. **/
game_control->player[2].card_is_throw = true ;
}
else {
/** Case we gather the computer card. **/
game_control->computer[2].card_is_throw = true ;
}
}
else if ((anim_cards_settings->step == 30) && (anim_cards_settings->card == 4)) {
/** The third card has reach the throw card frame.
* Even from the player or the computer hand first
* depending from the value from the boolean variable invert. **/
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
anim_cards_settings->cards_number++ ;
anim_cards_settings->pos_to_fill++ ;
if (! invert) {
/** Case we gather the player card. **/
game_control->computer[2].card_is_throw = true ;
}
else {
/** Case we gather the computer card. **/
game_control->player[2].card_is_throw = true ;
}
}
else if ((anim_cards_settings->step == 30) && (anim_cards_settings->card == 5)) {
/** The third card has reach the throw card frame.
* Even from the player or the computer hand first
* depending from the value from the boolean variable invert. **/
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
*sleep=10000 ; /** We set the pausing time from the mainloop. **/
anim_cards_settings->cards_number++ ;
if (! invert) {
/** Case we gather the player card. **/
game_control->player[3].card_is_throw = true ;
}
else {
/** Case we gather the computer card. **/
game_control->computer[3].card_is_throw = true ;
}
}
else if ((anim_cards_settings->step == 20) && (anim_cards_settings->card == 6 )) {
/** The fourth card has reach the throw card frame.
* Even from the player or the computer hand first
* depending from the value from the boolean variable invert. **/
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
anim_cards_settings->cards_number++ ;
anim_cards_settings->pos_to_fill++ ;
if (! invert) {
/** Case we gather the player card. **/
game_control->computer[3].card_is_throw = true ;
}
else {
/** Case we gather the computer card. **/
game_control->player[3].card_is_throw = true ;
}
}
else if ((anim_cards_settings->step == 20) && (anim_cards_settings->card == 7 )) {
/** The fourth card has reach the throw card frame.
* Even from the player or the computer hand first
* depending from the value from the boolean variable invert. **/
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
*sleep=12500 ; /** We set the pausing time from the mainloop. **/
anim_cards_settings->cards_number++ ;
if (! invert) {
/** Case we gather the player card. **/
game_control->player[4].card_is_throw = true ;
}
else {
/** Case we gather the computer card. **/
game_control->computer[4].card_is_throw = true ;
}
}
else if ((anim_cards_settings->step == 10) && (anim_cards_settings->card == 8)) {
/** The fives card has reach the throw card frame.
* Even from the player or the computer hand first
* depending from the value from the boolean variable invert. **/
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
anim_cards_settings->cards_number++ ;
anim_cards_settings->pos_to_fill++ ;
if (! invert) {
/** Case we gather the player card. **/
game_control->computer[4].card_is_throw = true ;
}
else {
/** Case we gather the computer card. **/
game_control->player[4].card_is_throw = true ;
}
}
else if ((anim_cards_settings->step == 10) && (anim_cards_settings->card == 9)) {
/** The fives card has reach the throw card frame.
* Even from the player or the computer hand first
* depending from the value from the boolean variable invert. **/
/** The animation is finish we process the settings. **/
game_control->GAME_STATUS=PLAYGROUND_CLEAN ;
anim_cards_settings->card=0 ;
anim_cards_settings->step=0 ;
*sleep=10000 ; /** We reset the pausing time from the mainloop on the default value. **/
anim_cards_settings->cards_number++ ;
}
}
display_throw_cards(pRenderer,card_back_face_texture) ;
return ;
}
/**
*rct2: 0x0068352C
*/
static void osinterface_load_cursors(){
RCT2_GLOBAL(0x14241BC, uint32) = 2;
HINSTANCE hInst = RCT2_GLOBAL(RCT2_ADDRESS_HINSTANCE, HINSTANCE);
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_ARROW, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x74));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_BLANK, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0xA1));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_UP_ARROW, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x6D));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_UP_DOWN_ARROW, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x6E));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_HAND_POINT, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x70));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_ZZZ, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x78));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_DIAGONAL_ARROWS, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x77));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_PICKER, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x7C));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_TREE_DOWN, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x83));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_FOUNTAIN_DOWN, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x7F));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_STATUE_DOWN, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x80));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_BENCH_DOWN, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x81));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_CROSS_HAIR, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x82));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_BIN_DOWN, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x84));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_LAMPPOST_DOWN, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x85));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_FENCE_DOWN, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x8A));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_FLOWER_DOWN, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x89));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_PATH_DOWN, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x8B));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_DIG_DOWN, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x8D));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_WATER_DOWN, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x8E));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_HOUSE_DOWN, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x8F));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_VOLCANO_DOWN, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x90));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_WALK_DOWN, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x91));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_PAINT_DOWN, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x9E));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_ENTRANCE_DOWN, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0x9F));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_HAND_OPEN, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0xA6));
RCT2_GLOBAL(RCT2_ADDRESS_HCURSOR_HAND_CLOSED, HCURSOR) = LoadCursor(hInst, MAKEINTRESOURCE(0xA5));
_cursors[0] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
_cursors[1] = SDL_CreateCursor(blank_cursor_data, blank_cursor_mask, 32, 32, BLANK_CURSOR_HOTX, BLANK_CURSOR_HOTY);
_cursors[2] = SDL_CreateCursor(up_arrow_cursor_data, up_arrow_cursor_mask, 32, 32, UP_ARROW_CURSOR_HOTX, UP_ARROW_CURSOR_HOTY);
_cursors[3] = SDL_CreateCursor(up_down_arrow_cursor_data, up_down_arrow_cursor_mask, 32, 32, UP_DOWN_ARROW_CURSOR_HOTX, UP_DOWN_ARROW_CURSOR_HOTY);
_cursors[4] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_HAND);
_cursors[5] = SDL_CreateCursor(zzz_cursor_data, zzz_cursor_mask, 32, 32, ZZZ_CURSOR_HOTX, ZZZ_CURSOR_HOTY);
_cursors[6] = SDL_CreateCursor(diagonal_arrow_cursor_data, diagonal_arrow_cursor_mask, 32, 32, DIAGONAL_ARROW_CURSOR_HOTX, DIAGONAL_ARROW_CURSOR_HOTY);
_cursors[7] = SDL_CreateCursor(picker_cursor_data, picker_cursor_mask, 32, 32, PICKER_CURSOR_HOTX, PICKER_CURSOR_HOTY);
_cursors[8] = SDL_CreateCursor(tree_down_cursor_data, tree_down_cursor_mask, 32, 32, TREE_DOWN_CURSOR_HOTX, TREE_DOWN_CURSOR_HOTY);
_cursors[9] = SDL_CreateCursor(fountain_down_cursor_data, fountain_down_cursor_mask, 32, 32, FOUNTAIN_DOWN_CURSOR_HOTX, FOUNTAIN_DOWN_CURSOR_HOTY);
_cursors[10] = SDL_CreateCursor(statue_down_cursor_data, statue_down_cursor_mask, 32, 32, STATUE_DOWN_CURSOR_HOTX, STATUE_DOWN_CURSOR_HOTY);
_cursors[11] = SDL_CreateCursor(bench_down_cursor_data, bench_down_cursor_mask, 32, 32, BENCH_DOWN_CURSOR_HOTX, BENCH_DOWN_CURSOR_HOTY);
_cursors[12] = SDL_CreateCursor(cross_hair_cursor_data, cross_hair_cursor_mask, 32, 32, CROSS_HAIR_CURSOR_HOTX, CROSS_HAIR_CURSOR_HOTY);
_cursors[13] = SDL_CreateCursor(bin_down_cursor_data, bin_down_cursor_mask, 32, 32, BIN_DOWN_CURSOR_HOTX, BIN_DOWN_CURSOR_HOTY);
_cursors[14] = SDL_CreateCursor(lamppost_down_cursor_data, lamppost_down_cursor_mask, 32, 32, LAMPPOST_DOWN_CURSOR_HOTX, LAMPPOST_DOWN_CURSOR_HOTY);
_cursors[15] = SDL_CreateCursor(fence_down_cursor_data, fence_down_cursor_mask, 32, 32, FENCE_DOWN_CURSOR_HOTX, FENCE_DOWN_CURSOR_HOTY);
_cursors[16] = SDL_CreateCursor(flower_down_cursor_data, flower_down_cursor_mask, 32, 32, FLOWER_DOWN_CURSOR_HOTX, FLOWER_DOWN_CURSOR_HOTY);
_cursors[17] = SDL_CreateCursor(path_down_cursor_data, path_down_cursor_mask, 32, 32, PATH_DOWN_CURSOR_HOTX, PATH_DOWN_CURSOR_HOTY);
_cursors[18] = SDL_CreateCursor(dig_down_cursor_data, dig_down_cursor_mask, 32, 32, DIG_DOWN_CURSOR_HOTX, DIG_DOWN_CURSOR_HOTY);
_cursors[19] = SDL_CreateCursor(water_down_cursor_data, water_down_cursor_mask, 32, 32, WATER_DOWN_CURSOR_HOTX, WATER_DOWN_CURSOR_HOTY);
_cursors[20] = SDL_CreateCursor(house_down_cursor_data, house_down_cursor_mask, 32, 32, HOUSE_DOWN_CURSOR_HOTX, HOUSE_DOWN_CURSOR_HOTY);
_cursors[21] = SDL_CreateCursor(volcano_down_cursor_data, volcano_down_cursor_mask, 32, 32, VOLCANO_DOWN_CURSOR_HOTX, VOLCANO_DOWN_CURSOR_HOTY);
_cursors[22] = SDL_CreateCursor(walk_down_cursor_data, walk_down_cursor_mask, 32, 32, WALK_DOWN_CURSOR_HOTX, WALK_DOWN_CURSOR_HOTY);
_cursors[23] = SDL_CreateCursor(paint_down_cursor_data, paint_down_cursor_mask, 32, 32, PAINT_DOWN_CURSOR_HOTX, PAINT_DOWN_CURSOR_HOTY);
_cursors[24] = SDL_CreateCursor(entrance_down_cursor_data, entrance_down_cursor_mask, 32, 32, ENTRANCE_DOWN_CURSOR_HOTX, ENTRANCE_DOWN_CURSOR_HOTY);
_cursors[25] = SDL_CreateCursor(hand_open_cursor_data, hand_open_cursor_mask, 32, 32, HAND_OPEN_CURSOR_HOTX, HAND_OPEN_CURSOR_HOTY);
_cursors[26] = SDL_CreateCursor(hand_closed_cursor_data, hand_closed_cursor_mask, 32, 32, HAND_CLOSED_CURSOR_HOTX, HAND_CLOSED_CURSOR_HOTY);
osinterface_set_cursor(CURSOR_ARROW);
RCT2_GLOBAL(0x14241BC, uint32) = 0;
}
void distribute_cards(SDL_Renderer *pRenderer,SDL_Texture *card_back_face_texture,Vector distribute_cards[10][50],Anim_Cards *anim_cards_settings, int *sleep, _Bool invert) {
/** Distribute cards animation.
* The function need a Anim_Cards structure to control the animation.
* Each vector represent the current card postion.
* For each card their an Vector array from size depending from the length of the travel to reach the throw card frame.
* ********************************************************************************************************************/
if (game_control->GAME_STATUS == CARDS_DISTRIBUTE) {
if ((anim_cards_settings->step == 0) && (anim_cards_settings->card == 0)) {
/** First time this function is called:
* So we initialize the setting for an animation.
*************************************************/
*sleep=12500 ;
game_control->cursor_type = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_WAITARROW) ;
SDL_SetCursor(game_control->cursor_type) ;
game_control->is_animation_running = true ;
}
/** Display the current card to throw during the animation. **/
display_a_card_by_animation(pRenderer,card_back_face_texture ,distribute_cards[anim_cards_settings->card][anim_cards_settings->step]) ;
anim_cards_settings->step++ ;
if ((anim_cards_settings->step == 10) && (anim_cards_settings->card == 0 )) {
/** The first card has reach his destination, even the player or the computer hand first
* depending from the value from the boolean variable invert. **/
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
anim_cards_settings->pos_to_fill++ ;
anim_cards_settings->cards_number++ ;
}
else if ((anim_cards_settings->step == 10) && (anim_cards_settings->card == 1)) {
/** The first card has reach his destination, even the player or the computer hand first
* depending from the value from the boolean variable invert. **/
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
/** The first card is distribute for the player and the computer
* so we set the sleep value for the next card animation. */
*sleep -= 2500 ;
anim_cards_settings->cards_number++ ;
}
else if ((anim_cards_settings->step == 20) && (anim_cards_settings->card == 2 )) {
/** The second card has reach his destination, even the player or the computer hand first
* depending from the value from the boolean variable invert. **/
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
anim_cards_settings->pos_to_fill++ ;
anim_cards_settings->cards_number++ ;
}
else if ((anim_cards_settings->step == 20) && (anim_cards_settings->card == 3)) {
/** The second card has reach his destination, even the player or the computer hand first
* depending from the value from the boolean variable invert. **/
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
/** The second card is distribute for the player and the computer
* so we set the sleep value for the next card animation. */
*sleep -= 2500 ;
anim_cards_settings->cards_number++ ;
}
else if ((anim_cards_settings->step == 30) && (anim_cards_settings->card == 4)) {
/** The third card has reach his destination, even the player or the computer hand first
* depending from the value from the boolean variable invert. **/
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
anim_cards_settings->cards_number++ ;
anim_cards_settings->pos_to_fill++ ;
}
else if ((anim_cards_settings->step == 30) && (anim_cards_settings->card == 5)) {
/** The third card has reach his destination, even the player or the computer hand first
* depending from the value from the boolean variable invert. **/
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
/** The third card is distribute for the player and the computer
* so we set the sleep value for the next card animation. */
*sleep -= 1125 ;
anim_cards_settings->cards_number++ ;
}
else if ((anim_cards_settings->step == 40) && (anim_cards_settings->card == 6 )) {
/** The fourth card has reach his destination, even the player or the computer hand first
* depending from the value from the boolean variable invert. **/
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
anim_cards_settings->cards_number++ ;
anim_cards_settings->pos_to_fill++ ;
}
else if ((anim_cards_settings->step == 40) && (anim_cards_settings->card == 7 )) {
/** The fourth card has reach his destination, even the player or the computer hand first
* depending from the value from the boolean variable invert. **/
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
/** The fourth card is distribute for the player and the computer
* so we set the sleep value for the next card animation. */
*sleep -= 1125 ;
anim_cards_settings->cards_number++ ;
}
else if ((anim_cards_settings->step == 50) && (anim_cards_settings->card == 8)) {
/** The fives card has reach his destination, even the player or the computer hand first
* depending from the value from the boolean variable invert. **/
anim_cards_settings->card++ ;
anim_cards_settings->step=0 ;
anim_cards_settings->cards_number++ ;
anim_cards_settings->pos_to_fill++ ;
}
else if ((anim_cards_settings->step == 50) && (anim_cards_settings->card == 9)) {
/** The fives card has reach his destination, even the player or the computer hand first
* depending from the value from the boolean variable invert. **/
/** The anilation has reach his end we reset the settings to play. **/
game_control->GAME_STATUS=CARDS_COVER ;
anim_cards_settings->card=0 ;
anim_cards_settings->step=0 ;
*sleep=10000 ;
anim_cards_settings->cards_number++ ;
game_control->cursor_type = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW) ;
SDL_SetCursor(game_control->cursor_type) ;
game_control->is_animation_running = false ;
}
}
if ( game_control->GAME_STATUS == CARDS_DISTRIBUTE ) {
/** Display the cards in relationship to which has reach the destination. **/
display_back_face_card(pRenderer,card_back_face_texture, anim_cards_settings->pos_to_fill, anim_cards_settings->cards_number, invert) ;
}
else if (game_control->GAME_STATUS == CARDS_COVER ) {
/** Display all cards returned **/
display_back_face_card(pRenderer,card_back_face_texture, 5, 10, invert) ;
anim_cards_settings->cards_number=0 ;
anim_cards_settings->pos_to_fill=0 ;
}
return ;
}
void Mouse::setCursor( const MouseCursor cursor )
{
SDL_SystemCursor cursorName(SDL_SYSTEM_CURSOR_ARROW);
switch(cursor)
{
case io::MouseCursor_Progress:
cursorName = SDL_SYSTEM_CURSOR_WAIT; break;
case io::MouseCursor_Custom:
case io::MouseCursor_ZoomIn:
case io::MouseCursor_ZoomOut:
case io::MouseCursor_Pointer:
case io::MouseCursor_Copy:
case io::MouseCursor_None:
case io::MouseCursor_VerticalText:
case io::MouseCursor_Cell:
case io::MouseCursor_ContextMenu:
case io::MouseCursor_Alias:
cursorName = SDL_SYSTEM_CURSOR_ARROW; break;
case io::MouseCursor_Cross:
cursorName = SDL_SYSTEM_CURSOR_CROSSHAIR; break;
case io::MouseCursor_Grab:
case io::MouseCursor_Grabbing:
case io::MouseCursor_Hand:
cursorName = SDL_SYSTEM_CURSOR_HAND; break;
case io::MouseCursor_Help:
cursorName = SDL_SYSTEM_CURSOR_ARROW; break;
case io::MouseCursor_IBeam:
cursorName = SDL_SYSTEM_CURSOR_IBEAM; break;
case io::MouseCursor_NoDrop:
case io::MouseCursor_NotAllowed:
cursorName = SDL_SYSTEM_CURSOR_NO; break;
case io::MouseCursor_Move:
case io::MouseCursor_MiddlePanning:
case io::MouseCursor_EastPanning:
case io::MouseCursor_WestPanning:
case io::MouseCursor_NorthPanning:
case io::MouseCursor_SouthPanning:
case io::MouseCursor_NorthEastPanning:
case io::MouseCursor_SouthWestPanning:
case io::MouseCursor_NorthWestPanning:
case io::MouseCursor_SouthEastPanning:
cursorName = SDL_SYSTEM_CURSOR_SIZEALL; break;
case io::MouseCursor_NorthEastSouthWestResize:
case io::MouseCursor_NorthEastResize:
case io::MouseCursor_SouthWestResize:
cursorName = SDL_SYSTEM_CURSOR_SIZENESW; break;
case io::MouseCursor_NorthSouthResize:
case io::MouseCursor_NorthResize:
case io::MouseCursor_RowResize:
case io::MouseCursor_SouthResize:
cursorName = SDL_SYSTEM_CURSOR_SIZENS; break;
case io::MouseCursor_NorthWestResize:
case io::MouseCursor_NorthWestSouthEastResize:
case io::MouseCursor_SouthEastResize:
cursorName = SDL_SYSTEM_CURSOR_SIZENWSE; break;
case io::MouseCursor_EastWestResize:
case io::MouseCursor_EastResize:
case io::MouseCursor_ColumnResize:
case io::MouseCursor_WestResize:
cursorName = SDL_SYSTEM_CURSOR_SIZEWE; break;
case io::MouseCursor_Wait:
cursorName = SDL_SYSTEM_CURSOR_WAITARROW; break;
default:
LOG(LogType_ProgrammerAssert, "Unknow mouse cursor %d", cursor);
}
SDL_Cursor* oldCursor(m_Cursor);
m_Cursor = SDL_CreateSystemCursor(cursorName);
SDL_SetCursor(m_Cursor);
if (oldCursor != nullptr)
SDL_FreeCursor(oldCursor);
}
