Cursor::Cursor(image::ImageData *data, int hotx, int hoty)
: cursor(nullptr)
, type(CURSORTYPE_IMAGE)
, systemType(CURSOR_MAX_ENUM)
{
Uint32 rmask, gmask, bmask, amask;
#ifdef LOVE_BIG_ENDIAN
rmask = 0xFF000000;
gmask = 0x00FF0000;
bmask = 0x0000FF00;
amask = 0x000000FF;
#else
rmask = 0x000000FF;
gmask = 0x0000FF00;
bmask = 0x00FF0000;
amask = 0xFF000000;
#endif
int w = data->getWidth();
int h = data->getHeight();
int pitch = w * 4;
SDL_Surface *surface = SDL_CreateRGBSurfaceFrom(data->getData(), w, h, 32, pitch, rmask, gmask, bmask, amask);
if (!surface)
throw love::Exception("Cannot create cursor: out of memory!");
cursor = SDL_CreateColorCursor(surface, hotx, hoty);
SDL_FreeSurface(surface);
if (!cursor)
throw love::Exception("Cannot create cursor: %s", SDL_GetError());
}
static SDL_Cursor*
init_color_cursor(const char *file)
{
SDL_Cursor *cursor = NULL;
SDL_Surface *surface = SDL_LoadBMP(file);
if (surface) {
if (surface->format->palette) {
SDL_SetColorKey(surface, 1, *(Uint8 *) surface->pixels);
} else {
switch (surface->format->BitsPerPixel) {
case 15:
SDL_SetColorKey(surface, 1, (*(Uint16 *)surface->pixels) & 0x00007FFF);
break;
case 16:
SDL_SetColorKey(surface, 1, *(Uint16 *)surface->pixels);
break;
case 24:
SDL_SetColorKey(surface, 1, (*(Uint32 *)surface->pixels) & 0x00FFFFFF);
break;
case 32:
SDL_SetColorKey(surface, 1, *(Uint32 *)surface->pixels);
break;
}
}
cursor = SDL_CreateColorCursor(surface, 0, 0);
SDL_FreeSurface(surface);
}
return cursor;
}
/**
* @brief Check call to SDL_CreateColorCursor and SDL_FreeCursor
*
* @sa http://wiki.libsdl.org/moin.cgi/SDL_CreateColorCursor
* @sa http://wiki.libsdl.org/moin.cgi/SDL_FreeCursor
*/
int
mouse_createFreeColorCursor(void *arg)
{
SDL_Surface *face;
SDL_Cursor *cursor;
/* Get sample surface */
face = SDLTest_ImageFace();
SDLTest_AssertCheck(face != NULL, "Validate sample input image is not NULL");
if (face == NULL) return TEST_ABORTED;
/* Create a color cursor from surface */
cursor = SDL_CreateColorCursor(face, 0, 0);
SDLTest_AssertPass("Call to SDL_CreateColorCursor()");
SDLTest_AssertCheck(cursor != NULL, "Validate result from SDL_CreateColorCursor() is not NULL");
if (cursor == NULL) {
SDL_FreeSurface(face);
return TEST_ABORTED;
}
/* Free cursor again */
SDL_FreeCursor(cursor);
SDLTest_AssertPass("Call to SDL_FreeCursor()");
/* Clean up */
SDL_FreeSurface(face);
return TEST_COMPLETED;
}
bool Menu::Init()
{
if( SDL_Init( SDL_INIT_EVERYTHING ) < 0 )
{
printf( "SDL could not initialize! SDL_Error: %s\n", SDL_GetError() );
return false;
}
//Create window
Window = SDL_CreateWindow( "Menu", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 640, 480
, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE );
if( Window == NULL )
{
printf( "Window could not be created! SDL_Error: %s\n", SDL_GetError() );
return false;
}
SDL_SetWindowMinimumSize(Window, 640, 480);
SDL_GetWindowSize(Window, &WINDOW_WIDTH, &WINDOW_HEIGHT);
Icon = IMG_Load("icon.png");
if(Icon == NULL)
{
printf( "Icon could not be loaded! SDL_Error: %s\n", SDL_GetError() );
return false;
}
SDL_SetWindowIcon(Window, Icon);
Renderer = SDL_CreateRenderer(Window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if(Renderer == NULL) {
printf( "Renderer could not be created! SDL_Error: %s\n", SDL_GetError() );
return false;
}
cursorSurf = IMG_Load("cursor.png");
if(cursorSurf == NULL)
{
printf( "Cursor image could not be loaded! SDL_Error: %s\n", SDL_GetError() );
return false;
}
cursor = SDL_CreateColorCursor(cursorSurf, 0, 0);
if(cursor == NULL)
{
printf( "Cursor could not be created! SDL_Error: %s\n", SDL_GetError() );
return false;
}
SDL_SetCursor(cursor);
Background = LoadKartinka("tank_back.png", Renderer);
single_Player.load(Renderer, "single.png", 265, 116);
two_Players.load(Renderer, "two.png", 265, 116);
exit.load(Renderer, "exit.png", 265, 116);
return true;
}
/* utility function mostly a copy of SDL_CreateCursor but allows us to change
* color and supports blenders flipped bits */
static SDL_Cursor *
sdl_ghost_CreateCursor(const Uint8 *data,
const Uint8 *mask,
int w,
int h,
int hot_x,
int hot_y)
{
SDL_Surface *surface;
SDL_Cursor *cursor;
int x, y;
Uint32 *pixel;
Uint8 datab = 0, maskb = 0;
const Uint32 black = 0xFF000000;
const Uint32 white = 0xFFFFFFFF;
const Uint32 transparent = 0x00000000;
/* Make sure the width is a multiple of 8 */
w = ((w + 7) & ~7);
/* Create the surface from a bitmap */
surface = SDL_CreateRGBSurface(0, w, h, 32,
0x00FF0000,
0x0000FF00,
0x000000FF,
0xFF000000);
if (!surface) {
return NULL;
}
for (y = 0; y < h; ++y) {
pixel = (Uint32 *) ((Uint8 *) surface->pixels + y * surface->pitch);
for (x = 0; x < w; ++x) {
if ((x % 8) == 0) {
datab = *data++;
maskb = *mask++;
/* reverse bit order */
datab = (datab * 0x0202020202ULL & 0x010884422010ULL) % 1023;
maskb = (maskb * 0x0202020202ULL & 0x010884422010ULL) % 1023;
}
if (maskb & 0x80) {
*pixel++ = (datab & 0x80) ? white : black;
}
else {
*pixel++ = (datab & 0x80) ? white : transparent;
}
datab <<= 1;
maskb <<= 1;
}
}
cursor = SDL_CreateColorCursor(surface, hot_x, hot_y);
SDL_FreeSurface(surface);
return cursor;
}
static SDL_Cursor*
init_color_cursor(const char *file)
{
SDL_Cursor *cursor = NULL;
SDL_Surface *surface = SDL_LoadBMP(file);
if (surface) {
cursor = SDL_CreateColorCursor(surface, 0, 0);
SDL_FreeSurface(surface);
}
return cursor;
}
bool Game::LoadContent()
{
///TEXTURES
handSurf = IMG_Load("./Resources/Images/cursor.png");
if(handSurf == NULL)
return false;
hand = SDL_CreateColorCursor(handSurf, 0, 0);
if(hand == NULL)
return false;
SDL_SetCursor(hand);
empty_layer.Tileset_Image = OnLoad(Renderer, TILESET);
empty_layer.Hover_Image = OnLoad(Renderer, TILESET);
Character.Image = OnLoad(Renderer, "./Resources/Images/ogre.png");
if(empty_layer.Hover_Image == NULL)
{
return false;
}
if(empty_layer.Tileset_Image == NULL)
{
return false;
}
if(Character.Image == NULL)
{
return false;
}
SDL_SetTextureAlphaMod(empty_layer.Hover_Image, 100);
///MAPS
empty_layer.loadMap.open("./Resources/empty_layer100x100.layer");
if(empty_layer.LoadTileSet() == false)
{
cout<<"Map not loaded"<<endl;
Sleep(1000);
return false;
}
return true;
}
int Surface::createColorCursor(State & state, SDL_Surface * surface){
Stack * stack = state.stack;
Cursor * interfaceCursor = state.getInterface<Cursor>("LuaSDL_Cursor");
interfaceCursor->push(
SDL_CreateColorCursor(
surface,
stack->to<int>(1),
stack->to<int>(2)
), true
);
return 1;
}
bool Cursor::createFromSurface(const Surface &surface, const Point &p)
{
SDL_Cursor *created = SDL_CreateColorCursor(surface, p.x, p.y);
if (!created)
{
Error() << "creating cursor from surface: " << SDL_GetError();
}
else
{
load(created);
}
return created;
}
void
sdl_set_cursor(const sprite_t *sprite)
{
if (NULL != cursor) {
SDL_SetCursor(NULL);
SDL_FreeCursor(cursor);
}
if (NULL == sprite) {
return;
}
SDL_Surface *surface = create_transp_surface(sprite, 0);
cursor = SDL_CreateColorCursor(surface, 8, 8);
SDL_SetCursor(cursor);
}
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_);
}
}
void
sdl_set_cursor(const sprite_t *sprite)
{
if (cursor != NULL) {
SDL_SetCursor(NULL);
SDL_FreeCursor(cursor);
cursor = NULL;
}
if (sprite == NULL) return;
SDL_Surface *surface = create_surface_from_sprite(sprite);
cursor = SDL_CreateColorCursor(surface, 8, 8);
SDL_SetCursor(cursor);
}
bool I_SetCursor(FTexture *cursorpic)
{
static SDL_Cursor *cursor;
static SDL_Surface *cursorSurface;
if (cursorpic != NULL && cursorpic->UseType != ETextureType::Null)
{
// Must be no larger than 32x32.
if (cursorpic->GetWidth() > 32 || cursorpic->GetHeight() > 32)
{
return false;
}
if (cursorSurface == NULL)
cursorSurface = SDL_CreateRGBSurface (0, 32, 32, 32, MAKEARGB(0,255,0,0), MAKEARGB(0,0,255,0), MAKEARGB(0,0,0,255), MAKEARGB(255,0,0,0));
SDL_LockSurface(cursorSurface);
uint8_t buffer[32*32*4];
memset(buffer, 0, 32*32*4);
FBitmap bmp(buffer, 32*4, 32, 32);
cursorpic->CopyTrueColorPixels(&bmp, 0, 0);
memcpy(cursorSurface->pixels, bmp.GetPixels(), 32*32*4);
SDL_UnlockSurface(cursorSurface);
if (cursor)
SDL_FreeCursor (cursor);
cursor = SDL_CreateColorCursor (cursorSurface, 0, 0);
SDL_SetCursor (cursor);
}
else
{
if (cursor)
{
SDL_SetCursor (NULL);
SDL_FreeCursor (cursor);
cursor = NULL;
}
if (cursorSurface != NULL)
{
SDL_FreeSurface(cursorSurface);
cursorSurface = NULL;
}
}
return true;
}
void SDLCursorManager::_createCursorFromResource(const std::string& name, int rotDegrees, osg::Image* image, Uint8 size_x, Uint8 size_y, Uint8 hotspot_x, Uint8 hotspot_y)
{
if (mCursorMap.find(name) != mCursorMap.end())
return;
osg::ref_ptr<osg::Image> decompressed = decompress(image, static_cast<float>(rotDegrees));
SDL_Surface* surf = SDLUtil::imageToSurface(decompressed, false);
//set the cursor and store it for later
SDL_Cursor* curs = SDL_CreateColorCursor(surf, hotspot_x, hotspot_y);
mCursorMap.insert(CursorMap::value_type(std::string(name), curs));
//clean up
SDL_FreeSurface(surf);
_setGUICursor(name);
}
/**
init_system_ColorCursor()-- Create a colored mouse cursor image
*/
SDL_Cursor *init_system_ColorCursor(CURSOR cur, const char *fileName)
{
iV_Image *psSprite = (iV_Image *)malloc(sizeof(iV_Image));
if (!psSprite)
{
debug(LOG_FATAL, "Could not allocate memory for cursor sprite. Exiting.");
exit(-1);
}
if (!iV_loadImage_PNG(fileName, psSprite))
{
debug(LOG_FATAL, "Could not load cursor sprite. Exiting.");
exit(-1);
}
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
uint32_t rmask = 0xff000000;
uint32_t gmask = 0x00ff0000;
uint32_t bmask = 0x0000ff00;
uint32_t amask = 0x000000ff;
#else
uint32_t rmask = 0x000000ff;
uint32_t gmask = 0x0000ff00;
uint32_t bmask = 0x00ff0000;
uint32_t amask = 0xff000000;
#endif
SDL_Surface *surface = SDL_CreateRGBSurfaceFrom(psSprite->bmp, psSprite->width, psSprite->height, psSprite->depth * 8, psSprite->width * 4, rmask, gmask, bmask, amask);
SDL_Cursor *pointer = SDL_CreateColorCursor(surface, psSprite->width / 2, psSprite->height / 2); // We center the hotspot for all (FIXME ?)
if (!pointer)
{
debug(LOG_FATAL, "Could not create cursor because %s", SDL_GetError());
exit(-1);
}
// free up image & surface data
free(psSprite->bmp);
free(psSprite);
SDL_FreeSurface(surface);
return pointer;
}
