/*---------------------------------------------------------------------------*

  Copyright (C) 2010-2011 Nintendo.  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.

 *---------------------------------------------------------------------------*/

#include <stdio.h>
#include <string.h>
#include <math.h>

#include <cafe/demo.h>
#include <cafe/gx2.h>

#define PI 3.14159f

// ----- Surface Information

#define RENDERTARGET_WIDTH  1280
#define RENDERTARGET_HEIGHT  720

#define SURFACE_WIDTH  1280
#define SURFACE_HEIGHT  720

////////////////////////////////////////////////////
//
// Assets Data
//
////////////////////////////////////////////////////

// ----- Attribute Layout

struct AttributeLayout
{
    const char*     shaderVarName;
    GX2AttribFormat attribFormat;
    u32             elementSize;
};

// ----- Model files

#define NUM_MODEL 4
static char* MODEL_FILES[NUM_MODEL][3] =
{
    {"assets/geometries/elephantPosition.dat",
     "assets/geometries/elephantNormal.dat",
     "assets/geometries/elephantIdx.dat"},
    {"assets/geometries/teapotPosition.dat",
     "assets/geometries/teapotNormal.dat",
     "assets/geometries/teapotIdx.dat"},
    {"assets/geometries/torusPosition.dat",
     "assets/geometries/torusNormal.dat",
     "assets/geometries/torusIdx.dat"},
    {"assets/geometries/spherePosition.dat",
     "assets/geometries/sphereNormal.dat",
     "assets/geometries/sphereIdx.dat"}
};

// ----- Shader files

static const char * const GSH_SHADER_FILE_DEFERRED_GEOMETRY = "assets/shaders/test_gx2/cafe/shading/deferredRenderingSetup.gsh";
static const char * const GSH_SHADER_FILE_DEFERRED_LIGHTING = "assets/shaders/test_gx2/cafe/shading/deferredRenderingLighting.gsh";
static const char * const GSH_SHADER_FILE_TEXTURE2D         = "assets/shaders/test_gx2/cafe/simple/texture2D.gsh";

// ----- Struct for geometry stage attribute buffers

static AttributeLayout s_modelAttributeLayout[] =
{
    { "a_position",     GX2_ATTRIB_FORMAT_32_32_32_FLOAT,   sizeof(DEMO_F32x3) },
    { "a_normal",       GX2_ATTRIB_FORMAT_32_32_32_FLOAT,   sizeof(DEMO_F32x3) },
};
static const u32 MODEL_NUM_ATTRIBUTES=sizeof(s_modelAttributeLayout)/sizeof(s_modelAttributeLayout[0]);

typedef struct _ModelAttribBuffer
{
    GX2RBuffer attributeBuffer[MODEL_NUM_ATTRIBUTES];
    GX2RBuffer indexBuffer;
} ModelAttribBuffer;

// ----- Struct for lighting stage attribute buffers

static AttributeLayout s_LightingAttributeLayout[] =
{
    { "a_position",     GX2_ATTRIB_FORMAT_32_32_32_FLOAT,   sizeof(DEMO_F32x3) },
    { "a_texCoord",     GX2_ATTRIB_FORMAT_32_32_FLOAT,      sizeof(DEMO_F32x2) },
};
static const u32 LIGHTING_NUM_ATTRIBUTES=sizeof(s_LightingAttributeLayout)/sizeof(s_LightingAttributeLayout[0]);

typedef struct _LightingAttribBuffer
{
    GX2RBuffer attributeBuffer[LIGHTING_NUM_ATTRIBUTES];
    GX2RBuffer indexBuffer;
} LightingAttribBuffer;

// ----- Struct for gbuffer stage attribute buffers

static AttributeLayout s_gBufferAttributeLayout[] =
{
    { "a_position",     GX2_ATTRIB_FORMAT_32_32_32_FLOAT,   sizeof(DEMO_F32x3) },
    { "a_texCoord",     GX2_ATTRIB_FORMAT_32_32_FLOAT,      sizeof(DEMO_F32x2) },
};
static const u32 G_BUFFER_NUM_ATTRIBUTES=sizeof(s_gBufferAttributeLayout)/sizeof(s_gBufferAttributeLayout[0]);

typedef struct _GBufferAttribBuffer
{
    GX2RBuffer attributeBuffer[G_BUFFER_NUM_ATTRIBUTES];
    GX2RBuffer indexBuffer;
} GBufferAttribBuffer;

static struct _GeometryPass
{
    // -- Shaders -- //
    DEMOGfxShader shaders;
    
    // -- Constant Buffers -- //
    Mtx44 modelMtx44;
    Mtx44 viewprojMtx44;
    Qtrn  color;

    // -- Attribute Buffers -- //
    ModelAttribBuffer attribs[NUM_MODEL];

    // -- Texture Setting -- //
    GX2ColorBuffer myColorBuffer[3];
    void * myColorBufferData[3];
    void * myScanBufferPtr;
} GeometryPass;

static struct _LightingPass
{
    // -- Shaders -- //
    DEMOGfxShader shaders;
    
    // -- Constant Buffers -- //
    Qtrn ambientColor;
    Qtrn lightColor;
    Qtrn lightPosition;
    Qtrn cameraPosition;

    // -- Attribute Buffers -- //
    LightingAttribBuffer attribs;

    // -- Texture Setting -- //
    GX2Texture myTextureBuffer[3];
    GX2Sampler mySampler;
} LightingPass;

static struct _BuffersPass
{
    // -- Shaders -- //
    DEMOGfxShader shaders;
    
    // -- Attribute Buffers -- //
    GBufferAttribBuffer attribs;

    // -- Texture Setting -- //
    GX2Texture myTextureBuffer[3];
    GX2Sampler mySampler;
} BuffersPass;

// Globals
static float s_rotateY;
static BOOL s_drawBuffers;
static u32 s_modelIdx;
static u32 s_avgNoSwizzleTime;
static u32 s_avgSwizzleTime;
static u32 s_noSwizzleTime;
static u32 s_swizzleTime;
static u64* s_timerData;
static u32 s_ticks;

// Prototype
static void CameraInit(Mtx44 resultViewProjMtx44);
static void SceneInit(void);
static void SceneUpdate(void);
static void GeometryPassInit(void);
static void LightingPassInit(void);
static void BuffersPassInit(void);
static void SceneFree(void);
static void GeometryPassDraw(void);
static void LightingPassDraw(void);
static void BuffersPassDraw(void);
static void SceneDraw(void);

// Init function for setting projection matrix
static void CameraInit(Mtx44 resultViewProjMtx44)
{
    // row major matricies
    Mtx   lookAtMtx34;
    Mtx44 projMtx44;
    Mtx44 viewMtx44;

    Vec     up = {0.0f,  1.0f, 0.0f};
    Vec  objPt = {0.0f, 0.0f, 0.0f};
    Vec camLoc = {0.0f, 0.0f, 300.0f};

    f32   pers = 30.0f;
    f32 aspect = (f32)SURFACE_WIDTH / (f32)SURFACE_HEIGHT;
    f32  znear = 50.0f;
    f32   zfar = 2000.0f;

    // Set light position
    LightingPass.cameraPosition.x = camLoc.x;
    LightingPass.cameraPosition.y = camLoc.y;
    LightingPass.cameraPosition.z = camLoc.z;
    LightingPass.cameraPosition.w = 1.0f;

    // Compute perspective matrix
    MTXPerspective(projMtx44, pers, aspect, znear, zfar);

    // Compute lookAt matrix
    MTXLookAt(lookAtMtx34, &camLoc, &up, &objPt);
    MTX34To44(lookAtMtx34, viewMtx44);

    // return view+proj
    MTX44Concat(projMtx44, viewMtx44, resultViewProjMtx44);
}

// The init function for the rendering portions of this app
static void SceneInit(void)
{
    // Initialize globals
    s_rotateY = 0.0f;
    s_drawBuffers = TRUE;
    s_modelIdx = 0;
    s_noSwizzleTime = 0;
    s_swizzleTime = 0;
    s_avgNoSwizzleTime = 0;
    s_avgSwizzleTime = 0;
    s_timerData = (u64*)DEMOGfxAllocMEM2(sizeof(u64)*2, GX2_DEFAULT_BUFFER_ALIGNMENT);
    s_ticks = 0;

    // Initialize passes
    GeometryPassInit();
    LightingPassInit();
    BuffersPassInit();
}

// rotate the model
static void SceneUpdate(void)
{
    Mtx modelWorldMtx;

    MTXRotRad(modelWorldMtx, 'y', s_rotateY / 4.0f);
    MTX34To44(modelWorldMtx, GeometryPass.modelMtx44);

    s_rotateY += 0.06f;
    if(s_rotateY > PI*8)
    {
        s_rotateY -= PI*8;
        s_drawBuffers = !s_drawBuffers;
        if(s_drawBuffers)
            s_modelIdx = (s_modelIdx + 1) % NUM_MODEL;
    }
    ++s_ticks;
}

static GX2RBuffer LoadModelBuffer(const char* modelFileName, GX2RResourceFlags resourceFlags, u32 elementSize)
{
    // This version does it's own file reading to eliminate the extra malloc/memcpy/free
    // and just load straight into the buffer memory.
    DEMOFSFileInfo file;
    u32 fileLen;
    s32 fileRet;

    fileRet = DEMOFSOpenFile(modelFileName, &file);
    DEMOAssert(fileRet == DEMO_FS_RESULT_OK && "couldn't open file");

    fileRet = DEMOFSGetLength(&file, &fileLen);
    DEMOAssert(fileRet == DEMO_FS_RESULT_OK && "couldn't get file length");

    u32 elementCount = fileLen/elementSize;

    GX2RBuffer gx2Buffer;
    GX2UTCreateBuffer(&gx2Buffer, resourceFlags | GX2R_USAGE_CPU_WRITE | GX2R_USAGE_GPU_READ, elementSize, elementCount);
    GX2RSetBufferName(&gx2Buffer, modelFileName);

    // Lock the buffer and read straight into the memory with no copying
    void* pMem=GX2RLockBuffer(&gx2Buffer);

    fileRet = DEMOFSRead(&file, pMem, (s32)fileLen, 0);
    DEMOAssert(fileRet == DEMO_FS_RESULT_OK && "couldn't read file");

    GX2RUnlockBuffer(&gx2Buffer);

    fileRet = DEMOFSCloseFile(&file);
    if (fileRet != DEMO_FS_RESULT_OK)
    {
        DEMOAssert(!"couldn't close file");
    }

    return gx2Buffer;
}
// Initialized the Geometry pass
static void GeometryPassInit(void)
{
    u32 i;
    u32 gshLen;
    void *gshBuf;

    // initialize uniforms
    CameraInit(GeometryPass.viewprojMtx44);
    SceneUpdate();
    GeometryPass.color.x = 1.0f;
    GeometryPass.color.y = 0.0f;
    GeometryPass.color.z = 0.0f;
    GeometryPass.color.w = 80.0f / 255.0f; // shininess / 255.0f

    // DEMOFSSimpleRead sets PPC_IO_BUFFER_ALIGN alignment.
    // This number must fit to vertex and index buffer alignment.
    ASSERT(PPC_IO_BUFFER_ALIGN % GX2_VERTEX_BUFFER_ALIGNMENT == 0);
    ASSERT(PPC_IO_BUFFER_ALIGN % GX2_INDEX_BUFFER_ALIGNMENT == 0);

    // load models
    for(i = 0; i < NUM_MODEL; ++i)
    {
        // Load attribute buffers
        for (u32 attribSlot=0; attribSlot<MODEL_NUM_ATTRIBUTES; attribSlot++)
        {
            GeometryPass.attribs[i].attributeBuffer[attribSlot] = LoadModelBuffer(MODEL_FILES[i][attribSlot], 
                                                                                          GX2R_BIND_VERTEX_BUFFER, 
                                                                                          s_modelAttributeLayout[attribSlot].elementSize);
        }
        // Load index buffer
        GeometryPass.attribs[i].indexBuffer = LoadModelBuffer(MODEL_FILES[i][MODEL_NUM_ATTRIBUTES], 
                                                                      GX2R_BIND_INDEX_BUFFER, 
                                                                      GX2UTGetIndexSize(GX2_INDEX_FORMAT_U32));
    };

    // Load shader binary to memory
    gshBuf = DEMOFSSimpleRead(GSH_SHADER_FILE_DEFERRED_GEOMETRY, &gshLen);

    // Load shaders from memory.
    DEMOGfxLoadShaders(&GeometryPass.shaders, 0, gshBuf);
    
    // Free memory used to load the shader file
    DEMOFree(gshBuf);

    // Init attribs
    for (u32 attribSlot=0; attribSlot<MODEL_NUM_ATTRIBUTES; attribSlot++)
    {
        DEMOGfxInitShaderAttribute(&GeometryPass.shaders,
                                   s_modelAttributeLayout[attribSlot].shaderVarName,
                                   attribSlot,
                                   0,
                                   s_modelAttributeLayout[attribSlot].attribFormat);
    }
    
    // Get uniform location
    DEMOGfxGetVertexShaderUniformLocation(&GeometryPass.shaders, "u_modelMtx");
    DEMOGfxGetVertexShaderUniformLocation(&GeometryPass.shaders, "u_viewprojMtx");

    // Get uniform location
    DEMOGfxGetPixelShaderUniformLocation(&GeometryPass.shaders, "u_color");

    // Initialize fetch Shader
    DEMOGfxInitFetchShader(&GeometryPass.shaders);


    // Initialize render color buffers
    GX2InitColorBuffer(&GeometryPass.myColorBuffer[0],
                       RENDERTARGET_WIDTH,
                       RENDERTARGET_HEIGHT,
                       GX2_SURFACE_FORMAT_TCS_R8_G8_B8_A8_UNORM,
                       GX2_AA_MODE_1X);
    GeometryPass.myColorBufferData[0] = DEMOGfxAllocMEM1(GeometryPass.myColorBuffer[0].surface.imageSize,
                                                         GeometryPass.myColorBuffer[0].surface.alignment);
    GX2InitColorBufferPtr(&GeometryPass.myColorBuffer[0], GeometryPass.myColorBufferData[0]);
    GX2SetSurfaceSwizzle(&GeometryPass.myColorBuffer[0].surface, 0);

    GX2InitColorBuffer(&GeometryPass.myColorBuffer[1],
                       RENDERTARGET_WIDTH,
                       RENDERTARGET_HEIGHT,
                       GX2_SURFACE_FORMAT_TC_R10_G10_B10_A2_SNORM,
                       GX2_AA_MODE_1X);
    GeometryPass.myColorBufferData[1] = DEMOGfxAllocMEM1(GeometryPass.myColorBuffer[1].surface.imageSize,
                                                         GeometryPass.myColorBuffer[1].surface.alignment);
    GX2InitColorBufferPtr(&GeometryPass.myColorBuffer[1], GeometryPass.myColorBufferData[1]);
    GX2SetSurfaceSwizzle(&GeometryPass.myColorBuffer[1].surface, 2);

    GX2InitColorBuffer(&GeometryPass.myColorBuffer[2],
                       RENDERTARGET_WIDTH,
                       RENDERTARGET_HEIGHT,
                       GX2_SURFACE_FORMAT_TC_R11_G11_B10_FLOAT,
                       GX2_AA_MODE_1X);
    GeometryPass.myColorBufferData[2] = DEMOGfxAllocMEM1(GeometryPass.myColorBuffer[2].surface.imageSize,
                                                         GeometryPass.myColorBuffer[2].surface.alignment);
    GX2InitColorBufferPtr(&GeometryPass.myColorBuffer[2], GeometryPass.myColorBufferData[2]);
    GX2SetSurfaceSwizzle(&GeometryPass.myColorBuffer[2].surface, 7);
}

// Initializes the Lighting pass
static void LightingPassInit(void)
{
    u32 gshLen;
    void *gshBuf;

    // initialize uniforms
    LightingPass.ambientColor.x = 0.3f;
    LightingPass.ambientColor.y = 0.3f;
    LightingPass.ambientColor.z = 0.3f;
    LightingPass.ambientColor.w = 1.0f;

    LightingPass.lightColor.x = 1.0f;
    LightingPass.lightColor.y = 1.0f;
    LightingPass.lightColor.z = 1.0f;
    LightingPass.lightColor.w = 10.0f / 255.0f; // attenuation / 255.0f

    LightingPass.lightPosition.x = 40.0f;
    LightingPass.lightPosition.y = 30.0f;
    LightingPass.lightPosition.z = 40.0f;
    LightingPass.lightPosition.w = 1.0f;

    // Initialize texture buffers
    GX2InitTexture(&LightingPass.myTextureBuffer[0],
                   RENDERTARGET_WIDTH,  // width
                   RENDERTARGET_HEIGHT,  // height
                   1,    // depth
                   0,    // num mips
                   GX2_SURFACE_FORMAT_TCS_R8_G8_B8_A8_UNORM,
                   GX2_SURFACE_DIM_2D);
    GX2SetSurfaceSwizzle(&LightingPass.myTextureBuffer[0].surface, 1);
    GX2InitTexture(&LightingPass.myTextureBuffer[1],
                   RENDERTARGET_WIDTH,  // width
                   RENDERTARGET_HEIGHT,  // height
                   1,    // depth
                   0,    // num mips
                   GX2_SURFACE_FORMAT_TC_R10_G10_B10_A2_SNORM,
                   GX2_SURFACE_DIM_2D);
    GX2SetSurfaceSwizzle(&LightingPass.myTextureBuffer[1].surface, 2);
    GX2InitTexture(&LightingPass.myTextureBuffer[2],
                   RENDERTARGET_WIDTH,  // width
                   RENDERTARGET_HEIGHT,  // height
                   1,    // depth
                   0,    // num mips
                   GX2_SURFACE_FORMAT_TC_R11_G11_B10_FLOAT,
                   GX2_SURFACE_DIM_2D);
    GX2SetSurfaceSwizzle(&LightingPass.myTextureBuffer[2].surface, 4);

    // Set up the sampler object
    GX2InitSampler(&LightingPass.mySampler,
                      GX2_TEX_CLAMP_CLAMP,
                      GX2_TEX_XY_FILTER_POINT);

    // geometry data 
    DEMO_F32x3 posInitData[] = {{-1.0f,-1.0f, 0.0f},
                                { 1.0f,-1.0f, 0.0f},
                                { 1.0f, 1.0f, 0.0f},
                                {-1.0f, 1.0f, 0.0f}
                               };
    DEMO_F32x2 texInitData[] = {{ 0.0f, 1.0f},
                                { 1.0f, 1.0f},
                                { 1.0f, 0.0f},
                                { 0.0f, 0.0f}
                               };
    DEMO_U32   idxInitData[] = {0, 1, 2, 3};

    // Create Vertex Buffer
    GX2UTCreateVertexBuffer(&LightingPass.attribs.attributeBuffer[0], 
                            sizeof(DEMO_F32x3), 
                            sizeof(posInitData) / sizeof(DEMO_F32x3));

    // Create Texture Buffer
    GX2UTCreateVertexBuffer(&LightingPass.attribs.attributeBuffer[1], 
                            sizeof(DEMO_F32x2), 
                            sizeof(texInitData) / sizeof(DEMO_F32x2));
                            
    // Create Index Buffer
    GX2UTCreateIndexBuffer(&LightingPass.attribs.indexBuffer,
                           sizeof(DEMO_U32),
                           sizeof(idxInitData) / sizeof(DEMO_U32));

    // Set attributes data
    GX2UTFillBuffer(&LightingPass.attribs.attributeBuffer[0], posInitData);
    GX2UTFillBuffer(&LightingPass.attribs.attributeBuffer[1], texInitData);
    GX2UTFillBuffer(&LightingPass.attribs.indexBuffer,     idxInitData);    
    
    // Load shader binary to memory
    gshBuf = DEMOFSSimpleRead(GSH_SHADER_FILE_DEFERRED_LIGHTING, &gshLen);

    // Load shaders from memory.
    DEMOGfxLoadShaders(&LightingPass.shaders, 0, gshBuf);

    // Free memory used to load the shader file
    DEMOFree(gshBuf);

    // Init attribs
    for (u32 attribSlot=0; attribSlot<G_BUFFER_NUM_ATTRIBUTES; attribSlot++)
    {
        DEMOGfxInitShaderAttribute(&LightingPass.shaders,
                                   s_LightingAttributeLayout[attribSlot].shaderVarName,
                                   attribSlot,
                                   0,
                                   s_LightingAttributeLayout[attribSlot].attribFormat);
    }
    
    // Get sampler location
    DEMOGfxGetPixelShaderSamplerLocation(&LightingPass.shaders, "s_diffuse");
    DEMOGfxGetPixelShaderSamplerLocation(&LightingPass.shaders, "s_normal");
    DEMOGfxGetPixelShaderSamplerLocation(&LightingPass.shaders, "s_position");
    
    // Get uniform location
    DEMOGfxGetPixelShaderUniformLocation(&LightingPass.shaders, "u_ambientColor");
    DEMOGfxGetPixelShaderUniformLocation(&LightingPass.shaders, "u_lightColor");
    DEMOGfxGetPixelShaderUniformLocation(&LightingPass.shaders, "u_lightPosition");
    DEMOGfxGetPixelShaderUniformLocation(&LightingPass.shaders, "u_cameraPosition");
            
    // Initialize fetch Shader
    DEMOGfxInitFetchShader(&LightingPass.shaders);

}

// Initializes the Buffers pass
static void BuffersPassInit(void)
{
    u32 gshLen;
    void *gshBuf;

    // Initialize texture buffers
    GX2InitTexture(&BuffersPass.myTextureBuffer[0],
                   RENDERTARGET_WIDTH,  // width
                   RENDERTARGET_HEIGHT,  // height
                   1,    // depth
                   0,    // num mips
                   GX2_SURFACE_FORMAT_TCS_R8_G8_B8_A8_UNORM,
                   GX2_SURFACE_DIM_2D);
    GX2SetSurfaceSwizzle(&BuffersPass.myTextureBuffer[0].surface, 1);
    GX2InitTexture(&BuffersPass.myTextureBuffer[1],
                   RENDERTARGET_WIDTH,  // width
                   RENDERTARGET_HEIGHT,  // height
                   1,    // depth
                   0,    // num mips
                   GX2_SURFACE_FORMAT_TC_R10_G10_B10_A2_SNORM,
                   GX2_SURFACE_DIM_2D);
    GX2SetSurfaceSwizzle(&BuffersPass.myTextureBuffer[1].surface, 2);
    GX2InitTexture(&BuffersPass.myTextureBuffer[2],
                   RENDERTARGET_WIDTH,  // width
                   RENDERTARGET_HEIGHT,  // height
                   1,    // depth
                   0,    // num mips
                   GX2_SURFACE_FORMAT_TC_R11_G11_B10_FLOAT,
                   GX2_SURFACE_DIM_2D);
    GX2SetSurfaceSwizzle(&BuffersPass.myTextureBuffer[2].surface, 4);

    // Set up the sampler object
    GX2InitSampler(&BuffersPass.mySampler,
                      GX2_TEX_CLAMP_CLAMP,
                      GX2_TEX_XY_FILTER_POINT);

    // geometry data 
    const f32 divs = 2.0f;
    DEMO_F32x3 posInitData[] = {{-1.0f/divs,-1.0f/divs, 0.0f},
                                { 1.0f/divs,-1.0f/divs, 0.0f},
                                { 1.0f/divs, 1.0f/divs, 0.0f},
                                {-1.0f/divs, 1.0f/divs, 0.0f}
                               };
    DEMO_F32x2 texInitData[] = {{ 0.0f, 1.0f},
                                { 1.0f, 1.0f},
                                { 1.0f, 0.0f},
                                { 0.0f, 0.0f}
                               };
    DEMO_U32   idxInitData[] = {0, 1, 2, 3};
    
    // Create Vertex Buffer
    GX2UTCreateVertexBuffer(&BuffersPass.attribs.attributeBuffer[0], 
                            sizeof(DEMO_F32x3), 
                            sizeof(posInitData) / sizeof(DEMO_F32x3));

    // Create Texture Buffer
    GX2UTCreateVertexBuffer(&BuffersPass.attribs.attributeBuffer[1], 
                            sizeof(DEMO_F32x2), 
                            sizeof(texInitData) / sizeof(DEMO_F32x2));
                            
    // Create Index Buffer
    GX2UTCreateIndexBuffer(&BuffersPass.attribs.indexBuffer,
                           sizeof(DEMO_U32),
                           sizeof(idxInitData) / sizeof(DEMO_U32));

    // Set attributes data
    GX2UTFillBuffer(&BuffersPass.attribs.attributeBuffer[0], posInitData);
    GX2UTFillBuffer(&BuffersPass.attribs.attributeBuffer[1], texInitData);
    GX2UTFillBuffer(&BuffersPass.attribs.indexBuffer,        idxInitData);    
    
    // Load shader binary to memory
    gshBuf = DEMOFSSimpleRead(GSH_SHADER_FILE_TEXTURE2D, &gshLen);

    // Load shaders from memory.
    DEMOGfxLoadShaders(&BuffersPass.shaders, 0, gshBuf);

    // Free memory used to load the shader file
    DEMOFree(gshBuf);

    // Init attribs
    for (u32 attribSlot=0; attribSlot<G_BUFFER_NUM_ATTRIBUTES; attribSlot++)
    {
        DEMOGfxInitShaderAttribute(&BuffersPass.shaders,
                                   s_gBufferAttributeLayout[attribSlot].shaderVarName,
                                   attribSlot,
                                   0,
                                   s_gBufferAttributeLayout[attribSlot].attribFormat);
    }
    
    // Get sampler location
    DEMOGfxGetPixelShaderSamplerLocation(&BuffersPass.shaders, "s_texture");
    
    // Get uniform location
    DEMOGfxGetVertexShaderUniformLocation(&BuffersPass.shaders, "u_offset");
            
    // Initialize fetch Shader
    DEMOGfxInitFetchShader(&BuffersPass.shaders);

}

// Deallocates all resources
static void SceneFree(void)
{
    u32 i;

    // Geometry pass free
    DEMOGfxFreeShaders(&GeometryPass.shaders);
        
    for(i = 0; i < NUM_MODEL; ++i)
    {
        for (u32 attribSlot=0; attribSlot<MODEL_NUM_ATTRIBUTES; attribSlot++)
        {
            GX2RDestroyBuffer(&GeometryPass.attribs[i].attributeBuffer[attribSlot]);
        }

        GX2RDestroyBuffer(&GeometryPass.attribs[i].indexBuffer);
    }
    
    DEMOGfxFreeMEM1(GeometryPass.myColorBufferData[0]);
    DEMOGfxFreeMEM1(GeometryPass.myColorBufferData[1]);
    DEMOGfxFreeMEM1(GeometryPass.myColorBufferData[2]);

    // Lighting pass free
    DEMOGfxFreeShaders(&LightingPass.shaders);
    
    for (u32 attribSlot=0; attribSlot<G_BUFFER_NUM_ATTRIBUTES; attribSlot++)
    {
        GX2RDestroyBuffer(&LightingPass.attribs.attributeBuffer[attribSlot]);
    }

    GX2RDestroyBuffer(&LightingPass.attribs.indexBuffer);

    // Buffers pass free
    DEMOGfxFreeShaders(&BuffersPass.shaders);
    
    for (u32 attribSlot=0; attribSlot<G_BUFFER_NUM_ATTRIBUTES; attribSlot++)
    {
        GX2RDestroyBuffer(&BuffersPass.attribs.attributeBuffer[attribSlot]);
    }

    GX2RDestroyBuffer(&BuffersPass.attribs.indexBuffer);
            
    // Free the timer
    DEMOGfxFreeMEM2(s_timerData);
}

// The draw function for the rendering portions of this app
static void SceneDraw(void)
{
    u32 sceneDraws;
    u32 swizzleValues[2][3] =
    {
        {0,0,0}, // all the same (no swizzle)
        {0,2,7}  // all different (swizzle)
    }; // 0-7 are valid values

    DEMOGfxBeforeRender();

    for(sceneDraws = 0; sceneDraws < 2; ++sceneDraws)
    {
        // Compare time with and without swizzle (normally swizzle is just set during init)
        u32 i, time;
        for(i = 0; i < 3; ++i)
        {
            GX2SetSurfaceSwizzle(&GeometryPass.myColorBuffer[i].surface, swizzleValues[sceneDraws][i]);
            GX2SetSurfaceSwizzle(&LightingPass.myTextureBuffer[i].surface, swizzleValues[sceneDraws][i]);
            GX2SetSurfaceSwizzle(&BuffersPass.myTextureBuffer[i].surface, swizzleValues[sceneDraws][i]);
        }

        // start timing
        GX2DrawDone();
        GX2SampleTopGPUCycle(&s_timerData[0]);
        GX2Flush();

        // 1ST PASS (SETUP)
        GeometryPassDraw();

        // 2ND PASS (LIGHTING)
        LightingPassDraw();

        // record time taken
        GX2SampleBottomGPUCycle(&s_timerData[1]);
        GX2DrawDone();
        DCInvalidateRange((void*)s_timerData, sizeof(u64)*2);
        time = (u32)((s_timerData[1] - s_timerData[0]) * 0.0370370);

        // average time over 15 frames
        if(sceneDraws == 0)
        {
            s_noSwizzleTime += time;
            if(s_ticks % 15 == 14)
            {
                s_avgNoSwizzleTime = s_noSwizzleTime / 15;
                s_noSwizzleTime = 0;
            }
        }
        else
        {
            s_swizzleTime += time;
            if(s_ticks % 15 == 14)
            {
                s_avgSwizzleTime = s_swizzleTime / 15;
                s_swizzleTime = 0;
            }
        }
    }

    // DRAW G-BUFFERS
    BuffersPassDraw();

    // Set Demo Font state
    DEMOFontSetContextState();

    if(s_drawBuffers == TRUE)
    {
        // label g-buffers
        DEMOFontPrintf(3, 1, "DIFFUSE G-BUFFER");
        DEMOFontPrintf(3, 2, "R8G8B8A8_UNORM");
        DEMOFontPrintf(43, 1, "NORMAL G-BUFFER");
        DEMOFontPrintf(43, 2, "R10G10B10A2_SNORM");
        DEMOFontPrintf(3, 21, "POSITION G-BUFFER");
        DEMOFontPrintf(3, 22, "R11G11B10_FLOAT");
    }

    // display times
    DEMOFontPrintf(32, 21, "Render Time w/o swizzle: %d", s_avgNoSwizzleTime);
    DEMOFontPrintf(32, 22, "Render Time w/ swizzle: %d (%d%%)", s_avgSwizzleTime, (u32)(100 * (f32)s_avgSwizzleTime / (f32)s_avgNoSwizzleTime));

    DEMOGfxDoneRender();
}


// Render Geometry Info to G-Buffers
static void GeometryPassDraw(void)
{
    u32 uniformVSCount = 0;
    u32 uniformPSCount = 0;
        
    GX2SetColorBuffer(&GeometryPass.myColorBuffer[0], GX2_RENDER_TARGET_0);
    GX2SetColorBuffer(&GeometryPass.myColorBuffer[1], GX2_RENDER_TARGET_1);
    GX2SetColorBuffer(&GeometryPass.myColorBuffer[2], GX2_RENDER_TARGET_2);

    GX2SetViewport(0.0f, 0.0f, RENDERTARGET_WIDTH, RENDERTARGET_HEIGHT, 0.0f, 1.0f);
    GX2SetScissor(0, 0, RENDERTARGET_WIDTH, RENDERTARGET_HEIGHT);

    GX2ClearColor(&GeometryPass.myColorBuffer[0], 0.4f, 0.4f, 0.4f, 0.0f);
    GX2ClearColor(&GeometryPass.myColorBuffer[1], 0.0f, 0.0f, 0.0f, 0.0f);
    GX2ClearColor(&GeometryPass.myColorBuffer[2], 0.0f, 0.0f, 0.0f, 0.0f);
    GX2ClearDepthStencil(&DEMODepthBuffer, GX2_CLEAR_BOTH);

    DEMOGfxSetContextState();

    // Set Depth Stencil Control Register
    GX2SetDepthOnlyControl(GX2_ENABLE, GX2_ENABLE, GX2_COMPARE_LESS);

    GX2SetShaders(&GeometryPass.shaders.fetchShader,
                  GeometryPass.shaders.pVertexShader,
                  GeometryPass.shaders.pPixelShader);

    // Bind attribute buffers
    for (u32 attribSlot=0; attribSlot<MODEL_NUM_ATTRIBUTES; attribSlot++)
    {
        GX2UTSetAttributeBuffer(&GeometryPass.attribs[s_modelIdx].attributeBuffer[attribSlot], attribSlot, 0);
    }
    
    // Uniform Location Lookup
    GX2SetVertexUniformReg(GeometryPass.shaders.uniformsVS.location[uniformVSCount++], 4*4, GeometryPass.modelMtx44);
    GX2SetVertexUniformReg(GeometryPass.shaders.uniformsVS.location[uniformVSCount++], 4*4, GeometryPass.viewprojMtx44);

    GX2SetPixelUniformReg(GeometryPass.shaders.uniformsPS.location[uniformPSCount], 4, &GeometryPass.color);

    // Draw Model
    GX2UTDrawIndexed(GX2_PRIMITIVE_TRIANGLES, &GeometryPass.attribs[s_modelIdx].indexBuffer);
    
    GX2Invalidate(GX2_INVALIDATE_COLOR_BUFFER,
                  GeometryPass.myColorBuffer[0].surface.imagePtr,
                  GeometryPass.myColorBuffer[0].surface.imageSize );
    GX2Invalidate(GX2_INVALIDATE_COLOR_BUFFER,
                  GeometryPass.myColorBuffer[1].surface.imagePtr,
                  GeometryPass.myColorBuffer[1].surface.imageSize );
    GX2Invalidate(GX2_INVALIDATE_COLOR_BUFFER,
                  GeometryPass.myColorBuffer[2].surface.imagePtr,
                  GeometryPass.myColorBuffer[2].surface.imageSize );
    GX2Invalidate(GX2_INVALIDATE_TEXTURE,
                  LightingPass.myTextureBuffer[0].surface.imagePtr,
                  LightingPass.myTextureBuffer[0].surface.imageSize );
    GX2Invalidate(GX2_INVALIDATE_TEXTURE,
                  LightingPass.myTextureBuffer[1].surface.imagePtr,
                  LightingPass.myTextureBuffer[1].surface.imageSize );
    GX2Invalidate(GX2_INVALIDATE_TEXTURE,
                  LightingPass.myTextureBuffer[2].surface.imagePtr,
                  LightingPass.myTextureBuffer[2].surface.imageSize );

    if(s_drawBuffers == TRUE)
    {
        GX2Invalidate(GX2_INVALIDATE_TEXTURE,
                      BuffersPass.myTextureBuffer[0].surface.imagePtr,
                      BuffersPass.myTextureBuffer[0].surface.imageSize );
        GX2Invalidate(GX2_INVALIDATE_TEXTURE,
                      BuffersPass.myTextureBuffer[1].surface.imagePtr,
                      BuffersPass.myTextureBuffer[1].surface.imageSize );
        GX2Invalidate(GX2_INVALIDATE_TEXTURE,
                      BuffersPass.myTextureBuffer[2].surface.imagePtr,
                      BuffersPass.myTextureBuffer[2].surface.imageSize );
    }
}

// Draw Lit Models using G-Buffers
static void LightingPassDraw(void)
{
    u32 samplerPSCount = 0;
    u32 uniformPSCount = 0;
    
    // Render lit scene in bottom-right if drawing g-buffers or fullscreen otherwise
    if(s_drawBuffers == TRUE)
    {
        GX2SetViewport(SURFACE_WIDTH/2, SURFACE_HEIGHT/2, SURFACE_WIDTH/2, SURFACE_HEIGHT/2, 0.0f, 1.0f);
        GX2SetScissor(SURFACE_WIDTH/2, SURFACE_HEIGHT/2, SURFACE_WIDTH/2, SURFACE_HEIGHT/2);
    }
    else
    {
        GX2SetViewport(0.0f, 0.0f, SURFACE_WIDTH, SURFACE_HEIGHT, 0.0f, 1.0f);
        GX2SetScissor(0, 0, SURFACE_WIDTH, SURFACE_HEIGHT);
    }

    GX2SetColorBuffer(&DEMOColorBuffer, GX2_RENDER_TARGET_0);

    GX2ClearColor(&DEMOColorBuffer, 0.4f, 0.4f, 0.4f, 0.0f);

    // Set Depth Stencil Control Register
    GX2SetDepthOnlyControl(GX2_DISABLE, GX2_DISABLE, GX2_COMPARE_NEVER);

    DEMOGfxSetContextState();

    GX2SetShaders(&LightingPass.shaders.fetchShader,
                  LightingPass.shaders.pVertexShader,
                  LightingPass.shaders.pPixelShader);

    // Bind attribute buffers
    for (u32 attribSlot=0; attribSlot<G_BUFFER_NUM_ATTRIBUTES; attribSlot++)
    {
        GX2UTSetAttributeBuffer(&LightingPass.attribs.attributeBuffer[attribSlot], attribSlot, 0);
    }
    
    // ------------------------------------------------------------

    GX2InitTexturePtrs(&LightingPass.myTextureBuffer[0], GeometryPass.myColorBuffer[0].surface.imagePtr, 0);
    GX2InitTexturePtrs(&LightingPass.myTextureBuffer[1], GeometryPass.myColorBuffer[1].surface.imagePtr, 0);
    GX2InitTexturePtrs(&LightingPass.myTextureBuffer[2], GeometryPass.myColorBuffer[2].surface.imagePtr, 0);

    GX2SetPixelTexture(&LightingPass.myTextureBuffer[0], LightingPass.shaders.samplersPS.location[samplerPSCount]);
    GX2SetPixelSampler(&LightingPass.mySampler,          LightingPass.shaders.samplersPS.location[samplerPSCount]);
    samplerPSCount += 1;
    GX2SetPixelTexture(&LightingPass.myTextureBuffer[1], LightingPass.shaders.samplersPS.location[samplerPSCount]);
    GX2SetPixelSampler(&LightingPass.mySampler,          LightingPass.shaders.samplersPS.location[samplerPSCount]);
    samplerPSCount += 1;    
    GX2SetPixelTexture(&LightingPass.myTextureBuffer[2], LightingPass.shaders.samplersPS.location[samplerPSCount]);
    GX2SetPixelSampler(&LightingPass.mySampler,          LightingPass.shaders.samplersPS.location[samplerPSCount]);
    
    // Uniform Location Lookup
    GX2SetPixelUniformReg(LightingPass.shaders.uniformsPS.location[uniformPSCount], 4, &LightingPass.ambientColor);
    uniformPSCount += 1;
    GX2SetPixelUniformReg(LightingPass.shaders.uniformsPS.location[uniformPSCount], 4, &LightingPass.lightColor);
    uniformPSCount += 1;
    GX2SetPixelUniformReg(LightingPass.shaders.uniformsPS.location[uniformPSCount], 4, &LightingPass.lightPosition);
    uniformPSCount += 1;
    GX2SetPixelUniformReg(LightingPass.shaders.uniformsPS.location[uniformPSCount], 4, &LightingPass.cameraPosition);
    
    // -----------------------
    // Draw quad
    GX2UTDrawIndexed(GX2_PRIMITIVE_QUADS, &LightingPass.attribs.indexBuffer);

}

// Draw G-Buffers used for Lighting
static void BuffersPassDraw(void)
{
    u32 samplerPSCount = 0;
    u32 uniformVSCount = 0;
    
    f32 mOffset[4] = { 0.0f, 0.0f, 0.0f, 0.0f };

    if(s_drawBuffers == FALSE)
        return;

    GX2SetColorBuffer(&DEMOColorBuffer, GX2_RENDER_TARGET_0);

    GX2SetViewport(0.0f, 0.0f, SURFACE_WIDTH, SURFACE_HEIGHT, 0.0f, 1.0f);
    GX2SetScissor(0, 0, SURFACE_WIDTH, SURFACE_HEIGHT);

    DEMOGfxSetContextState();

    GX2SetShaders(&BuffersPass.shaders.fetchShader,
                  BuffersPass.shaders.pVertexShader,
                  BuffersPass.shaders.pPixelShader);

    // Bind attribute buffers
    for (u32 attribSlot=0; attribSlot<G_BUFFER_NUM_ATTRIBUTES; attribSlot++)
    {
        GX2UTSetAttributeBuffer(&BuffersPass.attribs.attributeBuffer[attribSlot], attribSlot, 0);
    }
    
    // ------------------------------------------------------------

    mOffset[0] = -0.5f;
    mOffset[1] =  0.5f;

    // Uniform Location Lookup
    GX2SetVertexUniformReg(BuffersPass.shaders.uniformsVS.location[uniformVSCount], 4, mOffset);
    
    GX2InitTexturePtrs(&BuffersPass.myTextureBuffer[0],
                       GeometryPass.myColorBuffer[0].surface.imagePtr, 0);

    GX2SetPixelTexture(&BuffersPass.myTextureBuffer[0], BuffersPass.shaders.samplersPS.location[samplerPSCount]);
    GX2SetPixelSampler(&BuffersPass.mySampler,          BuffersPass.shaders.samplersPS.location[samplerPSCount]);
    // -----------------------
    // Draw quad
    GX2UTDrawIndexed(GX2_PRIMITIVE_QUADS, &BuffersPass.attribs.indexBuffer);
    
    // ------------------------------------------------------------

    mOffset[0] =  0.5f;
    mOffset[1] =  0.5f;

    // Uniform Location Lookup
    GX2SetVertexUniformReg(BuffersPass.shaders.uniformsVS.location[uniformVSCount], 4, mOffset);

    GX2InitTexturePtrs(&BuffersPass.myTextureBuffer[1],
                       GeometryPass.myColorBuffer[1].surface.imagePtr, 0);

    GX2SetPixelTexture(&BuffersPass.myTextureBuffer[1], BuffersPass.shaders.samplersPS.location[samplerPSCount]);
    GX2SetPixelSampler(&BuffersPass.mySampler,          BuffersPass.shaders.samplersPS.location[samplerPSCount]);
    // -----------------------
    // Draw quad
    GX2UTDrawIndexed(GX2_PRIMITIVE_QUADS, &BuffersPass.attribs.indexBuffer);

    // ------------------------------------------------------------

    mOffset[0] = -0.5f;
    mOffset[1] = -0.5f;

    // Uniform Location Lookup
    GX2SetVertexUniformReg(BuffersPass.shaders.uniformsVS.location[uniformVSCount], 4, mOffset);

    GX2InitTexturePtrs(&BuffersPass.myTextureBuffer[2],
                       GeometryPass.myColorBuffer[2].surface.imagePtr, 0);

    GX2SetPixelTexture(&BuffersPass.myTextureBuffer[2], BuffersPass.shaders.samplersPS.location[samplerPSCount]);
    GX2SetPixelSampler(&BuffersPass.mySampler,          BuffersPass.shaders.samplersPS.location[samplerPSCount]);
    // -----------------------
    // Draw quad
    GX2UTDrawIndexed(GX2_PRIMITIVE_QUADS, &BuffersPass.attribs.indexBuffer);
}

#ifndef TEST_MAIN
#define TEST_MAIN main
#endif

int TEST_MAIN(int argc, char **argv)
{
    DEMOInit();
    DEMOTestInit(argc, argv);
    DEMOGfxInit(argc, argv);
    DEMOFontInit();

    SceneInit();
    while(DEMOIsRunning())
    {
        SceneDraw();
        SceneUpdate();
    }
    GX2DrawDone();
    SceneFree();

    DEMOFontShutdown();
    DEMOGfxShutdown();
    DEMOShutdown();
    return DEMOTestResult();
}