D:/Zythum/DinoKod/MapEditor/MapEditorInterface.cpp

#include <conio.h>

#include "Common/Error.h"
#include "Common/Console.h"
#include "Common/Ini.h"
#include "Common/Time.h"
#include "Common/Directory.h"

#include "Render/Camera.h"
#include "Render/Render.h"
#include "Render/RenderDefs.h"

#include "Landscape/LandObject.h"
#include "Landscape/LandEntity.h"
#include "Landscape/LandscapeDraw.h"

#include "MapEditor/GameMapEditor.h"

#include "Input/InputDI.h"

#include "MapEditor/MapEditorInterface.h"

//---------------------------------------------------------------------------------------------------------------------
KMapEditorInterface::KMapEditorInterface( HINSTANCE hInstance, HWND hWnd, u32 Adapter, u32 Width, u32 Height, u32 Bpp, u32 bFullScreen, u32 RefreshRate )
: KInterface( hInstance, hWnd, Adapter, Width, Height, Bpp, bFullScreen, RefreshRate )
{
        m_pLandscape            = NULL;
        m_bFreeCamera           = false;
        m_LastFrameTime         = 0;

        m_CamPos                        = KVector( 0.0f, 0.0f, 100.0f );
        m_CamRot                        = KVector( 0.0f, 0.0f, 0.0f );
        m_CamZoom                       = 0.0f;

        m_pSelectedModel        = NULL;
        m_sSelectedModelName= "";
        m_RotAngle                      = 0.0f;

        m_bHighLight            = false;

        m_SunTime                       = 0.0f;

        m_pModelBank            = NULL;

        m_pCamera->SetFarPlane( 1000.0f );
}

//---------------------------------------------------------------------------------------------------------------------
KMapEditorInterface::~KMapEditorInterface()
{
        KLandModelObject*       pLandModelObject;

        while( pLandModelObject = m_LandModels.GetFirst() )
        {
                m_LandModels.Remove( pLandModelObject );
                Deletep( pLandModelObject );
        }

        if( m_pSelectedModel )
                Deletep( m_pSelectedModel );
}

//---------------------------------------------------------------------------------------------------------------------
bool KMapEditorInterface::Init()
{
        if( !KInterface::Init() )
                return false;
        
        m_pModelBank = new KClientModelBank( GetpRender() );

        GetpRender()->SetClear( true );
        GetpRender()->SetClearColor( KRGB( 128, 128, 255 ) );

        m_pCamera->Translate( 0.0f, -700.0f, 300.0f );

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::End()
{
        if( m_pModelBank )
                Deletep( m_pModelBank );

        KInterface::End();
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::Display()
{
        KInterface::Display();  

        // Affiche le landscape
        if( m_pLandscape )
                m_pLandscape->Draw( m_SunTime );

        // Affiche les objects
        KLandModelObject*       pLandModelObject;

        for( pLandModelObject = m_LandModels.GetFirst(); pLandModelObject; pLandModelObject = m_LandModels.GetNext( pLandModelObject ) )
        {
                m_pRender->SetWorldMatrix( pLandModelObject->m_WorldMatrix );

                KModelDraw*     pModel = (KModelDraw*)m_pModelBank->GetpModel( pLandModelObject->m_hModel );
                if( pModel )
                        pModel->Draw();
        }

        // Affiche la selection
        if( m_pSelectedModel )
        {
                KMatrix Matrix;

                Matrix.LoadIdentity();
                Matrix.RotZ( m_RotAngle );
                Matrix.Trans( m_pLandscape->GetBrushVector().x, m_pLandscape->GetBrushVector().y, m_pLandscape->GetBrushVector().z );
                m_pRender->SetWorldMatrix( Matrix );
                m_pSelectedModel->Draw();
        }
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::SetCameraPos( float x, float y, float z )
{
        m_CamPos.x = x;
        m_CamPos.y = y;
        m_CamPos.z = z;

        GetpRender()->GetCamera()->SetPos( x, y, z );
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::MoveFrame()
{
        KCamera*        pCamera = GetpRender()->GetCamera();
        KASSERT( pCamera );

        float   TransVelocity = 1.0f;
        float   RotVelocity = 0.01f;

        if( m_LastFrameTime != 0 )
        {
                TransVelocity *= ((float)(g_Time.GetTime() - m_LastFrameTime) / 10.0f);
                RotVelocity *= ((float)(g_Time.GetTime() - m_LastFrameTime) / 10.0f);
        }

        m_LastFrameTime = g_Time.GetTime();

        if( m_bFreeCamera )
        {
                // Free Camera
                if( GetAsyncKeyState( 'Z' ) )                   pCamera->Translate( 0, TransVelocity, 0 );
                if( GetAsyncKeyState( 'S' ) )                   pCamera->Translate( 0, -TransVelocity, 0 );
                if( GetAsyncKeyState( 'Q' ) )                   pCamera->Translate( -TransVelocity, 0, 0 );
                if( GetAsyncKeyState( 'D' ) )                   pCamera->Translate( TransVelocity, 0, 0 );
                if( GetAsyncKeyState( VK_NUMPAD8 ) )    pCamera->RotateX( -RotVelocity );
                if( GetAsyncKeyState( VK_NUMPAD5 ) )    pCamera->RotateX( RotVelocity );
                if( GetAsyncKeyState( VK_NUMPAD4 ) )    pCamera->RotateZ( -RotVelocity );
                if( GetAsyncKeyState( VK_NUMPAD6 ) )    pCamera->RotateZ( RotVelocity );
                if( GetAsyncKeyState( VK_NUMPAD1 ) )    pCamera->Translate( 0, 0, TransVelocity );
                if( GetAsyncKeyState( VK_NUMPAD0 ) )    pCamera->Translate( 0, 0, -TransVelocity );
                if( GetAsyncKeyState( VK_HOME ) )               pCamera->Reset();

                KInputMouseState        MouseState;

                if( m_pInput )
                {
                        m_pInput->GetMouseState( &MouseState );

                        if( MouseState.m_X )
                                pCamera->RotateZ( (MouseState.m_X / 2.0f) * RotVelocity );

                        if( MouseState.m_Y )
                                pCamera->RotateX( -(MouseState.m_Y / 2.0f) * RotVelocity );
                }
        }
        else
        {
                // Editor Camera
                if( GetAsyncKeyState( 'Z' ) )                   m_CamPos.y += TransVelocity;
                if( GetAsyncKeyState( 'S' ) )                   m_CamPos.y -= TransVelocity;
                if( GetAsyncKeyState( 'Q' ) )                   m_CamPos.x -= TransVelocity;
                if( GetAsyncKeyState( 'D' ) )                   m_CamPos.x += TransVelocity;
                if( GetAsyncKeyState( 'A' ) )                   m_CamZoom -= TransVelocity;
                if( GetAsyncKeyState( 'E' ) )                   m_CamZoom += TransVelocity;

                m_CamRot.x = -(PI/180.0f) * 60.0f;

                pCamera->Reset();
                pCamera->Translate( m_CamPos.x, m_CamPos.y, m_CamPos.z );
                pCamera->RotateX( m_CamRot.x );
                pCamera->RotateY( m_CamRot.y );
                pCamera->RotateZ( m_CamRot.z );
                pCamera->Translate( 0.0f, m_CamZoom, 0.0f );
        }
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::TranslateCamera( float x, float y, float z )
{
        KCamera*        pCamera = GetpRender()->GetCamera();
        KASSERT( pCamera );

        pCamera->Translate( x, y, z );
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::RotateCamera( float x, float y, float z )
{
        KCamera*        pCamera = GetpRender()->GetCamera();
        KASSERT( pCamera );

        if( x != 0.0f )
                pCamera->RotateX( x );
        if( y != 0.0f )
                pCamera->RotateY( y );
        if( z != 0.0f )
                pCamera->RotateZ( z );
}

//---------------------------------------------------------------------------------------------------------------------
bool KMapEditorInterface::LoadLandscape( char* pFileName )
{
        KASSERT( !m_pLandscape );

        KLandModelObject*       pLandModelObject;

        m_pLandscape = new KLandscapeDraw( m_pRender );

        if( !m_pLandscape->LoadLandscape( pFileName ) )
        {
                Deletep( m_pLandscape );
                return false;
        }

        // Charge les LandObject
        KLandObject*            pLandObject;
        for( pLandObject = m_pLandscape->GetFirstLandObject(); pLandObject; pLandObject = m_pLandscape->GetNextLandObject( pLandObject ) )
        {
                char                            pDirectory[1024];
                
                strcpy( pDirectory, "Objects/" );
                strcat( pDirectory, pLandObject->GetpObjectName() );
                
                // Convertion des \\ => /
                for( u32 i = 0; i < strlen( pDirectory ); i ++ )
                {
                        if( pDirectory[i] == '\\' )
                                pDirectory[i] = '/';
                }

                // Charge le model
                KMODEL  hModel = m_pModelBank->LoadModel( KStr( pDirectory ) );
                if( hModel == KMODEL_NO )
                        return NULL;

                // Ajoute le model dans la liste
                pLandModelObject = new KLandModelObject();
                pLandModelObject->m_hModel              = hModel;
                pLandModelObject->m_pLandEntity = NULL;
                pLandModelObject->m_pLandObject = pLandObject;
                pLandModelObject->m_WorldMatrix = pLandObject->GetMatrix();
                pLandModelObject->m_sModelName  = pLandObject->GetpObjectName();
                m_LandModels.Add( pLandModelObject );
        }

        // Charge les LandEntity
        KLandEntity*            pLandEntity;
        for( pLandEntity = m_pLandscape->GetFirstLandEntity(); pLandEntity; pLandEntity = m_pLandscape->GetNextLandEntity( pLandEntity ) )
        {
                char                            pDirectory[1024];
                
                strcpy( pDirectory, "Objects/Entity/Entity" );
                
                // Convertion des \\ => /
                for( u32 i = 0; i < strlen( pDirectory ); i ++ )
                {
                        if( pDirectory[i] == '\\' )
                                pDirectory[i] = '/';
                }

                // Charge le model
                KMODEL  hModel = m_pModelBank->LoadModel( KStr( pDirectory ) );
                if( hModel == KMODEL_NO )
                        return NULL;

                // Ajoute le model dans la liste
                pLandModelObject = new KLandModelObject();
                pLandModelObject->m_hModel              = hModel;
                pLandModelObject->m_pLandEntity = pLandEntity;
                pLandModelObject->m_pLandObject = NULL;
                pLandModelObject->m_WorldMatrix = pLandEntity->GetMatrix();
                pLandModelObject->m_sModelName  = KStr( "Entity" );
                m_LandModels.Add( pLandModelObject );
        }

        m_pLandscape->DrawSky( false );
        m_pLandscape->DrawMiniMap( false );

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KMapEditorInterface::SaveLandscape( char* pFileName )
{
        KASSERT( m_pLandscape );

        if( !m_pLandscape->SaveLandscape( pFileName ) )
                return false;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KMapEditorInterface::CloseLandscape()
{
        if( m_pLandscape)
                Deletep( m_pLandscape );

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KMapEditorInterface::NewLandscape( s32 Width, s32 Height )
{
        KASSERT( !m_pLandscape );

        m_pLandscape = new KLandscapeDraw( m_pRender );

        if( !m_pLandscape->NewLandscape( Width, Height ) )
        {
                Deletep( m_pLandscape );
                return false;
        }

        m_pLandscape->DrawSky( false );
        m_pLandscape->DrawMiniMap( false );

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::SetBrush( s32 x, s32 y, s32 Size )
{
        m_pLandscape->SetBrush( x, y, Size );
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::ChangeLevel( s32 Height )
{
        m_pLandscape->ChangeLevel( Height );
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::ChangeTexture( char* pTextureName )
{
        m_pLandscape->ChangeTexture( pTextureName );
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::RotateTexture( float Angle )
{
        m_pLandscape->RotateTexture( Angle );
}

//---------------------------------------------------------------------------------------------------------------------
KLandModelObject* KMapEditorInterface::AddModel( char* pModelName )
{
        KMatrix                         Matrix;
        char                            pDirectory[1024];
        
        strcpy( pDirectory, "Objects/" );
        strcat( pDirectory, pModelName );
        
        // Convertion des \\ => /
        for( u32 i = 0; i < strlen( pDirectory ); i ++ )
        {
                if( pDirectory[i] == '\\' )
                        pDirectory[i] = '/';
        }

        // Charge le model
        KMODEL  hModel = m_pModelBank->LoadModel( KStr( pDirectory ) );
        if( hModel == KMODEL_NO )
                return NULL;

        Matrix.LoadIdentity();
        Matrix.RotZ( m_RotAngle );
        Matrix.Trans( m_pLandscape->GetBrushVector().x, m_pLandscape->GetBrushVector().y, m_pLandscape->GetBrushVector().z );

        // Ajoute le model au landscape comme LandObject
        KLandObject*    pLandObject;
        pLandObject = new KLandObject();
        pLandObject->SetMatrix( Matrix );
        pLandObject->SetpObjectName( pModelName );
        m_pLandscape->AddLandObject( pLandObject );
        
        // Ajoute le model dans la liste
        KLandModelObject*       pLandModelObject;
        pLandModelObject = new KLandModelObject();
        pLandModelObject->m_hModel              = hModel;
        pLandModelObject->m_WorldMatrix = Matrix;
        pLandModelObject->m_pLandObject = pLandObject;
        pLandModelObject->m_pLandEntity = NULL;
        pLandModelObject->m_sModelName  = KStr( pModelName );
        m_LandModels.Add( pLandModelObject );
        
        return pLandModelObject;
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::DelModel( KLandModelObject& LandModelObject )
{
        // Recherche le plus proche
        float                           NearDistance = 100.0f;
        float                           Distance;
        KLandModelObject*       pLandModelObject;
        KLandModelObject*       pNearLandModelObject = NULL;
        KStr                            sEntity = KStr( "Entity" );

        for( pLandModelObject = m_LandModels.GetFirst(); pLandModelObject; pLandModelObject = m_LandModels.GetNext( pLandModelObject ) )
        {
                // Filtre
                if( pLandModelObject->m_sModelName == sEntity )
                        continue;

                Distance = KVector::Distance( m_pLandscape->GetBrushVector(), KVector( pLandModelObject->m_WorldMatrix._41, pLandModelObject->m_WorldMatrix._42, pLandModelObject->m_WorldMatrix._43 ) );

                if( Distance < NearDistance )
                {
                        NearDistance                    = Distance;
                        pNearLandModelObject    = pLandModelObject;
                }
        }

        // Detruit le model
        if( pNearLandModelObject )
        {
                LandModelObject.m_hModel                = KMODEL_NO;
                LandModelObject.m_sModelName    = pNearLandModelObject->m_sModelName;
                LandModelObject.m_WorldMatrix   = pNearLandModelObject->m_WorldMatrix;
                
                // Objects
                m_pLandscape->RemoveLandObject( pNearLandModelObject->m_pLandObject );
                Deletep( pNearLandModelObject->m_pLandObject );

                // LandModel
                m_LandModels.Remove( pNearLandModelObject );
                Deletep( pNearLandModelObject );
        }
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::SetSelectedModel( KStr& sModelName )
{
        if( m_sSelectedModelName == sModelName )
                return;

        if( m_pSelectedModel )
                Deletep( m_pSelectedModel );

        if( sModelName == KStr( "" ) )
        {
                m_sSelectedModelName = sModelName;
                return;
        }

        KStr    sDirectory = g_Directory.GetPath( KStr( "Models" ) );
        sDirectory += "Objects/";
        sDirectory += sModelName;
        
        // Convertion des \\ => /
        for( u32 i = 0; i < sDirectory.GetLength(); i ++ )
        {
                if( sDirectory[i] == '\\' )
                        sDirectory[i] = '/';
        }

        m_sSelectedModelName = sModelName;

        // Charge le model
        m_pSelectedModel = new KModelDraw( m_pRender );
        if( !m_pSelectedModel->LoadModel( sDirectory ) )
        {
                Deletep( m_pSelectedModel );
                return;
        }
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::SetRotModel( float Angle )
{
        m_RotAngle = Angle;
}

//---------------------------------------------------------------------------------------------------------------------
KLandModelObject* KMapEditorInterface::GetNearLandModelObject( bool bEntity )
{
        // Recherche le plus proche
        float                           NearDistance = 100.0f;
        float                           Distance;
        KStr                            sEntity = KStr( "Entity" );
        KLandModelObject*       pNearModelObject = NULL;

        for( KLandModelObject* pLandModelObject = m_LandModels.GetFirst(); pLandModelObject; pLandModelObject = m_LandModels.GetNext( pLandModelObject ) )
        {
                // Filtre
                if( ( bEntity && ( pLandModelObject->m_sModelName != sEntity ) ) || ( !bEntity && ( pLandModelObject->m_sModelName == sEntity ) ) )
                        continue;

                Distance = KVector::Distance( m_pLandscape->GetBrushVector(), KVector( pLandModelObject->m_WorldMatrix._41, pLandModelObject->m_WorldMatrix._42, pLandModelObject->m_WorldMatrix._43 ) );

                if( Distance < NearDistance )
                {
                        NearDistance            = Distance;
                        pNearModelObject        = pLandModelObject;
                }
        }

        return pNearModelObject;
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::HighLightNearModel( bool bHighLight, bool bEntity )
{
        if( bHighLight )
        {
                KLandModelObject*               pLandModelObject;
                KMDLMESHRENDEREFFECT    Effect;

                // Recherche le plus proche
                KLandModelObject*               pNearLandModelObject = GetNearLandModelObject( bEntity );

                for( pLandModelObject = m_LandModels.GetFirst(); pLandModelObject; pLandModelObject = m_LandModels.GetNext( pLandModelObject ) )
                {
                        if( pNearLandModelObject == pLandModelObject )
                                Effect = KMMRE_NORMALWIREFRAME;
                        else
                                Effect = KMMRE_NORMAL;

                        KModelDraw*     pModel = (KModelDraw*)m_pModelBank->GetpModel( pLandModelObject->m_hModel );
                        for( u32 m = 0; m < pModel->GetnMeshes(); m ++ )
                                pModel->GetpMesh( m )->m_RenderEffect = Effect;
                }

                m_bHighLight = true;
        }
        else
        {
                if( !m_bHighLight )
                        return;

                // Remet les models en mode normal
                KLandModelObject*       pLandModelObject;

                for( pLandModelObject = m_LandModels.GetFirst(); pLandModelObject; pLandModelObject = m_LandModels.GetNext( pLandModelObject ) )
                {
                        KModelDraw*     pModel = (KModelDraw*)m_pModelBank->GetpModel( pLandModelObject->m_hModel );

                        for( u32 m = 0; m < pModel->GetnMeshes(); m ++ )
                                pModel->GetpMesh( m )->m_RenderEffect = KMMRE_NORMAL;
                }

                m_bHighLight = false;
        }
}

//---------------------------------------------------------------------------------------------------------------------
//-- ENTITY
//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::AddEntity( KLandEntity* pEntity )
{
        KASSERT( m_pLandscape );
        m_pLandscape->AddLandEntity( pEntity );
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::RemoveEntity( KLandEntity* pEntity )
{
        KASSERT( m_pLandscape );
        m_pLandscape->RemoveLandEntity( pEntity );
}

//---------------------------------------------------------------------------------------------------------------------
KLandEntity* KMapEditorInterface::GetFirstEntity()
{
        KASSERT( m_pLandscape );
        return m_pLandscape->GetFirstLandEntity();
}

//---------------------------------------------------------------------------------------------------------------------
KLandEntity* KMapEditorInterface::GetNextEntity( KLandEntity* pEntity )
{
        KASSERT( m_pLandscape );
        return m_pLandscape->GetNextLandEntity( pEntity );
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::AddLandEntity( KLandEntity& LandEntity )
{
        KMatrix                 Matrix;
        KLandEntity*    pLandEntity = new KLandEntity();

        *pLandEntity = LandEntity;

        Matrix.LoadIdentity();
        Matrix.RotZ( m_RotAngle );
        Matrix.Trans( m_pLandscape->GetBrushVector().x, m_pLandscape->GetBrushVector().y, m_pLandscape->GetBrushVector().z );

        pLandEntity->SetMatrix( Matrix );       
        AddEntity( pLandEntity );

        KMODEL hModel = m_pModelBank->LoadModel( KStr( "Objects/Entity/Entity" ) );

        // Ajoute le model dans la liste
        KLandModelObject*       pLandModelObject;

        pLandModelObject = new KLandModelObject();
        pLandModelObject->m_hModel              = hModel;
        pLandModelObject->m_WorldMatrix = Matrix;
        pLandModelObject->m_pLandObject = NULL;
        pLandModelObject->m_pLandEntity = pLandEntity;
        pLandModelObject->m_sModelName  = KStr( "Entity" );
        m_LandModels.Add( pLandModelObject );
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::DelLandEntity()
{
        // Recherche le plus proche
        KLandModelObject*       pNearLandModelObject = GetNearLandModelObject( true );

        // Detruit l'entity
        if( pNearLandModelObject )
        {
                // Entity
                RemoveEntity( pNearLandModelObject->m_pLandEntity );
                Deletep( pNearLandModelObject->m_pLandEntity );

                // LandModel
                m_LandModels.Remove( pNearLandModelObject );
                Deletep( pNearLandModelObject );
        }
}

//---------------------------------------------------------------------------------------------------------------------
KLandEntity* KMapEditorInterface::GetSelectedLandEntity()
{
        // Recherche le plus proche
        KLandModelObject*       pNearLandModelObject = GetNearLandModelObject( true );

        if( pNearLandModelObject )
                return pNearLandModelObject->m_pLandEntity;

        return NULL;
}

//---------------------------------------------------------------------------------------------------------------------
void KMapEditorInterface::SetSelectedLandEntity( KLandEntity& LandEntity )
{
}

---