Source/System/NodeCores/Groups/Misc/OSGScreenTransform.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *               Copyright (C) 2000-2006 by the OpenSG Forum                 *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 //---------------------------------------------------------------------------
  40 //  Includes
  41 //---------------------------------------------------------------------------
  42
  43 #include <cstdlib>
  44 #include <cstdio>
  45
  46 #include <OSGConfig.h>
  47
  48 #include "OSGScreenTransform.h"
  49 #include "OSGVolume.h"
  50 #include "OSGPlane.h"
  51 #include "OSGIntersectAction.h"
  52
  53 #include "OSGRenderAction.h"
  54
  55 OSG_BEGIN_NAMESPACE
  56
  57 // Documentation for this class is emitted in the
  58 // OSGScreenTransformBase.cpp file.
  59 // To modify it, please change the .fcd file (OSGScreenTransform.fcd) and
  60 // regenerate the base file.
  61
  62 /***************************************************************************\
  63  *                           Class variables                               *
  64 \***************************************************************************/
  65
  66 /***************************************************************************\
  67  *                           Class methods                                 *
  68 \***************************************************************************/
  69
  70 void ScreenTransform::initMethod(InitPhase ePhase)
  71 {
  72     Inherited::initMethod(ePhase);
  73
  74     if(ePhase == TypeObject::SystemPost)
  75     {
  76         IntersectAction::registerEnterDefault(
  77             getClassType(),
  78             reinterpret_cast<Action::Callback>(
  79                 &ScreenTransform::intersectEnter));
  80
  81         IntersectAction::registerLeaveDefault(
  82             getClassType(),
  83             reinterpret_cast<Action::Callback>(
  84                 &ScreenTransform::intersectLeave));
  85
  86         RenderAction::registerEnterDefault(
  87             ScreenTransform::getClassType(),
  88             reinterpret_cast<Action::Callback>(&ScreenTransform::renderEnter));
  89
  90         RenderAction::registerLeaveDefault(
  91             ScreenTransform::getClassType(),
  92             reinterpret_cast<Action::Callback>(&ScreenTransform::renderLeave));
  93
  94     }
  95 }
  96
  97
  98 /***************************************************************************\
  99  *                           Instance methods                              *
 100 \***************************************************************************/
 101
 102 void ScreenTransform::calcMatrix(const Matrix  &toWorld,
 103                                        DrawEnv &oEnv   )
 104 {
 105     //Get the local to world transformation
 106     Matrix mBeaconToWorld;
 107
 108     if(getBeacon() != NULL)
 109     {
 110         mBeaconToWorld = getBeacon()->getToWorld();
 111     }
 112     else
 113     {
 114         mBeaconToWorld.setIdentity();
 115     }
 116
 117 #if 0
 118     //Get the Viewport Camera
 119     CameraUnrecPtr ViewportCamera = theViewport->getCamera();
 120
 121     //Get the World to View transformation
 122     ViewportCamera->getViewing(WorldToView, theViewport->getPixelWidth(), theViewport->getPixelHeight());
 123 #endif
 124
 125     Matrix mWorldToView = oEnv.getVPCameraViewing();
 126
 127     //Store the previous value
 128     Matrix mPrevValue = _mTransform;
 129
 130     //Invert the current Model Transformation
 131     if(getInvertWorldTransform())
 132     {
 133         _mTransform.invertFrom(toWorld);
 134     }
 135     else
 136     {
 137         _mTransform.setIdentity();
 138     }
 139
 140     //Invert the current View Transformation
 141     if(getInvertViewTransform())
 142     {
 143         Matrix mViewToWorld;
 144
 145         mViewToWorld.invertFrom(mWorldToView);
 146
 147         _mTransform.mult(mViewToWorld);
 148
 149
 150         //Setup a new view transformation
 151         _mTransform.mult(getView());
 152     }
 153
 154     //Setup a new Model Transformation, transform such that the screen
 155     //position of the origin of the beacon
 156     //node and the screen position of the origin of child nodes are the same.
 157     if(getApplyBeaconScreenTranslation())
 158     {
 159 #if 0
 160         //The Screen Pos should now be projected to the near plane
 161         Matrix proj, projtrans;
 162
 163         ViewportCamera->getProjection(proj,
 164                            theViewport->getPixelWidth(),
 165                            theViewport->getPixelHeight());
 166
 167         ViewportCamera->getProjectionTranslation(projtrans,
 168                                       theViewport->getPixelWidth(),
 169                                       theViewport->getPixelHeight());
 170 #endif
 171
 172         Matrix proj      = oEnv.getVPCameraProjection     ();
 173         Matrix projtrans = oEnv.getVPCameraProjectionTrans();
 174
 175         Matrix wctocc = proj;
 176
 177         wctocc.mult(projtrans);
 178
 179         Matrix cctowc;
 180
 181         cctowc.invertFrom(wctocc);
 182
 183         Pnt3f from, at;
 184
 185         Pnt3f vBeaconScreenPos = mBeaconToWorld * Pnt3f(0.0f,0.0f,0.0f);
 186
 187
 188         //Get the World to Screen transformation
 189         Matrix mWorldToScreen = oEnv.getVPWorldToScreen();
 190 //        ViewportCamera->getWorldToScreen(WorldToScreen, *theViewport);
 191
 192         mWorldToScreen.multFull(vBeaconScreenPos, vBeaconScreenPos);
 193
 194         cctowc.multFull(Pnt3f(vBeaconScreenPos.x(),
 195                               vBeaconScreenPos.y(), -1), from);
 196
 197         cctowc.multFull(Pnt3f(vBeaconScreenPos.x(),
 198                               vBeaconScreenPos.y(),  1), at  );
 199
 200         Vec3f dir = at - from;
 201
 202         Line line;
 203         line.setValue(from, dir);
 204
 205         Vec3f vPlaneNormal(0.0f, 0.0f, 1.0f);
 206         Pnt3f vPlanePoint (0.0f, 0.0f, 0.0f);
 207
 208         getView().mult(vPlaneNormal, vPlaneNormal);
 209         getView().mult(vPlanePoint,  vPlanePoint );
 210
 211         Plane p(vPlaneNormal, vPlanePoint);
 212
 213         Real32 t;
 214
 215         p.intersect(line,t);
 216
 217         Pnt3f vTransformedPoint = line.getPosition() + line.getDirection() * t;
 218
 219         Matrix mTranslateMat;
 220
 221         mTranslateMat.setIdentity();
 222
 223         mTranslateMat.setTranslate(Vec3f(vTransformedPoint.x(),
 224                                          vTransformedPoint.y(),
 225                                          0.0f                 ));
 226
 227         _mTransform.mult(mTranslateMat);
 228     }
 229
 230     //The new model transformation should be rotated by the Beacons rotation
 231     if(getApplyBeaconRotation())
 232     {
 233         Matrix mBeaconToView = mBeaconToWorld;
 234
 235         if(getInvertViewTransform())
 236         {
 237             mBeaconToView.multLeft(mWorldToView);
 238         }
 239
 240         Vec3f      vTranslation;       // for matrix decomposition
 241         Quaternion qBeaconRot;
 242         Vec3f      vScaleFactor;
 243         Quaternion qScaleOrientation;
 244
 245         mBeaconToView.getTransform(vTranslation,
 246                                    qBeaconRot,
 247                                    vScaleFactor,
 248                                    qScaleOrientation);
 249
 250         Matrix mRotMat;
 251
 252         mRotMat.setRotate(qBeaconRot);
 253
 254         _mTransform.mult(mRotMat);
 255     }
 256
 257     if(_mTransform != mPrevValue)
 258     {
 259         invalidateVolume();
 260     }
 261 }
 262
 263 void ScreenTransform::accumulateMatrix(Matrix &result)
 264 {
 265     result.mult(_mTransform);
 266 }
 267
 268 void ScreenTransform::adjustVolume(Volume &volume)
 269 {
 270     volume.transform(_mTransform);
 271 }
 272
 273 /*-------------------------------------------------------------------------*/
 274 /*                                Render                                   */
 275
 276 Action::ResultE ScreenTransform::renderEnter(Action *action)
 277 {
 278     RenderAction *pAction =
 279         dynamic_cast<RenderAction *>(action);
 280
 281     calcMatrix(pAction->topMatrix(),
 282                pAction->getActivePartition()->getDrawEnv());
 283
 284     pAction->pushVisibility();
 285
 286     pAction->pushMatrix(_mTransform);
 287
 288     return Action::Continue;
 289 }
 290
 291 Action::ResultE ScreenTransform::renderLeave(Action *action)
 292 {
 293     RenderAction *pAction =
 294         dynamic_cast<RenderAction *>(action);
 295
 296     pAction->popVisibility();
 297
 298     pAction->popMatrix();
 299
 300     return Action::Continue;
 301 }
 302
 303 /*-------------------------------------------------------------------------*/
 304 /*                            Intersect                                    */
 305
 306 Action::ResultE ScreenTransform::intersectEnter(Action *action)
 307 {
 308     IntersectAction *ia = dynamic_cast<IntersectAction *>(action);
 309     Matrix           m  = _mTransform;
 310
 311     m.invert();
 312
 313     Pnt3f pos;
 314     Vec3f dir;
 315
 316     m.multFull(ia->getLine().getPosition (), pos);
 317     m.mult    (ia->getLine().getDirection(), dir);
 318
 319     ia->setLine(Line(pos, dir), ia->getMaxDist());
 320     ia->scale(dir.length());
 321
 322     return Action::Continue;
 323 }
 324
 325 Action::ResultE ScreenTransform::intersectLeave(Action *action)
 326 {
 327     IntersectAction *ia = dynamic_cast<IntersectAction *>(action);
 328     Matrix           m  = _mTransform;
 329
 330     Pnt3f pos;
 331     Vec3f dir;
 332
 333     m.multFull(ia->getLine().getPosition (), pos);
 334     m.mult    (ia->getLine().getDirection(), dir);
 335
 336     ia->setLine(Line(pos, dir), ia->getMaxDist());
 337     ia->scale(dir.length());
 338
 339     return Action::Continue;
 340 }
 341
 342 /*-------------------------------------------------------------------------*\
 343  -  private                                                                 -
 344 \*-------------------------------------------------------------------------*/
 345
 346 /*----------------------- constructors & destructors ----------------------*/
 347
 348 ScreenTransform::ScreenTransform(void) :
 349      Inherited (),
 350     _mTransform()
 351 {
 352 }
 353
 354 ScreenTransform::ScreenTransform(const ScreenTransform &source) :
 355      Inherited (source            ),
 356     _mTransform(source._mTransform)
 357 {
 358 }
 359
 360 ScreenTransform::~ScreenTransform(void)
 361 {
 362 }
 363
 364 /*----------------------------- class specific ----------------------------*/
 365
 366 void ScreenTransform::changed(ConstFieldMaskArg whichField,
 367                               UInt32            origin,
 368                               BitVector         details)
 369 {
 370     Inherited::changed(whichField, origin, details);
 371
 372     if(whichField & BeaconFieldMask)
 373     {
 374         invalidateVolume();
 375     }
 376 }
 377
 378 void ScreenTransform::dump(      UInt32    ,
 379                            const BitVector ) const
 380 {
 381     SLOG << "Dump ScreenTransform NI" << std::endl;
 382 }
 383
 384 OSG_END_NAMESPACE