D:/Zythum/DinoKod/Bsp/BspDraw.cpp

//---------------------------------------------------------------------------------------------
//      This file is a part of "DinoKod".
//      Copyright © 2003 Dino Productions. All Rights Reserved.
//      
//      File                    : BspDraw.cpp
//      Author                  : Sebastien LEIX        sebastien.leix@wanadoo.fr
//      Date                    : 07/09/2002
//      Modification    :
//
//---------------------------------------------------------------------------------------------
#include <conio.h>

#include "Common/Assert.h"
#include "Common/Console.h"
#include "Common/Directory.h"
#include "Common/Plane.h"
#include "Common/Math3D.h"

#include "Bitmap/Bmp.h"

#include "Render/Render.h"
#include "Render/Texture.h"
#include "Render/Camera.h"
#include "Render/VertexBuffer.h"
#include "Landscape/SunDraw.h"
#include "Landscape/SkyDraw.h"

#include "Bsp/BezierPatch.h"

#include "Bsp/BspDraw.h"

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
KBspDraw::KBspDraw()
: KBsp()
{
        m_pShaderId                             = NULL;
        m_pLightMapId                   = NULL;

        m_bSwapRgb                              = false;
        m_bUseLightMaps                 = true;
        m_pCamera                               = NULL;
                                                        
        m_pRender                               = NULL;

        m_pVisibleFace                  = NULL;

        m_nVertex                               = 0;
        m_pVBuffer                              = NULL;
        m_bWireFrame                    = false;

        m_pSortedFaceList               = NULL;
        m_pRenderFaces                  = NULL;

        m_pSunDraw                              = NULL;
        m_pSkyDraw                              = NULL;
        m_CurrentLoadedShader   = 0;
}

//--------------------------------------------------------------------------
KBspDraw::~KBspDraw()
{
}

//--------------------------------------------------------------------------
s32 KBspDraw::Init( KRender* pRender )
{
        KASSERT( pRender );

        m_pRender       = pRender;
        m_bSwapRgb      = pRender->IsNeedToSwapRgb();
/*
        // Initialise le soleil
        m_pSunDraw = new KSunDraw();
        m_pSunDraw->Init( m_pRender );

        // Initialise le ciel
        m_pSkyDraw = new KSkyDraw();
        m_pSkyDraw->Init( pRender, 30, m_pSunDraw );
*/
        return BSP_OK;
}

//--------------------------------------------------------------------------
void KBspDraw::End()
{
        m_pRender       = NULL;
        m_pCamera       = NULL;

        if( m_pSkyDraw )
                Deletep( m_pSkyDraw );

        if( m_pSunDraw )
                Deletep( m_pSunDraw );
}

//--------------------------------------------------------------------------
s32 KBspDraw::LoadBSP( const char* pFileName )
{
        s32                     Result;

        Result = KBsp::LoadBSP( pFileName );
        if( Result != BSP_OK )
                return Result;

        m_bLoaded = false;

        m_CurrentLoadedShader   = 0;
        m_pVisibleFace                  = new bool[m_nFaces];
        m_pRenderFaces                  = new KRenderFace[m_nFaces];
        m_pSortedFaceList               = new KBspFaceList[m_nFaces];

        // Chargement des shaders
        Result = LoadShaders( m_pRender );

        if( Result != BSP_OK )
        {
                Close();
                return Result;
        }

        return BSP_OK;
}

//--------------------------------------------------------------------------
s32 KBspDraw::FinishLoad()
{
        // Chargement des lightmaps
        s32     Result = LoadLightMaps( m_pRender );

        if( Result != BSP_OK )
        {
                Close();
                return Result;
        }

        SortFacesByTextures();
        ComputeVertices();

        m_bLoaded = true;

        return BSP_OK;
}

//--------------------------------------------------------------------------
s32 KBspDraw::CloseBSP()
{
        if( m_pVisibleFace )            Deletev( m_pVisibleFace );
        if( m_pSortedFaceList )         Deletev( m_pSortedFaceList );
        
        if( m_pRenderFaces )
        {
                for( u32 f = 0; f < m_nFaces; f ++ )
                {
                        if( m_pRenderFaces[f].m_pVertex )
                                Deletev( m_pRenderFaces[f].m_pVertex );
                        if( m_pRenderFaces[f].m_pIndices )
                                Deletev( m_pRenderFaces[f].m_pIndices );
                }
                Deletev( m_pRenderFaces );
        }
        
        m_CurrentLoadedShader = 0;

        DestroyShaders();
        DestroyLightMaps();

        return KBsp::CloseBSP();
}

//--------------------------------------------------------------------------
void KBspDraw::Draw()
{
        if( !IsLoaded() )
                return;

        KASSERT( m_pRender );

//      m_pSunDraw->Draw( 0.22f );
//      m_pSkyDraw->Draw();
//      m_pSunDraw->DrawLensFlare();

        // Reset la liste des faces a afficher
        memset( m_pVisibleFace, 0, sizeof( bool ) * m_nFaces );

        m_pCamera = m_pRender->GetCamera();
        KASSERT( m_pCamera );

        m_pCamera->GetFrustumPlanes( m_pCameraPlane );
        u32 Leaf                = FindLeaf( 0, m_pCamera->GetPos() );

//      KVector Point, Normal;
//      CheckCollision( 0, KVector( 852, 2252, 184 ), KVector( 1176, -2252, 184 ), &Point, &Normal );
        
        if( Leaf )
        {
//              g_Console << "Leaf : " << (int)Leaf << KENDL;
//              m_pRender->SetRenderState( KRS_FILLMODE, KRFILLMODE_WIREFRAME );
                DrawVisiblesLeaves( Leaf );
                DrawFaces();

//              for( Leaf = 0; Leaf < m_nLeaves; Leaf ++ )
//                      DisplayLeaf( Leaf );
//              m_pRender->SetClear( true );
//              for( Leaf = 0; Leaf < m_nLeaves; Leaf ++ )
//                      DrawLeaf( Leaf );
/*      
                m_pRender->SetRenderState( KRS_FILLMODE, KRFILLMODE_SOLID );
                memset( m_pVisibleFace, 0, sizeof( bool ) * m_nFaces );
                DrawLeaf( Leaf );
                DrawFaces();*/
/*
                DrawVisiblesLeaves( Leaf );

                if( m_bWireFrame )
                        m_pRender->SetRenderState( KRS_FILLMODE, KRFILLMODE_WIREFRAME );
                
                DrawFaces();
*/
//              m_pRender->SetRenderState( KRS_FILLMODE, KRFILLMODE_SOLID );
        }
        else
        {
//              m_pRender->SetRenderState( KRS_FILLMODE, KRFILLMODE_WIREFRAME );
//              for( Leaf = 0; Leaf < m_nLeaves(); Leaf ++ )
//                      DrawLeaf( Leaf );
                if( m_bWireFrame )
                        m_pRender->SetRenderState( KRS_FILLMODE, KRFILLMODE_WIREFRAME );
                
                DrawFaces();
                
                m_pRender->SetRenderState( KRS_FILLMODE, KRFILLMODE_SOLID );
        }

//      // Reset la liste des faces a afficher
//      memset( m_pVisibleFace, 0, sizeof( bool ) * m_nFaces );
}

//--------------------------------------------------------------------------
void KBspDraw::DrawVisiblesLeaves( u32 CurrentLeaf )
{
        u32             l;
        u32             c;
        u32             m;
        
        KASSERT( CurrentLeaf < m_nLeaves );

        m = m_pLeaves[CurrentLeaf].m_FirstVisListId;

        for( l = 0; l < m_nLeaves; l ++ )
        {
                if( m_pVisiList )
                {
                        c = m_pLeaves[l].m_FirstVisListId;

                        if( ( c == -1 ) || ( m == -1 ) || (*(m_pVisiList->m_VisiList + m * m_pVisiList->m_SizeOfVector + ((c)>>3)) & (1 << ((c) & 7))) )
                                DrawLeaf( l );
                }
                else
                        DrawLeaf( l );
        }
}

//--------------------------------------------------------------------------
bool KBspDraw::IsBBoxInsideFrustum( KVector& Min, KVector Max )
{
        for( s32 i = 0; i < 6; i ++ )
        {
                if( m_pCameraPlane[i].m_Normal.x * Min.x + m_pCameraPlane[i].m_Normal.y * Min.y + m_pCameraPlane[i].m_Normal.z * Min.z + m_pCameraPlane[i].m_Distance > 0.0f )  continue;
                if( m_pCameraPlane[i].m_Normal.x * Max.x + m_pCameraPlane[i].m_Normal.y * Min.y + m_pCameraPlane[i].m_Normal.z * Min.z + m_pCameraPlane[i].m_Distance > 0.0f )  continue;
                if( m_pCameraPlane[i].m_Normal.x * Min.x + m_pCameraPlane[i].m_Normal.y * Max.y + m_pCameraPlane[i].m_Normal.z * Min.z + m_pCameraPlane[i].m_Distance > 0.0f )  continue;
                if( m_pCameraPlane[i].m_Normal.x * Max.x + m_pCameraPlane[i].m_Normal.y * Max.y + m_pCameraPlane[i].m_Normal.z * Min.z + m_pCameraPlane[i].m_Distance > 0.0f )  continue;
                if( m_pCameraPlane[i].m_Normal.x * Min.x + m_pCameraPlane[i].m_Normal.y * Min.y + m_pCameraPlane[i].m_Normal.z * Max.z + m_pCameraPlane[i].m_Distance > 0.0f )  continue;
                if( m_pCameraPlane[i].m_Normal.x * Max.x + m_pCameraPlane[i].m_Normal.y * Min.y + m_pCameraPlane[i].m_Normal.z * Max.z + m_pCameraPlane[i].m_Distance > 0.0f )  continue;
                if( m_pCameraPlane[i].m_Normal.x * Min.x + m_pCameraPlane[i].m_Normal.y * Max.y + m_pCameraPlane[i].m_Normal.z * Max.z + m_pCameraPlane[i].m_Distance > 0.0f )  continue;
                if( m_pCameraPlane[i].m_Normal.x * Max.x + m_pCameraPlane[i].m_Normal.y * Max.y + m_pCameraPlane[i].m_Normal.z * Max.z + m_pCameraPlane[i].m_Distance > 0.0f )  continue;
/*
                if(m_Frustum[i][A] * x  + m_Frustum[i][B] * y  + m_Frustum[i][C] * z  + m_Frustum[i][D] > 0)  continue;
                if(m_Frustum[i][A] * x2 + m_Frustum[i][B] * y  + m_Frustum[i][C] * z  + m_Frustum[i][D] > 0)  continue;
                if(m_Frustum[i][A] * x  + m_Frustum[i][B] * y2 + m_Frustum[i][C] * z  + m_Frustum[i][D] > 0)  continue;
                if(m_Frustum[i][A] * x2 + m_Frustum[i][B] * y2 + m_Frustum[i][C] * z  + m_Frustum[i][D] > 0)  continue;
                if(m_Frustum[i][A] * x  + m_Frustum[i][B] * y  + m_Frustum[i][C] * z2 + m_Frustum[i][D] > 0)  continue;
                if(m_Frustum[i][A] * x2 + m_Frustum[i][B] * y  + m_Frustum[i][C] * z2 + m_Frustum[i][D] > 0)  continue;
                if(m_Frustum[i][A] * x  + m_Frustum[i][B] * y2 + m_Frustum[i][C] * z2 + m_Frustum[i][D] > 0)  continue;
                if(m_Frustum[i][A] * x2 + m_Frustum[i][B] * y2 + m_Frustum[i][C] * z2 + m_Frustum[i][D] > 0)  continue;
*/
                return false;
        }

        return true;
}

//--------------------------------------------------------------------------
void KBspDraw::DrawLeaf( u32 Leaf )
{
        KASSERT( IsLoaded() );
        KASSERT( m_pRender );
        KASSERT( m_pCamera );
        KASSERT( Leaf < m_nLeaves );

        if( IsBBoxInsideFrustum(        KVector( m_pLeaves[Leaf].m_BBMin[0], m_pLeaves[Leaf].m_BBMin[1], m_pLeaves[Leaf].m_BBMin[2] ),
                                                                KVector( m_pLeaves[Leaf].m_BBMax[0], m_pLeaves[Leaf].m_BBMax[1], m_pLeaves[Leaf].m_BBMax[2] ) ) )
        {
                //
                //      DISPLAY DU LEAF
                //
                s32             FaceId;
                for(    FaceId = m_pLeaves[Leaf].m_FirstFaceId;
                                FaceId < m_pLeaves[Leaf].m_FirstFaceId + m_pLeaves[Leaf].m_NumFaces;
                                FaceId ++ )
                {
                        m_pVisibleFace[ m_pFaceList[FaceId].m_Face ] = true;
                }
        }
        return;
}

//--------------------------------------------------------------------------
void KBspDraw::DrawFaces()
{
        KRenderFace             RenderFace;
        u32                             Face;
        u32                             FaceId;
        u32                             TexId1 = -1;
        u32                             TexId2 = -1;
        KTEXTURE                LightMapId;

        KASSERT( m_pRenderFaces );
        KASSERT( m_pFaces );
        KASSERT( m_pSortedFaceList );
        KASSERT( m_pVisibleFace );

        m_CurrentShaderId       = KSHADER_NO;
        m_CurrentLightMapId     = KTEXTURE_NO;

        u32             FirstFace       = 0;//GetpModels( 0 )->m_FirstFaceId;
        u32             nFaces          = m_nFaces;//GetpModels( 0 )->m_NumFaces;

        for( Face = FirstFace; Face < FirstFace + nFaces; Face ++ )
        {
                FaceId = m_pSortedFaceList[Face].m_Face;

//              if( ( FaceId < GetpModels( 0 )->m_FirstFaceId ) && ( FaceId > ( GetpModels( 0 )->m_FirstFaceId + GetpModels( 0 )->m_NumFaces ) ) )
//                      continue;

                if( !m_pVisibleFace[FaceId] )
                        continue;

//              if( m_pFaces[FaceId].m_EffectId != -1 )
//                      continue;

                if( ( TexId1 != m_pFaces[FaceId].m_ShaderId ) || ( TexId2 != m_pFaces[FaceId].m_LightMapId ) )
                {
                        // Flush et Dessine les triangles
                        m_pRender->FlushTriangles();
                        // Change de shader
                        TexId1 = m_pFaces[FaceId].m_ShaderId;
                        TexId2 = m_pFaces[FaceId].m_LightMapId;

                        if( m_bUseLightMaps && m_pLightMapId )
                                LightMapId = (TexId2 == -1) ? KTEXTURE_NO : m_pLightMapId[TexId2];
                        else
                                LightMapId = KTEXTURE_NO;
                        
                        m_CurrentShaderId       = (TexId1 == -1) ? KTEXTURE_NO : m_pShaderId[TexId1];
                        m_CurrentLightMapId     = LightMapId;
                        m_pRender->SetShader( m_CurrentShaderId, m_CurrentLightMapId, (s32)m_pFaces[FaceId].m_Type == KBFT_MESH );
                }

                if( ( m_pFaces[FaceId].m_Type == KBFT_POLYGON ) || ( m_pFaces[FaceId].m_Type == KBFT_MESH ) )
                {
                        m_pRender->DrawTriangles( m_pRenderFaces[FaceId] );
                }
                else if( m_pFaces[FaceId].m_Type == KBFT_PATCH )
                {
                        RenderFace.m_VertexType = m_pBezierPatches[FaceId].GetVertexType();
                        RenderFace.m_pVertex    = m_pBezierPatches[FaceId].GetpVertices();
                        RenderFace.m_nVertex    = m_pBezierPatches[FaceId].GetnVertices();
                        RenderFace.m_pIndices   = m_pBezierPatches[FaceId].GetpIndices();
                        RenderFace.m_nIndices   = m_pBezierPatches[FaceId].GetnIndices();
                        m_pRender->DrawTriangles( RenderFace );
                }
        }
        m_pRender->FlushTriangles();
}

//--------------------------------------------------------------------------
void KBspDraw::DisplayLeaf( u32 LeafId )
{
        s32                             FaceId;
        u32                             Face;
        KRenderFace             RenderFace;
        u32                             TexId1;
        u32                             TexId2;
        KTEXTURE                ShaderId;
        KTEXTURE                LightMapId;

        for(    FaceId = m_pLeaves[LeafId].m_FirstFaceId;
                        FaceId < m_pLeaves[LeafId].m_FirstFaceId + m_pLeaves[LeafId].m_NumFaces;
                        FaceId ++ )
        {
                Face = m_pFaceList[FaceId].m_Face;
        
                TexId1 = m_pFaces[Face].m_ShaderId;
                TexId2 = m_pFaces[Face].m_LightMapId;

                LightMapId      = (TexId2 == -1) ? KTEXTURE_NO : m_pLightMapId[TexId2];
                ShaderId        = (TexId1 == -1) ? KTEXTURE_NO : m_pShaderId[TexId1];

                m_pRender->SetShader( ShaderId, LightMapId, (s32)m_pFaces[Face].m_Type == KBFT_MESH );
                
                if( ( m_pFaces[Face].m_Type == KBFT_POLYGON ) || ( m_pFaces[Face].m_Type == KBFT_MESH ) )
                {
                        m_pRender->DrawTriangles( m_pRenderFaces[Face] );
                }
                else if( m_pFaces[Face].m_Type == KBFT_PATCH )
                {
                        RenderFace.m_VertexType = m_pBezierPatches[Face].GetVertexType();
                        RenderFace.m_pVertex    = m_pBezierPatches[Face].GetpVertices();
                        RenderFace.m_nVertex    = m_pBezierPatches[Face].GetnVertices();
                        RenderFace.m_pIndices   = m_pBezierPatches[Face].GetpIndices();
                        RenderFace.m_nIndices   = m_pBezierPatches[Face].GetnIndices();
                        m_pRender->DrawTriangles( RenderFace );
                }
                m_pRender->FlushTriangles();
        }
}

//--------------------------------------------------------------------------
void KBspDraw::ActiveLightMaps( bool bActive )
{
        m_bUseLightMaps = bActive;

        ComputeVertices();
        ComputeBezier();
}

//---------------------------------------------------------------------------------------------------------------------
int KBspDraw::CumpareFunc( const void* pElem1, const void* pElem2 )
{
        s64             Result = ((KBspComputedFace*)pElem1)->m_SortId - ((KBspComputedFace*)pElem2)->m_SortId;

        if( Result > 0 )
                return 1;
        if( Result < 0 )
                return -1;

        return 0;
}

//---------------------------------------------------------------------------------------------------------------------
void KBspDraw::SortFacesByTextures()
{
        u32     Face;
        
        KBspComputedFace*       pComputedFaces  = new KBspComputedFace[m_nFaces];
        KShader*                        pShader;
        u64                                     ShaderSortValue;
        KSHADER                         ShaderId;

        for( Face = 0; Face < m_nFaces; Face ++ )
        {
                if( ( m_pFaces[Face].m_ShaderId >= 65535 ) || ( m_pFaces[Face].m_LightMapId >= 65535 ) )
                {
                        KError::FatalError( NULL, "KBspDraw::SortFacesByTextures(...) : ( m_pFaces[Face].m_TextureId >= 65535 ) || ( m_pFaces[Face].m_LightMapId >= 65535 )" );
                        return;
                }

                ShaderId = m_pShaderId[m_pFaces[Face].m_ShaderId];

                if( ( ShaderId != KSHADER_NO ) && ( pShader = m_pRender->GetpShaderBank()->GetpShader( ShaderId ) ) )
                        ShaderSortValue = pShader->m_SortValue;
                else
                        ShaderSortValue = 0;

                pComputedFaces[Face].m_ShaderId                 = m_pFaces[Face].m_ShaderId;
                pComputedFaces[Face].m_EffectId                 = m_pFaces[Face].m_EffectId;
                pComputedFaces[Face].m_Type                             = m_pFaces[Face].m_Type;
                pComputedFaces[Face].m_FirstVertexId    = m_pFaces[Face].m_FirstVertexId;
                pComputedFaces[Face].m_NumVertices              = m_pFaces[Face].m_NumVertices;
                pComputedFaces[Face].m_FirstMeshVert    = m_pFaces[Face].m_FirstMeshVert;
                pComputedFaces[Face].m_NumMeshVerts             = m_pFaces[Face].m_NumMeshVerts;
                pComputedFaces[Face].m_LightMapId               = m_pFaces[Face].m_LightMapId;
                pComputedFaces[Face].m_LightMapStart    = m_pFaces[Face].m_LightMapStart;
                pComputedFaces[Face].m_LightMapSize             = m_pFaces[Face].m_LightMapSize;
                pComputedFaces[Face].m_LightMapOrigin   = m_pFaces[Face].m_LightMapOrigin;
                pComputedFaces[Face].m_LightMapVecs[0]  = m_pFaces[Face].m_LightMapVecs[0];
                pComputedFaces[Face].m_LightMapVecs[1]  = m_pFaces[Face].m_LightMapVecs[1];
                pComputedFaces[Face].m_Normal                   = m_pFaces[Face].m_Normal;
                pComputedFaces[Face].m_Size                             = m_pFaces[Face].m_Size;
                pComputedFaces[Face].m_FaceId                   = Face;
                pComputedFaces[Face].m_SortId                   = (s64)( ( (ShaderSortValue+1) << 32 ) | ( (pComputedFaces[Face].m_LightMapId+1) << 16 ) | (pComputedFaces[Face].m_ShaderId+1) );
        }

        qsort( pComputedFaces, m_nFaces, sizeof( KBspComputedFace ), CumpareFunc );
        
        for( Face = 0; Face < m_nFaces; Face ++ )
        {
                // Creation de la liste de correspondance
                m_pSortedFaceList[Face].m_Face = pComputedFaces[Face].m_FaceId;

                // Creation de la liste de faces
                s32             MeshVertexId;
                u32             VertexId;

                if( m_pFaces[Face].m_NumMeshVerts )
                {
                        KLVertex2*              pTmpVertex = NULL;
                        KLVertex2               Vertex;
                        u16                             nVertex = 0;
                        u16                             nIndex  = 0;

                        pTmpVertex = new KLVertex2[m_pFaces[Face].m_NumMeshVerts];
                        m_pRenderFaces[Face].m_VertexType       = KRLVERTEX2;
                        m_pRenderFaces[Face].m_pIndices         = new u16[m_pFaces[Face].m_NumMeshVerts];
                        m_pRenderFaces[Face].m_nIndices         = (u16)m_pFaces[Face].m_NumMeshVerts;

                        // Construit la face avec les vertex et les indices
                        for(    MeshVertexId = m_pFaces[Face].m_FirstMeshVert;
                                        MeshVertexId < m_pFaces[Face].m_FirstMeshVert + m_pFaces[Face].m_NumMeshVerts;
                                        MeshVertexId ++ )
                        {
                                KASSERT( nVertex < m_pFaces[Face].m_NumMeshVerts );
                                KASSERT( nVertex < 65535 );
                                
                                // Construit le vertex
                                VertexId = m_pFaces[Face].m_FirstVertexId + m_pMeshVerts[MeshVertexId].m_FirstVertexId;
                                Vertex.Position = m_pVertices[VertexId].m_Position;
                                Vertex.Color    = KRGBA2INT( m_pVertices[VertexId].m_Color );
                                Vertex.tu1              = m_pVertices[VertexId].m_UV[0].x;
                                Vertex.tv1              = m_pVertices[VertexId].m_UV[0].y;
                                Vertex.tu2              = m_pVertices[VertexId].m_UV[1].x;
                                Vertex.tv2              = m_pVertices[VertexId].m_UV[1].y;

                                // Verifie si le vertex est deja dans la liste
                                // Dans ce cas on ne le duplique pas
                                KINDEX  Index = -1;
                                for( u32 i = 0; i < nVertex; i ++ )
                                {
                                        if( pTmpVertex[i] == Vertex )
                                        {
                                                Index = (KINDEX)i;
                                                break;
                                        }
                                }

                                if( Index != (KINDEX)-1 )
                                {
                                        // Index deja dans la liste
                                        m_pRenderFaces[Face].m_pIndices[nIndex] = Index;
                                        nIndex  ++;
                                }
                                else
                                {
                                        pTmpVertex[nVertex]     = Vertex;
                                        m_pRenderFaces[Face].m_pIndices[nIndex] = nVertex;
                                        nVertex ++;
                                        nIndex  ++;
                                }
                        }

                        KASSERT( nVertex );

                        m_pRenderFaces[Face].m_pVertex  = new KLVertex2[nVertex];
                        memcpy( m_pRenderFaces[Face].m_pVertex, pTmpVertex, sizeof( KLVertex2 ) * nVertex );
                        m_pRenderFaces[Face].m_nVertex  = nVertex;

                        Deletep( pTmpVertex );
                }
        }

        Deletev( pComputedFaces );
}

//--------------------------------------------------------------------------
s32 KBspDraw::LoadShaders( KRender* pRender )
{
        KASSERT( !m_pShaderId );
        
        if( !m_nShaders )
                return BSP_OK;
        
        m_pShaderId = new KSHADER[m_nShaders];
        for( u32 s = 0; s < m_nShaders; s ++ )
                m_pShaderId[s] = KSHADER_NO;

/*
        for( u32 s = 0; s < (u32)GetnShaders(); s ++ )
        {
                char*   pShaderName = GetpShaders( s )->m_pName;
                
                // Enleve le repertoire textures/ rajouté par q3radiant
                char*   pTextureDir = "textures/";
                if( strnicmp( pShaderName, pTextureDir, strlen( pTextureDir ) ) == 0 )
                        pShaderName += strlen( pTextureDir );

                m_pShaderId[s] = pRender->GetpShaderBank()->LoadShader( pShaderName );
                
                if( m_pShaderId[s] == KSHADER_NO )
                        g_Console << "Could not load Shader : " << GetpShaders( s )->m_pName << KENDL;
        }
*/
        return BSP_OK;
}

//--------------------------------------------------------------------------
s32 KBspDraw::LoadShader( KRender* pRender )
{
        if( m_CurrentLoadedShader < GetnShaders() )
        {
                char*   pShaderName = GetpShaders( m_CurrentLoadedShader )->m_pName;
                
                // Enleve le repertoire textures/ rajouté par q3radiant
                char*   pTextureDir = "textures/";
                if( strnicmp( pShaderName, pTextureDir, strlen( pTextureDir ) ) == 0 )
                        pShaderName += strlen( pTextureDir );

                m_pShaderId[m_CurrentLoadedShader] = pRender->GetpShaderBank()->LoadShader( pShaderName );
                
                if( m_pShaderId[m_CurrentLoadedShader] == KSHADER_NO )
                        g_Console << "Could not load Shader : " << GetpShaders( m_CurrentLoadedShader )->m_pName << KENDL;

                m_CurrentLoadedShader ++;
        }

        return m_CurrentLoadedShader;
}

//--------------------------------------------------------------------------
s32 KBspDraw::LoadLightMaps( KRender* pRender )
{
        KASSERT( !m_pLightMapId );

        float   OverBright = 5.0f;
        float   BaseBright = 0.0f;
        
        if( !m_nLightMaps )
                return BSP_OK;
        
        m_pLightMapId = new KTEXTURE[m_nLightMaps];

        u32             LightMap;

        g_Console << KENDL;
        
        for( LightMap = 0; LightMap < m_nLightMaps; LightMap ++ )
        {
                KTEXTURE        TexId;
                
                TexId = pRender->GetpTextureBank()->CreateTexture( 128, 128 );
                if( TexId == KTEXTURE_NO )
                {
                        KError::Error( pRender->GetWindow(), "KBspLoader::LoadLightMaps(...) : Cannot create lightmap" );
                        TexId = pRender->GetpTextureBank()->GetErrorTextureId();
                }

                KTexture*       pTexture = pRender->GetpTextureBank()->GetpTexture( TexId );
                u32                     x, y;
                KRgba           Pixel;
                char            pFileName[256];

                sprintf( pFileName, "$lightmap%i", LightMap );
                pTexture->SetpFileName( pFileName );

                pTexture->Lock();
                for( y = 0; y < 128; y ++ )
                {
                        for( x = 0; x < 128; x ++ )
                        {
                                float Scale = 1.0f;
                                float TmpScale;

                                float r = (float) m_pLightMaps[LightMap].m_Color[y][x].r;
                                float g = (float) m_pLightMaps[LightMap].m_Color[y][x].g;
                                float b = (float) m_pLightMaps[LightMap].m_Color[y][x].b;
                                
                                r = r * OverBright / 255.0f;
                                g = g * OverBright / 255.0f;
                                b = b * OverBright / 255.0f;
                                
                                if( r > 1.0f && ( TmpScale = ( 1.0f / r ) ) < Scale) Scale = TmpScale;
                                if( g > 1.0f && ( TmpScale = ( 1.0f / g ) ) < Scale) Scale = TmpScale;
                                if( b > 1.0f && ( TmpScale = ( 1.0f / b ) ) < Scale) Scale = TmpScale;

                                Scale *= 255.0f;
                                r *= Scale;
                                g *= Scale;
                                b *= Scale;

                                Pixel.b = (u8)b;
                                Pixel.g = (u8)g;
                                Pixel.r = (u8)r;
                                Pixel.a = 255;

                                pTexture->SetPixel( x, y, Pixel.GetColor() );
/*
                                pPixel  = &pBits[ ((y * 128) + x) * (Depth / 8)];
                                
                                if( Depth == 16 )
                                        *((u16*)pPixel) = (u16)( ((Pixel.a / 16 ) << 12) | ((Pixel.b / 16) << 8) | ((Pixel.g / 16) << 4) | (Pixel.r / 16) );
                                if( Depth == 32 )
                                {
                                        pPixel[0] = Pixel.r;
                                        pPixel[1] = Pixel.g;
                                        pPixel[2] = Pixel.b;
                                        pPixel[3] = Pixel.a;
                                }*/
                        }
                }
                pTexture->Unlock();

                m_pLightMapId[LightMap] = TexId;        
        }

        return BSP_OK;
}

//--------------------------------------------------------------------------
void KBspDraw::DestroyShaders()
{
        for( u32 s = 0; s < (u32)GetnShaders(); s ++ )
        {
                m_pRender->GetpShaderBank()->UnloadShader( m_pShaderId[s] );
        }
        
        if( m_pShaderId )
                Deletev( m_pShaderId );
}

//--------------------------------------------------------------------------
void KBspDraw::DestroyLightMaps()
{
        if( m_pLightMapId )
        {
                for( u32 i = 0; i < m_nLightMaps; i ++ )
                {
                        m_pRender->GetpTextureBank()->UnloadTexture( m_pLightMapId[i] );
                }
        }

        if( m_pLightMapId )
                Deletev( m_pLightMapId );
}

---