D:/Zythum/DinoKod/Landscape/SkyDraw.cpp

//---------------------------------------------------------------------------------------------
//      This file is a part of "DinoKod".
//      Copyright © 2003 Dino Productions. All Rights Reserved.
//      
//      File                    : SkyDraw.cpp
//      Author                  : Sebastien LEIX        sebastien.leix@wanadoo.fr
//      Date                    : 31/01/2003
//      Modification    :
//
//---------------------------------------------------------------------------------------------
#include "Render/Render.h"
#include "Render/Camera.h"
#include "Landscape/SunDraw.h"
#include "Landscape/SkyDraw.h"

//---------------------------------------------------------------------------------------------
KSkyDraw::KSkyDraw()
{
        m_pRender               = NULL;
        m_pSunDraw              = NULL;

        m_pVertex               = NULL;
        m_nVertex               = 0;
        m_pIndex                = NULL;
        m_nIndex                = 0;
}

//---------------------------------------------------------------------------------------------
KSkyDraw::~KSkyDraw()
{
        if( m_pVertex )
                Deletev( m_pVertex );
                
        if( m_pIndex )
                Deletev( m_pIndex );
}

//---------------------------------------------------------------------------------------------
bool KSkyDraw::Init( KRender* pRender, u32 nSegments, KSunDraw* pSunDraw )
{
        KASSERT( !m_pRender );

        m_pRender       = pRender;
        m_nSegments = nSegments;
        m_pSunDraw      = pSunDraw;

        u32     x, y;
        u32 nSegmentX = nSegments + 1;
        u32 nSegmentY = nSegments + 1;

        //
        //      Vertex
        //
        m_nVertex       = (m_nSegments + 1) * (m_nSegments + 1);
        m_pVertex       = new KLVertex[ m_nVertex ];

        u32             v = 0;
        float   AngleX;
        float   AngleY;
        float   BaseRadiusX = pRender->GetCamera()->GetFarPlane() * 0.95f;
        float   BaseRadiusY = BaseRadiusX / 2.0f;
        float   RadiusX;

        // Hemisphere
        for( y = 0; y < nSegmentY - 1; y ++ )
        {
                AngleY = ((PI / 2) / (float)(m_nSegments)) * (float)y;

                RadiusX = BaseRadiusX * cosf( AngleY );

                for( x = 0; x < nSegmentX; x ++ )
                {
                        AngleX = ((2 * PI) / (float)m_nSegments) * (float)x;
                        
                        m_pVertex[v].Position   = KVector( RadiusX * cosf( AngleX ), RadiusX * sinf( AngleX ), BaseRadiusY * sinf( AngleY ) );
                        m_pVertex[v].Color              = KRGB( 255, 255, 255 );//KRGB( 10, 255, 25 );
                        m_pVertex[v].Specular   = KRGB( 0, 0, 0 );
                        m_pVertex[v].tu                 = (1.0f / (float)(nSegmentX - 1)) * (float)x;
                        m_pVertex[v].tv                 = 1.0f - (1.0f / (float)(nSegmentY - 1)) * (float)y;
                        v ++;
                }
        }

        // Couvercle
        for( x = 0; x < nSegmentX; x ++ )
        {
                m_pVertex[v].Position   = KVector( 0.0f, 0.0f, BaseRadiusY );
                m_pVertex[v].Color              = KRGB( 255, 255, 255 );//KRGB( 10, 255, 25 );
                m_pVertex[v].Specular   = KRGB( 0, 0, 0 );
                m_pVertex[v].tu                 = (1.0f / (float)(nSegmentX - 1)) * (float)(x + 0.5f);
                m_pVertex[v].tv                 = 0.0f;
                v ++;
        }

        KASSERT( v == m_nVertex );

        //
        //      Index
        //
        u32     i = 0;

        m_nIndex        = m_nSegments * (m_nSegments - 1) * 6 + m_nSegments * 3;
        m_pIndex        = new KINDEX[ m_nIndex ];

        // Hemisphere
        for( y = 0; y < m_nSegments - 1; y ++ )
        {
                for( x = 0; x < m_nSegments; x ++ )
                {
                        // Triangles 1
                        m_pIndex[i + 0] = (KINDEX)((y * nSegmentX) + x );
                        m_pIndex[i + 1] = (KINDEX)((y * nSegmentX) + x + 1);
                        m_pIndex[i + 2] = (KINDEX)(((y + 1) * nSegmentX) + x);

                        // Triangles 2
                        m_pIndex[i + 3] = (KINDEX)((y * nSegmentX) + x + 1);
                        m_pIndex[i + 4] = (KINDEX)(((y + 1) * nSegmentX) + x + 1);
                        m_pIndex[i + 5] = (KINDEX)(((y + 1) * nSegmentX) + x);

                        i += 6;
                }
        }

        // Couvercle du trou en haut
        for( x = 0; x < m_nSegments; x ++ )
        {
                // Triangles 1
                m_pIndex[i + 0] = (KINDEX)(((m_nSegments - 1)* nSegmentX) + x );
                m_pIndex[i + 1] = (KINDEX)(((m_nSegments - 1 )* nSegmentX) + x + 1);
                m_pIndex[i + 2] = (KINDEX)(((m_nSegments) * nSegmentX) + x);

                i += 3;
        }

        KASSERT( i == m_nIndex );

        //
        //      Shader
        //
        m_hShader = m_pRender->GetpShaderBank()->LoadShader( "Sky/Sky" );

        return true;
}

//---------------------------------------------------------------------------------------------
void KSkyDraw::Draw()
{
        KVector                 CamPos = m_pRender->GetCamera()->GetPos();
        KMatrix                 Matrix;
        KMatrix                 CurrentMatrix;
        KRenderFace             RenderFace;

        // Sauvegarde la matrice courante
        CurrentMatrix = m_pRender->GetWorldMatrix();
        
        // Eclaire le ciel
        if( m_pSunDraw )
        {
                KRgb    Diffuse;
                KRgb    Specular;

                Diffuse.r       = (u8)MIN( 255.0f, m_pSunDraw->GetAmbient().r * 4.0f * 255.0f );
                Diffuse.g       = (u8)MIN( 255.0f, m_pSunDraw->GetAmbient().g * 4.0f * 255.0f );
                Diffuse.b       = (u8)MIN( 255.0f, m_pSunDraw->GetAmbient().b * 4.0f * 255.0f );
                Specular.r      = (u8)MIN( 100.0f, m_pSunDraw->GetSpecular().r * 300.0f );
                Specular.g      = (u8)MIN( 100.0f, m_pSunDraw->GetSpecular().g * 300.0f );
                Specular.b      = (u8)MIN( 100.0f, m_pSunDraw->GetSpecular().b * 300.0f );

                for( u32 v = 0; v < m_nVertex; v ++ )
                {
                        m_pVertex[v].Color              = Diffuse.GetColor();
                        m_pVertex[v].Specular   = Specular.GetColor();
                }
        }

        float h = CamPos.z + m_pRender->GetCamera()->GetFarPlane() / 2.0f;
        float s = h / (m_pRender->GetCamera()->GetFarPlane() / 2.0f);

        Matrix.LoadIdentity();
        Matrix.Trans( CamPos.x, CamPos.y, 0.0f/*CamPos.z*/ );
        Matrix.Scale( 1.0f, 1.0f, s );
        m_pRender->SetWorldMatrix( Matrix );

//      m_pRender->SetWireFrame( true );

        m_pRender->SetShader( m_hShader );
        RenderFace.m_VertexType = KRLVERTEX;
        RenderFace.m_nVertex    = (u16)m_nVertex;
        RenderFace.m_pVertex    = m_pVertex;
        RenderFace.m_nIndices   = (u16)m_nIndex;
        RenderFace.m_pIndices   = m_pIndex;
        m_pRender->DrawTriangles( RenderFace );
        m_pRender->FlushTriangles();

//      m_pRender->SetWireFrame( false );

        // Restore la matrice courante
        m_pRender->SetWorldMatrix( CurrentMatrix );
}

---