CWE-ou-minkata/Sources/Plasma/PubUtilLib/plModifier/plLayerSDLModifier.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 "hsMatrix44.h"
#include "plLayerSDLModifier.h"
#include "plSDL/plSDL.h"
#include "plSurface/plLayerAnimation.h"

// static vars
char plLayerSDLModifier::kStrAtc[]="atc";
char plLayerSDLModifier::kStrPassThruChannels[]="passThruChannels";
char plLayerSDLModifier::kStrTransform[]="transform";
char plLayerSDLModifier::kStrChannelData[]="channelData";
//char plLayerSDLModifier::kStrPreShadeColor[]="preshadeColor";
//char plLayerSDLModifier::kStrRuntimeColor[]="runtimeColor";
//char plLayerSDLModifier::kStrAmbientColor[]="ambientColor";
//char plLayerSDLModifier::kStrOpacity[]="opacity";

plKey plLayerSDLModifier::GetStateOwnerKey() const
{ 
    return fLayerAnimation ? fLayerAnimation->GetKey() : nil; 
}

//
// Copy atc from current state into sdl
//
void plLayerSDLModifier::IPutCurrentStateIn(plStateDataRecord* dstState)
{
    plLayerAnimation* layer=GetLayerAnimation();
    hsAssert(layer, "nil layer animation");

    plSDStateVariable* atcVar = dstState->FindSDVar(kStrAtc);
    plStateDataRecord* atcStateDataRec = atcVar->GetStateDataRecord(0);
    IPutATC(atcStateDataRec, &layer->GetTimeConvert());

    int passThru=layer->fPassThruChannels;
    dstState->FindVar(kStrPassThruChannels)->Set(passThru);

    int transformSize = 0;
    if (layer->fTransform && (layer->fOwnedChannels & plLayerInterface::kTransform))
        transformSize = 16;

    plSimpleStateVariable *transformVar = dstState->FindVar(kStrTransform);
    if (transformVar->GetCount() != transformSize)
        transformVar->Alloc(transformSize);
    
    if (transformSize > 0)
    {
        int i,j;
        for(i=0;i<4;i++)
        {
            for(j=0;j<4;j++)
            {
                float f=layer->fTransform->fMap[i][j];
                transformVar->Set(&f, i*4+j);
            }
        }
    }

    int channelDataSize = 0;
    if (layer->fPreshadeColor && (layer->fOwnedChannels & plLayerInterface::kPreshadeColor))
        channelDataSize += 3;
    if (layer->fRuntimeColor && (layer->fOwnedChannels & plLayerInterface::kRuntimeColor))
        channelDataSize += 3;
    if (layer->fAmbientColor && (layer->fOwnedChannels & plLayerInterface::kAmbientColor))
        channelDataSize += 3;
    if (layer->fOpacity && (layer->fOwnedChannels & plLayerInterface::kOpacity))
        channelDataSize += 1;
    
    plSimpleStateVariable *channelVar = dstState->FindVar(kStrChannelData);
    if (channelVar->GetCount() != channelDataSize)
        channelVar->Alloc(channelDataSize);

    int channelIdx = 0;
    if (layer->fPreshadeColor && (layer->fOwnedChannels & plLayerInterface::kPreshadeColor))
    {
        channelVar->Set((UInt8)(layer->fPreshadeColor->r * 255), channelIdx++);
        channelVar->Set((UInt8)(layer->fPreshadeColor->g * 255), channelIdx++);
        channelVar->Set((UInt8)(layer->fPreshadeColor->b * 255), channelIdx++);
    }       
    if (layer->fRuntimeColor && (layer->fOwnedChannels & plLayerInterface::kRuntimeColor))
    {
        channelVar->Set((UInt8)(layer->fRuntimeColor->r * 255), channelIdx++);
        channelVar->Set((UInt8)(layer->fRuntimeColor->g * 255), channelIdx++);
        channelVar->Set((UInt8)(layer->fRuntimeColor->b * 255), channelIdx++);
    }       
    if (layer->fAmbientColor && (layer->fOwnedChannels & plLayerInterface::kAmbientColor))
    {
        channelVar->Set((UInt8)(layer->fAmbientColor->r * 255), channelIdx++);
        channelVar->Set((UInt8)(layer->fAmbientColor->g * 255), channelIdx++);
        channelVar->Set((UInt8)(layer->fAmbientColor->b * 255), channelIdx++);
    }           
    if (layer->fOpacity && (layer->fOwnedChannels & plLayerInterface::kOpacity))
        channelVar->Set((UInt8)(*layer->fOpacity * 255), channelIdx++);
}

//
// Change the object's animation state to reflect what is specified in the 
// stateDataRecord.
//
void plLayerSDLModifier::ISetCurrentStateFrom(const plStateDataRecord* srcState)
{
    plLayerAnimation* layer=GetLayerAnimation();
    hsAssert(layer, "nil layer animation");
    
    plSDStateVariable* atcVar = srcState->FindSDVar(kStrAtc);
    plStateDataRecord* atcStateDataRec = atcVar->GetStateDataRecord(0);
    ISetCurrentATC(atcStateDataRec, &layer->GetTimeConvert());
    
    int pass;
    if (srcState->FindVar(kStrPassThruChannels)->Get(&pass))
        layer->fPassThruChannels=pass;
    
    plSimpleStateVariable *transformVar = srcState->FindVar(kStrTransform);
    if (transformVar->IsUsed() && transformVar->GetCount() == 16)
    {
        int i,j;
        for(i=0;i<4;i++)
        {
            for(j=0;j<4;j++)
            {
                float f;
                srcState->FindVar(kStrTransform)->Get(&f, i*4+j);
                layer->fTransform->fMap[i][j]=f;
            }
        }
    }
    
    plSimpleStateVariable *channelVar = srcState->FindVar(kStrChannelData);
    int channelIdx = 0;
    UInt8 val;
    if (layer->fPreshadeColor && (layer->fOwnedChannels & plLayerInterface::kPreshadeColor))
    {
        channelVar->Get(&val, channelIdx++);
        layer->fPreshadeColor->r = val / 255.f;
        channelVar->Get(&val, channelIdx++);
        layer->fPreshadeColor->g = val / 255.f;
        channelVar->Get(&val, channelIdx++);
        layer->fPreshadeColor->b = val / 255.f;
    }       
    if (layer->fRuntimeColor && (layer->fOwnedChannels & plLayerInterface::kRuntimeColor))
    {
        channelVar->Get(&val, channelIdx++);
        layer->fRuntimeColor->r = val / 255.f;
        channelVar->Get(&val, channelIdx++);
        layer->fRuntimeColor->g = val / 255.f;
        channelVar->Get(&val, channelIdx++);
        layer->fRuntimeColor->b = val / 255.f;
    }       
    if (layer->fAmbientColor && (layer->fOwnedChannels & plLayerInterface::kAmbientColor))
    {
        channelVar->Get(&val, channelIdx++);
        layer->fAmbientColor->r = val / 255.f;
        channelVar->Get(&val, channelIdx++);
        layer->fAmbientColor->g = val / 255.f;
        channelVar->Get(&val, channelIdx++);
        layer->fAmbientColor->b = val / 255.f;
    }       
    if (layer->fOpacity && (layer->fOwnedChannels & plLayerInterface::kOpacity))
    {
        channelVar->Get(&val, channelIdx++);
        *layer->fOpacity = val / 255.f;
    }

    layer->fCurrentTime = -1.f; // force an eval
}