/*************************************************************************************
 [Include File]

 PURPOSE: 
    Define for material, light, texture mapped.
*************************************************************************************/

#ifndef TEXTURE_CONE_H
#define TEXTURE_CONE_H

////////////////////////////////////////// TYPES AND MACROS //////////////////////////////////////////

#define TIGER   0
#define CHESS   1
#define WALL    2

// define for cone
struct CONE_CUSTOM_VERTEX
{
    float x, y, z;
    float nx, ny, nz;
    float u, v;
};

#define CONE_CUSTOM_VERTEX_FVF  (D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1)

// define for square
struct SQUARE_CUSTOM_VERTEX
{
    float x, y, z, rhw;
    float u, v;
};

#define SQUARE_CUSTOM_VERTEX_FVF    (D3DFVF_XYZRHW | D3DFVF_TEX1)

////////////////////////////////////////// CLASS //////////////////////////////////////////

class TEXTURE_CONE
{
    IDirect3D9* _d3d;
    IDirect3DDevice9* _d3d_device;

    IDirect3DVertexBuffer9* _cone_vertex_buffer;
    IDirect3DVertexBuffer9* _square_vertex_buffer;

    IDirect3DTexture9* _tiger_texture;
    IDirect3DTexture9* _chess_texture;
    IDirect3DTexture9* _wall_texture;

public:
    TEXTURE_CONE();
    ~TEXTURE_CONE();

    bool Create_D3D_Device(HWND hwnd, bool full_screen = true);
    bool Init_Cone_Vertex_Buffer();
    bool Init_Square_Vertex_Buffer();
    void Set_Camera();
    void Set_Point_Light(D3DCOLORVALUE& dif, D3DCOLORVALUE& amb, D3DCOLORVALUE& spe, D3DVECTOR& pos);
    void Set_Object_Material(D3DCOLORVALUE& dif, D3DCOLORVALUE& amb, D3DCOLORVALUE& spe, 
                             D3DCOLORVALUE& emi, float power);
    void Compute_Triangle_Normal(D3DXVECTOR3& v1, D3DXVECTOR3& v2, D3DXVECTOR3& v3, D3DVECTOR& normal);
    bool Create_All_Texture();
    void Set_Texture(int choice);
    void Render();
    void Release_COM_Object();
};

#endif

/*************************************************************************************
 [Implement File]

 PURPOSE: 
    Define for material, light, texture mapped.
*************************************************************************************/

#include "GE_COMMON.h"
#include "TextureCone.h"

//------------------------------------------------------------------------------------
// Constructor, initialize all pointer with NULL.
//------------------------------------------------------------------------------------
TEXTURE_CONE::TEXTURE_CONE()
{
    _d3d = NULL;
    _d3d_device = NULL;

    _cone_vertex_buffer   = NULL;
    _square_vertex_buffer = NULL;

    _tiger_texture = NULL;
    _chess_texture = NULL;
    _wall_texture  = NULL;
}

//------------------------------------------------------------------------------------
// Destructor, release resource allocated for COM object.
//------------------------------------------------------------------------------------
TEXTURE_CONE::~TEXTURE_CONE()
{
    Release_COM_Object();
}

//------------------------------------------------------------------------------------
// Create direct3D interface and direct3D device.
//------------------------------------------------------------------------------------
bool TEXTURE_CONE::Create_D3D_Device(HWND hwnd, bool full_screen)
{
    // Create a IDirect3D9 object and returns an interace to it.
    _d3d = Direct3DCreate9(D3D_SDK_VERSION);
    if(_d3d == NULL)
        return false;

    // retrieve adapter capability
    D3DCAPS9 d3d_caps;    
    _d3d->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &d3d_caps);
    
    bool hardware_process_enable = (d3d_caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT ? true : false);

    // Retrieves the current display mode of the adapter.
    D3DDISPLAYMODE display_mode;
    if(FAILED(_d3d->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &display_mode)))
        return false;

    // set present parameter for direct3D device
    D3DPRESENT_PARAMETERS present_param = {0};

    present_param.BackBufferWidth      = WINDOW_WIDTH;
    present_param.BackBufferHeight     = WINDOW_HEIGHT;
    present_param.BackBufferFormat     = display_mode.Format;
    present_param.BackBufferCount      = 1;
    present_param.hDeviceWindow        = hwnd;
    present_param.Windowed             = !full_screen;
    present_param.SwapEffect           = D3DSWAPEFFECT_FLIP;
    present_param.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;

    // Creates a device to represent the display adapter.
    DWORD behavior_flags;

    behavior_flags = hardware_process_enable ? 
D3DCREATE_HARDWARE_VERTEXPROCESSING : D3DCREATE_SOFTWARE_VERTEXPROCESSING;

    if(FAILED(_d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd, behavior_flags, 
                                 &present_param, &_d3d_device)))
    {
        return false;
    }
    
    // create successfully
    return true;
}

//------------------------------------------------------------------------------------
// Initialize vertex buffer for cone.
//------------------------------------------------------------------------------------
bool TEXTURE_CONE::Init_Cone_Vertex_Buffer()
{
    CONE_CUSTOM_VERTEX cone_custom_vertex[12];
    
    D3DXVECTOR3 v[] = 
    {
        D3DXVECTOR3(5.0f, 6.0f, 5.0f),    // left triangle
        D3DXVECTOR3(6.0f, 0.0f, 3.0f),
        D3DXVECTOR3(1.0f, 0.0f, 7.0f),  
        D3DXVECTOR3(5.0f, 6.0f, 5.0f),    // right triangle
        D3DXVECTOR3(10.0f, 0.0f, 8.0f),
        D3DXVECTOR3(6.0f, 0.0f, 3.0f), 
        D3DXVECTOR3(5.0f, 6.0f, 5.0f),    // back triangle
        D3DXVECTOR3(1.0f, 0.0f, 7.0f),
        D3DXVECTOR3(10.0f, 0.0f, 8.0f),
        D3DXVECTOR3(1.0f, 0.0f, 7.0f),    // bottom triangle
        D3DXVECTOR3(6.0f, 0.0f, 3.0f),
        D3DXVECTOR3(10.0f, 0.0f, 8.0f)      
    };

    D3DVECTOR normal;

    // compute all triangle normal
    for(int i = 0; i < 12; i += 3)
    {
        // compute current triangle's normal
        Compute_Triangle_Normal(v[i], v[i+1], v[i+2], normal);

        // assign current vertex coordinate and current triangle normal to custom vertex array
        for(int j = 0; j < 3; j++)
        {
            int k = i + j;

            cone_custom_vertex[k].x  = v[k].x;
            cone_custom_vertex[k].y  = v[k].y;
            cone_custom_vertex[k].z  = v[k].z;
            cone_custom_vertex[k].nx = normal.x;
            cone_custom_vertex[k].ny = normal.y;
            cone_custom_vertex[k].nz = normal.z;
        }
    }

    cone_custom_vertex[0].u  = 0.0f;
    cone_custom_vertex[0].v  = 0.0f;
    cone_custom_vertex[1].u  = 0.0f;
    cone_custom_vertex[1].v  = 1.0f;
    cone_custom_vertex[2].u  = 1.0f;
    cone_custom_vertex[2].v  = 1.0f;

    cone_custom_vertex[3].u  = 0.0f;
    cone_custom_vertex[3].v  = 0.0f;
    cone_custom_vertex[4].u  = 1.0f;
    cone_custom_vertex[4].v  = 0.0f;
    cone_custom_vertex[5].u  = 1.0f;
    cone_custom_vertex[5].v  = 1.0f;

    cone_custom_vertex[6].u  = 0.0f;
    cone_custom_vertex[6].v  = 0.0f;
    cone_custom_vertex[7].u  = 1.0f;
    cone_custom_vertex[7].v  = 0.0f;
    cone_custom_vertex[8].u  = 1.0f;
    cone_custom_vertex[8].v  = 1.0f;

    cone_custom_vertex[9].u  = 0.0f;
    cone_custom_vertex[9].v  = 0.0f;
    cone_custom_vertex[10].u = 1.0f;
    cone_custom_vertex[10].v = 0.0f;
    cone_custom_vertex[11].u = 1.0f;
    cone_custom_vertex[11].v = 1.0f;

    BYTE* vertex_data;

    // create vertex buffer
    if(FAILED(_d3d_device->CreateVertexBuffer(12 * sizeof(CONE_CUSTOM_VERTEX), 0, CONE_CUSTOM_VERTEX_FVF,
                            D3DPOOL_DEFAULT, &_cone_vertex_buffer, NULL)))
    {
        return false;
    }

    // get data pointer to vertex buffer
    if(FAILED(_cone_vertex_buffer->Lock(0, 0, (void **) &vertex_data, 0)))
        return false;

    // copy custom vertex data into vertex buffer
    memcpy(vertex_data, cone_custom_vertex, sizeof(cone_custom_vertex));

    // unlock vertex buffer
    _cone_vertex_buffer->Unlock();

    return true;
}

//------------------------------------------------------------------------------------
// Initialize vertex buffer for square.
//------------------------------------------------------------------------------------
bool TEXTURE_CONE::Init_Square_Vertex_Buffer()
{
    SQUARE_CUSTOM_VERTEX square_custom_vertex[] =     
    {
        {0.0f,   0.0f,   0.0f, 1.0f, 0.0f, 0.0f}, 
        {130.0f, 0.0f,   0.0f, 1.0f, 1.0f, 0.0f}, 
        {0.0f,   130.0f, 0.0f, 1.0f, 0.0f, 1.0f},
        {130.0f, 130.0f, 0.0f, 1.0f, 1.0f, 1.0f}
    };

    BYTE* vertex_data;

    // create vertex buffer
    if(FAILED(_d3d_device->CreateVertexBuffer(12 * sizeof(SQUARE_CUSTOM_VERTEX), 0, SQUARE_CUSTOM_VERTEX_FVF,
                            D3DPOOL_MANAGED, &_square_vertex_buffer, NULL)))
    {
        return false;
    }

    // get data pointer to vertex buffer
    if(FAILED(_square_vertex_buffer->Lock(0, 0, (void **) &vertex_data, 0)))
        return false;

    // copy custom vertex data into vertex buffer
    memcpy(vertex_data, square_custom_vertex, sizeof(square_custom_vertex));

    // unlock vertex buffer
    _square_vertex_buffer->Unlock();

    return true;
}

//------------------------------------------------------------------------------------
// Set camera position.
//------------------------------------------------------------------------------------
void TEXTURE_CONE::Set_Camera()
{
    D3DXVECTOR3 eye(-6.0, 1.5, 10.0);
    D3DXVECTOR3 at(6.0, 2.0, 3.0);
    D3DXVECTOR3 up(0.0, 1.0, 0.0);

    D3DXMATRIX view_matrix;

    // Builds a left-handed, look-at matrix.
    D3DXMatrixLookAtLH(&view_matrix, &eye, &at, &up);

    // Sets d3d device view transformation state.
    _d3d_device->SetTransform(D3DTS_VIEW, &view_matrix);

    D3DXMATRIX proj_matrix;

    // Builds a left-handed perspective projection matrix based on a field of view.
    D3DXMatrixPerspectiveFovLH(&proj_matrix, D3DX_PI/2, WINDOW_WIDTH / WINDOW_HEIGHT, 1.0, 1000.0);
    
    // Sets d3d device projection transformation state.
    _d3d_device->SetTransform(D3DTS_PROJECTION, &proj_matrix);
    // enable automatic normalization of vertex normals
    _d3d_device->SetRenderState(D3DRS_NORMALIZENORMALS, true);
}

//------------------------------------------------------------------------------------
// Set point light.
//------------------------------------------------------------------------------------
void TEXTURE_CONE::Set_Point_Light(D3DCOLORVALUE& dif, D3DCOLORVALUE& amb, D3DCOLORVALUE& spe, D3DVECTOR& pos)
{
    D3DLIGHT9 light;

    // clear memory with 0
    ZeroMemory(&light, sizeof(D3DLIGHT9));

    light.Type          = D3DLIGHT_POINT;
    light.Diffuse       = dif;
    light.Ambient       = amb;
    light.Specular      = spe;
    light.Position      = pos;
    light.Attenuation0  = 1.0;
    light.Attenuation1  = 0.0;
    light.Attenuation2  = 0.0;
    light.Range         = 1000.0;

    // Assigns point lighting properties for this device
    _d3d_device->SetLight(0, &light);
    // enable point light
    _d3d_device->LightEnable(0, TRUE);
    // enable light 
    _d3d_device->SetRenderState(D3DRS_LIGHTING, TRUE);
    // add ambient light
    _d3d_device->SetRenderState(D3DRS_AMBIENT, D3DCOLOR_XRGB(50, 50, 50));
}

//------------------------------------------------------------------------------------
// Sets the material properties for the device.
//------------------------------------------------------------------------------------
void TEXTURE_CONE::Set_Object_Material(D3DCOLORVALUE& dif, D3DCOLORVALUE& amb, D3DCOLORVALUE& spe, 
                                       D3DCOLORVALUE& emi, float power)
{
    D3DMATERIAL9 material;

    material.Diffuse  = dif;
    material.Ambient  = amb;
    material.Specular = spe;
    material.Emissive = emi;
    material.Power    = power;

    // Sets the material properties for the device.
    _d3d_device->SetMaterial(&material);
}

//------------------------------------------------------------------------------------
// Create all texture interface.
//------------------------------------------------------------------------------------
bool TEXTURE_CONE::Create_All_Texture()
{
    if(FAILED( D3DXCreateTextureFromFile(_d3d_device, "tiger.jpg", &_tiger_texture) ))
        goto fail;

    if(FAILED( D3DXCreateTextureFromFile(_d3d_device, "chess.bmp", &_chess_texture) ))
        goto fail;

    if(FAILED( D3DXCreateTextureFromFile(_d3d_device, "wall.bmp", &_wall_texture) ))
        goto fail;

    return true;

fail:
    MessageBox(NULL, "Create texture interface failed.", "ERROR", MB_OK);
    return false;
}

//------------------------------------------------------------------------------------
// Set texture interface to DirectX3D.
//------------------------------------------------------------------------------------
void TEXTURE_CONE::Set_Texture(int choice)
{
    switch(choice)
    {
    case TIGER:
        _d3d_device->SetTexture(0, _tiger_texture);
        break;
    case CHESS:
        _d3d_device->SetTexture(0, _chess_texture);
        break;
    case WALL:
        _d3d_device->SetTexture(0, _wall_texture);
        break;
    }
}

//------------------------------------------------------------------------------------
// Draw cone and square.
//------------------------------------------------------------------------------------
void TEXTURE_CONE::Render()
{
    if(_d3d_device == NULL)
        return;

    // clear surface with black
    _d3d_device->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0, 0);

    // begin scene
    _d3d_device->BeginScene();

    // 1) draw cone with texture stick on surface

    // Binds a vertex buffer to a device data stream.
    _d3d_device->SetStreamSource(0, _cone_vertex_buffer, 0, sizeof(CONE_CUSTOM_VERTEX));

    // Sets the current vertex stream declaration.
    _d3d_device->SetFVF(CONE_CUSTOM_VERTEX_FVF);

    // Sets the sampler state value.
    
    // D3DSAMP_MIPFILTER: 
    //      Mipmap filter to use during minification.
    //
    // D3DTEXF_POINT:
    //      Point filtering used as a texture magnification or minification filter. The texel with coordinates 
    //      nearest to the desired pixel value is used. The texture filter to be used between mipmap levels 
    //      is nearest-point mipmap filtering. The rasterizer uses the color from the texel of the nearest 
    //      mipmap texture. 
    _d3d_device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);

    // D3DSAMP_MAGFILTER:
    //      Magnification filter of type D3DTEXTUREFILTERTYPE. 
    //
    // D3DTEXF_LINEAR:
    //      Bilinear interpolation filtering used as a texture magnification or minification filter.
    //      A weighted average of a 2 × 2 area of texels surrounding the desired pixel is used. 
    //      The texture filter to use between mipmap levels is trilinear mipmap interpolation. 
    //      The rasterizer linearly interpolates pixel color, using the texels of the two nearest mipmap textures.
    _d3d_device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);

    // D3DSAMP_MINFILTER:
    //      Minification filter of type D3DTEXTUREFILTERTYPE. 
    _d3d_device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);

    // Renders a sequence of nonindexed, geometric primitives of the specified type from the current 
    // set of data input streams.
    _d3d_device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 4);

    // 2) draw square with texture stick on surface

    // Binds a vertex buffer to a device data stream. 
    _d3d_device->SetStreamSource(0, _square_vertex_buffer, 0, sizeof(SQUARE_CUSTOM_VERTEX));

    // Sets the current vertex stream declaration.
    _d3d_device->SetFVF(SQUARE_CUSTOM_VERTEX_FVF);

    // draw square
    _d3d_device->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);

    // end scene
    _d3d_device->EndScene();

    // Presents the contents of the next buffer in the sequence of back buffers owned by the device.
    _d3d_device->Present(NULL, NULL, NULL, NULL);
}

//------------------------------------------------------------------------------------
// Compute triangle normal.
//------------------------------------------------------------------------------------
void TEXTURE_CONE::Compute_Triangle_Normal(D3DXVECTOR3& v1, D3DXVECTOR3& v2, D3DXVECTOR3& v3, D3DVECTOR& normal)
{
    D3DXVECTOR3 vec1 = v1 - v2;
    D3DXVECTOR3 vec2 = v1 - v3;
    D3DXVECTOR3 normal_vec;

    D3DXVec3Cross(&normal_vec, &vec1, &vec2);
    D3DXVec3Normalize(&normal_vec, &normal_vec);

    normal = (D3DVECTOR) normal_vec;
}

//------------------------------------------------------------------------------------
// Release all resource allocated for D3D.
//------------------------------------------------------------------------------------
void TEXTURE_CONE::Release_COM_Object()
{
    Safe_Release(_tiger_texture);
    Safe_Release(_chess_texture);
    Safe_Release(_wall_texture);

    Safe_Release(_square_vertex_buffer);
    Safe_Release(_cone_vertex_buffer);

    Safe_Release(_d3d_device);
    Safe_Release(_d3d);
}

D3DPT_TRIANGLELIST
Renders the specified vertices as a sequence of isolated triangles. Each group of three vertices defines a separate triangle.
Back-face culling is affected by the current winding-order render state.

D3DPT_TRIANGLESTRIP
Renders the vertices as a triangle strip. The backface-culling flag is automatically flipped on even-numbered triangles.
 

/*************************************************************************************
 [Implement File]

 PURPOSE: 
    Test for texture, material, lighting.
*************************************************************************************/

#define DIRECTINPUT_VERSION 0x0800

#include "GE_COMMON.h"
#include "GE_APP.h"
#include "GE_INPUT.h"
#include "GE_TIMER.h"
#include "TextureCone.h"

#pragma warning(disable : 4305 4996)

int WINAPI WinMain(HINSTANCE instance, HINSTANCE, LPSTR cmd_line, int cmd_show)
{
    GE_APP ge_app;
    GE_INPUT ge_input;  
    GE_TIMER ge_timer;  
    TEXTURE_CONE texture_cone;

    MSG msg = {0};

    // define property for material
    D3DCOLORVALUE material_dif = {1.0f, 1.0f, 1.0f, 1.0f}; 
    D3DCOLORVALUE material_amb = {1.0f, 1.0f, 1.0f, 1.0f};
    D3DCOLORVALUE material_spe = {1.0f, 0.0f, 0.0f, 1.0f};
    D3DCOLORVALUE material_emi = {0.0f, 0.0f, 1.0f, 1.0f};

    // define property for light
    D3DCOLORVALUE light_dif = {1.0f, 0.0f, 0.0f, 1.0f};  
    D3DCOLORVALUE light_amb = {0.0f, 0.7f, 0.0f, 1.0f};
    D3DCOLORVALUE light_spe = {0.0f, 0.0f, 0.0f, 0.0f};

    D3DVECTOR light_pos = {5.0f, 6.0f, -20.0f};

    float last_render_time = 0;

    // create window
    if(! ge_app.Create_Window("Material and light test", instance, cmd_show))
        return false;

    HWND hwnd = ge_app.Get_Window_Handle();

    // create directinput
    ge_input.Create_Input(instance, hwnd);

    SetWindowPos(hwnd, 0, 0,0,0,0, SWP_NOSIZE);
    SetCursorPos(0, 0);

    // initialize game time
    ge_timer.Init_Game_Time();

    // Create direct3D interface and direct3D device.
    if(! texture_cone.Create_D3D_Device(hwnd, false))
        return false;

    // Initialize cone vertex buffer with curstom vertex structure.
    if(! texture_cone.Init_Cone_Vertex_Buffer())
        return false;

    // Initialize square vertex buffer with curstom vertex structure.
    if(! texture_cone.Init_Square_Vertex_Buffer())
        return false;

    // Create all texture interface.
    texture_cone.Create_All_Texture();

    // Set camera position.
    texture_cone.Set_Camera();

    // Sets the material properties for the device.
    texture_cone.Set_Object_Material(material_dif, material_amb, material_spe, material_emi, 0);

    // Set point light.
    texture_cone.Set_Point_Light(light_dif, light_amb, light_spe, light_pos);

    // Set texture interface to tiger
    texture_cone.Set_Texture(TIGER);

    // Draw cone and square.
    texture_cone.Render();

    while(msg.message != WM_QUIT)
    {
        if(PeekMessage(&msg, NULL, 0,0 , PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        else
        {           
            // read data from keyboard buffer
            if(ge_input.Read_Keyboard())
            {
                // press "ESC", close window.
                if(ge_input.Is_Key_Pressed(DIK_ESCAPE))
                    PostQuitMessage(0);

                bool key_left_pressed  = ge_input.Is_Key_Pressed(DIK_LEFT);
                bool key_right_pressed = ge_input.Is_Key_Pressed(DIK_RIGHT);
                bool key_up_pressed    = ge_input.Is_Key_Pressed(DIK_UP);                
                
                // set texture address mode
                if(key_left_pressed || key_right_pressed || key_up_pressed)
                {
                    // Set texture interface to DirectX3D.

                    if(key_left_pressed)                                            
                        texture_cone.Set_Texture(TIGER);                        

                    if(key_right_pressed)
                        texture_cone.Set_Texture(CHESS);            

                    if(key_up_pressed)
                        texture_cone.Set_Texture(WALL);       
                    
                    // draw cone and square
                    texture_cone.Render();
                }                
            } 
            
            // if it is time to reset light
            if((ge_timer.Get_Game_Play_Time() - last_render_time) > 30)
            {
                if(light_amb.r < 1.0f)
                    light_amb.r += 0.001f;
                else
                    light_amb.r = 0.0f;

                if(light_amb.g < 1.0f)
                    light_amb.g += 0.02f;
                else
                    light_amb.g = 0.0f;

                if(light_amb.b < 1.0f)
                    light_amb.b += 0.03f;
                else
                    light_amb.b = 0.0f;

                texture_cone.Set_Point_Light(light_dif, light_amb, light_spe, light_pos);
                texture_cone.Render();

                // update last render time
                last_render_time = ge_timer.Get_Game_Play_Time();
            }
        }
    }    

    UnregisterClass(WINDOW_CLASS_NAME, instance);

    return true;
}