CWE-ou-minkata/Sources/Tools/MaxComponent/plLightGrpComponent.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 "HeadSpin.h"
#include "max.h"
#include "resource.h"
#include "plComponent.h"
#include "plComponentReg.h"

#include "MaxMain/plPlasmaRefMsgs.h"
#include "MaxMain/plMaxNode.h"
#include "hsResMgr.h"


// LightGroup component
#include "pnSceneObject/plSceneObject.h"
#include "plGLight/plLightInfo.h"
#include "plDrawable/plDrawableSpans.h"
#include "pnSceneObject/plDrawInterface.h"
#include "MaxPlasmaLights/plRealTimeLightBase.h"

#include "plLightGrpComponent.h"

/////////////////////////////////////////////////////////////////////////////////////////////////
//
//  LightGroup Component
//
//

enum    
{
    kIncludeChars,
    kAffectedLightSel,
    kTest
};




CLASS_DESC(plLightGrpComponent, gLightGrpDesc, "Light Group",  "LightGroup", COMP_TYPE_GRAPHICS, LIGHTGRP_COMP_CID)



ParamBlockDesc2 gLightGrpBk
(
    plComponent::kBlkComp, _T("LightGroup"), 0, &gLightGrpDesc, P_AUTO_CONSTRUCT+P_AUTO_UI, plComponent::kRefComp,

    IDD_COMP_LIGHTINC, IDS_COMP_LIGHTINCS,  0, 0, nil,

    kIncludeChars,  _T("Include characters"), TYPE_BOOL,        0, 0,
        p_default,  TRUE,
        p_ui,   TYPE_SINGLECHEKBOX, IDC_COMP_LIGHTINC_CHARS,
        end,

    kAffectedLightSel, _T("AffectedLightChoice"),   TYPE_INODE,     0, 0,
        end,

    kTest, _T("TestBox"), TYPE_BOOL, 0, 0,
        p_default,  FALSE,
        p_ui,   TYPE_SINGLECHEKBOX, IDC_COMP_LIGHTINC_FILTER,
        end,

    end

);

plLightGrpComponent::plLightGrpComponent()
:   fValid(false)
{
    fClassDesc = &gLightGrpDesc;
    fClassDesc->MakeAutoParamBlocks(this);
}

class plLightGrpPostLoadCallback : public PostLoadCallback
{
public:
    plLightGrpComponent*    fLightGrp;

    plLightGrpPostLoadCallback(plLightGrpComponent* lg) : fLightGrp(lg) {}

    void proc(ILoad *iload) 
    {
        IParamBlock2* compPB = fLightGrp->GetParamBlock(plComponentBase::kBlkComp);
        INode* light = compPB->GetINode(kAffectedLightSel);
        if( light )
        {
            fLightGrp->AddTarget((plMaxNodeBase*)light);
            compPB->SetValue(kAffectedLightSel, TimeValue(0), (INode*)nil);
        }
        delete this;
    }
};

IOResult plLightGrpComponent::Load(ILoad* iLoad)
{
    iLoad->RegisterPostLoadCallback(new plLightGrpPostLoadCallback(this));

    return plComponent::Load(iLoad);
}

hsBool plLightGrpComponent::IAddLightsToSpans(plMaxNode* pNode, plErrorMsg* pErrMsg)
{
    int i;
    for( i = 0; i < fLightInfos.GetCount(); i++ )
    {
        if( !fLightInfos[i] )
            continue;

        const plDrawInterface* di = pNode->GetSceneObject()->GetDrawInterface();

        int iDraw;
        for( iDraw = 0; iDraw < di->GetNumDrawables(); iDraw++ )
        {
            plDrawableSpans* drawable = plDrawableSpans::ConvertNoRef(di->GetDrawable(iDraw));
            if( drawable )
            {
                UInt32 diIndex = di->GetDrawableMeshIndex(iDraw);

                ISendItOff(fLightInfos[i], drawable, diIndex);
            }
        }
    }
    return true;
}

hsBool plLightGrpComponent::ISendItOff(plLightInfo* liInfo, plDrawableSpans* drawable, UInt32 diIndex)
{
    plDISpanIndex spans = drawable->GetDISpans(diIndex);

    if( spans.fFlags & plDISpanIndex::kMatrixOnly )
        return false;

    if( !fCompPB->GetInt(kTest) )
    {
        UInt8 liMsgType = liInfo->GetProjection() ? plDrawable::kMsgPermaProjDI : plDrawable::kMsgPermaLightDI;
        plGenRefMsg* refMsg = TRACKED_NEW plGenRefMsg(drawable->GetKey(), plRefMsg::kOnCreate, diIndex, liMsgType);
        hsgResMgr::ResMgr()->AddViaNotify(liInfo->GetKey(), refMsg, plRefFlags::kPassiveRef);
    }
    else
    {

        hsBitVector litSpans;
        liInfo->GetAffectedForced(drawable->GetSpaceTree(), litSpans, false);

        UInt8 liMsgType = liInfo->GetProjection() ? plDrawable::kMsgPermaProj : plDrawable::kMsgPermaLight;
        int i;
        for( i = 0; i < spans.GetCount(); i++ )
        {
            if( litSpans.IsBitSet(spans[i]) )
            {
                plGenRefMsg* refMsg = TRACKED_NEW plGenRefMsg(drawable->GetKey(), plRefMsg::kOnCreate, spans[i], liMsgType);
                hsgResMgr::ResMgr()->AddViaNotify(liInfo->GetKey(), refMsg, plRefFlags::kPassiveRef);
            }
        }
    }

    return true;
}

hsBool plLightGrpComponent::IGetLightInfos()
{
    if( !fLightInfos.GetCount() )
    {
        // Already checked that lightnodes are cool. just get the light interfaces.
        int i;
        for( i = 0; i < fLightNodes.GetCount(); i++ )
        {
            plMaxNode* lightNode = fLightNodes[i];
            plSceneObject* lightSO = lightNode->GetSceneObject();
            if( !lightSO )
                continue;

            plLightInfo* liInfo = plLightInfo::ConvertNoRef(lightSO->GetGenericInterface(plLightInfo::Index()));
            if( !liInfo )
                continue;

            liInfo->SetProperty(plLightInfo::kLPHasIncludes, true);
            if( fCompPB->GetInt(kIncludeChars) )
                liInfo->SetProperty(plLightInfo::kLPIncludesChars, true);
            fLightInfos.Append(liInfo);
        }
    }
    return fValid = (fLightInfos.GetCount() > 0);
}

const hsTArray<plLightInfo*>& plLightGrpComponent::GetLightInfos()
{
    IGetLightInfos();
    return fLightInfos;
}

plLightGrpComponent* plLightGrpComponent::GetComp(plMaxNode* node)
{
    int i;
    for( i = 0; i < node->NumAttachedComponents(); i++ )
    {
        plComponentBase* comp = node->GetAttachedComponent(i);
        if( comp && comp->ClassID() == LIGHTGRP_COMP_CID )
            return (plLightGrpComponent*)comp;
    }
    return nil;
}

hsBool plLightGrpComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
    const char* dbgNodeName = node->GetName();
    if( !fValid )
        return true;

    if( !IGetLightInfos() )
        return true;

    if( !node->GetDrawable() )
        return true;

    if( !node->GetSceneObject() || !node->GetSceneObject()->GetDrawInterface() )
        return true;

    // If it's shaded as a character, ignore any light groups attached.
    if( node->GetItinerant() )
        return true;

    IAddLightsToSpans(node, pErrMsg);

    return true;
}

hsBool plLightGrpComponent::SetupProperties(plMaxNode *pNode,  plErrorMsg *pErrMsg)
{
    fValid = false;
    fLightInfos.Reset();
    fLightNodes.Reset();

    int i;
    for( i = 0; i < NumTargets(); i++ )
    {
        plMaxNodeBase* liNode = GetTarget(i);

        if( liNode && liNode->CanConvert() )
        {
            Object *obj = liNode->GetObjectRef();
            if( obj )
            {
                Class_ID cid = obj->ClassID();

                if( (cid == RTSPOT_LIGHT_CLASSID)
                    || (cid == RTOMNI_LIGHT_CLASSID)
                    || (cid == RTDIR_LIGHT_CLASSID)
                    || (cid == RTPDIR_LIGHT_CLASSID) )
                {
                    fLightNodes.Append((plMaxNode*)liNode);
                }
            }
        }

    }
    if( !fLightNodes.GetCount() )
        return true;

    fValid = true;
    return true;
}

hsBool plLightGrpComponent::PreConvert(plMaxNode* pNode, plErrorMsg* pErrMsg)
{
    if( !fValid )
        return true;

    fValid = false;

    fValid = true;


    return true;
}