LightDlg.cpp

Go to the documentation of this file.

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 Source Code 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.

Doom 3 Source Code 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 Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "../../idlib/precompiled.h"
#pragma hdrstop

#include "qe3.h"
#include "Radiant.h"
#include "../../game/game.h"
#include "../comafx/DialogColorPicker.h"
#include "LightDlg.h"

#ifdef ID_DEBUG_MEMORY
#undef new
#undef DEBUG_NEW
#define DEBUG_NEW new
#endif


void CLightInfo::Defaults() {
        pointLight = true;
        fallOff = 1;
        strTexture = "";
        equalRadius = true;
        explicitStartEnd = false;
        lightRadius.Zero();
        lightTarget.Zero();
        lightRight.Zero();
        lightUp.Zero();
        lightStart.Zero();
        lightEnd.Zero();
        lightCenter.Zero();
        hasCenter = false;
        isParallel = false;
        castShadows = true;
        castSpecular = true;
        castDiffuse = true;
        rotate = false;
        strobe = false;
        rotateSpeed = 0;
        strobeSpeed = 0;
        color[0] = color[1] = color[2] = 255;
        fogDensity[0] = fogDensity[1] = fogDensity[2] = 0;
        fog = false;
        lightRadius[0] = lightRadius[1] = lightRadius[2] = 300;
}


void CLightInfo::DefaultPoint() {
        idVec3 oldColor = color;
        Defaults();
        color = oldColor;
        pointLight = true;
}

void CLightInfo::DefaultProjected() {
        idVec3 oldColor = color;
        Defaults();
        color = oldColor;
        pointLight = false;
        lightTarget[2] = -256;
        lightUp[1] = -128;
        lightRight[0] = -128;
}

void CLightInfo::FromDict( const idDict *e ) {

        lightRadius.Zero();
        lightTarget.Zero();
        lightRight.Zero();
        lightUp.Zero();
        lightStart.Zero();
        lightEnd.Zero();
        lightCenter.Zero();

        castShadows = !e->GetBool("noshadows");
        castSpecular = !e->GetBool("nospecular");
        castDiffuse = !e->GetBool("nodiffuse");
        fallOff = e->GetFloat("falloff");
        strTexture = e->GetString("texture");

        isParallel = e->GetBool("parallel");

        if (!e->GetVector("_color", "", color)) {
                color[0] = color[1] = color[2] = 1;
        }
        // windows needs 0-255 scale
        color[0] *= 255;
        color[1] *= 255;
        color[2] *= 255;

        if (e->GetVec4("fog", "", fogDensity)) {
                fog = true;
        } else {
                fog = false;
        }

        if (e->GetVector("light_right","", lightRight)) {
                // projected light
                pointLight = false;
                e->GetVector("light_target", "", lightTarget);
                e->GetVector("light_up", "", lightUp);
                if (e->GetVector("light_start", "", lightStart)) {
                        // explicit start and end points
                        explicitStartEnd = true;
                        if (!e->GetVector("light_end", "", lightEnd)) {
                                // no end, use target
                                VectorCopy(lightTarget, lightEnd);
                        }
                } else {
                        explicitStartEnd = false;
                        // create a start a quarter of the way to the target
                        lightStart = lightTarget * 0.25;
                        VectorCopy(lightTarget, lightEnd);
                }
        } else {
                pointLight = true;
                if (e->GetVector("light_radius", "", lightRadius)) {
                        equalRadius = false;
                } else {
                        float radius = e->GetFloat("light");
                        if (radius == 0) {
                                radius = 300;
                        }
                        lightRadius[0] = lightRadius[1] = lightRadius[2] = radius;
                        equalRadius = true;
                }
                if (e->GetVector("light_center", "", lightCenter)) {
                        hasCenter = true;
                }
        }
}

void CLightInfo::ToDictFromDifferences ( idDict *e, const idDict *differences ) {
    for ( int i = 0 ; i < differences->GetNumKeyVals () ; i ++ ) {
        const idKeyValue *kv = differences->GetKeyVal( i );
        
        if ( kv->GetValue().Length() > 0 ) {
            e->Set ( kv->GetKey() ,kv->GetValue() );
                } else {
                e->Delete ( kv->GetKey() );
                }

        common->Printf( "Applied difference: %s %s\n" , kv->GetKey().c_str() , kv->GetValue().c_str() );
    }
}

//write all info to a dict, regardless of light type
void CLightInfo::ToDictWriteAllInfo( idDict *e ) {
    e->Set("noshadows", (!castShadows) ? "1" : "0");
        e->Set("nospecular", (!castSpecular) ? "1" : "0");
        e->Set("nodiffuse", (!castDiffuse) ? "1" : "0");

        e->SetFloat("falloff",fallOff);
        
        if (strTexture.GetLength() > 0 ) {
                e->Set("texture", strTexture);
        }

        idVec3 temp = color;
        temp /= 255;
        e->SetVector("_color", temp);

        if (!equalRadius) {
                e->Set("light_radius", va("%g %g %g", lightRadius[0], lightRadius[1], lightRadius[2]));
        } else {
                e->Set("light_radius", va("%g %g %g", lightRadius[0], lightRadius[0], lightRadius[0]));
        }

        e->Set("light_center", va("%g %g %g", lightCenter[0], lightCenter[1], lightCenter[2]));
    e->Set("parallel", isParallel?"1":"0");

    e->Set("light_target", va("%g %g %g", lightTarget[0], lightTarget[1], lightTarget[2]));
        e->Set("light_up", va("%g %g %g", lightUp[0], lightUp[1], lightUp[2]));
        e->Set("light_right", va("%g %g %g", lightRight[0], lightRight[1], lightRight[2]));
    e->Set("light_start", va("%g %g %g", lightStart[0], lightStart[1], lightStart[2]));
        e->Set("light_end", va("%g %g %g", lightEnd[0], lightEnd[1], lightEnd[2]));
}

void CLightInfo::ToDict( idDict *e ) {

        e->Delete("noshadows");
        e->Delete("nospecular");
        e->Delete("nodiffuse");
        e->Delete("falloff");
        e->Delete("parallel");
        e->Delete("texture");
        e->Delete("_color");
        e->Delete("fog");
        e->Delete("light_target");
        e->Delete("light_right");
        e->Delete("light_up");
        e->Delete("light_start");
        e->Delete("light_end");
        e->Delete("light_radius");
        e->Delete("light_center");
        e->Delete("light");

        e->Set("noshadows", (!castShadows) ? "1" : "0");
        e->Set("nospecular", (!castSpecular) ? "1" : "0");
        e->Set("nodiffuse", (!castDiffuse) ? "1" : "0");

        e->SetFloat("falloff",fallOff);
        
        if (strTexture.GetLength() > 0) {
                e->Set("texture", strTexture);
        }

        idVec3 temp = color;
        temp /= 255;
        e->SetVector("_color", temp);

        if (fog) {
                e->Set("fog", va("%g %g %g %g", fogDensity[0]/255.0, fogDensity[1]/255.0, fogDensity[2]/255.0, fogDensity[3]/255.0));
        }

        if (pointLight) {
                if (!equalRadius) {
                        e->Set("light_radius", va("%g %g %g", lightRadius[0], lightRadius[1], lightRadius[2]));
                } else {
                        e->Set("light_radius", va("%g %g %g", lightRadius[0], lightRadius[0], lightRadius[0]));
                }

                if (hasCenter) {
                        e->Set("light_center", va("%g %g %g", lightCenter[0], lightCenter[1], lightCenter[2]));
                }

                if (isParallel) {
                        e->Set("parallel", "1");
                }
        } else {
                e->Set("light_target", va("%g %g %g", lightTarget[0], lightTarget[1], lightTarget[2]));
                e->Set("light_up", va("%g %g %g", lightUp[0], lightUp[1], lightUp[2]));
                e->Set("light_right", va("%g %g %g", lightRight[0], lightRight[1], lightRight[2]));
                if (explicitStartEnd) {
                        e->Set("light_start", va("%g %g %g", lightStart[0], lightStart[1], lightStart[2]));
                        e->Set("light_end", va("%g %g %g", lightEnd[0], lightEnd[1], lightEnd[2]));
                }
        }
}

CLightInfo::CLightInfo() {
        Defaults();
}



// CLightDlg dialog

CLightDlg *g_LightDialog = NULL;


CLightDlg::CLightDlg(CWnd* pParent /*=NULL*/)
        : CDialog(CLightDlg::IDD, pParent)
{
        //{{AFX_DATA_INIT(CLightDlg)
        m_bEqualRadius = FALSE;
        m_bExplicitFalloff = FALSE;
        m_bPointLight = FALSE;
        m_bCheckProjected = FALSE;
        m_fFallloff = 0.0f;
        m_nFalloff = -1;
        m_bRotate = FALSE;
        m_bShadows = FALSE;
        m_bSpecular = FALSE;
        m_bDiffuse = FALSE;
        m_fEndX = 0.0f;
        m_fEndY = 0.0f;
        m_fEndZ = 0.0f;
        m_fRadiusX = 0.0f;
        m_fRadiusY = 0.0f;
        m_fRadiusZ = 0.0f;
        m_fRightX = 0.0f;
        m_fRightY = 0.0f;
        m_fRightZ = 0.0f;
        m_fRotate = 0.0f;
        m_fStartX = 0.0f;
        m_fStartY = 0.0f;
        m_fStartZ = 0.0f;
        m_fTargetX = 0.0f;
        m_fTargetY = 0.0f;
        m_fTargetZ = 0.0f;
        m_fUpX = 0.0f;
        m_fUpY = 0.0f;
        m_fUpZ = 0.0f;
        m_hasCenter = FALSE;
        m_centerX = 0.0f;
        m_centerY = 0.0f;
        m_centerZ = 0.0f;
    m_bIsParallel = FALSE;
        //}}AFX_DATA_INIT
        m_drawMaterial = new idGLDrawableMaterial();
}

CLightDlg::~CLightDlg() {
        delete m_drawMaterial;
}

void CLightDlg::DoDataExchange(CDataExchange* pDX)
{
        CDialog::DoDataExchange(pDX);
        //{{AFX_DATA_MAP(CLightDlg)
        if ( com_editorActive ) {
                DDX_Control(pDX, IDC_LIGHTPREVIEW, m_wndPreview);
        }
        DDX_Control(pDX, IDC_COMBO_TEXTURE, m_wndLights);
        DDX_Check(pDX, IDC_CHECK_EQUALRADIUS, m_bEqualRadius);
        DDX_Check(pDX, IDC_CHECK_EXPLICITFALLOFF, m_bExplicitFalloff);
        DDX_Check(pDX, IDC_CHECK_POINT, m_bPointLight);
        DDX_Check(pDX, IDC_CHECK_PROJECTED, m_bCheckProjected);
        DDX_Radio(pDX, IDC_RADIO_FALLOFF, m_nFalloff);
        DDX_Check(pDX, IDC_CHECK_SHADOWS, m_bShadows);
        DDX_Check(pDX, IDC_CHECK_SPECULAR, m_bSpecular);
        DDX_Check(pDX, IDC_CHECK_DIFFUSE, m_bDiffuse);
    DDX_Check(pDX , IDC_CHECK_PARALLEL , m_bIsParallel );
        DDX_Text(pDX, IDC_EDIT_ENDX, m_fEndX);
        DDX_Text(pDX, IDC_EDIT_ENDY, m_fEndY);
        DDX_Text(pDX, IDC_EDIT_ENDZ, m_fEndZ);
        DDX_Text(pDX, IDC_EDIT_RADIUSX, m_fRadiusX);
        DDX_Text(pDX, IDC_EDIT_RADIUSY, m_fRadiusY);
        DDX_Text(pDX, IDC_EDIT_RADIUSZ, m_fRadiusZ);
        DDX_Text(pDX, IDC_EDIT_RIGHTX, m_fRightX);
        DDX_Text(pDX, IDC_EDIT_RIGHTY, m_fRightY);
        DDX_Text(pDX, IDC_EDIT_RIGHTZ, m_fRightZ);
        DDX_Text(pDX, IDC_EDIT_STARTX, m_fStartX);
        DDX_Text(pDX, IDC_EDIT_STARTY, m_fStartY);
        DDX_Text(pDX, IDC_EDIT_STARTZ, m_fStartZ);
        DDX_Text(pDX, IDC_EDIT_TARGETX, m_fTargetX);
        DDX_Text(pDX, IDC_EDIT_TARGETY, m_fTargetY);
        DDX_Text(pDX, IDC_EDIT_TARGETZ, m_fTargetZ);
        DDX_Text(pDX, IDC_EDIT_UPX, m_fUpX);
        DDX_Text(pDX, IDC_EDIT_UPY, m_fUpY);
        DDX_Text(pDX, IDC_EDIT_UPZ, m_fUpZ);
        DDX_Check(pDX, IDC_CHECK_CENTER, m_hasCenter);
        DDX_Text(pDX, IDC_EDIT_CENTERX, m_centerX);
        DDX_Text(pDX, IDC_EDIT_CENTERY, m_centerY);
        DDX_Text(pDX, IDC_EDIT_CENTERZ, m_centerZ);
        //}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CLightDlg, CDialog)
        //{{AFX_MSG_MAP(CLightDlg)
        ON_BN_CLICKED(IDC_BTN_TEXTURE, OnBtnTexture)
        ON_BN_CLICKED(IDC_CHECK_EQUALRADIUS, OnCheckEqualradius)
        ON_BN_CLICKED(IDC_CHECK_EXPLICITFALLOFF, OnCheckExplicitfalloff)
        ON_BN_CLICKED(IDC_CHECK_POINT, OnCheckPoint)
        ON_BN_CLICKED(IDC_CHECK_PROJECTED, OnCheckProjected)
        ON_BN_CLICKED(IDC_RADIO_FALLOFF, OnRadioFalloff)
        ON_BN_CLICKED(IDC_APPLY, OnApply)
    ON_BN_CLICKED(IDC_APPLY_DIFFERENT, OnApplyDifferences)
        ON_BN_CLICKED(IDC_BTN_COLOR, OnBtnColor)
        ON_WM_CTLCOLOR()
        ON_CBN_SELCHANGE(IDC_COMBO_TEXTURE, OnSelchangeComboTexture)
        ON_BN_CLICKED(IDC_CHECK_CENTER, OnCheckCenter)
        ON_BN_CLICKED(IDC_CHECK_PARALLEL, OnCheckParallel)
        //}}AFX_MSG_MAP
END_MESSAGE_MAP()

// CLightDlg message handlers

void CLightDlg::SetSpecifics() {
        if (lightInfo.pointLight) {
                GetDlgItem(IDC_EDIT_RADIUSY)->EnableWindow(!lightInfo.equalRadius);
                GetDlgItem(IDC_EDIT_RADIUSZ)->EnableWindow(!lightInfo.equalRadius);
                GetDlgItem(IDC_EDIT_CENTERX)->EnableWindow(lightInfo.hasCenter);
                GetDlgItem(IDC_EDIT_CENTERY)->EnableWindow(lightInfo.hasCenter);
                GetDlgItem(IDC_EDIT_CENTERZ)->EnableWindow(lightInfo.hasCenter);
        } else {
                GetDlgItem(IDC_EDIT_STARTX)->EnableWindow(lightInfo.explicitStartEnd);
                GetDlgItem(IDC_EDIT_STARTY)->EnableWindow(lightInfo.explicitStartEnd);
                GetDlgItem(IDC_EDIT_STARTZ)->EnableWindow(lightInfo.explicitStartEnd);
                GetDlgItem(IDC_EDIT_ENDX)->EnableWindow(lightInfo.explicitStartEnd);
                GetDlgItem(IDC_EDIT_ENDY)->EnableWindow(lightInfo.explicitStartEnd);
                GetDlgItem(IDC_EDIT_ENDZ)->EnableWindow(lightInfo.explicitStartEnd);
        }
}

void CLightDlg::EnableControls() {
        GetDlgItem(IDC_CHECK_EQUALRADIUS)->EnableWindow(lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_RADIUSX)->EnableWindow(lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_RADIUSY)->EnableWindow(lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_RADIUSZ)->EnableWindow(lightInfo.pointLight);
        GetDlgItem(IDC_RADIO_FALLOFF)->EnableWindow(lightInfo.pointLight);
        GetDlgItem(IDC_RADIO_FALLOFF2)->EnableWindow(lightInfo.pointLight);
        GetDlgItem(IDC_RADIO_FALLOFF3)->EnableWindow(lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_TARGETX)->EnableWindow(!lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_TARGETY)->EnableWindow(!lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_TARGETZ)->EnableWindow(!lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_RIGHTX)->EnableWindow(!lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_RIGHTY)->EnableWindow(!lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_RIGHTZ)->EnableWindow(!lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_UPX)->EnableWindow(!lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_UPY)->EnableWindow(!lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_UPZ)->EnableWindow(!lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_STARTX)->EnableWindow(!lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_STARTY)->EnableWindow(!lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_STARTZ)->EnableWindow(!lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_ENDX)->EnableWindow(!lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_ENDY)->EnableWindow(!lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_ENDZ)->EnableWindow(!lightInfo.pointLight);
        GetDlgItem(IDC_CHECK_EXPLICITFALLOFF)->EnableWindow(!lightInfo.pointLight);
        GetDlgItem(IDC_CHECK_POINT)->EnableWindow(!lightInfo.pointLight);
        GetDlgItem(IDC_CHECK_PROJECTED)->EnableWindow(lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_CENTERX)->EnableWindow(lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_CENTERY)->EnableWindow(lightInfo.pointLight);
        GetDlgItem(IDC_EDIT_CENTERZ)->EnableWindow(lightInfo.pointLight);
        GetDlgItem(IDC_CHECK_CENTER)->EnableWindow(lightInfo.pointLight);

        reinterpret_cast<CButton*>(GetDlgItem(IDC_CHECK_PROJECTED))->SetCheck(!lightInfo.pointLight);
        reinterpret_cast<CButton*>(GetDlgItem(IDC_CHECK_POINT))->SetCheck(lightInfo.pointLight);

        SetSpecifics();
}

void CLightDlg::UpdateDialogFromLightInfo( void ) {
        m_hasCenter = lightInfo.hasCenter;
        m_bEqualRadius = lightInfo.equalRadius;
        m_bExplicitFalloff = lightInfo.explicitStartEnd;
        m_bPointLight = lightInfo.pointLight;
        m_bCheckProjected = !lightInfo.pointLight;
        m_fFallloff = lightInfo.fallOff;
        if (lightInfo.fallOff < 0.35) {
                m_nFalloff = 0;
        } else if (lightInfo.fallOff < 0.70) {
                m_nFalloff = 1;
        } else {
                m_nFalloff = 2;
        }
        //m_bFog = lightInfo.fog;
        m_bRotate = lightInfo.rotate;
        m_bShadows = lightInfo.castShadows;
        m_bSpecular = lightInfo.castSpecular;
        //m_bStrobe = lightInfo.strobe;
        //m_fStrobe = lightInfo.strobeSpeed;
        int sel = m_wndLights.FindStringExact(-1, lightInfo.strTexture);
        m_wndLights.SetCurSel(sel);
        if (sel >= 0) {
                m_drawMaterial->setMedia(lightInfo.strTexture);
        } else {
                m_drawMaterial->setMedia(lightInfo.strTexture);
        }

        m_bDiffuse = lightInfo.castDiffuse;
        m_fEndX = lightInfo.lightEnd[0];
        m_fEndY = lightInfo.lightEnd[1];
        m_fEndZ = lightInfo.lightEnd[2];
        m_fRadiusX = lightInfo.lightRadius[0];
        m_fRadiusY = lightInfo.lightRadius[1];
        m_fRadiusZ = lightInfo.lightRadius[2];
        m_fRightX = lightInfo.lightRight[0];
        m_fRightY = lightInfo.lightRight[1];
        m_fRightZ = lightInfo.lightRight[2];
        //m_bRotate = lightInfo.rotate;
        //m_fRotate = lightInfo.rotateSpeed;
        m_fStartX = lightInfo.lightStart[0];
        m_fStartY = lightInfo.lightStart[1];
        m_fStartZ = lightInfo.lightStart[2];
        m_fTargetX = lightInfo.lightTarget[0];
        m_fTargetY = lightInfo.lightTarget[1];
        m_fTargetZ = lightInfo.lightTarget[2];
        m_fUpX = lightInfo.lightUp[0];
        m_fUpY = lightInfo.lightUp[1];
        m_fUpZ = lightInfo.lightUp[2];
        VectorCopy(lightInfo.color, color);
        //m_fFogAlpha = lightInfo.fogDensity[3];
        m_centerX = lightInfo.lightCenter[0];
        m_centerY = lightInfo.lightCenter[1];
        m_centerZ = lightInfo.lightCenter[2];

    //jhefty - added parallel light updating
    m_bIsParallel = lightInfo.isParallel;

        UpdateData(FALSE);
}

void CLightDlg::UpdateLightInfoFromDialog( void ) {
        UpdateData( TRUE );
        
        lightInfo.pointLight = ( m_bPointLight != FALSE );
        lightInfo.equalRadius = ( m_bEqualRadius != FALSE );
        lightInfo.explicitStartEnd = ( m_bExplicitFalloff != FALSE );
        
        if (lightInfo.pointLight) {
                if (m_nFalloff == 0) {
                        m_fFallloff = 0.0;
                } else if (m_nFalloff == 1) {
                        m_fFallloff = 0.5;
                } else {
                        m_fFallloff = 1.0;
                }
        }

        lightInfo.fallOff = m_fFallloff;

        //lightInfo.fog = m_bFog;
        lightInfo.rotate = ( m_bRotate != FALSE );
        lightInfo.castShadows = ( m_bShadows != FALSE );
        lightInfo.castSpecular = ( m_bSpecular != FALSE );

        VectorCopy(color, lightInfo.color);
    lightInfo.isParallel = (m_bIsParallel == TRUE);

        //lightInfo.fogDensity[3] = m_fFogAlpha;

        //lightInfo.strobe = m_bStrobe;
        //lightInfo.strobeSpeed = m_fStrobe;
        //lightInfo.rotate = m_bRotate; 
        //lightInfo.rotateSpeed = m_fRotate;

        int sel = m_wndLights.GetCurSel();
        CString str("");
        if (sel >= 0) {
                m_wndLights.GetLBText(sel, str);
        }
        lightInfo.strTexture = str;

        lightInfo.castDiffuse = ( m_bDiffuse != FALSE );
        lightInfo.lightEnd[0] = m_fEndX;
        lightInfo.lightEnd[1] = m_fEndY;
        lightInfo.lightEnd[2] = m_fEndZ;
        lightInfo.lightRadius[0] = m_fRadiusX;
        lightInfo.lightRadius[1] = m_fRadiusY; 
        lightInfo.lightRadius[2] = m_fRadiusZ; 
        lightInfo.lightRight[0] = m_fRightX;
        lightInfo.lightRight[1] = m_fRightY;
        lightInfo.lightRight[2] = m_fRightZ;
        lightInfo.lightStart[0] = m_fStartX;
        lightInfo.lightStart[1] = m_fStartY;
        lightInfo.lightStart[2] = m_fStartZ;
        lightInfo.lightTarget[0] = m_fTargetX;
        lightInfo.lightTarget[1] = m_fTargetY; 
        lightInfo.lightTarget[2] = m_fTargetZ;
        lightInfo.lightUp[0] = m_fUpX;
        lightInfo.lightUp[1] = m_fUpY; 
        lightInfo.lightUp[2] = m_fUpZ;

        lightInfo.hasCenter = ( m_hasCenter != FALSE );
        lightInfo.lightCenter[0] = m_centerX;
        lightInfo.lightCenter[1] = m_centerY;
        lightInfo.lightCenter[2] = m_centerZ;
}

void CLightDlg::SaveLightInfo( const idDict *differences ) {

        if ( com_editorActive ) {

                // used from Radiant
                for ( brush_t *b = selected_brushes.next; b && b != &selected_brushes; b = b->next ) {
                        if ( ( b->owner->eclass->nShowFlags & ECLASS_LIGHT ) && !b->entityModel ) {
                                if ( differences ) {
                                        lightInfo.ToDictFromDifferences( &b->owner->epairs, differences );
                                } else {
                                        lightInfo.ToDict( &b->owner->epairs );
                                }
                                Brush_Build( b );
                        }
                }

        } else {

                // used in-game
                idList<idEntity *> list;

                list.SetNum( 128 );
                int count = gameEdit->GetSelectedEntities( list.Ptr(), list.Num() );
                list.SetNum( count );

                for ( int i = 0; i < count; i++ ) {
                        if ( differences ) {
                                gameEdit->EntityChangeSpawnArgs( list[i], differences );
                                gameEdit->EntityUpdateChangeableSpawnArgs( list[i], NULL );
                        } else {
                                idDict newArgs;
                                lightInfo.ToDict( &newArgs );
                                gameEdit->EntityChangeSpawnArgs( list[i], &newArgs );
                                gameEdit->EntityUpdateChangeableSpawnArgs( list[i], NULL );
                        }
                        gameEdit->EntityUpdateVisuals( list[i] );
                }
    }
}

void CLightDlg::ColorButtons() {
        CRect r;

        CClientDC dc(this);
        
        CButton *pBtn = (CButton *)GetDlgItem(IDC_BTN_COLOR);
        pBtn->GetClientRect(&r);
        colorBitmap.DeleteObject();
        colorBitmap.CreateCompatibleBitmap(&dc, r.Width(), r.Height());
        CDC MemDC;
        MemDC.CreateCompatibleDC(&dc);
        CBitmap *pOldBmp = MemDC.SelectObject(&colorBitmap);
        {
                CBrush br(RGB(color[0], color[1], color[2])); 
                MemDC.FillRect(r,&br);
        }
        dc.SelectObject(pOldBmp);
        pBtn->SetBitmap(HBITMAP(colorBitmap)); 
}


void CLightDlg::LoadLightTextures() {
        int count = declManager->GetNumDecls( DECL_MATERIAL );
        int i;
        const idMaterial *mat;
        for (i = 0; i < count; i++) {
                mat = declManager->MaterialByIndex(i, false);
                idStr str = mat->GetName();
                str.ToLower();
                if (str.Icmpn("lights/", strlen("lights/")) == 0 || str.Icmpn("fogs/", strlen("fogs/")) == 0) {
                        m_wndLights.AddString(mat->GetName());
                }
        }
}

BOOL CLightDlg::OnInitDialog() 
{
        CDialog::OnInitDialog();

        com_editors |= EDITOR_LIGHT;

        UpdateDialog( true );

        LoadLightTextures();

        if ( com_editorActive ) {
                m_wndPreview.setDrawable(m_drawMaterial);
        }

        return TRUE;  // return TRUE unless you set the focus to a control
                      // EXCEPTION: OCX Property Pages should return FALSE
}

void CLightDlg::OnDestroy() {

        com_editors &= ~EDITOR_LIGHT;

        return CDialog::OnDestroy();
}

void CLightDlg::OnBtnTexture() 
{
        // TODO: Add your control notification handler code here
        
}

void CLightDlg::OnCheckEqualradius() 
{
        lightInfo.equalRadius = ( reinterpret_cast<CButton*>(GetDlgItem(IDC_CHECK_EQUALRADIUS))->GetCheck() != 0 );
        SetSpecifics();
}

void CLightDlg::OnCheckExplicitfalloff() 
{
        lightInfo.explicitStartEnd = ( reinterpret_cast<CButton*>(GetDlgItem(IDC_CHECK_EXPLICITFALLOFF))->GetCheck() != 0 );
        SetSpecifics();
}

void CLightDlg::OnCheckPoint() 
{
        lightInfo.DefaultPoint();
        UpdateDialogFromLightInfo();
        EnableControls();
}

void CLightDlg::OnCheckProjected() 
{
        lightInfo.DefaultProjected();
        UpdateDialogFromLightInfo();
        EnableControls();
}

void CLightDlg::OnRadioFalloff() 
{
}

void CLightDlg::OnOK() {
        UpdateLightInfoFromDialog();
        SaveLightInfo( NULL );
        Sys_UpdateWindows(W_ALL);
        CDialog::OnOK();
}

entity_t *SingleLightSelected() {
        if ( QE_SingleBrush( true, true ) ) {
                brush_t *b = selected_brushes.next;
                if ( ( b->owner->eclass->nShowFlags & ECLASS_LIGHT ) && !b->entityModel ) {
                        return b->owner;
                }
        }
        return NULL;
}

void CLightDlg::UpdateDialog( bool updateChecks )
{       
        CString title;

        lightInfo.Defaults();
        lightInfoOriginal.Defaults ();

        if ( com_editorActive ) {
                // used from Radiant
                entity_t *e = SingleLightSelected();
                if ( e ) {
                        lightInfo.FromDict(&e->epairs);
                        lightInfoOriginal.FromDict(&e->epairs); //our original copy of the values that we compare against for apply differences
                        title = "Light Editor";
                } else {   
                        //find the last brush belonging to the last entity selected and use that as the source
                        e = NULL;
                        for ( brush_t *b = selected_brushes.next ; b != &selected_brushes ; b = b->next ) {
                                if ( ( b->owner->eclass->nShowFlags & ECLASS_LIGHT ) && !b->entityModel ) {
                                        e = b->owner;
                                        break;
                                }
                        }

                        if ( e ) {
                                lightInfo.FromDict( &e->epairs );
                                lightInfoOriginal.FromDict(&e->epairs); //our original copy of the values that we compaer against for apply differences
                                title = "Light Editor - (Multiple lights selected)";
                        } else {
                                title = "Light Editor - (No lights selected)";
                        }
                }
        } else {
                // used in-game
                idList<idEntity *> list;

                list.SetNum( 128 );
                int count = gameEdit->GetSelectedEntities( list.Ptr(), list.Num() );
                list.SetNum( count );

                if ( count > 0 ) {
                        lightInfo.FromDict( gameEdit->EntityGetSpawnArgs( list[count-1] ) );
                        title = "Light Editor";
                } else {
                        title = "Light Editor - (No entities selected)";
                }
        }

        SetWindowText( title );

        UpdateDialogFromLightInfo();
        ColorButtons();

        if ( updateChecks ) {
                EnableControls();
        }
}

void LightEditorInit( const idDict *spawnArgs ) {
        if ( renderSystem->IsFullScreen() ) {
                common->Printf( "Cannot run the light editor in fullscreen mode.\n"
                                        "Set r_fullscreen to 0 and vid_restart.\n" );
                return;
        }

        if ( g_LightDialog == NULL ) {
                InitAfx();
                g_LightDialog = new CLightDlg();
        }

        if ( g_LightDialog->GetSafeHwnd() == NULL ) {
                g_LightDialog->Create( IDD_DIALOG_LIGHT );
                CRect rct;
                LONG lSize = sizeof( rct );
                if ( LoadRegistryInfo( "Radiant::LightWindow", &rct, &lSize ) ) {
                        g_LightDialog->SetWindowPos(NULL, rct.left, rct.top, 0,0, SWP_NOSIZE);
                }
        }

        idKeyInput::ClearStates();

        g_LightDialog->ShowWindow( SW_SHOW );
        g_LightDialog->SetFocus();
        g_LightDialog->UpdateDialog( true );

        if ( spawnArgs ) {
                // FIXME: select light based on spawn args
        }
}

void LightEditorRun( void ) {
#if _MSC_VER >= 1300
        MSG *msg = AfxGetCurrentMessage();                      // TODO Robert fix me!!
#else
        MSG *msg = &m_msgCur;
#endif

        while( ::PeekMessage(msg, NULL, NULL, NULL, PM_NOREMOVE) ) {
                // pump message
                if ( !AfxGetApp()->PumpMessage() ) {
                }
        }
}

void LightEditorShutdown( void ) {
        delete g_LightDialog;
        g_LightDialog = NULL;
}

void UpdateLightInspector() {
        if ( g_LightDialog && g_LightDialog->GetSafeHwnd() != NULL ) {
                g_LightDialog->UpdateDialog(true);   //jhefty - update ALL info about the light, including check boxes
        }
}

void CLightDlg::OnApply() {
        UpdateLightInfoFromDialog();
        SaveLightInfo( NULL );
        Sys_UpdateWindows( W_ALL );
}

void UpdateLightDialog( float r, float g, float b, float a ) {
        UpdateRadiantColor( 0.0f, 0.0f, 0.0f, 0.0f );
        g_LightDialog->UpdateColor( r, g, b, a );
}

void CLightDlg::UpdateColor( float r, float g, float b, float a ) {
        color[0] = a * r;
        color[1] = a * g;
        color[2] = a * b;
        ColorButtons();
        UpdateLightInfoFromDialog();
        SaveLightInfo( NULL );
        Sys_UpdateWindows( W_CAMERA );
}

void CLightDlg::OnBtnColor() {
        int r, g, b;
        float ob;
        r = color[0];
        g = color[1];
        b = color[2];
        if ( DoNewColor( &r, &g, &b, &ob, UpdateLightDialog ) ) {
                color[0] = ob * r;
                color[1] = ob * g;
                color[2] = ob * b;
                ColorButtons();
        }
}

void CLightDlg::OnCancel() {
        CDialog::OnCancel();
}

HBRUSH CLightDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor) 
{
        HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);

        return hbr;
}

BOOL CLightDlg::DestroyWindow() 
{
        if (GetSafeHwnd())
        {
                CRect rct;
                GetWindowRect(rct);
                SaveRegistryInfo("Radiant::LightWindow", &rct, sizeof(rct));
        }
        return CDialog::DestroyWindow();
}

void CLightDlg::OnSelchangeComboTexture() 
{
        UpdateData(TRUE);
        int sel = m_wndLights.GetCurSel();
        CString str;
        if (sel >= 0) {
                m_wndLights.GetLBText(sel, str);
                m_drawMaterial->setMedia(str);
                if ( com_editorActive ) {
                        m_wndPreview.RedrawWindow();
                }
        }
        Sys_UpdateWindows(W_ALL);
}

void CLightDlg::OnCheckCenter() 
{
        if (reinterpret_cast<CButton*>(GetDlgItem(IDC_CHECK_CENTER))->GetCheck()) {
                lightInfo.hasCenter = true;
                lightInfo.lightCenter.x = 0;
                lightInfo.lightCenter.y = 0;
                lightInfo.lightCenter.z = 32;
        } else {
                lightInfo.hasCenter = false;
                lightInfo.lightCenter.Zero();
        }
        UpdateDialogFromLightInfo();
        SetSpecifics();
}

void CLightDlg::OnCheckParallel() {
        if ( reinterpret_cast<CButton*>(GetDlgItem(IDC_CHECK_PARALLEL))->GetCheck() ) {
                lightInfo.hasCenter = true;
                lightInfo.isParallel = true;
                lightInfo.lightCenter.x = 0;
                lightInfo.lightCenter.y = 0;
                lightInfo.lightCenter.z = 32;
        } else {
                lightInfo.isParallel = false;
                lightInfo.hasCenter = false;
        }

        UpdateDialogFromLightInfo();
        SetSpecifics();
}

//jhefty - only apply settings that are different
void CLightDlg::OnApplyDifferences () {
        idDict differences, modified, original;

        UpdateLightInfoFromDialog();

        lightInfo.ToDict( &modified );
        lightInfoOriginal.ToDictWriteAllInfo( &original );

        differences = modified;

        // jhefty - compile a set of modified values to apply
        for ( int i = 0; i < modified.GetNumKeyVals (); i ++ ) {
                const idKeyValue* valModified = modified.GetKeyVal ( i );
                const idKeyValue* valOriginal = original.FindKey ( valModified->GetKey() );

                //if it hasn't changed, remove it from the list of values to apply
                if ( !valOriginal || ( valModified->GetValue() == valOriginal->GetValue() ) ) {
                        differences.Delete ( valModified->GetKey() );
                }
        }

        SaveLightInfo( &differences );

        lightInfoOriginal.FromDict( &modified );

        Sys_UpdateWindows( W_ALL );
}