Petari/source/Game/Map/Sky.cpp

#include "Game/Map/Sky.hpp"
#include "Game/LiveActor/MirrorReflectionModel.hpp"
#include "Game/Map/SpaceInner.hpp"

NrvSky::HostTypeWait NrvSky::HostTypeWait::sInstance;
NrvSky::HostTypeChange NrvSky::HostTypeChange::sInstance;

Sky::Sky(const char *pSkyName) : LiveActor(pSkyName) {
    mSpaceInner = 0;
    mReflectionModel = 0;
}

void Sky::init(const JMapInfoIter &rIter) {
    MR::initDefaultPos(this, rIter);
    const char* objectName = 0;
    MR::getObjectName(&objectName, rIter);
    initModel(objectName);
    MR::connectToSceneSky(this);
    MR::useStageSwitchReadA(this, rIter);
    MR::useStageSwitchReadB(this, rIter);
    MR::useStageSwitchReadAppear(this, rIter);

    if (MR::isEqualString(objectName, "SummerSky")) {
        mSpaceInner = new SpaceInner("内側宇宙");
        mSpaceInner->initWithoutIter();

        if (MR::isValidSwitchB(this)) {
            void (Sky::*d)(void) = &Sky::disappearSpaceInner;
            void (Sky::*a)(void) = &Sky::appearSpaceInner;
            MR::listenStageSwitchOnOffB(this, MR::Functor(this, d), MR::Functor(this, a));
        } 
    }

    s32 arg = -1;
    MR::getJMapInfoArg0NoInit(rIter, &arg);

    if (!arg) {
        mReflectionModel = new MirrorReflectionModel(this, "鏡内モデル", objectName, getBaseMtx());
        mReflectionModel->initWithoutIter();
    }

    MR::tryStartAllAnim(this, objectName);

    if (mReflectionModel) {
        MR::tryStartAllAnim(mReflectionModel, objectName);
    }

    MR::invalidateClipping(this);
    MR::registerDemoSimpleCastAll(this);
    initNerve(&NrvSky::HostTypeWait::sInstance);

    if (MR::isValidSwitchAppear(this)) {
        MR::syncStageSwitchAppear(this);
        makeActorDead();
    }
    else {
        makeActorAppeared();
    }
}

void Sky::calcAnim() {
    TVec3f pos = MR::getCamPos();
    mPosition.x = pos.x;
    mPosition.y = pos.y;
    mPosition.z = pos.z;
    LiveActor::calcAnim();
}

void Sky::initModel(const char *pModelName) {
    initModelManagerWithAnm(pModelName, 0, false);
}

void Sky::control() {
    if (mSpaceInner && MR::isValidSwitchB(this)) {
        if (MR::isDead(mSpaceInner)) {
            MR::showModelIfHidden(this);
        }
        else {
            if (mSpaceInner->isAppeared()) {
                MR::hideModelIfHidden(this);
            }
            else {
                MR::showModelIfHidden(this);
            }
        }
    }
}

void Sky::appearSpaceInner() {
    if (mSpaceInner && MR::isValidSwitchB(this)) {
        mSpaceInner->appear();
    }
}

void Sky::disappearSpaceInner() {
    if (mSpaceInner && MR::isValidSwitchB(this)) {
        mSpaceInner->disappear();
    }
}

ProjectionMapSky::ProjectionMapSky(const char *pSkyName) : Sky(pSkyName) {
    mMtxSetter = 0;
}

Sky::~Sky() {

}

void ProjectionMapSky::calcAndSetBaseMtx() {
    LiveActor::calcAndSetBaseMtx();

    if (mMtxSetter) {
        mMtxSetter->updateMtxUseBaseMtx();
    }
}

void ProjectionMapSky::initModel(const char *pName) {
    initModelManagerWithAnm(pName, 0, true);
    mMtxSetter = MR::initDLMakerProjmapEffectMtxSetter(this);
    MR::newDifferedDLBuffer(this);
    mMtxSetter->updateMtxUseBaseMtx();
}

namespace NrvSky {
    void HostTypeChange::execute(Spine *pSpine) const {
        Sky* sky = reinterpret_cast<Sky*>(pSpine->mExecutor);

        if (MR::isFirstStep(sky)) {
            MR::startAllAnim(sky, cChangeAnimName);
        }
    }

    void HostTypeWait::execute(Spine *pSpine) const {
        Sky* sky = reinterpret_cast<Sky*>(pSpine->mExecutor);

        if (MR::isValidSwitchA(sky) && MR::isOnSwitchA(sky)) {
            sky->setNerve(&NrvSky::HostTypeChange::sInstance);
        }
    }
};

ProjectionMapSky::~ProjectionMapSky() {

}