CWE-ou-minkata/Sources/Plasma/PubUtilLib/plSurface/plLayerInterface.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/

#include "hsTypes.h"
#include "plLayerInterface.h"
#include "plMessage/plLayRefMsg.h"
#include "plLayer.h"
#include "hsMatrix44.h"
#include "hsGMatState.h"
#include "hsResMgr.h"
#include "pnNetCommon/plSDLTypes.h"

plLayerInterface::plLayerInterface() 
:   fUnderLay(nil),
    fOverLay(nil),
    fState(nil), 
    fTransform(nil), 
    fPreshadeColor(nil),
    fRuntimeColor(nil),
    fAmbientColor(nil),
    fOpacity(nil),
    fTexture(nil),
    fUVWSrc(nil),
    fLODBias(nil),
    fSpecularColor(nil),
    fSpecularPower(nil),
    fOwnedChannels(0),
    fPassThruChannels(0),
    fVertexShader(nil),
    fPixelShader(nil),
    fBumpEnvXfm(nil)
{

}

plLayerInterface::~plLayerInterface()
{
    if( fUnderLay )
        Detach(fUnderLay);

    delete fState;
    delete fPreshadeColor;
    delete fRuntimeColor;
    delete fAmbientColor;
    delete fSpecularColor;
    delete fOpacity;
    delete fTransform;

    delete fTexture;
    
    delete fUVWSrc;
    delete fLODBias;
    delete fSpecularPower;

    delete fVertexShader;
    delete fPixelShader;

    delete fBumpEnvXfm;
}

void plLayerInterface::ISetPassThru(UInt32 chans)
{
    fPassThruChannels |= chans;
    if( fOverLay )
        fOverLay->ISetPassThru(chans);

    // Since plLayerAnimation is the only derived class that uses its
    // fPassThruChannels info, it's the only one that actually saves
    // it to state.
    DirtySynchState(kSDLLayer, 0);
}

// The arbitration rules for different layers on the same stack
// wanting to control the same channel are currently:
// 1) Only one write-only value setter can be active at a time,
//      otherwise results are undefined.
// 2) A layer will only become active due to receiving a message.
// 3) A channel value for the stack is the value as set by the
//      last layer that was active. If no layers have ever been
//      active, the value is the static value of the bottom of the stack.
// 4) Since the stack is only Eval'd when visible, the third rule
//      must appear to be true when different layers become active
//      and inactive without ever having been Eval'd.
// 5) Taking advantage of rules 1) and 2), it follows that the last
//      layer to have become active on response to a message is also
//      the last layer to have been active.
// 6) So when a layer becomes active in it's MsgReceive(), it notifies
//      all channels above it that it now owns its channels, and they
//      should just pass through those channel values.
// Note that a layer may claim ownership of its channels but then lose
//      ownership (because another layer went active) before ever having
//      been Eval'd.
void plLayerInterface::ClaimChannels(UInt32 chans)
{
    if( fOverLay )
        fOverLay->ISetPassThru(chans);
    fPassThruChannels &= ~chans;
    DirtySynchState(kSDLLayer, 0);
}

UInt32 plLayerInterface::Eval(double secs, UInt32 frame, UInt32 ignore)
{
    if( fUnderLay )
        return fUnderLay->Eval(secs, frame, ignore);

    return UInt32(0);
}

// Export Only
void plLayerInterface::AttachViaNotify(plLayerInterface *prev)
{
    plLayRefMsg* refMsg = TRACKED_NEW plLayRefMsg(GetKey(), plRefMsg::kOnCreate, 0, plLayRefMsg::kUnderLay);
    hsgResMgr::ResMgr()->AddViaNotify(prev->GetKey(), refMsg, plRefFlags::kActiveRef);
}

plLayerInterface* plLayerInterface::Attach(plLayerInterface* prev)
{
    if( !prev )
        return this;

    if( fUnderLay == prev )
        return this;

    if( fUnderLay )
    {
        fUnderLay->Attach(prev);
        prev = fUnderLay;
    }

    if( !OwnChannel(kState) )
        fState = prev->fState;

    if( !OwnChannel(kPreshadeColor) )
        fPreshadeColor = prev->fPreshadeColor;

    if( !OwnChannel( kRuntimeColor ) )
        fRuntimeColor = prev->fRuntimeColor;

    if( !OwnChannel(kAmbientColor) )
        fAmbientColor = prev->fAmbientColor;

    if( !OwnChannel( kSpecularColor ) )
        fSpecularColor = prev->fSpecularColor;

    if( !OwnChannel(kOpacity) )
        fOpacity = prev->fOpacity;

    if( !OwnChannel(kTransform) )
        fTransform = prev->fTransform;

    if( !OwnChannel(kTexture) )
        fTexture = prev->fTexture;

    if( !OwnChannel(kUVWSrc) )
        fUVWSrc = prev->fUVWSrc;

    if( !OwnChannel(kLODBias) )
        fLODBias = prev->fLODBias;

    if( !OwnChannel(kSpecularPower) )
        fSpecularPower = prev->fSpecularPower;

    if( !OwnChannel(kVertexShader) )
        fVertexShader = prev->fVertexShader;

    if( !OwnChannel(kPixelShader) )
        fPixelShader = prev->fPixelShader;

    if( !OwnChannel(kBumpEnvXfm) )
        fBumpEnvXfm = prev->fBumpEnvXfm;

    fUnderLay = prev;
    prev->fOverLay = this;

    return this;
}

void plLayerInterface::IUnthread()
{
    if( fUnderLay )
    {
        if( !OwnChannel(kState) )
            fState = nil;
        if( !OwnChannel(kPreshadeColor) )
            fPreshadeColor = nil;
        if( !OwnChannel( kRuntimeColor ) )
            fRuntimeColor = nil;
        if( !OwnChannel(kAmbientColor) )
            fAmbientColor = nil;
        if( !OwnChannel( kSpecularColor ) )
            fSpecularColor = nil;
        if( !OwnChannel(kOpacity) )
            fOpacity = nil;
        if( !OwnChannel(kTransform) )
            fTransform = nil;
        if( !OwnChannel(kTexture) )
            fTexture = nil;

        if( !OwnChannel(kUVWSrc) )
            fUVWSrc = nil;
        if( !OwnChannel(kLODBias) )
            fLODBias = nil;
        if( !OwnChannel(kSpecularPower) )
            fSpecularPower = nil;

        if( !OwnChannel(kVertexShader) )
            fVertexShader = nil;
        if( !OwnChannel(kPixelShader) )
            fPixelShader = nil;

        if( !OwnChannel(kBumpEnvXfm) )
            fBumpEnvXfm = nil;

        fUnderLay->fOverLay = nil;
        fUnderLay = nil;
    }
}

// Detach:
// If we are the one being detached, break our links to underlay
//      and then return nil, since everything has just been detached
//      from the stack.
// If our underlay is the one being detached, we need to unthread from it
//      and return ourselves.
// If it's not us, and not our underlay, just pass it to our underlay and let
//      it deal.
//
// Return value is new TOP of stack. li is now top of a separate stack.
plLayerInterface* plLayerInterface::Detach(plLayerInterface* li)
{
    if( li == this )
        return nil;

    if( li == fUnderLay )
    {
        IUnthread();
        return this;
    }

    fUnderLay->Detach(li);

    return this;
}

// Remove:
// If we are the one being removed, break our links to underlay
//      and then just return underlay, since it doesn't even know 
//      about our existence (so it doesn't need to know about the remove).
// If our underlay is the one being removed, we need to unthread it from
//      its underlay (if any), and then thread ourselves onto the underlay's 
//      former underlay.
// If it's not us, and not our underlay, just pass it to our underlay and let
//      it deal.
//
// Return value is new TOP of stack.
plLayerInterface* plLayerInterface::Remove(plLayerInterface* li)
{
    plLayerInterface* under = fUnderLay;

    if( li == this )
    {
        
        IUnthread();

        return under;
    }

    // This is an error, because it means we're being asked
    // to detach from something we aren't attached to.
    if( !under )
    {
        hsAssert(false, "Detaching from unknown layerinterface");
        return this;
    }

    IUnthread();

    plLayerInterface* newUnderLay = under->Remove(li);

    Attach(newUnderLay);

    return this;
}

plLayerInterface *plLayerInterface::GetAttached()
{
    return fUnderLay;
}

void plLayerInterface::Read(hsStream* s, hsResMgr* mgr)
{
    plSynchedObject::Read(s, mgr);

    plLayRefMsg* refMsg = TRACKED_NEW plLayRefMsg(GetKey(), plRefMsg::kOnCreate, 0, plLayRefMsg::kUnderLay);    
    plKey key = mgr->ReadKeyNotifyMe(s,refMsg, plRefFlags::kActiveRef);
    if( key && !fUnderLay )
        Attach(plLayer::DefaultLayer());

    // Temporary setting default netgroup by our key.
    SetNetGroup(SelectNetGroup(GetKey()));
}

void plLayerInterface::Write(hsStream* s, hsResMgr* mgr)
{
    plSynchedObject::Write(s, mgr);

    mgr->WriteKey(s, fUnderLay);
}

hsBool plLayerInterface::MsgReceive(plMessage* msg)
{
    plLayRefMsg* refMsg = plLayRefMsg::ConvertNoRef(msg);
    if( refMsg )
    {
        switch( refMsg->fType )
        {
        case plLayRefMsg::kUnderLay:
            {
                plLayerInterface* underLay = plLayerInterface::ConvertNoRef(refMsg->GetRef());
                if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
                {
                    if( fUnderLay )
                        Detach(fUnderLay);

                    Attach(underLay);
                }
                else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
                {
                    Detach(fUnderLay);
                }
                return true;
            }
        }
    }
    return plSynchedObject::MsgReceive(msg);
}