ryzom/client/src/r2/tool_choose_pos.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2013  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "stdpch.h"
  21 //
  22 #include "editor.h"
  23 #include "tool_choose_pos.h"
  24 #include "../interface_v3/interface_manager.h"
  25 #include "../global.h"
  26 #include "nel/gui/group_tree.h"
  27 #include "../interface_v3/group_map.h"
  28 #include "../landscape_poly_drawer.h"
  29 //
  30 #include "../entities.h"
  31 //
  32 #include "nel/misc/vector.h"
  33 #include "nel/misc/quat.h"
  34 #include "nel/misc/aabbox.h"
  35 #include "nel/3d/u_instance.h"
  36 //
  37 #include "game_share/object.h"
  38 #include "dmc/idmc.h"
  39 #include "r2_config.h"
  40
  41 #ifdef DEBUG_NEW
  42 #define new DEBUG_NEW
  43 #endif
  44
  45 using namespace NLPACS;
  46 using namespace NLMISC;
  47
  48 namespace R2
  49 {
  50
  51
  52 // ***************************************************************
  53 CToolChoosePos::CToolChoosePos(sint ghostSlot,
  54                                                            const std::string &cursValid,
  55                                                            const std::string &cursInvalid,
  56                                                            const std::vector<CPolygon2D> &polyList,
  57                                                            const CPrimLook &polyValidLook,
  58                                                            const CPrimLook &polyInvalidLook
  59                                                           )
  60 {
  61         _CursValid = cursValid;
  62         _CursInvalid = cursInvalid;
  63         _GhostSlot = ghostSlot,
  64         _Valid = false;
  65         _WantedAction = NoAction;
  66         _WarningNoMeshOrSkeletonShown = false;
  67         CEntityCL *entity = getGhost();
  68         _LocalSelectBoxSize = 1;
  69         if (entity)
  70         {
  71                 entity->getMeshDefaultScale(_DefaultScale);
  72                 if (!entity->skeleton())
  73                 {
  74                         const CVector &hs = getEditor().getLocalSelectBox(*entity).getHalfSize();
  75                         _LocalSelectBoxSize = maxof(fabsf(hs.x), fabsf(hs.y), fabsf(hs.z));
  76                 }
  77         }
  78         else
  79         {
  80                 _DefaultScale.set(1.f, 1.f, 1.f);
  81         }
  82         _MultiPos = false;
  83         _MultiPosLocked = false;
  84         _BadPlaceDecal.setTexture("*accessibility_texture*", true, true, false);
  85         _TestDecal.setTexture("encyclopedia_box_zo.tga", true, true, false);
  86         //
  87         _PolyList = polyList;
  88         _PolyRender.resize(polyList.size());
  89         _PolyValidLook = polyValidLook;
  90         _PolyInvalidLook = polyInvalidLook;
  91         CGroupMap *gm = getWorldMap();
  92         for (uint k = 0; k < _PolyRender.size(); ++k)
  93         {
  94                 _PolyRender[k].setActive(false);
  95                 if (gm)
  96                 {
  97                         gm->addDeco(&_PolyRender[k]);
  98                 }
  99         }
 100 }
 101
 102 // ***************************************************************
 103 void CToolChoosePos::showPolys(bool visible)
 104 {
 105         //H_AUTO(R2_CToolChoosePos_showPolys)
 106         for (uint k = 0; k < _PolyRender.size(); ++k)
 107         {
 108                 _PolyRender[k].setActive(visible);
 109         }
 110 }
 111
 112 // ***************************************************************
 113 void CToolChoosePos::enableMultiPos(const std::string &cursValidMulti /*="curs_create_multi.tga"*/)
 114 {
 115         //H_AUTO(R2_CToolChoosePos_enableMultiPos)
 116         _MultiPos = true;
 117         _CursValidMulti = cursValidMulti;
 118 }
 119
 120 // ***************************************************************
 121 CToolChoosePos::~CToolChoosePos()
 122 {
 123         cancel();
 124         CGroupMap *gm = getWorldMap();
 125         if (gm)
 126         {
 127                 for (uint k = 0; k < _PolyRender.size(); ++k)
 128                 {
 129                         _PolyRender[k].setActive(false);
 130                         gm->removeDeco(&_PolyRender[k]);
 131                 }
 132         }
 133 }
 134
 135 // ***************************************************************
 136 CEntityCL *CToolChoosePos::getGhost()
 137 {
 138         //H_AUTO(R2_CToolChoosePos_getGhost)
 139         if (_GhostSlot == -1) return NULL;
 140         return EntitiesMngr.entity(_GhostSlot);
 141 }
 142
 143 // ***************************************************************
 144 void CToolChoosePos::hideMapSelectionAxis()
 145 {
 146         //H_AUTO(R2_CToolChoosePos_hideMapSelectionAxis)
 147         CGroupMap *worldMap = getWorldMap();
 148         if (worldMap) worldMap->setSelectionAxis(false);
 149 }
 150
 151 // ***************************************************************
 152 void CToolChoosePos::updateInvalidCursorOnUI()
 153 {
 154         //H_AUTO(R2_CToolChoosePos_updateInvalidCursorOnUI)
 155         setMouseCursor(DEFAULT_CURSOR);
 156 }
 157
 158 // ***************************************************************
 159 void CToolChoosePos::updateBeforeRender()
 160 {
 161         //H_AUTO(R2_CToolChoosePos_updateBeforeRender)
 162         CGroupMap *worldMap = getWorldMap();
 163         CEntityCL *entity = getGhost();
 164         float dtBackup  = DT;
 165         DT = RZ_TIME_TO_BECOME_TRANSPARENT_IN_SECOND; // don't want a transition
 166         if (entity)
 167         {
 168                 uint32 oldOpacity = CEntityCL::getOpacityMin();
 169                 CEntityCL::setOpacityMin(DEFAULT_ENTITY_MIN_OPACITY);
 170                 entity->makeTransparent(true);
 171                 CEntityCL::setOpacityMin(oldOpacity);
 172         }
 173         DT = dtBackup;
 174         // Build vector for direction pointed by mouse in world
 175         sint32 mouseX,  mouseY;
 176         getMousePos(mouseX,  mouseY);
 177         if (!isInScreen(mouseX,  mouseY) || (isMouseOnUI() && !isMouseOnWorldMap()))
 178         {
 179                 if (worldMap) worldMap->setSelectionAxis(false);
 180                 if (entity)
 181                 {
 182                         entity->show(false);
 183                 }
 184                 updateInvalidCursorOnUI();
 185                 showPolys(false);
 186                 return;
 187         }
 188         //
 189         CTool::CWorldViewRay worldViewRay;
 190         //
 191         computeWorldViewRay(mouseX,  mouseY,  worldViewRay);
 192         //
 193         CVector entityPos; // the pos where the ghost will be shown
 194         CVector inter;     // intersection of view ray with landscape
 195         _Valid = false;
 196         CVector scale = _DefaultScale;
 197         TRayIntersectionType rayIntersectionType = computeLandscapeRayIntersection(worldViewRay,  inter);
 198         switch(rayIntersectionType)
 199         {
 200                 case NoIntersection:
 201                 {
 202                         // no collision,  can't drop entity
 203                         entityPos = worldViewRay.Origin + 3.f * worldViewRay.Dir;
 204                         // change the scale so that the entity has always the same size on screen
 205                         float refScale = CV_FloatingShapeRefScale.get();
 206                         if (refScale == 0.f) refScale = 1.f;
 207                         if (_LocalSelectBoxSize != 0.f)
 208                         {
 209                                 scale *= refScale / _LocalSelectBoxSize;
 210                         }
 211                         if (worldMap) worldMap->setSelectionAxis(false);
 212                         showPolys(false);
 213                 }
 214                 break;
 215                 case ValidPacsPos:
 216                         entityPos = inter;
 217                         _CreatePosition = entityPos;
 218                         _Valid = isValidChoosePos(inter); // good pos to drop entity
 219                         if (worldMap) worldMap->setSelectionAxis(true, inter);
 220                         showPolys(true);
 221                 break;
 222                 case InvalidPacsPos:
 223                         entityPos = inter;
 224                         if (worldMap) worldMap->setSelectionAxis(true, inter);
 225                         showPolys(true);
 226                 break;
 227                 default:
 228                         nlassert(0);
 229                 break;
 230         }
 231         // compute front vector
 232         CVector front = - MainCam.getMatrix().getJ();
 233         front.z = 0.f;
 234         front.normalize();
 235         // compute angle around Z
 236         _CreateAngle = (float) atan2(front.y,  front.x);
 237         //
 238         if (entity)
 239         {
 240                 CMatrix mat;
 241                 if (worldViewRay.OnMiniMap && rayIntersectionType == NoIntersection)
 242                 {
 243                         entity->show(false);
 244                 }
 245                 else if (!entity->skeleton())
 246                 {
 247                         /*
 248                         nlwarning("Selected entity for the 'create' tool has no skeleton");
 249                         entity->show(false);
 250                         return;
 251                         */
 252                         //bool loading = true;
 253                         NL3D::UInstance inst = entity->instance();
 254                         if (inst.empty())
 255                         {
 256                                 if (!entity->instances().empty())
 257                                 {
 258                                         inst = entity->instances()[0].Current;
 259                                         //loading = !entity->instances()[0].Loading.empty() && entity->instances()[0].Current.empty();
 260                                 }
 261                         }
 262                         if (inst.empty())
 263                         {
 264                                 if (!_WarningNoMeshOrSkeletonShown)
 265                                 {
 266                                         nlwarning("Selected entity for the 'create' tool has no instance");
 267                                         _WarningNoMeshOrSkeletonShown = true;
 268                                 }
 269                                 entity->show(false);
 270                                 showPolys(false);
 271                                 return;
 272                         }
 273                         entity->show(true);
 274                         //
 275                         CQuat frontQuat(CVector::K,  _CreateAngle - (float) (NLMISC::Pi / 2));
 276                         inst.setRotQuat(frontQuat);
 277                         inst.setPos(entityPos);
 278                         inst.setScale(scale);
 279                         mat = inst.getMatrix();
 280                 }
 281                 else
 282                 {
 283                         entity->show(true);
 284                         //
 285                         entity->updateVisible(T1,  NULL);
 286                         entity->updatePos(T1,  NULL);
 287
 288                         /*
 289                         CMatrix skelMatrix = entity->skeleton()->getMatrix();
 290                         // relative position to skeleton root
 291                         CVector skelRootRelativePos = entity->skeleton()->getMatrix().getPos() - entity->pos().asVector();
 292                         // combine quat for front face xform & anim quat
 293                         CQuat frontQuat(CVector::K,  _CreateAngle);
 294                         entity->skeleton()->setRotQuat(frontQuat * entity->skeleton()->getRotQuat());
 295                         entity->skeleton()->setPos(entityPos + skelRootRelativePos);
 296                         mat.setRot(frontQuat);
 297                         mat.setPos(entityPos);
 298                         */
 299                         // relative position to skeleton root
 300                         CVector skelRootRelativePos = entity->skeleton()->getMatrix().getPos() - entity->pos().asVector();
 301                         // combine quat for front face xform & anim quat
 302                         CQuat frontQuat(CVector::K,  _CreateAngle);
 303                         entity->skeleton()->setRotQuat(frontQuat * entity->skeleton()->getRotQuat());
 304                         CMatrix frontMat;
 305                         frontMat.setRot(frontQuat);
 306                         entity->skeleton()->setPos(entityPos + frontMat * skelRootRelativePos);
 307                         /*mat.setRot(frontQuat);
 308                         mat.setPos(entityPos);*/
 309
 310                 }
 311                 // see if all pos are accessible and update the _Valid flag
 312                 // NB NICO : THE FOLLOWING CODE IS WORKING BUT
 313                 // see with others if it's useful to check this type of collisions
 314                 // finally -> since check is never done, limited/no interest ...
 315                 /*
 316                 if (shown && entity->getPrimitive())
 317                 {
 318                         float w;
 319                         float h;
 320                         if (entity->getPrimitive()->getPrimitiveType() == UMovePrimitive::_2DOrientedBox)
 321                         {
 322                                 entity->getPrimitive()->getSize(w, h);
 323                         }
 324                         else
 325                         {
 326                                 w = h = 2.f * entity->getPrimitive()->getRadius();
 327                         }
 328                         // transform from [0, 1] x [0, 1] to local bbox
 329                         CMatrix unitBoxToLocalPrim;
 330                         unitBoxToLocalPrim.setScale(CVector(w, h, 1.f));
 331                         //unitBoxToLocalBox.setPos(CVector(localBox.getMin().x / favoid0(w), localBox.getMin().y / favoid0(h), 1.f);
 332                         unitBoxToLocalPrim.setPos(CVector(- 0.5f * w, - 0.5f * h, 0.f));
 333                         CMatrix worldMat = mat * unitBoxToLocalPrim;
 334                         // test if place is valid
 335                         CPolygon poly;
 336                         poly.Vertices.resize(4);
 337                         poly.Vertices[0].set(0.f, 0.f, 0.f);
 338                         poly.Vertices[1].set(1.f, 0.f, 0.f);
 339                         poly.Vertices[2].set(1.f, 1.f, 0.f);
 340                         poly.Vertices[3].set(0.f, 1.f, 0.f);
 341                         CPolygon2D poly2D(poly, worldMat);
 342
 343                         if (getEditor().getIslandCollision().isValidPoly(poly2D))
 344                         {
 345                                 _TestDecal.setWorldMatrix(worldMat);
 346                                 _TestDecal.addToRenderList();
 347                         }
 348                         else
 349                         {
 350                                 _Valid = false;
 351                                 _BadPlaceDecal.setWorldMatrix(worldMat);
 352                                 _BadPlaceDecal.setDiffuse(getInvalidPosColor());
 353                                 _BadPlaceDecal.setCustomUVMatrix(true, getEditor().getIslandCollision().getWorldToAccessibilityTexMat(true));
 354                                 _BadPlaceDecal.addToRenderList();
 355
 356                         }
 357                 }
 358                 */
 359         }
 360         // additionnal polygons
 361         if (!_PolyRender.empty() && _PolyRender[0].getActive())
 362         {
 363                 static NLMISC::CPolygon2D tmpPoly;
 364                 std::vector<NLMISC::CVector2f> &verts = tmpPoly.Vertices;
 365                 nlassert(_PolyRender.size() == _PolyList.size());
 366                 CIslandCollision &ic = getEditor().getIslandCollision();
 367                 for (uint k = 0; k < _PolyRender.size(); ++k)
 368                 {
 369                         verts.resize(_PolyList[k].Vertices.size());
 370                         for (uint l = 0; l < verts.size(); ++l)
 371                         {
 372                                 verts[l].set(_PolyList[k].Vertices[l].x + _CreatePosition.x,
 373                                                          _PolyList[k].Vertices[l].y + _CreatePosition.y);
 374                         }
 375                         bool validPoly = ic.isValidPoly(tmpPoly); // Test all position because entities may be created in that zone
 376
 377
 378                         // also test zone vertices because in the end, a valid zone is a zone for which all vertices
 379                         // are valid
 380                         for (uint l = 0; validPoly && l < verts.size(); ++l)
 381                         {
 382                                 if (!ic.isValidPos(verts[l])) validPoly = false;
 383                         }
 384
 385
 386                         if (!validPoly) _Valid = false;
 387
 388                         /*
 389                         bool validPoly = true;
 390                         for (uint l = 0; l < verts.size() && validPoly; ++l)
 391                         {
 392                                 if (!ic.isValidSegment(verts[l], verts[(l + 1) % verts.size()]))
 393                                 {
 394                                         validPoly = false;
 395                                         _Valid = false;
 396                                 }
 397                         }
 398                         */
 399                         _PolyRender[k].setLook(validPoly ? _PolyValidLook : _PolyInvalidLook);
 400                         _PolyRender[k].setVertices(verts);
 401                         _PolyRender[k].addDecalsToRenderList();
 402
 403                         if (_PolyRender[k].getLook().Shape == CPrimLook::ClosedPolyLine)
 404                         {
 405                                 NLMISC::CAABBox bbox;
 406                                 static volatile bool showPoly = true;
 407                                 if (showPoly)
 408                                 {
 409                                         CLandscapePolyDrawer::getInstance().computeBBoxFromPolygon(tmpPoly, bbox);
 410                                         CLandscapePolyDrawer::getInstance().addPoly(tmpPoly,  _PolyRender[k].getLook().EdgeLook.WorldMapColor, bbox);
 411                                 }
 412                                 _PolyRender[k].setWorldMapPolyColor(_PolyRender[k].getLook().EdgeLook.WorldMapColor);
 413                         }
 414                 }
 415         }
 416         // change mouse depending on result
 417         if (!isMouseOnUI() || isMouseOnWorldMap())
 418         {
 419
 420                 if (_Valid)
 421                 {
 422                         if (_MultiPos && isShiftDown() && !_MultiPosLocked)
 423                         {
 424                                 setMouseCursor(_CursValidMulti);
 425                         }
 426                         else
 427                         {
 428                                 setMouseCursor(_CursValid);
 429                         }
 430                 }
 431                 else
 432                 {
 433                         setMouseCursor(_CursInvalid);
 434                 }
 435         }
 436         else
 437         {
 438                 setMouseCursor(_CursValid);
 439         }
 440 }
 441
 442 // ***************************************************************
 443 void CToolChoosePos::updateAfterRender()
 444 {
 445         //H_AUTO(R2_CToolChoosePos_updateAfterRender)
 446         CTool::TSmartPtr oldThis(this); // may be changed during commit
 447         switch(_WantedAction)
 448         {
 449                 case SelectPos:
 450                 {
 451                         showPolys(false);
 452                         hideMapSelectionAxis();
 453                         if (_Valid)
 454                         {
 455                                 // signal deriver that a position has been chosen
 456                                 commit(_CreatePosition, _CreateAngle);
 457                                 if (stopAfterCommit() && (!_MultiPos || !isShiftDown()) && !_MultiPosLocked)
 458                                 {
 459                                         if (_GhostSlot != -1)
 460                                         {
 461                                                 //EntitiesMngr.remove(_GhostSlot,  true);
 462                                                 CEntityCL *ghost = EntitiesMngr.entity(_GhostSlot);
 463                                                 if (ghost)
 464                                                 {
 465                                                         // just hide the slot because creation may happen just after, so keep
 466                                                         // a ref on textures and shape
 467                                                         ghost->show(false);
 468                                                 }
 469                                         }
 470                                         getEditor().setCurrentTool(NULL);
 471                                 }
 472                                 else
 473                                 {
 474                                         _WantedAction = NoAction;
 475                                 }
 476                         }
 477                 }
 478                 break;
 479                 case Cancel:
 480                 {
 481                         cancel();
 482                         getEditor().setCurrentTool(NULL);
 483                 }
 484                 break;
 485                 case NoAction:
 486                         // no-op
 487                 break;
 488                 default:
 489                         nlassert(0);
 490                 break;
 491         }
 492 }
 493
 494
 495 // ***************************************************************
 496 void CToolChoosePos::removeGhostSlot()
 497 {
 498         //H_AUTO(R2_CToolChoosePos_removeGhostSlot)
 499         if (_GhostSlot != - 1 && getGhost())
 500         {
 501                 CEntityCL *ghost = EntitiesMngr.entity(_GhostSlot);
 502                 if (ghost)
 503                 {
 504                         // just hide the slot because creation may happen just after, so keep
 505                         // a ref on textures and shape (this avoid a release from memory)
 506                         ghost->show(false);
 507                         ghost->displayable(false);
 508                 }
 509                 //EntitiesMngr.remove(_GhostSlot,  true); // remove the ghost
 510                 _GhostSlot = -1;
 511         }
 512 }
 513
 514 // ***************************************************************
 515 bool CToolChoosePos::onMouseLeftButtonClicked()
 516 {
 517         //H_AUTO(R2_CToolChoosePos_onMouseLeftButtonClicked)
 518         if (_Valid)
 519         {
 520                 _WantedAction = SelectPos;
 521         }
 522         return true;
 523 }
 524
 525 // ***************************************************************
 526 bool CToolChoosePos::onMouseRightButtonClicked()
 527 {
 528         //H_AUTO(R2_CToolChoosePos_onMouseRightButtonClicked)
 529         _WantedAction = Cancel;
 530         return true;
 531 }
 532
 533 // ***************************************************************
 534 void CToolChoosePos::cancel()
 535 {
 536         //H_AUTO(R2_CToolChoosePos_cancel)
 537         showPolys(false);
 538         // TODO nico : potential crash here if called just before render (in updateBeforeRender)
 539         // TODO nico : rethink the deferred action stuff to avoid this possible case
 540         hideMapSelectionAxis();
 541         removeGhostSlot();
 542 }
 543
 544
 545
 546
 547 } // R2