/*==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/>.

Additional permissions under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.

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==*/
#ifndef PL_RTLIGHT_BASE_H
#define PL_RTLIGHT_BASE_H

// Max related headers
#include "max.h"
#include "iparamb2.h"
#include "iparamm2.h"

// Our generic headers
#include "HeadSpin.h"
#include "MaxPlasmaMtls/Layers/plLayerTex.h"
#include "MaxMain/MaxCompat.h"


extern TCHAR *GetString(int id);



extern HINSTANCE hInstance;

#define RTOMNI_LIGHT_CLASSID    Class_ID(0x57cf7089, 0x282e5b71)
#define RTSPOT_LIGHT_CLASSID    Class_ID(0x2b263fdd, 0x19c4351f)
#define RTTSPOT_LIGHT_CLASSID   Class_ID(0x48cb06ab, 0x3c142832)
#define RTDIR_LIGHT_CLASSID     Class_ID(0x5a6d278c, 0x780a78b1)
// Projected Directional Light
#define RTPDIR_LIGHT_CLASSID    Class_ID(0x2f611934, 0x3681ff0)



#define FOREVER Interval(TIME_NegInfinity, TIME_PosInfinity)

#define DEF_TDIST       240.0f // 160.0f

#define NUM_HALF_ARC    5
#define NUM_ARC_PTS     (2*NUM_HALF_ARC+1)
#define NUM_CIRC_PTS    28
#define SEG_INDEX       7

#define ATTEN_START     2  // far
#define ATTEN_END       3  // far


#define WM_SET_TYPE     WM_USER + 0x04002


inline float MaxF(float a, float b) { return a>b?a:b; }
inline float MinF(float a, float b) { return a<b?a:b; }

class plMaxNode;
class ClassDesc2;


///////////////////////////////////////////////////////////////////////////////
//// Base LightDlgProc ////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

class plRTLightBase;

class plBaseLightProc : public ParamMap2UserDlgProc
{
    protected:
        void            ILoadComboBox( HWND hComboBox, const char *names[] );
        void            IBuildLightMesh( plRTLightBase *base, float coneSize );

    public:
        virtual BOOL    DlgProc( TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam );
};

///////////////////////////////////////////////////////////////////////////////
//// plLightTexPBAccessor /////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

class plLightTexPBAccessor : public PBAccessor
{
    public:
        void Set( PB2Value& val, ReferenceMaker* owner, ParamID id, int tabIndex, TimeValue t );
        void Get( PB2Value& v, ReferenceMaker* owner, ParamID id, int tabIndex, TimeValue t, Interval &valid );

        static plLightTexPBAccessor *Instance( void ) { return &fAccessor; }

    protected:

        static plLightTexPBAccessor fAccessor;
};

///////////////////////////////////////////////////////////////////////////////
//// plRTLightBase Class //////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

class plRTLightBase : public GenLight
{

protected:
    ClassDesc2   *fClassDesc;   // Must set in derived classes constructor
    Color        fColor;        // Color of mesh
    Mesh         fMesh;         // Mesh to draw
    IParamBlock2 *fLightPB;     // The derived component's paramblock (optional)
    plLayerTex*  fTex;


    virtual hsBool  IHasAttenuation( void ) { return false; }
    virtual void    IBuildMeshes( BOOL isNew ) {}

    void    BuildStaticMeshes();
    void    BuildSpotMesh(float coneSize);
    int     meshBuilt;
    int     extDispFlags;

    
    Mesh    staticMesh[2];
    Mesh    spotMesh;


public:
    friend class plBaseLightProc;
    friend class plLightTexPBAccessor;
    friend class SetTypeRest;

    ExclList exclList;
    IObjParam    *fIP;



    enum LightType
    {
        RT_OMNI,
        RT_TARGET_SPOT,
        RT_FREE_SPOT,
        RT_TARGET_DIR,
        RT_FREE_DIR
    };


    //// NOTE /////////////////////////////////////////////////////////////////////
    //  I would've overhauled this entire system to be far more sane, but doing
    //  so would break every scene with RT lights that the artists have (as in
    //  they would crash and burn, or at best just not read in). As a result,
    //  as much as it annoys me to death, we can't do a damn thing about it.
    //  Hopefully, in the future we will be able to clean all of this out somehow
    //  (a conversion utility might come in handy, dunno). 
    //
    //  For reference, the setup SHOULD have separate paramBlocks for each rollout,
    //  using the P_USE_PARAMS to duplicate the shared ones, and all the rollouts
    //  should have *IDENTICAL* block and ref #s, so the shared code actually looks
    //  sane. The final block/ref #s needed would be kBlkMain, kBlkAnim, kBlkProj 
    //  (for spots and proj dir) and kBlkAttenuation (projMaps don't need ref #s, 
    //  since they're part of the paramBlocks).
    ///////////////////////////////////////////////////////////////////////////////

    // Blk Numbers
    enum BlkNumber
    {
        // Old numbers. Phase out when possible
        kBlkGeneralLightProp,
        kBlkAttenLightProp,
        kBlkOmniLightProp,
        kBlkOtherLightProp,
        kBlkOmniLight,
        kBlkSpotLight,
        kBlkTSpotLight,
        kBlkDirLight,
        kBlkTDirLight,

        // New ones
        kBlkMain = 0,
        kBlkAnim = 9,

        kBlkDerivedStart = 20
    };

    // Ref numbers
    enum    RefNumber
    {
        kRefGeneralLightProp,
        kRefProjMap,
        kRefShadowProjMap,
        kRefShadowType,
        kRefOmniLight,
        kRefSpotLight,
        kRefTSpotLight,
        kRefDirLight,
        kRefTDirLight,
        kRefProjDirLight,
        kRefAnimParams_DEAD,

        kNumRefs,

        kRefDerivedStart = 30
    };

    //Multimap Support?
    enum    MapChoice
    {
        kLightMap1,
        kLightMap2,
        kLightMap3,
        kLightMap4,
        kLightMap5,
        kLightMap6
    };

    enum    ParamVals
    {
        kLightType,         //Inserted in v1, Removed in v4
        kAffectDiffuse,     //Inserted in v1
        kLightColor,        //Inserted in v1
        kLightExclude,      //Inserted in v1
        kCastShadows,       //Inserted in v2, OBSOLETE
        kIntensity,         //Inserted in v1
        kContrast,          //Inserted in v1
        kDiffSoft,          //Inserted in v1
        kDiffOn,            //Inserted in v1
        kSpec,              //Inserted in v1
        kAmbiOnly,          //Inserted in v1
        kStartAttenNear,     //Inserted in v1, Removed in v3
        kEndAttenNear,       //Inserted in v1, Removed in v3
        kUseNearAtten,       //Inserted in v1, Removed in v3
        kShowNearAttenRanges,//Inserted in v1, Removed in v3
        kStartAttenFar,      //Inserted in v1, Removed in v3
        kEndAttenFar,        //Inserted in v1, Removed in v3
        kUseFarAtten,        //Inserted in v1, Removed in v3
        kShowFarAttenRanges, //Inserted in v1, Removed in v3
        kLightDecay,         //Inserted in v1, Removed in v3
        kDecayEdit,          //Inserted in v1, Removed in v3
        kShowDecay,          //Inserted in v1, Removed in v3
        kUseProjectBool,    //Inserted in v1
        kProjMapTexButton,  //Inserted in v1
        kShowConeBool,      //Inserted in v1
        kOvershootBool,     //Inserted in v1, Removed in v2
        kHotSpot,           //Inserted in v1
        kFallOff,           //Inserted in v1
        kLightShapeRadio,   //Inserted in v1, Removed in v2
        kAspect,            //Inserted in v1, Removed in v2
        kUseProjectorBool,  //Inserted in v1
        kProjMapTexButton2, //Inserted in v1
        kTargetDist,        //Inserted in v1
        
        kShadowOn,          //Inserted in v2
        kShadowChoice,      //Inserted in v2
        kUseShadGlobal,     //Inserted in v2
        kShadowColor,       //Inserted in v2
        kShadowDensity,     //Inserted in v2
        kUseShadMapBool,    //Inserted in v2
        kShadMapButton,     //Inserted in v2
        kLightColorEffects, //Inserted in v2
        kAtmosShadowsBool,  //Inserted in v2
        kAtmosShadOpacity,  //Inserted in v2
        kAtmosShadColor,    //Inserted in v2
        kShadMapBias,       //Inserted in v2
        kShadMapSize,       //Inserted in v2
        kShadSampleRange,   //Inserted in v2
        kAbsoluteShadBias,  //Inserted in v2

        kUseAttenuationBool,//Inserted in v3
        kAttenMaxFalloffEdit, //Inserted in v3
        kAttenTypeRadio,    //Inserted in v3
        kSpecularColorSwatch,//Inserted in v3

        kAttenSlider,
        kLightOn,
        kAmbientOnlyStub,

        kProjTypeRadio,
        kProjNoCompress,
        kProjNoMip
    };

    // Projection types.
    enum
    {
        kIlluminate, 
        kAdd, 
        kMult, 
        kMADD
    };
    
    // Animation rollout parameters
    enum
    {
        kAnimName,
        kAnimAutoStart,
        kAnimLoop,
        kAnimLoopName
    };
    
    plRTLightBase() { }//meshBuilt = 0; fClassDesc = NULL;  fLightPB = NULL; fIP = NULL; BuildMeshes(true); }
    virtual ~plRTLightBase();
    void DeleteThis() { delete this; }

    static ParamBlockDesc2  *GetAnimPBDesc( void );

    TCHAR* GetObjectName()      { return (TCHAR*)fClassDesc->ClassName(); }
    void GetClassName(TSTR& s)  { s = fClassDesc->ClassName(); }

    virtual IParamBlock2 *GetParamBlock( int i );
    virtual IParamBlock2* GetParamBlock2();
    virtual IParamBlock2* GetParamBlockByID(short id);
    plLayerTex*   GetTex() { return fTex; }
    // So our animatables will show up in the trackview
    virtual int NumParamBlocks() { return 1; }
    virtual int NumSubs();
    virtual Animatable* SubAnim(int i);
    virtual TSTR SubAnimName(int i);

    // plug-in mouse creation callback
    CreateMouseCallBack* GetCreateMouseCallBack();
    RefTargetHandle Clone(RemapDir &remap = DEFAULTREMAP){ plRTLightBase* thisObj = new plRTLightBase(); BaseClone(this, thisObj, remap); return thisObj;}
    
    virtual void BeginEditParams(IObjParam *ip, ULONG flags, Animatable *prev);
    virtual void EndEditParams(IObjParam *ip, ULONG flags, Animatable *next);
    
    // main function that will build our mesh
    void FreeCaches();
    
    // retreives bounding box in object space/world space
    void GetLocalBoundBox(TimeValue t, INode *node, ViewExp *vpt, Box3 &box);
    void GetWorldBoundBox(TimeValue t, INode *node, ViewExp *vpt, Box3 &box);
    
    // main display function for this object
    int Display(TimeValue t, INode *node, ViewExp *vpt, int flags);
    virtual int DrawConeAndLine(TimeValue t, INode* inode, GraphicsWindow *gw, int drawing );
    void GetConePoints(TimeValue t, float aspect, float angle, float dist, Point3 *q);
    virtual void DrawCone(TimeValue t, GraphicsWindow *gw, float dist);
    int GetSpotShape(void){ return 0; }
    void SetExtendedDisplay(int flags){ extDispFlags = flags; }
    void BoxCircle(TimeValue t, float r, float d, Box3& box, int extraPt, Matrix3 *tm);
    void BoxDirPoints(TimeValue t, float angle, float dist, Box3 &box, Matrix3 *tm);
    void BoxPoints(TimeValue t, float angle, float dist, Box3 &box, Matrix3 *tm);

    void    DrawArrow( TimeValue t, GraphicsWindow *gw, Point3 &direction, float dist );
    
    void GetAttenPoints(TimeValue t, float rad, Point3 *q);
    int GetRectXPoints(TimeValue t, float angle, float dist, Point3 *q);
    int GetCirXPoints(TimeValue t, float angle, float dist, Point3 *q);
    void DrawSphereArcs(TimeValue t, GraphicsWindow *gw, float r, Point3 *q);
    
//
    void DrawX(TimeValue t, float asp, int npts, float dist, GraphicsWindow *gw, int indx); 
    void DrawCircleX(TimeValue t, GraphicsWindow *gw, float angle, float dist, Point3 *q);
    void DrawWarpRect(TimeValue t, GraphicsWindow *gw, float angle, float dist, Point3 *q);
    void DrawAttenCirOrRect(TimeValue t, GraphicsWindow *gw, float dist, BOOL froze, int uicol);
    int DrawAtten(TimeValue t, INode *inode, GraphicsWindow *gw);
    
    
    
    
    //void SetType(int tp);

    

    // hit testing of this object
    int HitTest(TimeValue t, INode *node, int type, int crossing, int flags, IPoint2 *p, ViewExp *vpt);
    
    void Snap(TimeValue t, INode* inode, SnapInfo *snap, IPoint2 *p, ViewExp *vpt);
    void GetDeformBBox(TimeValue t, Box3& box, Matrix3 *tm, BOOL useSel );


    //Internal routines
    void BoxLight(TimeValue t, INode *inode, Box3& box, Matrix3 *tm);
    void GetMat(TimeValue t, INode* inode, ViewExp *vpt, Matrix3& tm);

    virtual RefTargetHandle GetReference(int i);
    virtual void SetReference(int ref, RefTargetHandle rtarg);
    virtual int NumRefs() { return kNumRefs;}
    
    RefResult NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget, PartID& partID, RefMessage message);

    // Called to retreive the state of this object at the specified time.
    ObjectState Eval(TimeValue t) { return ObjectState(this); }

    const char *GetCategory(){ return fClassDesc->Category(); }

    //
    //  LightObject Specific Stuff below
    //
    //

    virtual BOOL IsSpot( void ) { return FALSE; }
    virtual BOOL IsDir( void )  { return FALSE; }

    RefResult EvalLightState(TimeValue time, Interval& valid, LightState *ls);
    ObjLightDesc *CreateLightDesc(INode *n, BOOL forceShadowBuffer=FALSE);
    void SetUseLight(int onOff) { fLightPB->SetValue(kLightOn, 0, onOff); NotifyDependents(FOREVER, PART_OBJ, REFMSG_CHANGE); }
    BOOL GetUseLight(void) { BOOL v; fLightPB->GetValue(kLightOn, 0, v, FOREVER); return v; }
    void SetHotspot(TimeValue time, float f); 
    float GetHotspot(TimeValue t, Interval& valid = Interval(0,0));
    void SetFallsize(TimeValue time, float f); 
    float GetFallsize(TimeValue t, Interval& valid = Interval(0,0));
    void SetAtten(TimeValue time, int which, float f);
    float GetAtten(TimeValue t, int which, Interval& valid = Interval(0,0));
    
    // TDist funcs needs implementation  as of 31/5/01
    void SetTDist(TimeValue time, float f); 
    float GetTDist(TimeValue t, Interval& valid = Interval(0,0));

    void SetConeDisplay(int s, int notify=TRUE);
    BOOL GetConeDisplay(void);

    void SetRGBColor(TimeValue t, Point3& rgb); //fLightPB->SetValue(kRGB, t, rgb); NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);}
    Point3 GetRGBColor(TimeValue t, Interval &valid = Interval(0,0)); //return fLightPB->GetPoint3(kRGB, t); }        
    void SetIntensity(TimeValue t, float f) { fLightPB->SetValue(kIntensity, t, f); NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);}
    float GetIntensity(TimeValue t, Interval& valid = Interval(0,0)) {return fLightPB->GetFloat(kIntensity, t); }
    void SetAspect(TimeValue t, float f) {}
    float GetAspect(TimeValue t, Interval& valid = Interval(0,0)) { return 0.0; }    
    void SetUseAtten(int s){ fLightPB->SetValue(kUseAttenuationBool, 0, s); NotifyDependents(FOREVER, PART_OBJ, REFMSG_CHANGE); }
    BOOL GetUseAtten(void) {return fLightPB->GetInt(kUseAttenuationBool, 0);}
    void SetUseAttenNear(int s) {  }
    BOOL GetUseAttenNear(void) {return false;}
    void SetAttenDisplay(int s){  }
    BOOL GetAttenDisplay(void) {return fLightPB->GetInt(kUseAttenuationBool, 0);}      
    void SetAttenDisplayNear(int s){ }
    BOOL GetAttenDisplayNear(void){return false;}      
    void Enable(int enab) { fLightPB->SetValue(kLightOn, 0, enab); }
    void SetMapBias(TimeValue t, float f) {}
    float GetMapBias(TimeValue t, Interval& valid = Interval(0,0)){return 0.0f;}
    void SetMapRange(TimeValue t, float f) {}
    float GetMapRange(TimeValue t, Interval& valid = Interval(0,0)) {return 0.0f;}
    void SetMapSize(TimeValue t, int f) {}
    int GetMapSize(TimeValue t, Interval& valid = Interval(0,0)){return 0;}
    void SetRayBias(TimeValue t, float f) {}
    float GetRayBias(TimeValue t, Interval& valid = Interval(0,0)) {return 0.0;} //{return 0.0f;}
    int GetAbsMapBias() {return 0;}
    void SetAbsMapBias(int a) {}
    int GetOvershoot(){return 0;}
    void SetOvershoot(int a){}
    virtual int GetProjector() { return 0; }
    void SetProjector(int a){fLightPB->SetValue(kUseProjectorBool, 0, a); }
    ExclList* GetExclList(){return NULL;}
    BOOL Include() {return false;}
    virtual Texmap* GetProjMap(); //{ Interval valid = Interval(0,0); Texmap* MyMap; fLightPB->GetValue(kProjMapTexButton, 0, MyMap, valid); return MyMap; }
    void SetProjMap(BitmapInfo* pmap);
    void UpdateTargDistance(TimeValue t, INode* inode);

    // GenLight Specific Stuff below

    BOOL GetUseGlobal() { return false; }   //Global Shadow param
    void SetUseGlobal(int a) {}
    BOOL GetShadow();
    void SetShadow(int a);
    BOOL GetShadowType() { return -1; } //No Shadows generated ....
    void SetShadowType(int a) {}        //Until implemented....
    GenLight* NewLight(int type) { return NULL;} 
    int Type()  {return -1;}
    void SetSpotShape(int a) {}
    void SetHSVColor(TimeValue t, class Point3 &b);
    Point3 GetHSVColor(TimeValue t, Interval& b);
    void SetContrast(int a, float other) {} // fLightPB->SetValue(kContrast, a, other); NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);}
    float GetContrast(int a, Interval &valid) {return 0.0;} //float f; f = fLightPB->GetFloat(kContrast, a); return f;}
    void SetAttenNearDisplay(int a) {}
    BOOL GetAttenNearDisplay() {return false;}
    ExclList& GetExclusionList() {return exclList;}
    void SetExclusionList(ExclList & a) {}
    BOOL SetHotSpotControl(Control* a) {SetParamBlock2Controller(fLightPB, ParamID(kHotSpot),0, a); return true;}
    BOOL SetFalloffControl(Control* a) {SetParamBlock2Controller(fLightPB, ParamID(kFallOff),0, a); return true;}
    Control* GetHotSpotControl() {return GetParamBlock2Controller(fLightPB, ParamID(kHotSpot));}
    Control* GetFalloffControl() {return GetParamBlock2Controller(fLightPB, ParamID(kFallOff));}
    BOOL SetColorControl(Control * a) {SetParamBlock2Controller(fLightPB, ParamID(kLightColor),0, a); return true;}
    Control* GetColorControl() {return GetParamBlock2Controller(fLightPB, ParamID(kLightColor)); }

    BOOL GetDecayType() { return fLightPB->GetInt(kAttenTypeRadio, 0) + 1;} //Offset for the radio.
    void SetDecayType(BOOL onOff) {if (!onOff) return; else {fLightPB->SetValue(kAttenTypeRadio, 0, ((int) onOff - 1)); return;} } 
    void SetDecayRadius(TimeValue time, float f) { fLightPB->SetValue(kAttenMaxFalloffEdit, time, f); }
    float GetDecayRadius(TimeValue t, Interval& valid = Interval(0,0)) {return fLightPB->GetFloat(kAttenMaxFalloffEdit, t); }

    void SetDiffuseSoft(TimeValue time, float f) {}//fLightPB->SetValue(kDiffSoft, time, f);}
    float GetDiffuseSoft(TimeValue t, Interval& valid = Interval(0,0)) {return 0.0;} //return fLightPB->GetFloat(kDiffSoft, t);}
    void SetAffectDiffuse(BOOL onOff) {}//fLightPB->SetValue(kDiffOn, 0, onOff); }
    BOOL GetAffectDiffuse() {return false; } //fLightPB->GetInt(kDiffOn, 0); }

    LRESULT CALLBACK TrackViewWinProc( HWND hwnd,  UINT message, 
            WPARAM wParam,   LPARAM lParam ){return(0);}
};

#endif
