458 lines
13 KiB
C++
458 lines
13 KiB
C++
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#include "stdpch.h"
|
|
#include "custom_mouse.h"
|
|
//
|
|
#include "../global.h"
|
|
#include "../input.h"
|
|
#include "input_handler_manager.h"
|
|
|
|
|
|
CCustomMouse CustomMouse;
|
|
|
|
using namespace NLMISC;
|
|
using namespace NL3D;
|
|
|
|
#ifdef NL_OS_WINDOWS
|
|
|
|
// *************************************************************************************
|
|
CCustomMouse::CCursor::CCursor() : ColorDepth(CCustomMouse::ColorDepth32),
|
|
OrigHeight(32),
|
|
HotspotScale(1.f),
|
|
HotspotOffsetX(0),
|
|
HotspotOffsetY(0),
|
|
HotSpotX(0),
|
|
HotSpotY(0),
|
|
Icon(0),
|
|
Col(CRGBA::White),
|
|
Rot(0)
|
|
{
|
|
}
|
|
|
|
// *************************************************************************************
|
|
CCustomMouse::CCursor::~CCursor()
|
|
{
|
|
if (Icon)
|
|
{
|
|
DestroyIcon(Icon);
|
|
}
|
|
}
|
|
|
|
// *************************************************************************************
|
|
CCustomMouse::CCustomMouse()
|
|
{
|
|
_ColorDepth = CCustomMouse::ColorDepth32;
|
|
_DefaultCursor = LoadCursor(NULL, IDC_ARROW);
|
|
_AlphaBlendedCursorSupported = false;
|
|
_AlphaBlendedCursorSupportRetrieved = false;
|
|
_CurrCol = CRGBA::White;
|
|
_CurrRot = 0;
|
|
_CurrHotSpotX = 0;
|
|
_CurrHotSpotY = 0;
|
|
}
|
|
|
|
|
|
|
|
// *************************************************************************************
|
|
bool CCustomMouse::isAlphaBlendedCursorSupported()
|
|
{
|
|
if (!_AlphaBlendedCursorSupportRetrieved)
|
|
{
|
|
// Support starts with windows 2000 (not only from XP as seen in most docs)
|
|
// NB : Additionnaly, could query D3D caps to know if
|
|
// color hardware cursor is supported, not only emulated,
|
|
// but can't be sure that using the win32 api 'SetCursor' uses the same resources
|
|
// So far, seems to be supported on any modern card used by the game anyway ...
|
|
OSVERSIONINFO osvi;
|
|
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
|
|
if (GetVersionEx(&osvi))
|
|
{
|
|
_AlphaBlendedCursorSupported = (osvi.dwMajorVersion >= 5);
|
|
}
|
|
_AlphaBlendedCursorSupportRetrieved = true;
|
|
}
|
|
return _AlphaBlendedCursorSupported;
|
|
}
|
|
|
|
bool VerboseCursorRT12516 = true;
|
|
|
|
namespace NLMISC
|
|
{
|
|
extern bool TempMaxVerboseResample;
|
|
}
|
|
|
|
// *************************************************************************************
|
|
void CCustomMouse::addCursor(const std::string &name, const NLMISC::CBitmap &cursorBitmap)
|
|
{
|
|
if (!isAlphaBlendedCursorSupported()) return;
|
|
nlassert(cursorBitmap.getWidth() != 0);
|
|
nlassert(cursorBitmap.getHeight() != 0);
|
|
// find used part base on alpha, to avoid too much shrinking
|
|
const CRGBA *pixels = (const CRGBA *) &cursorBitmap.getPixels()[0];
|
|
uint minX, maxX, minY, maxY;
|
|
uint width = cursorBitmap.getWidth();
|
|
uint height = cursorBitmap.getHeight();
|
|
//
|
|
minX = 0;
|
|
for (uint x = 0; x < width; ++x)
|
|
{
|
|
bool stop = false;
|
|
minX = x;
|
|
for (uint y = 0; y < height; ++y)
|
|
{
|
|
if(pixels[x + y * width].A != 0)
|
|
{
|
|
stop = true;
|
|
break;
|
|
}
|
|
}
|
|
if (stop) break;
|
|
}
|
|
//
|
|
maxX = width - 1;
|
|
for (sint x = width - 1; x >= 0; --x)
|
|
{
|
|
bool stop = false;
|
|
maxX = (uint) x;
|
|
for (uint y = 0; y < height; ++y)
|
|
{
|
|
if(pixels[x + y * width].A != 0)
|
|
{
|
|
stop = true;
|
|
break;
|
|
}
|
|
}
|
|
if (stop) break;
|
|
}
|
|
//
|
|
minY = 0;
|
|
for (uint y = 0; y < height; ++y)
|
|
{
|
|
bool stop = false;
|
|
minY = y;
|
|
for (uint x = 0; x < width; ++x)
|
|
{
|
|
if(pixels[x + y * width].A != 0)
|
|
{
|
|
stop = true;
|
|
break;
|
|
}
|
|
}
|
|
if (stop) break;
|
|
}
|
|
//
|
|
maxY = height - 1;
|
|
for (sint y = height - 1; y >= 0; --y)
|
|
{
|
|
bool stop = false;
|
|
maxY = (uint) y;
|
|
for (uint x = 0; x < width; ++x)
|
|
{
|
|
if(pixels[x + y * width].A != 0)
|
|
{
|
|
stop = true;
|
|
break;
|
|
}
|
|
}
|
|
if (stop) break;
|
|
}
|
|
//
|
|
CCursor &curs = _Cursors[name];
|
|
curs = CCursor(); // erase possible previous cursor
|
|
|
|
uint destWidth = GetSystemMetrics(SM_CXCURSOR);
|
|
uint destHeight = GetSystemMetrics(SM_CYCURSOR);
|
|
// build a square bitmap
|
|
uint tmpSize = std::max(maxX - minX + 1, maxY - minY + 1);
|
|
curs.Src.resize(tmpSize, tmpSize),
|
|
// blit at top left corner
|
|
curs.Src.blit(cursorBitmap, minX, minY, maxX - minX + 1, maxY - minY + 1, 0, 0);
|
|
|
|
curs.OrigHeight = cursorBitmap.getHeight();
|
|
curs.HotspotOffsetX = minX;
|
|
curs.HotspotOffsetY = minY;
|
|
//
|
|
curs.HotspotScale = ClientCfg.HardwareCursorScale;
|
|
clamp(curs.HotspotScale, 0.f, 1.f);
|
|
// first resampling, same for all cursors
|
|
tmpSize = (uint) (tmpSize * curs.HotspotScale);
|
|
if (tmpSize == 0) tmpSize = 1;
|
|
|
|
if (VerboseCursorRT12516 && ((name == "curs_stop.tga") || (name == "curs_pick_dup.tga")))
|
|
TempMaxVerboseResample = true;
|
|
|
|
if (TempMaxVerboseResample)
|
|
{
|
|
try
|
|
{
|
|
//nldebug("RT12516: BEFORE FIRST RESAMPLE");
|
|
//nldebug("RT12516: %s: curs=%p curs.Src=%p curs.Src.PixelPtr=%p", name.c_str(), &curs, &(curs.Src), &curs.Src.getPixels(0)[0]);
|
|
//nldebug("RT12516: %s: curs.Src.PixelSize=%u", name.c_str(), curs.Src.getPixels(0).size());
|
|
}
|
|
catch (...)
|
|
{
|
|
//nldebug("RT12516: An exception occurred!");
|
|
}
|
|
}
|
|
|
|
// TMP for RT 12406
|
|
/* nlwarning("Resampling mouse %s cursor : initial size = %d x %d, new size = %d x %d",
|
|
name.c_str(),
|
|
curs.Src.getWidth(),
|
|
curs.Src.getHeight(),
|
|
tmpSize,
|
|
tmpSize
|
|
);*/
|
|
curs.Src.resample(tmpSize, tmpSize);
|
|
|
|
if (TempMaxVerboseResample)
|
|
{
|
|
try
|
|
{
|
|
//nldebug("RT12516: AFTER FIRST RESAMPLE");
|
|
//nldebug("RT12516: %s: curs=%p curs.Src=%p curs.Src.PixelPtr=%p", name.c_str(), &curs, &(curs.Src), &curs.Src.getPixels(0)[0]);
|
|
//nldebug("RT12516: %s: curs.Src.PixelSize=%u", name.c_str(), curs.Src.getPixels(0).size());
|
|
}
|
|
catch (...)
|
|
{
|
|
//nldebug("RT12516: An exception occurred!");
|
|
}
|
|
}
|
|
|
|
// shrink if necessary
|
|
if (tmpSize > destWidth || tmpSize > destHeight) // need to shrink ?
|
|
{
|
|
// constraint proportions
|
|
curs.HotspotScale *= std::min(float(destWidth) / tmpSize, float(destHeight) / tmpSize);
|
|
// TMP for RT 12406
|
|
/* nlwarning("Resampling mouse %s cursor : initial size = %d x %d, new size = %d x %d",
|
|
name.c_str(),
|
|
curs.Src.getWidth(),
|
|
curs.Src.getHeight(),
|
|
destWidth,
|
|
destHeight
|
|
);*/
|
|
curs.Src.resample(destWidth, destHeight);
|
|
}
|
|
else
|
|
{
|
|
CBitmap final;
|
|
final.resize(destWidth, destHeight);
|
|
final.blit(&curs.Src, 0, 0);
|
|
curs.Src.swap(final);
|
|
}
|
|
|
|
if (TempMaxVerboseResample)
|
|
{
|
|
try
|
|
{
|
|
//nldebug("RT12516: AFTER SECOND RESAMPLE");
|
|
//nldebug("RT12516: %s: curs=%p curs.Src=%p curs.Src.PixelPtr=%p", name.c_str(), &curs, &(curs.Src), &curs.Src.getPixels(0)[0]);
|
|
//nldebug("RT12516: %s: curs.Src.PixelSize=%u", name.c_str(), curs.Src.getPixels(0).size());
|
|
}
|
|
catch (...)
|
|
{
|
|
//nldebug("RT12516: An exception occurred!");
|
|
}
|
|
}
|
|
|
|
if (name == _CurrName)
|
|
{
|
|
updateCursor();
|
|
}
|
|
TempMaxVerboseResample = false;
|
|
}
|
|
|
|
|
|
// *************************************************************************************
|
|
void CCustomMouse::release()
|
|
{
|
|
if (!isAlphaBlendedCursorSupported()) return;
|
|
nlassert(Driver);
|
|
HWND drvWnd = Driver->getDisplay();
|
|
if (drvWnd)
|
|
{
|
|
SetClassLongPtr(drvWnd, GCLP_HCURSOR, 0);
|
|
}
|
|
_Cursors.clear();
|
|
}
|
|
|
|
// *************************************************************************************
|
|
void CCustomMouse::setColorDepth(TColorDepth colorDepth)
|
|
{
|
|
if (colorDepth == _ColorDepth) return;
|
|
_ColorDepth = colorDepth;
|
|
updateCursor(true);
|
|
}
|
|
|
|
// *************************************************************************************
|
|
void CCustomMouse::updateCursor(bool forceRebuild)
|
|
{
|
|
if (!Driver) return;
|
|
setCursor(_CurrName, _CurrCol, _CurrRot, _CurrHotSpotX, _CurrHotSpotY, forceRebuild);
|
|
}
|
|
|
|
// *************************************************************************************
|
|
void CCustomMouse::setCursor(const std::string &name, NLMISC::CRGBA col, uint8 rot, sint hotSpotX, sint hotSpotY, bool forceRebuild)
|
|
{
|
|
if (!isAlphaBlendedCursorSupported()) return;
|
|
_CurrName = name;
|
|
_CurrCol = col;
|
|
_CurrRot = rot;
|
|
_CurrHotSpotX = hotSpotX;
|
|
_CurrHotSpotY = hotSpotY;
|
|
//
|
|
if (rot > 3) rot = 3; // same than 'CViewRenderer::drawRotFlipBitmapTiled
|
|
TIconMap::iterator it = _Cursors.find(name);
|
|
HCURSOR cursorHandle = _DefaultCursor;
|
|
if (it != _Cursors.end())
|
|
{
|
|
// Update cursor if modified or not already built
|
|
CCursor &curs = it->second;
|
|
hotSpotX = (sint) (curs.HotspotScale * (hotSpotX - curs.HotspotOffsetX));
|
|
hotSpotY = (sint) (curs.HotspotScale * ((curs.OrigHeight - hotSpotY) - curs.HotspotOffsetY));
|
|
if (curs.Icon == 0 ||
|
|
curs.HotSpotX != hotSpotX ||
|
|
curs.HotSpotY != hotSpotY ||
|
|
curs.Col != col ||
|
|
curs.Rot != rot ||
|
|
curs.ColorDepth != _ColorDepth ||
|
|
forceRebuild
|
|
)
|
|
{
|
|
if (curs.Icon != 0)
|
|
{
|
|
DestroyIcon(curs.Icon);
|
|
}
|
|
curs.Icon = buildCursor(curs.Src, col, rot, hotSpotX, hotSpotY);
|
|
curs.Col = col;
|
|
curs.Rot = rot;
|
|
curs.HotSpotX = hotSpotX;
|
|
curs.HotSpotY = hotSpotY;
|
|
curs.ColorDepth = _ColorDepth;
|
|
}
|
|
cursorHandle = curs.Icon ? (HCURSOR) curs.Icon : _DefaultCursor;
|
|
}
|
|
if (IsSystemCursorInClientArea() || IsSystemCursorCaptured() || forceRebuild)
|
|
{
|
|
if (CInputHandlerManager::getInstance()->hasFocus())
|
|
{
|
|
::SetCursor(cursorHandle);
|
|
HWND drvWnd = Driver->getDisplay();
|
|
if (drvWnd)
|
|
{
|
|
SetClassLongPtr(drvWnd, GCLP_HCURSOR, (LONG_PTR) cursorHandle); // set default mouse icon to the last one
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// *************************************************************************************
|
|
HICON CCustomMouse::buildCursor(const CBitmap &src, NLMISC::CRGBA col, uint8 rot, sint hotSpotX, sint hotSpotY)
|
|
{
|
|
nlassert(isAlphaBlendedCursorSupported());
|
|
uint mouseW = GetSystemMetrics(SM_CXCURSOR);
|
|
uint mouseH = GetSystemMetrics(SM_CYCURSOR);
|
|
nlassert(src.getWidth() == mouseW);
|
|
nlassert(src.getHeight() == mouseH);
|
|
CBitmap rotSrc = src;
|
|
if (rot > 3) rot = 3; // mimic behavior of 'CViewRenderer::drawRotFlipBitmapTiled' (why not rot & 3 ??? ...)
|
|
switch(rot)
|
|
{
|
|
case 0: break;
|
|
case 1: rotSrc.rot90CW(); break;
|
|
case 2: rotSrc.rot90CW(); rotSrc.rot90CW(); break;
|
|
case 3: rotSrc.rot90CCW(); break;
|
|
}
|
|
return rotSrc.getHICON(mouseW, mouseH, _ColorDepth == ColorDepth16 ? 16:32, col, hotSpotX, hotSpotY, true);
|
|
}
|
|
|
|
|
|
// *************************************************************************************
|
|
void CCustomMouse::setSystemArrow()
|
|
{
|
|
extern HINSTANCE HInstance;
|
|
HCURSOR arrow = LoadCursor(NULL, IDC_ARROW);
|
|
if (IsSystemCursorInClientArea() || IsSystemCursorCaptured())
|
|
{
|
|
::SetCursor(arrow);
|
|
}
|
|
HWND drvWnd = Driver->getDisplay();
|
|
if (drvWnd)
|
|
{
|
|
SetClassLongPtr(drvWnd, GCLP_HCURSOR, (LONG_PTR) arrow); // set default mouse icon to the last one
|
|
}
|
|
}
|
|
|
|
#else
|
|
|
|
// not implemented yet for other OS
|
|
|
|
// *************************************************************************************
|
|
CCustomMouse::CCustomMouse()
|
|
{
|
|
// NOT IMPLEMENTED
|
|
}
|
|
|
|
// *************************************************************************************
|
|
void CCustomMouse::setCursor(const std::string &name, NLMISC::CRGBA col, uint8 rot, sint hotSpotX, sint hotSpotY, bool forceRebuild)
|
|
{
|
|
// NOT IMPLEMENTED
|
|
}
|
|
|
|
// *************************************************************************************
|
|
void CCustomMouse::release()
|
|
{
|
|
// NOT IMPLEMENTED
|
|
}
|
|
|
|
// *************************************************************************************
|
|
bool CCustomMouse::isAlphaBlendedCursorSupported()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// *************************************************************************************
|
|
void CCustomMouse::setSystemArrow()
|
|
{
|
|
//
|
|
}
|
|
|
|
void CCustomMouse::addCursor(const std::string &name, const NLMISC::CBitmap &cursorBitmap)
|
|
{
|
|
// TODO for Linux
|
|
}
|
|
|
|
// *************************************************************************************
|
|
void CCustomMouse::setColorDepth(TColorDepth colorDepth)
|
|
{
|
|
// TODO for Linux
|
|
}
|
|
|
|
// *************************************************************************************
|
|
void CCustomMouse::updateCursor(bool forceRebuild)
|
|
{
|
|
// TODO for Linux
|
|
}
|
|
|
|
#endif // NL_OS_WINDOWS
|
|
|
|
|
|
|
|
|
|
|