nel/src/3d/driver/direct3d/driver_direct3d_inputs.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010-2020  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "stddirect3d.h"
  18 #include "driver_direct3d.h"
  19
  20 #ifdef DEBUG_NEW
  21 #define new DEBUG_NEW
  22 #endif
  23
  24 using namespace std;
  25 using namespace NLMISC;
  26
  27 namespace NL3D
  28 {
  29
  30 // *************************************************************************************
  31 CDriverD3D::CCursor::CCursor() : ColorDepth(CDriverD3D::ColorDepth32),
  32                                                                 OrigHeight(32),
  33                                                                 HotspotScale(1.f),
  34                                                                 HotspotOffsetX(0),
  35                                                                 HotspotOffsetY(0),
  36                                                                 HotSpotX(0),
  37                                                                 HotSpotY(0),
  38                                                                 Cursor(EmptyCursor),
  39                                                                 Col(CRGBA::White),
  40                                                                 Rot(0)
  41 {
  42 }
  43
  44 // *************************************************************************************
  45 CDriverD3D::CCursor::~CCursor()
  46 {
  47         reset();
  48 }
  49
  50 // *************************************************************************************
  51 void CDriverD3D::CCursor::reset()
  52 {
  53         if (Cursor != EmptyCursor)
  54         {
  55                 DestroyIcon(Cursor);
  56         }
  57 }
  58
  59 // *************************************************************************************
  60 CDriverD3D::CCursor& CDriverD3D::CCursor::operator= (const CDriverD3D::CCursor& from)
  61 {
  62         if (&from == this)
  63                 return *this;
  64         Src = from.Src; // requires more than a surface copy
  65         OrigHeight = from.OrigHeight;
  66         HotspotScale = from.HotspotScale;
  67         HotspotOffsetX = from.HotspotOffsetX;
  68         HotspotOffsetY = from.HotspotOffsetY;
  69         HotSpotX = from.HotSpotX;
  70         HotSpotY = from.HotSpotY;
  71         Cursor = from.Cursor;
  72         Col = from.Col;
  73         Rot = from.Rot;
  74         return *this;
  75 }
  76
  77 // *************************************************************************************
  78 bool CDriverD3D::isAlphaBlendedCursorSupported()
  79 {
  80         if (!_AlphaBlendedCursorSupportRetrieved)
  81         {
  82                 // Support starts with windows 2000 (not only from XP as seen in most docs)
  83                 // NB : Additionnaly, could query D3D caps to know if
  84                 // color hardware cursor is supported, not only emulated,
  85                 // but can't be sure that using the win32 api 'SetCursor' uses the same resources
  86                 // So far, seems to be supported on any modern card used by the game anyway ...
  87                 OSVERSIONINFO osvi;
  88                 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  89                 if (GetVersionEx(&osvi))
  90                 {
  91                         _AlphaBlendedCursorSupported = (osvi.dwMajorVersion     >= 5);
  92                 }
  93
  94                 _AlphaBlendedCursorSupportRetrieved = true;
  95         }
  96
  97         return _AlphaBlendedCursorSupported;
  98 }
  99
 100 // *************************************************************************************
 101 void CDriverD3D::addCursor(const std::string &name, const NLMISC::CBitmap &cursorBitmap)
 102 {
 103         if (!isAlphaBlendedCursorSupported()) return;
 104
 105         nlassert(cursorBitmap.getWidth() != 0);
 106         nlassert(cursorBitmap.getHeight() != 0);
 107
 108         // find used part base on alpha, to avoid too much shrinking
 109         const CRGBA *pixels = (const CRGBA *) &cursorBitmap.getPixels()[0];
 110         uint minX, maxX, minY, maxY;
 111         uint width = cursorBitmap.getWidth();
 112         uint height = cursorBitmap.getHeight();
 113         //
 114         minX = 0;
 115         for (uint x = 0; x < width; ++x)
 116         {
 117                 bool stop = false;
 118                 minX = x;
 119                 for (uint y = 0; y < height; ++y)
 120                 {
 121                         if(pixels[x + y * width].A != 0)
 122                         {
 123                                 stop = true;
 124                                 break;
 125                         }
 126                 }
 127                 if (stop) break;
 128         }
 129         //
 130         maxX = width - 1;
 131         for (sint x = width - 1; x >= 0; --x)
 132         {
 133                 bool stop = false;
 134                 maxX = (uint) x;
 135                 for (uint y = 0; y < height; ++y)
 136                 {
 137                         if(pixels[x + y * width].A != 0)
 138                         {
 139                                 stop = true;
 140                                 break;
 141                         }
 142                 }
 143                 if (stop) break;
 144         }
 145         //
 146         minY = 0;
 147         for (uint y = 0; y < height; ++y)
 148         {
 149                 bool stop = false;
 150                 minY = y;
 151                 for (uint x = 0; x < width; ++x)
 152                 {
 153                         if(pixels[x + y * width].A != 0)
 154                         {
 155                                 stop = true;
 156                                 break;
 157                         }
 158                 }
 159                 if (stop) break;
 160         }
 161         //
 162         maxY = height - 1;
 163         for (sint y = height - 1; y >= 0; --y)
 164         {
 165                 bool stop = false;
 166                 maxY = (uint) y;
 167                 for (uint x = 0; x < width; ++x)
 168                 {
 169                         if(pixels[x + y * width].A != 0)
 170                         {
 171                                 stop = true;
 172                                 break;
 173                         }
 174                 }
 175                 if (stop) break;
 176         }
 177         //
 178         CCursor &curs = _Cursors[name];
 179         curs = CCursor(); // erase possible previous cursor
 180
 181         uint destWidth = GetSystemMetrics(SM_CXCURSOR);
 182         uint destHeight = GetSystemMetrics(SM_CYCURSOR);
 183
 184         // build a square bitmap
 185         uint tmpSize = std::max(maxX - minX + 1, maxY - minY + 1);
 186         curs.Src.resize(tmpSize, tmpSize);
 187         // blit at top left corner
 188         curs.Src.blit(cursorBitmap, minX, minY, maxX - minX + 1, maxY - minY + 1, 0, 0);
 189
 190         curs.OrigHeight = cursorBitmap.getHeight();
 191         curs.HotspotOffsetX = minX;
 192         curs.HotspotOffsetY = minY;
 193         //
 194         curs.HotspotScale = _CursorScale;
 195         clamp(curs.HotspotScale, 0.f, 1.f);
 196         // first resampling, same for all cursors
 197         tmpSize = (uint) (tmpSize * curs.HotspotScale);
 198         if (tmpSize == 0) tmpSize = 1;
 199
 200         if (curs.HotspotScale < 1.f)
 201         {
 202                 curs.Src.resample(tmpSize, tmpSize);
 203         }
 204
 205         // shrink if necessary
 206         if (tmpSize > destWidth || tmpSize > destHeight) // need to shrink ?
 207         {
 208                 // constraint proportions
 209                 curs.HotspotScale *= std::min(float(destWidth) / tmpSize, float(destHeight) / tmpSize);
 210                 curs.Src.resample(destWidth, destHeight);
 211         }
 212         else
 213         {
 214                 CBitmap final;
 215                 final.resize(destWidth, destHeight);
 216                 final.blit(&curs.Src, 0, 0);
 217                 curs.Src.swap(final);
 218         }
 219
 220         if (name == _CurrName)
 221         {
 222                 updateCursor();
 223         }
 224 }
 225
 226 // *************************************************************************************
 227 void CDriverD3D::createCursors()
 228 {
 229         _DefaultCursor = LoadCursor(NULL, IDC_ARROW);
 230 }
 231
 232 // *************************************************************************************
 233 void CDriverD3D::releaseCursors()
 234 {
 235         SetClassLongPtr(_HWnd, GCLP_HCURSOR, 0);
 236
 237         _Cursors.clear();
 238 }
 239
 240 // *************************************************************************************
 241 void CDriverD3D::updateCursor(bool forceRebuild)
 242 {
 243         setCursor(_CurrName, _CurrCol, _CurrRot, _CurrHotSpotX, _CurrHotSpotY, forceRebuild);
 244 }
 245
 246 // *************************************************************************************
 247 void CDriverD3D::setCursor(const std::string &name, NLMISC::CRGBA col, uint8 rot, sint hotSpotX, sint hotSpotY, bool forceRebuild)
 248 {
 249         // don't update cursor if it's hidden or if custom cursors are not suppported
 250         if (!isAlphaBlendedCursorSupported() || _CurrName == "none") return;
 251
 252         _CurrName = name;
 253         _CurrCol = col;
 254         _CurrRot = rot;
 255         _CurrHotSpotX = hotSpotX;
 256         _CurrHotSpotY = hotSpotY;
 257
 258         // cursor has to be changed next time
 259         if (_CurrName.empty()) return;
 260
 261         if (rot >       3) rot = 3; // same than 'CViewRenderer::drawRotFlipBitmapTiled
 262
 263         TCursorMap::iterator it = _Cursors.find(name);
 264
 265         nlCursor cursorHandle = _DefaultCursor;
 266
 267         if (it != _Cursors.end())
 268         {
 269                 // Update cursor if modified or not already built
 270                 CCursor &curs = it->second;
 271                 hotSpotX = (sint) (curs.HotspotScale * (hotSpotX - curs.HotspotOffsetX));
 272                 hotSpotY = (sint) (curs.HotspotScale * ((curs.OrigHeight - hotSpotY) - curs.HotspotOffsetY));
 273                 if (curs.Cursor == EmptyCursor ||
 274                         curs.HotSpotX != hotSpotX ||
 275                         curs.HotSpotY != hotSpotY ||
 276                         curs.Col != col ||
 277                         curs.Rot != rot ||
 278                         curs.ColorDepth != _ColorDepth ||
 279                         forceRebuild
 280                    )
 281                 {
 282                         curs.reset();
 283                         curs.Cursor = buildCursor(curs.Src, col, rot, hotSpotX, hotSpotY);
 284                         curs.Col = col;
 285                         curs.Rot = rot;
 286                         curs.HotSpotX = hotSpotX;
 287                         curs.HotSpotY = hotSpotY;
 288                         curs.ColorDepth = _ColorDepth;
 289                 }
 290                 cursorHandle = curs.Cursor ? curs.Cursor : _DefaultCursor;
 291         }
 292
 293         if (isSystemCursorInClientArea() || isSystemCursorCaptured() || forceRebuild)
 294         {
 295 //              if (CInputHandlerManager::getInstance()->hasFocus())
 296                 {
 297                         ::SetCursor(cursorHandle);
 298                         SetClassLongPtr(_HWnd, GCLP_HCURSOR, (LONG_PTR) cursorHandle); // set default mouse icon to the last one
 299                 }
 300         }
 301
 302 }
 303
 304 // *************************************************************************************
 305 void CDriverD3D::setCursorScale(float scale)
 306 {
 307         _CursorScale = scale;
 308 }
 309
 310 // *************************************************************************************
 311 nlCursor CDriverD3D::buildCursor(const CBitmap &src, NLMISC::CRGBA col, uint8 rot, sint hotSpotX, sint hotSpotY)
 312 {
 313         nlassert(isAlphaBlendedCursorSupported());
 314
 315         uint mouseW = GetSystemMetrics(SM_CXCURSOR);
 316         uint mouseH = GetSystemMetrics(SM_CYCURSOR);
 317
 318         CBitmap rotSrc = src;
 319         if (rot > 3) rot = 3; // mimic behavior of 'CViewRenderer::drawRotFlipBitmapTiled' (why not rot & 3 ??? ...)
 320         switch(rot)
 321         {
 322                 case 0: break;
 323                 case 1: rotSrc.rot90CW(); break;
 324                 case 2: rotSrc.rot90CW(); rotSrc.rot90CW(); break;
 325                 case 3: rotSrc.rot90CCW(); break;
 326         }
 327
 328         // create a cursor from bitmap
 329         nlCursor result = NULL;
 330         convertBitmapToCursor(rotSrc, result, mouseW, mouseH, _ColorDepth == ColorDepth16 ? 16:32, col, hotSpotX, hotSpotY);
 331         return result;
 332 }
 333
 334
 335 // *************************************************************************************
 336 void CDriverD3D::setSystemArrow()
 337 {
 338         H_AUTO_D3D(CDriverD3D_setSystemArrow);
 339
 340         if (isSystemCursorInClientArea() || isSystemCursorCaptured())
 341         {
 342                 SetCursor(_DefaultCursor);
 343         }
 344
 345         // set default mouse icon to the default one
 346         SetClassLongPtr(_HWnd, GCLP_HCURSOR, (LONG_PTR) _DefaultCursor);
 347 }
 348
 349 // ***************************************************************************
 350 void CDriverD3D::showCursor(bool b)
 351 {
 352         H_AUTO_D3D(CDriverD3D_showCursor);
 353
 354         if (_HWnd == EmptyWindow)
 355                 return;
 356
 357         if (b)
 358         {
 359                 // update current hardware icon to avoid to have the plain arrow
 360                 updateCursor(true);
 361
 362                 while (ShowCursor(b) < 0)
 363                         ;
 364         }
 365         else
 366         {
 367                 while (ShowCursor(b) >= 0)
 368                         ;
 369         }
 370 }
 371
 372 // ***************************************************************************
 373 void CDriverD3D::setMousePos(float x, float y)
 374 {
 375         H_AUTO_D3D(CDriverD3D_setMousePos);
 376
 377         if (_HWnd == EmptyWindow || !_WindowFocus)
 378                 return;
 379
 380         // convert position size from float to pixels
 381         sint x1 = (sint)((float)_CurrentMode.Width*x);
 382         sint y1 = (sint)((float)_CurrentMode.Height*(1.0f-y));
 383
 384         // NeL window coordinate to MSWindows coordinates
 385         POINT pt;
 386         pt.x = x1;
 387         pt.y = y1;
 388         ClientToScreen (_HWnd, &pt);
 389         SetCursorPos(pt.x, pt.y);
 390 }
 391
 392 // ***************************************************************************
 393 void CDriverD3D::setCapture (bool b)
 394 {
 395         H_AUTO_D3D(CDriverD3D_setCapture);
 396
 397         if (b && isSystemCursorInClientArea() && !isSystemCursorCaptured())
 398         {
 399                 SetCapture(_HWnd);
 400         }
 401         else if (!b && isSystemCursorCaptured())
 402         {
 403                 // if hardware mouse and not in client area, then force to update its aspect by updating its pos
 404                 if (!isSystemCursorInClientArea())
 405                 {
 406                         // force update
 407                         showCursor(true);
 408                 }
 409
 410                 ReleaseCapture();
 411         }
 412 }
 413
 414 // ***************************************************************************
 415 bool CDriverD3D::isSystemCursorInClientArea()
 416 {
 417         if (_FullScreen /* || !IsMouseCursorHardware() */)
 418         {
 419                 return IsWindowVisible(_HWnd) != FALSE;
 420         }
 421         else
 422         {
 423                 POINT cursPos;
 424                 // the mouse should be in the client area of the window
 425                 if (!GetCursorPos(&cursPos))
 426                 {
 427                         return false;
 428                 }
 429                 HWND wnd = WindowFromPoint(cursPos);
 430                 if (wnd != _HWnd)
 431                 {
 432                         return false; // not the same window
 433                 }
 434                 // want that the mouse be in the client area
 435                 RECT clientRect;
 436                 if (!GetClientRect(_HWnd, &clientRect))
 437                 {
 438                         return false;
 439                 }
 440                 POINT tl, br;
 441                 tl.x = clientRect.left;
 442                 tl.y = clientRect.top;
 443                 br.x = clientRect.right;
 444                 br.y = clientRect.bottom;
 445                 if (!ClientToScreen(_HWnd, &tl))
 446                 {
 447                         return false;
 448                 }
 449                 if (!ClientToScreen(_HWnd, &br))
 450                 {
 451                         return false;
 452                 }
 453                 if ((cursPos.x < tl.x) || (cursPos.x >= br.x) || (cursPos.y < tl.y) || (cursPos.y >= br.y))
 454                 {
 455                         return false;
 456                 }
 457         }
 458
 459         return true;
 460 }
 461
 462 // ***************************************************************************
 463 bool CDriverD3D::isSystemCursorCaptured()
 464 {
 465         H_AUTO_D3D(CDriverD3D_isSystemCursorCaptured);
 466
 467         return GetCapture() == _HWnd;
 468 }
 469
 470 bool CDriverD3D::convertBitmapToCursor(const NLMISC::CBitmap &bitmap, nlCursor &cursor, uint iconWidth, uint iconHeight, uint iconDepth, const NLMISC::CRGBA &col, sint hotSpotX, sint hotSpotY)
 471 {
 472         return convertBitmapToIcon(bitmap, cursor, iconWidth, iconHeight, iconDepth, col, hotSpotX, hotSpotY, true);
 473 }
 474
 475 } // NL3D