/*---------------------------------------------------------------------------*
  Project:  Horizon
  File:     gx_AlphaTest.cpp

  Copyright (C)2009-2012 Nintendo Co., Ltd.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

  $Rev: 47228 $
 *---------------------------------------------------------------------------*/

/*
    Test for alpha test using fragment shader
    
    About texture combiner input
    srcRgb inputs the the color calculated by fragment lighting and srcAlpha inputs the alpha value set as a vertex attribute.
    
*/

#include <nn/types.h>

#include <nn/os.h>
#include <nn/fnd.h>
#include <nn/gx.h>
#include <nn/math.h>
#include <nn/fs.h>
#include <nn/init.h>
#include <nn/applet.h>

#include "demo_Models.h"

#include "demo.h"

namespace
{
    const f32 ALPHA_TEST_REF_VALUE = 0.510f;     // Alpha test threshold
    const int MODE_SWITCH_SPAN = 50;             // Loop count interval that switches the alpha test mode

    const int MAX_OBJ_NUM = 9;
    
    u32   s_Count = 1;
    u32   s_TestFuncMode = 0;
    
    demo::CubeModel  s_CubeObject[MAX_OBJ_NUM];
    
    GLuint s_ProgramId;
    GLuint s_ShaderId;
    
    f32   s_AlphaArray[MAX_OBJ_NUM] =
    {
        1.0f, 0.85f, 0.70f,
        0.55f, 0.51f, 0.501f,
        0.4f, 0.25f, 0.1f
    };
    
    u32   s_AlphaTestFunc[] =
    {
        GL_ALWAYS,      // Default
        GL_NEVER,
        GL_LESS,
        GL_LEQUAL,
        GL_EQUAL,
        GL_GEQUAL,
        GL_GREATER,
        GL_NOTEQUAL,
    };

    char* s_AlphaTestFuncName[] =
    {
        "GL_ALWAYS",        // Default
        "GL_NEVER",
        "GL_LESS",
        "GL_LEQUAL",
        "GL_EQUAL",
        "GL_GEQUAL",
        "GL_GREATER",
        "GL_NOTEQUAL"
    };

    /* ExpHeap for app. */
    nn::fnd::ExpHeap s_AppHeap;
    uptr s_AddrForGxHeap;
    const u32 s_GxHeapSize = 0x400000;
    
    demo::RenderSystemDrawing s_RenderSystem;
}

#define ALPHA_TEST_FUNC_NUM (sizeof(s_AlphaTestFunc)/sizeof(u32))

void SetUniforms(void)
{
    // Enable alpha test
    glUseProgram(s_ProgramId);
    glUniform1i(glGetUniformLocation(s_ProgramId, "dmp_FragOperation.enableAlphaTest"), GL_TRUE);
    glUniform1f(glGetUniformLocation(s_ProgramId, "dmp_FragOperation.alphaRefValue"), ALPHA_TEST_REF_VALUE);
    glUniform1i(glGetUniformLocation(s_ProgramId, "dmp_FragOperation.alphaTestFunc"), s_AlphaTestFunc[s_TestFuncMode]);

    // Texture combiner settings
    glUniform1i(glGetUniformLocation(s_ProgramId, "dmp_TexEnv[2].combineRgb"), GL_REPLACE);
    glUniform1i(glGetUniformLocation(s_ProgramId, "dmp_TexEnv[2].combineAlpha"), GL_REPLACE);
    glUniform3i(glGetUniformLocation(s_ProgramId, "dmp_TexEnv[2].operandRgb"), GL_SRC_COLOR, GL_SRC_COLOR, GL_SRC_COLOR);
    glUniform3i(glGetUniformLocation(s_ProgramId, "dmp_TexEnv[2].operandAlpha"), GL_SRC_ALPHA, GL_SRC_ALPHA, GL_SRC_ALPHA);
    glUniform3i(glGetUniformLocation(s_ProgramId, "dmp_TexEnv[2].srcRgb"), GL_FRAGMENT_PRIMARY_COLOR_DMP, GL_PREVIOUS, GL_PREVIOUS);
    glUniform3i(glGetUniformLocation(s_ProgramId, "dmp_TexEnv[2].srcAlpha"), GL_PRIMARY_COLOR, GL_PREVIOUS, GL_PREVIOUS);
    
    // Fragment light settings
    glUniform1i(glGetUniformLocation(s_ProgramId, "dmp_FragmentLighting.enabled"), GL_TRUE);
    
    f32 gAmb[] = { 0.3f,  0.3f, 0.3f, 1.0f};  // Global environment light color
    glUniform4fv(glGetUniformLocation(s_ProgramId, "dmp_FragmentLighting.ambient"), 1, gAmb);
    
    f32 lAmb[] = { 0.3f,  0.3f, 0.1f, 1.0f};  // Ambient light color for Light 0
    f32 lDif[] = { 0.7f,  0.7f, 0.2f, 1.0f};  // Diffuse light color for Light 0
    f32 lPos[] = {15.0f, 15.0f, 0.0f, 0.0f};  // Position in view coordinate system for Light 0
    glUniform1i(glGetUniformLocation(s_ProgramId, "dmp_FragmentLightSource[0].enabled"), GL_TRUE);
    glUniform4fv(glGetUniformLocation(s_ProgramId, "dmp_FragmentLightSource[0].ambient"), 1, lAmb);
    glUniform4fv(glGetUniformLocation(s_ProgramId, "dmp_FragmentLightSource[0].diffuse"), 1, lDif);
    glUniform4fv(glGetUniformLocation(s_ProgramId, "dmp_FragmentLightSource[0].position"), 1, lPos);

    // Material color settings
    f32 mAmb[] = {0.3f, 0.0f, 0.0f, 1.0f};  // Ambient light color for the material
    f32 mDif[] = {0.7f, 0.0f, 0.0f, 1.0f};  // Diffuse light color for the material
    glUniform4fv(glGetUniformLocation(s_ProgramId, "dmp_FragmentMaterial.ambient"), 1, mAmb);
    glUniform4fv(glGetUniformLocation(s_ProgramId, "dmp_FragmentMaterial.diffuse"), 1, mDif);
}

void PrintInfo(void)
{
    s_RenderSystem.DrawText(0.0f, 0.0f, 
        "Count: %d", s_Count);
    s_RenderSystem.DrawText(0.0f, 8.0f, 
        "MODE: %s", s_AlphaTestFuncName[s_TestFuncMode]);
    s_RenderSystem.DrawText(0.0f, 16.0f,
        "REF: %.4f", ALPHA_TEST_REF_VALUE);

    for ( u32 j = 0; j<MAX_OBJ_NUM; ++j)
    {
        s32 ofs_sx = 300 - (j / 3) * 130;
        s32 ofs_sy = nn::gx::DISPLAY0_WIDTH - (j % 3) * 80 - 16;
        s_RenderSystem.DrawText(ofs_sx, ofs_sy, 
            "a = %.4f", s_AlphaArray[j]);
    }
}

int DrawFrame(void)
{
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    // Switch the alpha test conditions
    if ((s_Count % MODE_SWITCH_SPAN) == 0)
    {
        s_TestFuncMode++;
        if(s_TestFuncMode >= ALPHA_TEST_FUNC_NUM)
        {
            s_TestFuncMode = 0;
        }
    }

    nn::math::Matrix44 proj;
    nn::math::MTX44Perspective(&proj, 45.0f, static_cast<f32>(nn::gx::DISPLAY0_WIDTH)/static_cast<f32>(nn::gx::DISPLAY0_HEIGHT), 0.2f, 100.0f);

    nn::math::Matrix34 mv, rot;
    nn::math::Vector3 camPos(0.f, 0.f, 18.f);
    nn::math::Vector3 camUp(0.f, 1.f, 0.f);
    nn::math::Vector3 target(0.f, 0.f, 0.f);
    nn::math::Vector3 axis(1.f, 1.f, 0.f);
    
    nn::math::MTX34LookAt(&mv, &camPos, &camUp, &target);
    nn::math::MTX34RotAxisDeg(&rot, &axis, static_cast<f32>(s_Count));

    SetUniforms();

    s_RenderSystem.SetRenderTarget(NN_GX_DISPLAY0);
    s_RenderSystem.Clear();
        
    for ( u32 i = 0; i<MAX_OBJ_NUM; i++)
    {
        f32 ofs_x = (i % 3) * 3.0f - 3.0f;
        f32 ofs_y = (i / 3) * 4.5f - 4.5f;

        nn::math::Matrix34 mvtmp;
        nn::math::Vector3 trans(ofs_x, ofs_y, 0.f);

        nn::math::MTX34MultTranslate(&mvtmp, &mv, &trans);
        nn::math::MTX34Mult(&mvtmp, &mvtmp, &rot);

        glUseProgram(s_ProgramId);
        glUniformMatrix4fv(glGetUniformLocation(s_ProgramId, "uProjection"), 1, GL_TRUE, static_cast<f32*>(proj));

        nn::math::Matrix44 m(mvtmp);
        glUniformMatrix4fv(glGetUniformLocation(s_ProgramId, "uModelView"), 1, GL_TRUE, static_cast<f32*>(m));

        s_CubeObject[i].Draw();
    }

    PrintInfo();

    s_RenderSystem.SwapBuffers();

    s_RenderSystem.SetRenderTarget(NN_GX_DISPLAY1);
    s_RenderSystem.Clear();
    s_RenderSystem.SwapBuffers();

    s_RenderSystem.WaitVsync(NN_GX_DISPLAY_BOTH);

    s_Count++;

    return 1;
}

/* initialization */
int Initialize(void)
{
    nn::fs::Initialize();

    const size_t ROMFS_BUFFER_SIZE = 1024 * 64;
    static char buffer[ROMFS_BUFFER_SIZE];
    NN_UTIL_PANIC_IF_FAILED(
        nn::fs::MountRom(16, 16, buffer, ROMFS_BUFFER_SIZE));

    /* Initialize display */
    s_AppHeap.Initialize(nn::os::GetDeviceMemoryAddress(), nn::os::GetDeviceMemorySize() );
    s_AddrForGxHeap = reinterpret_cast<uptr>(s_AppHeap.Allocate(s_GxHeapSize));
    s_RenderSystem.Initialize(s_AddrForGxHeap, s_GxHeapSize);

    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glClearDepthf(1.f);

    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);
    glEnable(GL_CULL_FACE);
    glFrontFace(GL_CCW);
    glCullFace(GL_BACK);

    s_ProgramId = glCreateProgram();
    s_ShaderId = glCreateShader(GL_VERTEX_SHADER);
    
    nn::fs::FileReader file(L"rom:/shader.shbin");
    size_t fileSize = file.GetSize();
    void* buf = s_AppHeap.Allocate(fileSize);

    s32 read = file.Read(buf, fileSize);
    glShaderBinary(1, &s_ShaderId, GL_PLATFORM_BINARY_DMP, buf, read);
    file.Finalize();
    s_AppHeap.Free(buf);

    glAttachShader(s_ProgramId, s_ShaderId);
    glAttachShader(s_ProgramId, GL_DMP_FRAGMENT_SHADER_DMP);
    glBindAttribLocation(s_ProgramId, 0, "aPosition");

    glBindAttribLocation(s_ProgramId, 1, "aNormal");
    glBindAttribLocation(s_ProgramId, 2, "aColor");

    glLinkProgram(s_ProgramId);
    glValidateProgram(s_ProgramId);
    
    for (int i=0; i<MAX_OBJ_NUM; ++i)
    {
        s_CubeObject[i].Initialize(demo::ATTR_POSITION | demo::ATTR_NORMAL | demo::ATTR_VERTEX_COLOR, 
            0.0f, 0.0f, 1.0f, 
            s_AlphaArray[i]);
    }
    
    s_RenderSystem.SetColor(1.0f, 1.0f, 1.0f, 1.0f);
    
    return 0;
}

void nnMain(void)
{
    // Call only nn::applet::Enable to also allow execution from the HOME Menu
    // HOME Menu transitions, POWER Button presses, and sleep are all unsupported
    nn::applet::Enable();

    /* initialization */
    if (Initialize() >= 0)
    {
        /* Enter loop */
        while (1)
        {
            (void)DrawFrame();
        }
    }
    
    /* shutdown_display (never reached.) */
    for (int i=0; i<MAX_OBJ_NUM; ++i)
    {
        s_CubeObject[i].Finalize();
    }
    s_RenderSystem.Finalize();
    s_AppHeap.Free(reinterpret_cast<void*>(s_AddrForGxHeap));
    s_AppHeap.Finalize();
}