laTile.cpp

/*

Jump'n'Run Engine
http://www.atanaslaskov.com/jnr/

BSD LICENSE
Copyright (c) 2007-2013, Atanas Laskov
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL ATANAS LASKOV BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

//
// FILE: laTile.cpp
//
// Copyright (C) 2007-2013 Atanas Laskov, <latanas@gmail.com>
//
#include "stdafx.h"
#include "Core-Level-JR.h"

// Constructor
//
laTile::laTile(void)
{
    _pSegment = NULL;
    _nSegX = _nSegY = 0;

    _pTileset = NULL;

    _nTileIndex = 0;
    _pTile      = NULL;
    _nVaration  = 0;

    _pTrap = NULL;
}

laTile::~laTile(void){

    if(_pTrap)
    {
        delete _pTrap;
        delete _pfxTrap;
    }
}

// Read the tile form file
//
void laTile::load(class laFileParser *fp)
{
    fp->readUnsigned(&_nTileIndex, M_FALSE);

    ASSERT(_pTileset, "Nil tileset");
    ASSERT( _pTileset->getElementCnt() >_nTileIndex,
        "Tile index %u exceeds tileset size %u", _nTileIndex, _pTileset->getElementCnt());

    _pTile = _pTileset->getElement(_nTileIndex);

    // Try to load a trap
    //
    try{
        // Locate the specified trap elment (if any)
        //
        unsigned nTrap = _pTileset->getElementIndex( _pTile->getText("trap-name") );
        laPropertyList* pTrapElem = _pTileset->getElement( nTrap );//_pTile->getChild("trap");

        // Extract properties
        //
        _pTrap = new rpgTrap();
        _pTrap->load( pTrapElem );

        _rgbTrap = pTrapElem->getColor("color");
        _texTrap.load( pTrapElem->getText("texture") );

        // NOTE: it is also necessary to create a copy of the particle Fx,
        // because the angle of the emitter changes dynamically for each trap;
        // Fixing the emitter for the same trap won't work because all particles must follow
        //
        _pfxTrap = new fxParticleSystem();
        _pfxTrap->create(pTrapElem->getFx("fx")->parameters);

        _pfxTrap->parameters.gen_linearEmitter = M_TRUE;
        _pfxTrap->lnEmitter.origin = laPoint3(0, - M_UNIT*1.5, M_UNIT*0.4);
    }
    catch(laError_PropertyNotDefined&){ _pTrap = NULL; _pfxTrap = NULL; };
}

// Draw the 3D geometry associated with a tile
//
void laTile::drawGeometry(laRenderer *r) {
    ASSERT(_pTile, "Nil tile");
    _pTile->drawGeometry(r);
    //_domain.draw(r, laPoint3());
}

// Draw animated geometry that can't be cached
//
void laTile::drawDynamicGeometry(laRenderer *r)
{
    PROFILE_REN(laTile_drawDynamicGeometry);
    ASSERT(_pTile, "Nil tile TS object");

    // Draw animated lava surface
    //
    double dOffsetDelta = _pSegment->terrainZOffset(_nSegX) - _pSegment->terrainZOffset(_nSegX+1);
    double dLenght = sqrt( M_UNIT*M_UNIT + dOffsetDelta*dOffsetDelta );

    double y0  = _pSegment->getWave(_nSegX)*WAVE_AMPLITUDE - M_LAVASURFACE_OFFSET;
    double y1  = _pSegment->getWave(_nSegX+1)*WAVE_AMPLITUDE - M_LAVASURFACE_OFFSET;

    double an0 = _pSegment->terrainAngle(_nSegX-1);
    double an1 = _pSegment->terrainAngle(_nSegX);
    double an2 = _pSegment->terrainAngle(_nSegX+1);
    double sin1=sin(0.5*(an0-an1)), cos1=cos(0.5*(an0-an1));
    double sin2=sin(0.5*(an2-an1)), cos2=cos(0.5*(an2-an1));

    double v   = _pTileset->getAnimatedOffset()*0.1;

    laPoint3 *pquad = r->vquadsData(0);
    laPoint2 *puv = r->vquadsTexCoord(0);

    laPoint3 ptStart(0, y0, M_UNIT/2.0);
    laPoint3 ptEnd(dLenght, y1, M_UNIT/2.0);

    *(pquad++) = ptStart + 0.5*M_UNIT*laPoint3(sin1, 0, cos1);
    *(pquad++) = ptStart - 0.5*M_UNIT*laPoint3(sin1, 0, cos1);
    *(pquad++) = ptEnd   - 0.5*M_UNIT*laPoint3(sin2, 0, cos2);
    *(pquad++) = ptEnd   + 0.5*M_UNIT*laPoint3(sin2, 0, cos2);

    *(puv++) = laPoint2(0.7, v);
    *(puv++) = laPoint2(1, v);
    *(puv++) = laPoint2(1, v+1);
    *(puv++) = laPoint2(0.7, v+1);

    r->styleSet( _rgbTrap );
    _texTrap.use();
    r->vquadsDrawSingle();

    /*r->drawRect(
        laPoint3(0, y0, 0),
        laPoint3(dScale + 0.01, dy, M_UNIT*0.9 ),
        laPoint2(0.7, v), laPoint2(0.3, 1),
        an1, an2, M_FALSE);*/
}

// Draw the effects associated with a tile
//
void laTile::drawFx(laRenderer *r)
{
    ASSERT(_pTile, "Nil tile TS object");

    // Attach particle fx to lava surface
    //
    if( _pTrap )
    {
        double dCurrentOffset   = _pSegment->terrainZOffset( _nSegX );
        double dNextOffset      = _pSegment->terrainZOffset( _nSegX+1 );
        double _y0  = _pSegment->getWave( _nSegX )*WAVE_AMPLITUDE;
        double _y1  = _pSegment->getWave( _nSegX+1 )*WAVE_AMPLITUDE;

        _pfxTrap->lnEmitter.vector[0] = M_UNIT;
        _pfxTrap->lnEmitter.vector[2] = dNextOffset - dCurrentOffset;
        _pfxTrap->lnEmitter.vector[1] = _y1 - _y0;

        r->transPush();
        r->transTranslate( laPoint3(0, _y0, 0) );
        _pfxTrap->draw(r);
        r->transPop();
    }

    _pTile->drawFx(r);
}

// Animate the tile
//
void laTile::animate(laTimer &t){
    if( _pTrap )    _pfxTrap->animate( t );
}

// Build collision domain
//
// This information is extracted from the correspodning 3D models in the tileset
// and positioned at the appropriate location
//
unsigned  laTile::bulidDomain(laPoint3 pos)
{
    ASSERT(_pTile, "Nil tile TS element");

    _domain.offset(pos);
    _pTile->buildCollisionData(&_domain, _pTrap);
    _domain.updateBounds();

    return _domain.countLines();
}

// Terrain curviture
//

double laTile::getOffset() {
    return _pSegment->terrainZOffset(_nSegX);
}

double laTile::getAngle() {
    return _pSegment->terrainAngle(_nSegX);
}