laObject.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: laObject.cpp
//
// This base class begins the class hierarchy of all dynamic objects that placed in a level
//
// Copyright (C) 2007-2013 Atanas Laskov, <latanas@gmail.com>
//
#include "stdafx.h"
#include "Core-Level-JR.h"

laTexture laObject::_texShadow;

// Constructor
//
laObject::laObject()
{
    _nNext_ID = 0;

    _strTSName[0]=0;
    _pLevel   = NULL;
    _pTileset = NULL;
    _pTSObject  = NULL;
    _nTSIndex = 0;

    //_pNestedObject = NULL;

    _outline = laOutline(M_TRUE, laColor(), 0.8);
    _color = laColor(255,255,255);
    _bLightOn = M_TRUE;
}

// Destructor
laObject::~laObject(void)
{
    //while( nestedGet() ) nestedRemove(M_TRUE);
    //MSG("ssd");

    _nested_destroy();
}

// Respawn. Revert object to its original state
//
void laObject::respawn()
{
    ERRORLEVEL_BEGIN;

    _nested_destroy();

    if( _ai.isActive() ) _ai.reset();

    ERRORLEVEL_END;
}

// Dynamicly create a new object
//
void laObject::create(laPoint3 pos)
{
    ERRORLEVEL_BEGIN;

    _ptPivot.size = _pTSObject->getPoint("bounding-box");
    _ptPivot = pos; // + laPoint3(((laElement*)_pObject)->getBoundingPos() - _ptPivot.size);

    ERRORLEVEL_END;
}

// Load the object from file
//
void laObject::load(class laFileParser *fp)
{
    ERRORLEVEL_BEGIN;
    ASSERT(_pTileset, "Nil tileset");

    laEnvironment_win32* pCE = ((laEnvironment_win32*)::laSystemIntegrator::getEnvironment());
    unsigned   seg;
    laPoint3 offset;

    //Get an object pointer from the tileset
    _pTSObject = _pTileset->getElement(_nTSIndex);

    //Read the position of the object
    //
    fp->readUnsigned(&seg);
    fp->readObj(&offset, M_FALSE);

    _ptPivot.x( M_UNIT*M_SEGW*seg + offset.x()*M_UNIT + M_UNIT/2.0 );
    _ptPivot.y( offset.y()*M_UNIT );
    _ptPivot.z( offset.z()*M_UNIT + M_UNIT/2.0 );

    //Lazy-load shadow texture
    if(!_texShadow.id())
        _texShadow.load("particle_generic.png", M_TEX_TMAP);

    // Setup bounding-box
    //
    if( _pTSObject->getModelCnt() )
    {
        _ptPivot.size  = _pTSObject->getPoint("bounding-box");
    }
    else
    {
        //No models, set an arbitrary size
        _ptPivot.size = laPoint3(M_UNIT/2.0, M_UNIT/2.0);
    }

    // Set color
    try{ _color = this->getObject()->getColor("color"); }
    catch(laError_PropertyNotDefined&){
        _color = laColor(255,255,255,255);
    }

    // Load AI
    //
    try{
        char* strAI = getObject()->getText("ai-type");

        laFileParser fp_ai( getObject()->getText("ai-type") );

        if(_pLevel->getObjCnt())
            _ai.controllers(this, (aiController*)(_pLevel->getPlayer()), _pLevel->getGlobalPercepts() );
        else
            _ai.controllers(this, this, _pLevel->getGlobalPercepts() );

        _ai.load( &fp_ai );
        _ai.activate();
    }
    catch(laError_PropertyNotDefined& p){
        _ai.activate(M_FALSE);
    }

    // For static objects shadow can be projected only 1ce,
    // no need to do it on very frame
    _ptPivot.projectShadow();

    ERRORLEVEL_END;
}

// Prepare the tranformation matrix for drawing the object
//
void laObject::_offset(laRenderer *r, laPoint3 ptBasePos)
{
    ERRORLEVEL_BEGIN;
    PROFILE_REN(laObject__offset);

    // Note: This is a workover for the laState_Intro,
    // where an object is created for the narrator, without link to the level
    if(!_pLevel) return;

    // Get terrain offset and curviture
    //
    double dTileOffset = _pLevel->terrainZOffset_atPixel(_ptPivot.x());

    laPoint3 pos(0,0,dTileOffset);
    pos += ptBasePos + _ptPivot;

    // Move and rotate geometry
    //
    r->transTranslate( pos + _ptPivot.ptGeometryOffset );

    ERRORLEVEL_END;
}

void laObject::_rotation(laRenderer *r)
{
    ERRORLEVEL_BEGIN;
    PROFILE_REN(laObject__rotation);

    // Note: This is a workover for the laState_Intro,
    // where an object is created for the narrator, without link to the level
    if(!_pLevel) return;

    // Get terrain offset and curviture
    //
    double dTileAngle  = _pLevel->terrainAngle_atPixel(_ptPivot.x());

    // Rotate geometry
    //
    r->transRotate(dTileAngle + _ptPivot.angleY, laPoint3(0,1,0));
    r->transRotate(_ptPivot.angleX, laPoint3(1,0,0));
    r->transRotate(_ptPivot.angleZ, laPoint3(0,0,1));

    ERRORLEVEL_END;
}

void laObject::_offset_and_rotation(laRenderer *r, laPoint3 ptBasePos) {
    PROFILE_REN(laObject__offset_and_rotation);
    _offset(r, ptBasePos);
    _rotation(r);
}

void laObject::_set_style(laRenderer *r) {
    PROFILE_REN(laObject__set_style);
    r->styleSet(_color);
    r->modeOutline(_outline);
    //r->modeLight(_bLightOn);
}

// Draw the object geometry
//
void laObject::drawGeometry(laRenderer *r, laPoint3 ptBasePos)
{
    _set_style(r);

    r->transPush();
        _offset(r, ptBasePos);
        this->_draw_positioned(r);      //< laObject derivatives can overload this method

        _rotation(r);
        this->_draw_positioned_rotated(r);
    r->transPop();

    this->_draw_notrans(r, ptBasePos);  //< laObject derivatives can overload this method
}

void laObject::_draw_positioned(laRenderer *r) {
}

void laObject::_draw_positioned_rotated(laRenderer *r) {
    _pTSObject->drawGeometry( r );
}

void laObject::_draw_notrans(laRenderer *r, laPoint3 ptBasePos) {
    _nested_draw(r, ptBasePos);
}

// Draw the object's associated effects;
// this method also draws a pseudo-shadow projected beneath the object
//
void laObject::drawFx(laRenderer *r, laPoint3 ptBasePos)
{
    r->transPush();
        _offset(r, ptBasePos);
        this->_drawFx_positioned(r);        //< laObject derivatives can overload this method

        // NOTE: Rotation doesnt really matter for Fx; Don't calculate rot
        //_rotation(r);
        //this->_drawFx_positioned_rotated(r);
    r->transPop();

    this->_drawFx_notrans(r, ptBasePos);    //< laObject derivatives can overload this method
}

void laObject::_drawFx_positioned(laRenderer *r) {
    _draw_shadow_fx( r );
    _pTSObject->drawFx( r );
}

void laObject::_drawFx_positioned_rotated(laRenderer *r) {
}

void laObject::_drawFx_notrans(laRenderer *r, laPoint3 ptBasePos) {
    _nested_draw_fx(r, ptBasePos);
}

// Draw the object's associated GUI
//
void laObject::drawInterface(laRenderer *r, laPoint3 ptBasePos) {
    _nested_draw_interface(r, ptBasePos);
}

// Draw a shadow under the object
//
void laObject::_draw_shadow_fx(laRenderer *r)
{
    ERRORLEVEL_BEGIN;
    PROFILE_REN(laObject__draw_shadow_fx);

    // Shadow pos
    //
    double w    = M_MIN(M_UNIT, _ptPivot.size.x() * 0.9);
    laPoint3 pt1( -w/2.0, _ptPivot.dShadowY - _ptPivot.y(), -w/2.0 );

    double distance = M_MIN(1, M_ABS(_ptPivot.dShadowY - _ptPivot.y())/(M_UNIT*6.0) );
    unsigned alpha  = (1-distance) * 220;

    // Draw shadow
    //
    static laPoint3 p[3] = { laPoint3(w,0,0), laPoint3(w,0,w), laPoint3(0,0,w) };
    static laPoint2 uv[4] = { laPoint3(0,0), laPoint3(0,1), laPoint3(1,1), laPoint3(1,0) };

    laPoint3 *pquad = r->vquadsData(0);
    *(pquad++) = pt1;
    *(pquad++) = pt1 + p[0];
    *(pquad++) = pt1 + p[1];
    *(pquad++) = pt1 + p[2];

    r->styleSet(laColor(0,0,0,alpha));
    _texShadow.use();
    r->vquadsDraw(1, uv);

    //r->drawRect(pt1, laPoint3(w, 0, w), laPoint2(), laPoint2(1,1));

    // Draw messages
    // NOTE: Messages are not drawn camera facing, and this can be fixed by doing rot( -camera_angy ),
    // but it's nice the way it is
    //
    fxMessages.draw(r, laPoint3(0, -1.1*_ptPivot.size.y(), 0) );
    ERRORLEVEL_END;
}

void laObject::_execute_ai(laTimer &t)
{
    ERRORLEVEL_BEGIN;
    PROFILE_ANIM(laObject__execute_ai);

    // Perceive player distance
    //
    laPlayer *pPlayer = (laPlayer*)( getLevelObject()->getPlayer() );
    laLine2 ln(pPlayer->getPosition(), _ptPivot);
    double dPlayer = ln.lenght();

    _ai.perceive(P__PLAYER_DISTANCE, aiPerceptData(dPlayer));

    // Execute AI
    _ai.execute(&t);
    _ai.perceptsClear();

    ERRORLEVEL_END;
}

// Animate the object
//
void laObject::animate(laTimer &t)
{
    ERRORLEVEL_BEGIN;
    PROFILE_ANIM(laObject_animate);

    // Animate pivot physics
    // NOTE: It is best to keep this commented, as most object don't really need colision detection etc.
    // Inherited objects that need it (e.g. laMovingCreature) should make this call for themselves
    //
    //_ptPivot.simulate(t);

    if(_ai.isActive()) this->_execute_ai(t);

    fxMessages.animate(t);

    _nested_animate(t);
    //if(_pNestedObject)
    //  _pNestedObject->animate(t);

    ERRORLEVEL_END;
}

void  laObject::_nested_draw(laRenderer *r, laPoint3 ptBasePos)
{
    ERRORLEVEL_BEGIN;
    std::map<unsigned, laObject*>::iterator i;

    for(i = _mNestedObjects.begin(); i != _mNestedObjects.end(); i++){
        (*i).second->drawGeometry(r, ptBasePos);
    }

    ERRORLEVEL_END;
}

void  laObject::_nested_draw_fx(laRenderer *r, laPoint3 ptBasePos)
{
    ERRORLEVEL_BEGIN;
    std::map<unsigned, laObject*>::iterator i;

    for(i = _mNestedObjects.begin(); i != _mNestedObjects.end(); i++){
        (*i).second->drawFx(r, ptBasePos);
    }

    ERRORLEVEL_END;
}

void  laObject::_nested_draw_interface(laRenderer *r, laPoint3 ptBasePos)
{
    ERRORLEVEL_BEGIN;
    std::map<unsigned, laObject*>::iterator i;

    for(i = _mNestedObjects.begin(); i != _mNestedObjects.end(); i++){
        (*i).second->drawInterface(r, ptBasePos);
    }

    ERRORLEVEL_END;
}

void  laObject::_nested_animate(laTimer &t)
{
    ERRORLEVEL_BEGIN;
    std::map<unsigned, laObject*>::iterator i;

    for(i = _mNestedObjects.begin(); i != _mNestedObjects.end(); i++){
        (*i).second->animate(t);
    }

    ERRORLEVEL_END;
}

void laObject::_nested_destroy()
{
    ERRORLEVEL_BEGIN;
    std::map<unsigned, laObject*>::iterator i;

    for(i = _mNestedObjects.begin(); i != _mNestedObjects.end(); i++){
        delete (*i).second;
    }
    _mNestedObjects.clear();

    ERRORLEVEL_END;
}