photo.cpp

#include "main.h"
#include "photo.h"
#include "videoTexture.h"


// default constructor
Photo::Photo()
: nxActor(NULL),
  node(NULL),
  texture(NULL),
  videoTexture(NULL),
  particelNode(NULL),
  particelEmitter(NULL),
  particelAffector(NULL),
  zoomStartPosition(0.0f),
  zoomDirection(0.0f),
  zoomTimeStart(0),
  zoomTimeForWay(0),
  zoomTimeStep(0),
  zoomState(PZS_ZOOMING_FINISHED)
{
        logger->log( "Photo ctor()" );
}

// destructor
Photo::~Photo()
{
        if ( NULL != this->nxActor )
        {
                // todo: Avoid release calls while the scene is simulating (in between simulate() and fetchResults() calls)
                nxScene->releaseActor( *this->nxActor );
                this->nxActor = NULL;
        }
        if ( NULL != this->texture )
        {
                // do not remove texture with "driver->removeTexture()" -> other Photos might still use this texture
                this->texture = NULL;
        }
        if ( NULL != this->particelEmitter )
        {
                this->particelEmitter->drop();
                this->particelEmitter = NULL;
        }
        if ( NULL != this->particelAffector )
        {
                this->particelAffector->drop();
                this->particelAffector = NULL;
        }
        if ( NULL != this->particelNode )
        {
                this->particelNode->removeAllAffectors();
                this->particelNode->remove();
                this->particelNode = NULL;
        }
        if ( NULL != this->node )
        {
                this->node->remove();
                this->node = NULL;
        }
        if ( NULL != this->videoTexture )
        {
                delete this->videoTexture;
                this->videoTexture = NULL;
        }

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


// reorient/reposition the irrlicht sceneNode from data from physX nxActor
// play video
// animate zoom
ERR_TYPE Photo::update( u32 timeMS )
{
        if ( (NULL == this->nxActor) || (NULL == this->node) )
        {
                return ERR_PHOTO_CREATEACTOR_FAILED;
        }

        // transform physx pose to irrlicht
        if ( ! this->nxActor->isSleeping() )
        {
                // this code's from the Beginner Lesson 101 tutorial
                // modified to use for a irrlicht matrix4
                NxMat34 pose = this->nxActor->getGlobalPose();

                const NxVec3 pos = pose.t;
                const NxMat33 orient = pose.M;
                matrix4 irrMat; // a 4x4 matrix in the irrlicht engine
                orient.getColumnMajorStride4( &irrMat[0] );
                pos.get( &irrMat[12] );
                //clear the elements we don't need:
                irrMat[3] = irrMat[7] = irrMat[11] = 0.0f;
                irrMat[15] = 1.0f;

                // with that newly made matrix, let's use it to transform/rotate the node
                if ( NULL != this->node )
                {
                        this->node->setPosition( irrMat.getTranslation() );
                        this->node->setRotation( irrMat.getRotationDegrees() );
                }
        }

        // render video into videoTexture, if present
        if ( NULL != this->videoTexture )
        {
                this->videoTexture->update( timeMS );
        }

        // animate zoom, if active
        if ( PZS_ZOOMING_FINISHED != this->zoomState )
        {
                // zoom is active, check if time for way is over
                NxU32 t = ( timeMS - this->zoomTimeStart );
                NxVec3 pos = this->zoomStartPosition;

                if ( t < this->zoomTimeForWay )
                {
                        // not over yet, animate
                        pos += this->zoomDirection * ((NxF32) t) * this->zoomTimeStep;
                        this->nxActor->moveGlobalPosition( pos );
                }
                else
                {
                        // time is over (either to camera or to table)
                        // check if zoom should finish
                        if ( PZS_ZOOMING_TO_TABLE == this->zoomState )
                        {
                                // reset zoom
                                this->zoomState = PZS_ZOOMING_FINISHED;

                                // re-enable dynamic behavior
                                this->nxActor->clearActorFlag( NX_AF_DISABLE_COLLISION );
                                this->nxActor->clearBodyFlag( NX_BF_KINEMATIC );

                                // clear all added forces while zoom was active
                                this->nxActor->setAngularVelocity( NxVec3(0.0f) );
                                this->nxActor->setLinearVelocity( NxVec3(0.0f) );
                                this->nxActor->wakeUp();
                        }
                }
        }

        return ERR_OK;
}


// apply mesh and texture files and make physX actor
ERR_TYPE Photo::load( stringc meshFileName, stringc textureFileName, vector3df scale )
{
        ERR_TYPE status = ERR_OK;
        stringc err("");

        this->node = smgr->addAnimatedMeshSceneNode( smgr->getMesh( meshFileName.c_str() ) );
        if ( NULL == this->node )
        {
                return ERR_PHOTO_LOAD_FAILED;
        }

        // this checks also if fileName indicates to video or bitmap
        status = this->createTextureWithBoarder( textureFileName );
        if ( (ERR_OK != status) || (NULL == this->texture) )
        {
                err  = "Photo::load() cannot load ";
                err += textureFileName;
                err += " as bitmap. Trying to create as video.";
                logger->log( err.c_str() );

                // irrlicht refused to load bitmap -> try to load as video
                this->videoTexture = new VideoTexture();
                status = this->videoTexture->openStream( textureFileName );
                if ( ERR_OK != status )
                {
                        err  = "Photo::load() cannot load ";
                        err += textureFileName;
                        err += " as video stream.";
                        logger->log( err.c_str() );

                        delete this->videoTexture;
                        this->videoTexture = NULL;
                        this->node->remove();
                        this->node = NULL;
                        return ERR_PHOTO_LOAD_FAILED;
                }

                this->texture = this->videoTexture->getTexture();

                // we cannot handle dynamic light on video textures
                // dynamic lighting NO
                this->node->setMaterialFlag( EMF_LIGHTING, false );

        }
        else
        {
                // irrlicht loaded bitmap with success  
                // dynamic lighting YES
                this->node->setMaterialFlag( EMF_LIGHTING, true );
        }

        // attach (video) texture to mesh
        this->node->setMaterialTexture( 0, this->texture );

        // only allow texture to appear either on front or on back side of cube mesh
        // do not display texture on "side polygons"
        // get the meshBuffer and iterate all vertices
        S3DVertex* vertices = (S3DVertex*) this->node->getMesh()->getMesh(0)->getMeshBuffer(0)->getVertices();
        u32 vertexCount = this->node->getMesh()->getMesh(0)->getMeshBuffer(0)->getVertexCount();
        for ( u32 i=0; i<vertexCount; i++ )
        {
                // check if the normal of the vertex faces not up OR down
                if ( false == vertices[i].Normal.equals( vector3df(0.0f,  1.0f, 0.0f ) ) && 
                         false == vertices[i].Normal.equals( vector3df(0.0f, -1.0f, 0.0f ) ) )
                {
                        // disable texture on side ploygon
                        vertices[i].TCoords.X = 0.0f;
                        vertices[i].TCoords.Y = 0.0f;
                }
        }

        // set irrlicht scale
        this->node->setScale( scale );

        // we want photos to cast shadows 
        // note: irrlicht device must be created with option "use StencilBuffer"
        this->node->addShadowVolumeSceneNode();

        // get irrlicht boundingbox and create a NxActor with its dimension
        this->node->OnAnimate( 0 );     // ensure recalculation of node's pos/rot/scale
        aabbox3df boundingBox = this->node->getTransformedBoundingBox();
        vector3df sizeMax = boundingBox.MaxEdge;
        vector3df sizeMin = boundingBox.MinEdge;
        vector3df size = sizeMax + (-1.0f * sizeMin);

        status = this->createNxActor( size );
        if ( ERR_OK != status )
        {
                this->node->remove();
                this->node = NULL;
                logger->log( "*** Error *** Photo::load() cannot create physX actor" );
                return status;
        }

        return ERR_OK;
}


// this zooms photo either to camera or back to table,
// depending on destinantionPos
ERR_TYPE Photo::zoomStart( NxVec3 destinationPos, NxU32 timeForWayMS )
{
        if ( (NULL == this->nxActor) || (NULL == this->node) )
        {
                return ERR_PHOTO_CREATEACTOR_FAILED;
        }

        // setup zoom, done in update()
        this->zoomStartPosition = this->nxActor->getGlobalPosition();
        this->zoomTimeStart = timer->getRealTime();
        this->zoomTimeForWay = timeForWayMS;
        this->zoomDirection = destinationPos - this->zoomStartPosition;
        NxF32 zoomLength = this->zoomDirection.magnitude();
        this->zoomDirection.normalize();
        this->zoomTimeStep = zoomLength / timeForWayMS;

        // make photo undynmaic
        this->nxActor->raiseActorFlag( NX_AF_DISABLE_COLLISION );
        this->nxActor->raiseBodyFlag( NX_BF_KINEMATIC );

        this->zoomState = PZS_ZOOMING_TO_CAMERA;

        return ERR_OK;
}


// drops photo on table
ERR_TYPE Photo::zoomEnd()
{
        // just zoom back from where we started, but with double speed
        this->zoomStart( this->zoomStartPosition, this->zoomTimeForWay / 2 );
        // overwrite zoom state
        this->zoomState = PZS_ZOOMING_TO_TABLE;

        return ERR_OK;
}


// start to emitt particels around position of this photo
ERR_TYPE Photo::particelStart( irr::core::stringc particelFileName )
{
        // check if particel system is already running
        if ( NULL == this->particelNode )
        {
                // load particel texture
                ITexture* particelTexture = driver->getTexture( particelFileName.c_str() );
                if ( NULL == particelTexture )
                {
                        stringc err( "particelStart() cannot find texture: " );
                        err += particelFileName;
                        logger->log( err.c_str() );
                        return ERR_PHOTO_CREATEPARTICEL_FAILED;
                }

                // setup particel system
                this->particelNode = smgr->addParticleSystemSceneNode();
                this->particelNode->setParticleSize( dimension2d<f32>(100.0f, 100.0f) );
                this->particelNode->setMaterialTexture( 0, particelTexture );
                this->particelNode->setMaterialFlag( EMF_LIGHTING, false );
                this->particelNode->setMaterialType( EMT_TRANSPARENT_ADD_COLOR );

                // create particel emitter, deleted in destrucor
                aabbox3d<f32> emittterBox(-8.0f, -1.0f, -8.0f, 8.0f, 1.0f, 8.0f);
                vector3df emitterDirection(0.0f, 0.02f, 0.0f);
                this->particelEmitter = this->particelNode->createBoxEmitter(   emittterBox,
                                                                                                                                                emitterDirection,
                                                                                                                                                5,                                                      // min particels per second
                                                                                                                                                10,                                                     // max particels per second
                                                                                                                                                SColor(255,255,255,255),        // start color
                                                                                                                                                SColor(255,255,255,255),        // end color
                                                                                                                                                1100,                                           // min life time
                                                                                                                                                2000 );                                         // max life time

                // create particel affector
                this->particelAffector = this->particelNode->createFadeOutParticleAffector();
                this->particelNode->addAffector( this->particelAffector );
        }

        // add some X and some (minor) Z position to final emitting position
        // in order to respect table holes' position
        vector3df particelNodeOffsetPos = this->node->getPosition();
        particelNodeOffsetPos.normalize();
        particelNodeOffsetPos.X *= 20.0f;
        particelNodeOffsetPos.Z *= 2.0f;

        this->particelNode->setPosition( this->node->getPosition() + particelNodeOffsetPos );
        this->particelNode->setEmitter( this->particelEmitter );

        return ERR_OK;
}


// stop emitting particels
ERR_TYPE Photo::particelEnd()
{
        if ( NULL != this->particelNode )
        {
                this->particelNode->setEmitter( NULL );
        }

        return ERR_OK;
}


ERR_TYPE Photo::applyForce( NxVec3 forceVector )
{
        if ( NULL != this->nxActor )
        {
                this->nxActor->addForce( forceVector );
        }
        return ERR_OK;
}

ERR_TYPE Photo::setPosition( NxVec3 newPosition )
{
        if ( NULL != this->nxActor )
        {
                this->nxActor->setGlobalPosition( newPosition );
        }
        return ERR_OK;
}

ERR_TYPE Photo::getPosition( NxVec3* outPosition )
{
        if ( NULL != this->nxActor )
        {
                *outPosition = this->nxActor->getGlobalPosition();
        }
        return ERR_OK;
}




// *** private: ***



ERR_TYPE Photo::createNxActor( vector3df size )
{
        // box dimension in [m] on a side
        NxReal irrToPhysxScaler = 0.5f;         // one unit in irrlicht is 1/2 unit in physx. always.
        NxVec3 boxDim( size.X * irrToPhysxScaler, size.Y * irrToPhysxScaler, size.Z * irrToPhysxScaler );

    // 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 );

        actorDesc.shapes.pushBack( &boxDesc );

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

        actorDesc.userData = (void*) this;

    this->nxActor = nxScene->createActor( actorDesc );
        if ( NULL == this->nxActor )
        {
                return ERR_TABLE_CREATEACTOR_FAILED;
        }

        this->nxActor->setName( "Photo" );

        return ERR_OK;
}


// 1. loads image from file and copies it into center of hand made, white texture
// 2. works only if video card is capable of creating ECF_A8R8G8B8 textures
// 3. keeps original size of loaded image, if video card is capable of creating
//    "non power(2)" textures. else scaling loaded image up to power(2) size (looks messy)
ERR_TYPE Photo::createTextureWithBoarder( stringc imageFileName )
{
        IImage* image = driver->createImageFromFile( imageFileName.c_str() );
        if ( NULL == image )
        {
                return ERR_PHOTO_LOAD_FAILED;
        }

        // get size of image
        dimension2d<s32> imageSize( image->getDimension() );

        // setup final texture size
        dimension2d<s32> textureSize( imageSize );
        // white border size depends on size of loaded image
        s32 borderX = imageSize.Width / 8;
        s32 borderY = imageSize.Height / 8;
        // add border to final texture size
        textureSize.Width  += borderX;
        textureSize.Height += borderY;
        
        // older graphic cards cannot handle odd texture sizes
        if ( false == driver->queryFeature(EVDF_TEXTURE_NPOT) )
        {
                // make width power 2 based
                s32 optimalTextureWidth = 0x01;
                while ( optimalTextureWidth < textureSize.Width )
                {
                        optimalTextureWidth <<= 1;
                }
                textureSize.Width = optimalTextureWidth;

                // make height power 2 based
                s32 optimalTextureHeight = 0x01;
                while ( optimalTextureHeight < textureSize.Height )
                {
                        optimalTextureHeight <<= 1;
                }
                textureSize.Height = optimalTextureHeight;

                // resize image in order to fit into texture nicely with a white border
                dimension2d<s32> scaledImageSize( textureSize.Width - borderX, textureSize.Height - borderY );
                u8* scaledData = (u8*) malloc( scaledImageSize.Width * scaledImageSize.Height * 4 );
                if ( NULL != scaledData )
                {
                        IImage* scaledImage = driver->createImageFromData( ECF_A8R8G8B8, scaledImageSize, scaledData );
                        image->copyToScaling( scaledImage );
                        free( scaledData );
                        // dispose loaded image
                        image->drop();
                        // assign scaled image for copy routine below
                        image = scaledImage;
                        imageSize = scaledImageSize;
                }
                else
                {
                        // out of memory, just copy loaded image into center of (too big) white texture
                        borderX = textureSize.Width - imageSize.Width;
                        borderY = textureSize.Height - imageSize.Height;
                }
        }       // end of old graphic cards

        // hand made texture, fileName just for irrlicht internal "getTexture() by name"
        this->texture = driver->addTexture( textureSize, imageFileName.c_str(), ECF_A8R8G8B8 );
        if ( NULL == this->texture )
        {
                image->drop();
                return ERR_PHOTO_LOAD_FAILED;
        }

        // check if irrlicht could request right color format at device
        ECOLOR_FORMAT colorFormat = this->texture->getColorFormat();
        if ( colorFormat != ECF_A8R8G8B8 )
        {
                logger->log( "createTextureWithBoarder() Warning, texture color format mismatch" );
                image->drop();
                return ERR_PHOTO_LOAD_FAILED;
        }
        
        // need read access from imageData
        u8* imageData = (u8*) image->lock();
        if ( NULL == imageData )
        {
                logger->log( "createTextureWithBoarder() cannot access image data" );
                image->drop();
                return ERR_PHOTO_LOAD_FAILED;
        }

        // need write access to textureData
        u8* textureData = (u8*) this->texture->lock();
        if ( NULL == textureData )
        {
                logger->log( "createTextureWithBoarder() cannot access texture data" );
                image->drop();
                return ERR_PHOTO_LOAD_FAILED;
        }

        // make final texture all white
        memset( textureData, 0xFF, textureSize.Height * textureSize.Width * 4 );

        // clip loaded image into handmade texture and offset some pixels (leave border white)
        // taken from setPixel() @ CImage.cpp in irrlicht source code
        u32 pitch = this->texture->getPitch();
        for (s32 y=0; y<imageSize.Height; y++)
        {
                for (s32 x=0; x<imageSize.Width; x++)
                {
                        s32 color = image->getPixel( x, y ).color;
                        u32* dest = (u32*) ((u8*) textureData + ( (y+borderY/2) * pitch ) + ( (x+borderX/2) << 2 ));
                        *dest = color;
                }
        }

        this->texture->unlock();
        image->unlock();

        // we create it, we destroy it
        image->drop();

        return ERR_OK;
}

---