mouse.cpp

#include "main.h"
#include "mouse.h"



// constructor
Mouse::Mouse( NxReal size, NxReal mouseOperatingHight, NxReal pickedActorLiftUp )
: mouseActor(NULL), 
  joint(NULL), 
  mouseOperatingHight(mouseOperatingHight),
  pickedActorLiftUp(pickedActorLiftUp)
{
        logger->log( "Mouse ctor()" );
        this->createMouseActor( size );
}


// destructor
Mouse::~Mouse()
{
        // todo: Avoid release calls while the scene is simulating (in between simulate() and fetchResults() calls)
        if ( NULL != this->joint )
        {
                nxScene->releaseJoint( *this->joint );
                this->joint = NULL;
        }
        if ( NULL != this->mouseActor )
        {
                nxScene->releaseActor( *this->mouseActor );
                this->mouseActor = NULL;
        }

        logger->log( "Mouse dtor()" );
}


// set new position on virtual plane, transformed from screen x/y
ERR_TYPE Mouse::moveTo( NxU32 x, NxU32 y )
{
        if ( NULL != this->mouseActor )
        {
                // wake up our joint members to ensure movement even mouse stands still
                // is joint active?
                if ( NULL != this->joint )
                {
                        NxActor* tempActor;
                        NxActor* tempMouse;     // unused
                        this->joint->getActors( &tempActor, &tempMouse );
                        tempActor->wakeUp();
                }
                // create a line from camera to mouseX, mouseY hitPoint in 3D space
                line3df line = getCameraToTableRay( x, y );
                // get intersection between line and table
                NxVec3 intersection = getRayIntersectionWithTable( line );
                // move the virtual mouse pointer on the table
                NxVec3 newPos( intersection.x, this->mouseOperatingHight, intersection.z );
                this->mouseActor->setGlobalPosition( newPos );
        }

        return ERR_OK;
}


// lift actor and create DistanceJoint with our mouseActor
ERR_TYPE Mouse::pickActorElasticStrap( NxActor* actor )
{
        if ( NULL != actor )
        {
                // lift picked actor up
                NxVec3 actorPos( actor->getGlobalPosition() );
                actorPos.y += this->pickedActorLiftUp;
                actor->setGlobalPosition( actorPos );
                
                // use our mouse position -SomeHightOffset as new joint position
                NxVec3 jointPos( this->mouseActor->getGlobalPosition() );
                jointPos.y -= 1.0f;
        
                // create a joint between our mouse and picked actor
                this->createDistanceJoint( actor, jointPos );
        }
        
        return ERR_OK;
}


// lift actor and create SphericalJoint with our mouseActor
ERR_TYPE Mouse::pickActorFixed( NxActor* actor )
{
        if ( NULL != actor )
        {
                // lift picked actor up and disable dynamic behaviour
                NxVec3 actorPos( actor->getGlobalPosition() );
                actorPos.y += this->pickedActorLiftUp;
                actor->setGlobalPosition( actorPos );
                actor->raiseBodyFlag( NX_BF_FROZEN_ROT );
                
                // use our mouse position -SomeHightOffset as new joint position
                NxVec3 jointPos( this->mouseActor->getGlobalPosition() );
                jointPos.y -= 1.0f;

                // create a joint between our mouse and picked actor
                this->createSphericalJoint( actor, jointPos );
        }
        
        return ERR_OK;
}


// release joint with active actor
ERR_TYPE Mouse::dropActor()
{
        // is our joint active?
        if ( NULL != this->joint )
        {
                // re-enable dynamic bahaviour ( case: fixed type joint )
                NxActor* tempActor;
                NxActor* tempMouse;     // unused
                this->joint->getActors( &tempActor, &tempMouse );
                tempActor->clearBodyFlag( NX_BF_FROZEN_ROT );

                nxScene->releaseJoint( *this->joint );
                this->joint = NULL;
                //logger->log( "Joint deleted" );
        }

        return ERR_OK;
}


// returns valid NxActor if mouse raycast hits an actor in the scene,
// transformed from screen x/y
// NULL otherwise 
NxActor* Mouse::actorHit( NxU32 inX, NxU32 inY )
{
        // create a line from camera to mouseX, mouseY hitPoint in 3D space
        line3df line = this->getCameraToTableRay( inX, inY );

        // create a NxRay from that line
        NxVec3 rayStart( line.start.X, line.start.Y, line.start.Z );
        NxVec3 rayEnd( line.end.X, line.end.Y, line.end.Z );
        NxVec3 rayDir = rayEnd - rayStart;
        rayDir.normalize();

        NxRay theRay( rayStart, rayDir );

        // feed physx with that ray and look if it hits something
        NxRaycastHit hit;
        NxShape* thePickedPhotoShape = NULL;
        thePickedPhotoShape = nxScene->raycastClosestShape( theRay, NX_ALL_SHAPES, hit );

        if ( NULL != thePickedPhotoShape )
        {
                return &thePickedPhotoShape->getActor();
        }

        return NULL;
}




// *** private: ***


// creates our virtual NxActor used to create a joint on any photo
// this actor is used as a mouse pointer
ERR_TYPE Mouse::createMouseActor( NxReal size )
{
        // box dimension in [m] on a side
        NxVec3 boxDim( size, size, size );

    // Add a single-shape actor to the scene
    NxActorDesc actorDesc;
    NxBodyDesc bodyDesc;

    // The actor has one shape, a box
    NxBoxShapeDesc boxDesc;
        boxDesc.dimensions.set( boxDim );

        // this virtual mouse pointer box should not respond to raycasts
        // because it would block our "photo hit test" as it is always between the camera and table
        boxDesc.shapeFlags |= NX_SF_DISABLE_RAYCASTING;

        // we put the box shape at a local "bootom" position within the actor.
        boxDesc.localPose.t = NxVec3( 0.0f, boxDim.y, 0.0f );

        actorDesc.shapes.pushBack( &boxDesc );

    actorDesc.body = &bodyDesc;
    actorDesc.density = 10000.0f;

    this->mouseActor = nxScene->createActor( actorDesc );
        if ( NULL == this->mouseActor )
        {
                logger->log( "createMouseActor() cannot create NxActor" );
                return ERR_MOUSE_CREATE_MOUSE_FAILED;
        }

        this->mouseActor->setName( "MousePointer" );
        // set kind of static behavior. no forces, no gravity...
        this->mouseActor->raiseBodyFlag( NX_BF_KINEMATIC );
        // be invisible for other objects
        this->mouseActor->raiseActorFlag( NX_AF_DISABLE_COLLISION );

        return ERR_OK;
}


// setup our joint with type "DistanceJoint with Spring"
ERR_TYPE Mouse::createDistanceJoint( NxActor* actor, NxVec3 position )
{
        NxDistanceJointDesc jointDesc;
        jointDesc.name = "MousePick";
        jointDesc.actor[0] = actor;
        jointDesc.actor[1] = this->mouseActor;
        // maximum rest length of the rope or rod between the two anchor points
        jointDesc.maxDistance = 2.0f;
        // minimum rest length of the rope or rod between the two anchor points
        jointDesc.minDistance = 1.0f;
        // combination of the bits defined by ::NxDistanceJointFlag
        jointDesc.flags = ( NX_DJF_MIN_DISTANCE_ENABLED | NX_DJF_MAX_DISTANCE_ENABLED );
        
        // compute "pick global pos" to "photo local pos"
        NxMat34 photoInverse;
        actor->getGlobalPose().getInverse( photoInverse );
        NxVec3 photoLocalPos;
        photoInverse.multiply( this->mouseActor->getGlobalPosition(), photoLocalPos );
        photoLocalPos.y = 0.0f; // y: center of photo boundingbox

        // set both anchor points of joint
        jointDesc.localAnchor[0] = photoLocalPos;       // where screen mouse hits photo
        jointDesc.localAnchor[1] = NxVec3(0.0f, 0.0f, 0.0f);    // center of mouse' virtual bounding box

        // makes the joint springy. The spring.targetValue field is not used.
        NxSpringDesc spring;
        spring.spring = 90000.0;
        spring.damper = 80000.0f;
        jointDesc.spring = spring; 
        jointDesc.flags |= NX_DJF_SPRING_ENABLED;
        
        jointDesc.jointFlags |= NX_JF_VISUALIZATION;

        // check if we have done things right
        if ( jointDesc.isValid() )
        {
                this->joint = nxScene->createJoint( jointDesc );
                if ( NULL != joint )
                {
                        //logger->log( "Joint created" );
                }
                else
                {
                        logger->log( "Cannot create joint to pick photo" );
                        return ERR_MOUSE_CREATE_JOINT_FAILED;
                }
        }
        else
        {
                logger->log( "Cannot create joint to pick photo" );
                return ERR_MOUSE_CREATE_JOINT_FAILED;
        }

        return ERR_OK;
}


// setup our joint with type "SphericalJoint"
ERR_TYPE Mouse::createSphericalJoint( NxActor* actor, NxVec3 position )
{
        NxSphericalJointDesc jointDesc;
        jointDesc.name = "MousePick";
        jointDesc.actor[0] = actor;             // set picked photo as joint memeber 1
        jointDesc.actor[1] = this->mouseActor;  // set virtual mouse actor as joint memeber 2
        jointDesc.jointFlags |= NX_JF_VISUALIZATION;            // enable debug visuals
        jointDesc.setGlobalAnchor( position );
        jointDesc.setGlobalAxis( NxVec3(0.0f, 1.0f, 0.0f) );    // +Y is your up-axis
        
        // check if we have done things right
        if ( jointDesc.isValid() )
        {
                this->joint = nxScene->createJoint( jointDesc );
                if ( NULL != joint )
                {
                        //logger->log( "Joint created" );
                }
                else
                {
                        logger->log( "Cannot create joint to pick photo" );
                        return ERR_MOUSE_CREATE_JOINT_FAILED;
                }
        }
        else
        {
                logger->log( "Cannot create joint to pick photo" );
                return ERR_MOUSE_CREATE_JOINT_FAILED;
        }

        return ERR_OK;
}


// return 3D point, where ray hits table
NxVec3 Mouse::getRayIntersectionWithTable( line3df line )
{
        f32 tableSurfaceYPos = 10.0f;

        //create a plane, representing the table
        plane3df tempTable = plane3df( vector3df( -100.0f,  tableSurfaceYPos,  100.0f ),
                                                                   vector3df(  100.0f,  tableSurfaceYPos,  100.0f ),
                                                                   vector3df(    0.0f,  tableSurfaceYPos, -100.0f ) );

        // use irrlicht to get intersection between line and table
        vector3df theIntersection;
        tempTable.getIntersectionWithLimitedLine( line.start, line.end, theIntersection );
        
        // todo: use physx
        NxVec3 result( theIntersection.X, theIntersection.Y, theIntersection.Z );

        return result;
}


// returns a ray from camera to table at mouse position x/y
line3df Mouse::getCameraToTableRay( s32 mouseX, s32 mouseY )
{
        line3df line( 0, 0, 0, 0, 0, 0 );

        ICameraSceneNode* aCam = smgr->getActiveCamera();

        const SViewFrustum* f = aCam->getViewFrustum();

        vector3df farLeftUp = f->getFarLeftUp();
        vector3df lefttoright = f->getFarRightUp() - farLeftUp;
        vector3df uptodown = f->getFarLeftDown() - farLeftUp;

        rect<s32> viewPort = driver->getViewPort();
        dimension2d<s32> screenSize(viewPort.getWidth(), viewPort.getHeight());

        f32 dx = mouseX / (f32)screenSize.Width;
        f32 dy = mouseY / (f32)screenSize.Height;

        line.start = f->cameraPosition;
        line.end = farLeftUp + (lefttoright * dx) + (uptodown * dy);

        return line;
}

---