CWE-ou-minkata/Sources/Tools/MaxPlasmaLights/plRTProjDirLight.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==*/
///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  plRTProjDirLight.cpp - Functions for the Projected Directional MAX light //
//  Cyan, Inc.                                                               //
//                                                                           //
//// Version History //////////////////////////////////////////////////////////
//                                                                           //
//  8.2.2001 mcn - Created.                                                  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include "HeadSpin.h"
#include "plRTProjDirLight.h"
#include "plRTProjDirLightClassDesc.h"
#include "iparamm2.h"
#include "MaxPlasmaMtls/Layers/plLayerTex.h"
#include "MaxPlasmaMtls/Layers/plLayerTexBitmapPB.h"
#include "MaxComponent/plMaxAnimUtils.h"
#include "plRTObjLightDesc.h"
#include "plRTLightBaseAnimDlgProc.h"


//// Static ClassDesc2 Get Functions //////////////////////////////////////////

plRTProjDirLightDesc    plRTProjDirLightDesc::fStaticDesc;


//// Dialog Proc //////////////////////////////////////////////////////////////

class plProjDirDlgProc : public plBaseLightProc
{
    public:
        BOOL DlgProc(TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
        {
            IParamBlock2        *pb = map->GetParamBlock();
            plRTProjDirLight    *lite = (plRTProjDirLight *)pb->GetOwner();
            PBBitmap            *bitmap;
            plLayerTex          *layer = (plLayerTex *)lite->GetProjMap();
            ICustButton         *bmSelectBtn;


            switch( msg )
            {
                case WM_COMMAND:
                    if( LOWORD( wParam ) == IDC_PROJ_MAPNAME )
                    {
                        BOOL selectedNewBitmap = layer->HandleBitmapSelection();
                        if( selectedNewBitmap )
                        {
                            bmSelectBtn = GetICustButton( GetDlgItem( hWnd, IDC_PROJ_MAPNAME ) );
                            bitmap = layer->GetPBBitmap();
                            bmSelectBtn->SetText( bitmap != nil ? (TCHAR *)bitmap->bi.Filename() : "");
                            ReleaseICustButton( bmSelectBtn );
                        }
                        return false;
                    }
                    break;

                case WM_INITDIALOG:

                    // Set projection map bitmap name
                    bmSelectBtn = GetICustButton( GetDlgItem( hWnd, IDC_PROJ_MAPNAME ) );
                    if( bmSelectBtn != nil )
                    {
                        bitmap = ( layer == nil ) ? nil : layer->GetPBBitmap();
                        if( bitmap != nil )
                            bmSelectBtn->SetText( (TCHAR *)bitmap->bi.Filename() );
                        else
                            bmSelectBtn->SetText( _T( "<none>" ) );
                        ReleaseICustButton( bmSelectBtn );
                    }

                    break;
            }

            return plBaseLightProc::DlgProc( t, map, hWnd, msg, wParam, lParam );
        }
        void DeleteThis() {};
};
static plProjDirDlgProc     gPPDirLiteDlgProc;

/// Include for the ParamBlock2 definition

#include "plRTProjDirLightPBDec.h"


///////////////////////////////////////////////////////////////////////////////
//// plRTProjPBAccessor Class Functions ///////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

plRTProjPBAccessor  plRTProjPBAccessor::fAccessor;

void    plRTProjPBAccessor::Set( PB2Value& val, ReferenceMaker* owner, ParamID id, int tabIndex, TimeValue t )
{
    plRTProjDirLight *obj = (plRTProjDirLight *)owner;
    IParamBlock2 *pb = obj->GetParamBlockByID( plRTProjDirLight::kBlkProj );
    
    switch( id )
    {
        case plRTProjDirLight::kProjMap:
/*          {
                if( pb->GetMap() )
                    pb->GetMap()->Invalidate( plRTProjDirLight::kProjMap );
                PBBitmap *thisMap = val.bm;
                obj->SetProjMap( &thisMap->bi );
            }
*/          break;
        default:
            break;
    }
}

void    plRTProjPBAccessor::Get( PB2Value& v, ReferenceMaker* owner, ParamID id, int tabIndex, TimeValue t, Interval &valid )
{
}

///////////////////////////////////////////////////////////////////////////////
//// Projected Directional Light //////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

plRTProjDirLight::plRTProjDirLight()
{
    fIP = nil; 
    fLightPB = nil; 
    fProjPB = nil;
    fClassDesc = plRTProjDirLightDesc::GetDesc();
    fClassDesc->MakeAutoParamBlocks( this );

    fLightPB->SetValue(kLightColor, 0,  Color(255,255,255));
    SetHSVColor(0, Point3(255, 255, 255));
    
    fTex = nil;
    meshBuilt = 0; 
    
    IBuildMeshes(true);
}

ObjLightDesc *plRTProjDirLight::CreateLightDesc( INode *n, BOOL forceShadowBuf )
{
    return TRACKED_NEW DirLight( n, forceShadowBuf );
}

RefTargetHandle plRTProjDirLight::Clone( RemapDir &remap )
{
    plRTProjDirLight *obj = TRACKED_NEW plRTProjDirLight;

    obj->ReplaceReference( kRefDirLight, fLightPB->Clone( remap ) );
    BaseClone( this, obj, remap );

    return obj;
}

//// SubAnim /////////////////////////////////////////////////////////////////

Animatable  *plRTProjDirLight::SubAnim( int i )
{
    switch( i )
    {           
        case 0:
            return (Animatable *)fLightPB;
        case 1:
            return (Animatable *)fProjPB;
        default: 
            return nil;
    }
}

//// SubAnimName /////////////////////////////////////////////////////////////

TSTR    plRTProjDirLight::SubAnimName( int i ) 
{ 
    switch( i ) 
    {   
        case 0:
            return fLightPB->GetLocalName();
        case 1:
            return fProjPB->GetLocalName();
        default:
            return TSTR( "" );
    }
}

//// GetReference ////////////////////////////////////////////////////////////

RefTargetHandle plRTProjDirLight::GetReference( int i )
{
    switch( i )
    {
        case kRefMainRollout:
            return (RefTargetHandle)fLightPB;
        case kRefProjRollout:
            return (RefTargetHandle)fProjPB;
        default:
            return plRTLightBase::GetReference( i );
    }
}       

//// SetReference ////////////////////////////////////////////////////////////

void    plRTProjDirLight::SetReference( int ref, RefTargetHandle rtarg )
{
    switch( ref )
    {       
        case kRefMainRollout:
            fLightPB = (IParamBlock2 *)rtarg; 
            break;
        case kRefProjRollout:
            fProjPB = (IParamBlock2 *)rtarg;
            break;

        default:
            plRTLightBase::SetReference( ref, rtarg );
            break;
    }   
}

//// ParamBlock Functions ////////////////////////////////////////////////////

int plRTProjDirLight::NumParamBlocks()
{
    return plRTLightBase::NumParamBlocks() + 1;
}

IParamBlock2    *plRTProjDirLight::GetParamBlock( int i )
{
    switch ( i )
    {
        case 2: return fProjPB;
        default: return plRTLightBase::GetParamBlock( i );
    }
}

IParamBlock2    *plRTProjDirLight::GetParamBlockByID( BlockID id )
{
    if( fProjPB->ID() == id )
        return fProjPB;
    else
        return plRTLightBase::GetParamBlockByID( id );
}

//// GetProjMap //////////////////////////////////////////////////////////////

Texmap  *plRTProjDirLight::GetProjMap() 
{ 
    // If we don't have one, create one
    plLayerTex  *layer = (plLayerTex *)fProjPB->GetTexmap( kTexmap, 0 );
    if( layer == nil || layer->ClassID() != LAYER_TEX_CLASS_ID )
    {
        layer = TRACKED_NEW plLayerTex;
        fProjPB->SetValue( kTexmap, 0, (Texmap *)layer );

        IParamBlock2 *bitmapPB = layer->GetParamBlockByID( plLayerTex::kBlkBitmap );
        bitmapPB->SetValue( kBmpUseBitmap, 0, 1 );
    }

    // Backwards compatability here
    PBBitmap    *bitmap = fProjPB->GetBitmap( kProjMap, 0 );
    if( bitmap != nil )
    {
        layer->SetBitmap( &bitmap->bi );
        fProjPB->SetValue( kProjMap, 0, (PBBitmap *)nil );
    }

    if( layer )
    {
        const char* dbgTexName = layer->GetName();

        IParamBlock2 *bitmapPB = layer->GetParamBlockByID(plLayerTex::kBlkBitmap);
        hsAssert(bitmapPB, "LayerTex with no param block");

        int noCompress = fProjPB->GetInt(kProjNoCompress);
        int noMip = fProjPB->GetInt(kProjNoMip);
        bitmapPB->SetValue(kBmpNonCompressed, TimeValue(0), noCompress);
        bitmapPB->SetValue(kBmpNoFilter, TimeValue(0), noMip);
    }
    return (Texmap *)layer;
}
    
//// IBuildMeshes ////////////////////////////////////////////////////////////

void    plRTProjDirLight::IBuildMeshes( BOOL isnew ) 
{
    BuildStaticMeshes();

    fMesh = staticMesh[ plRTLightBase::RT_OMNI + 1 ];
}

//// GetLocalBoundBox ////////////////////////////////////////////////////////

void    plRTProjDirLight::GetLocalBoundBox( TimeValue t, INode *node, ViewExp *vpt, Box3 &box )
{
    Point3  loc = node->GetObjectTM( t ).GetTrans();
    float   scaleFactor = vpt->NonScalingObjectSize() * vpt->GetVPWorldWidth( loc ) / 360.0f;
    float   width, height, depth;

    box = fMesh.getBoundingBox();
    // Because we want to scale about the origin, not the box center, we have to do this funky offset
    Point3  boxCenter = box.Center();
    box.Translate( -boxCenter );
    box.Scale( scaleFactor );
    boxCenter *= scaleFactor;
    box.Translate( boxCenter );

    if( ( extDispFlags & EXT_DISP_ONLY_SELECTED ) )
    {
        fProjPB->GetValue( kWidth, t, width, FOREVER );
        fProjPB->GetValue( kHeight, t, height, FOREVER );
        fProjPB->GetValue( kRange, t, depth, FOREVER );
        width /= 2.f;
        height /= 2.f;

        box += Point3( -width, -height, 0.f );
        box += Point3( width, height, -depth );
    }
}

//// DrawConeAndLine /////////////////////////////////////////////////////////

int     plRTProjDirLight::DrawConeAndLine( TimeValue t, INode* inode, GraphicsWindow *gw, int drawing ) 
{
    Matrix3 tm = inode->GetObjectTM( t );
    gw->setTransform( tm );
    gw->clearHitCode();

    if( extDispFlags & EXT_DISP_ONLY_SELECTED )
        DrawCone( t, gw, 500 );

    return gw->checkHitCode();
}

//// DrawCone ////////////////////////////////////////////////////////////////
//  Function called by MAX to render the cone shape in the viewport for this
//  light. Note that this is the cone, not the actual object itself!

void    plRTProjDirLight::DrawCone( TimeValue t, GraphicsWindow *gw, float dist ) 
{
    Point3  nearPts[ 5 ], farPts[ 5 ], u[ 3 ];
    int     i;
    float   width, height;


    // Get values
    fProjPB->GetValue( kWidth, t, width, FOREVER );
    fProjPB->GetValue( kHeight, t, height, FOREVER );
    fProjPB->GetValue( kRange, t, dist, FOREVER );

    // Draw a rectangle showing the extents of the light (width, height and depth)
    IBuildRectangle( width, height, 0, nearPts );
    IBuildRectangle( width, height, -dist, farPts );

    gw->setColor( LINE_COLOR, GetUIColor( COLOR_HOTSPOT ) );

    gw->polyline( 4, nearPts, nil, nil, true, nil );
    gw->polyline( 4, farPts, nil, nil, true, nil );
    for( i = 0; i < 4; i++ )
    {
        u[ 0 ] = nearPts[ i ];
        u[ 1 ] = farPts[ i ];
        gw->polyline( 2, u, nil, nil, false, nil );
    }
}

//// IBuildRectangle /////////////////////////////////////////////////////////

void    plRTProjDirLight::IBuildRectangle( float width, float height, float z, Point3 *pts )
{
    width /= 2.f;
    height /= 2.f;

    pts[ 0 ] = Point3( -width, -height, z );
    pts[ 1 ] = Point3( width, -height, z );
    pts[ 2 ] = Point3( width, height, z );
    pts[ 3 ] = Point3( -width, height, z );
}

//// GetFallsize /////////////////////////////////////////////////////////////
//  To get using-light-as-camera-viewport to work

float   plRTProjDirLight::GetFallsize( TimeValue t, Interval &valid )
{
    if( fProjPB == nil )
        return -1.f;

    return fProjPB->GetFloat( kWidth, t );
}

//// GetAspect ///////////////////////////////////////////////////////////////
//  To get using-light-as-camera-viewport to work

float   plRTProjDirLight::GetAspect( TimeValue t, Interval &valid )
{
    if( fProjPB == nil )
        return -1.f;

    return( fProjPB->GetFloat( kHeight, t ) / fProjPB->GetFloat( kWidth, t ) );
}

//// GetTDist ////////////////////////////////////////////////////////////////
//  To get using-light-as-camera-viewport to work

float   plRTProjDirLight::GetTDist( TimeValue t, Interval &valid )
{
    return 0.f;
    if( fProjPB == nil )
        return -1.f;

    return fProjPB->GetFloat( kRange, t );
}

//// SetFallsize /////////////////////////////////////////////////////////////
//  To get using-light-as-camera-viewport to work

void    plRTProjDirLight::SetFallsize( TimeValue time, float f )
{
    if( fProjPB != nil )
        fProjPB->SetValue( kWidth, time, f );
}

//// EvalLightState //////////////////////////////////////////////////////////
//  To get using-light-as-camera-viewport to work

RefResult plRTProjDirLight::EvalLightState( TimeValue t, Interval& valid, LightState *ls )
{
    ls->type = DIRECT_LGT;
    if( fLightPB->GetInt( kLightOn, t ) == true )
        ls->color = GetRGBColor( t, valid );
    else
        ls->color = Color( 0, 0, 0 );
    ls->on = fLightPB->GetInt( kLightOn, t );
    ls->intens = GetIntensity( t, valid );
    
    float   fall = fProjPB->GetFloat( kWidth, t );
    if( fall < fProjPB->GetFloat( kHeight, t ) )
        fall = fProjPB->GetFloat( kHeight, t );

    ls->hotsize = ls->fallsize = fall / 2.f;
    ls->useNearAtten = false;
    ls->useAtten = false;
    ls->shape = RECT_LIGHT;

    ls->aspect = fProjPB->GetFloat( kHeight, t ) / fProjPB->GetFloat( kWidth, t );
    ls->overshoot = false;
    ls->shadow = false;
    ls->ambientOnly = false;
    ls->affectDiffuse = fLightPB->GetInt( kAffectDiffuse, t );
    ls->affectSpecular = fLightPB->GetInt( kSpec, t );

    return REF_SUCCEED;
}