Renderer.cpp

#include "Renderer.h"

Renderer::Renderer(){
    WHBLogPrintf("New Renderer");
    GX2InitSampler(&this->sampler, GX2_TEX_CLAMP_MODE_WRAP, GX2_TEX_XY_FILTER_MODE_POINT);
    GX2InitSamplerLOD(&this->sampler, 0, 13, -3.0f);
}

Renderer::~Renderer(){
    WHBLogPrintf("Destroy Renderer");
    for(unsigned int i = 0; i < this->vertexBuffers.size(); i++) GX2RDestroyBufferEx(this->vertexBuffers.at(i), (GX2RResourceFlags) 0);
    for(unsigned int i = 0; i < this->texCoordBuffers.size(); i++) GX2RDestroyBufferEx(this->texCoordBuffers.at(i), (GX2RResourceFlags) 0);
    for(unsigned int i = 0; i < this->shaderGroups.size(); i++) WHBGfxFreeShaderGroup(this->shaderGroups.at(i));
}

void Renderer::loadVertexData(float vertexData[]){
    WHBLogPrintf("Load Vertex Data");
    GX2RBuffer positionBuffer;
    void *buffer = NULL;
    positionBuffer.flags = (GX2RResourceFlags)(GX2R_RESOURCE_BIND_VERTEX_BUFFER |
                        GX2R_RESOURCE_USAGE_CPU_READ |
                        GX2R_RESOURCE_USAGE_CPU_WRITE |
                        GX2R_RESOURCE_USAGE_GPU_READ);
    positionBuffer.elemSize = 3 * sizeof(float);
    positionBuffer.elemCount = (sizeof(&vertexData) / sizeof(float)) / 3;
    GX2RCreateBuffer(&positionBuffer);
    buffer = GX2RLockBufferEx(&positionBuffer, (GX2RResourceFlags)0);
    memcpy(buffer, vertexData, positionBuffer.elemSize * positionBuffer.elemCount);
    GX2RUnlockBufferEx(&positionBuffer, (GX2RResourceFlags)0);
    this->vertexBuffers.push_back(&positionBuffer);
}

void Renderer::loadTexCoordData(float texCoordData[]){
    WHBLogPrintf("Load Tex Coord Data");
    GX2RBuffer texCoordBuffer;
    void *buffer = NULL;
    texCoordBuffer.flags = (GX2RResourceFlags)(GX2R_RESOURCE_BIND_VERTEX_BUFFER |
                            GX2R_RESOURCE_USAGE_CPU_READ |
                            GX2R_RESOURCE_USAGE_CPU_WRITE |
                            GX2R_RESOURCE_USAGE_GPU_READ);
    texCoordBuffer.elemSize = 2 * sizeof(float);
    texCoordBuffer.elemCount = (sizeof(&texCoordData) / sizeof(float)) / 2;
    GX2RCreateBuffer(&texCoordBuffer);
    buffer = GX2RLockBufferEx(&texCoordBuffer, (GX2RResourceFlags)0);
    memcpy(buffer, texCoordData, texCoordBuffer.elemSize * texCoordBuffer.elemCount);
    GX2RUnlockBufferEx(&texCoordBuffer, (GX2RResourceFlags)0);
    this->texCoordBuffers.push_back(&texCoordBuffer);
}

void Renderer::loadShaderGroup(char* filePath){
    WHBLogPrintf("Load Shader Group");
}

void Renderer::loadTexture(char* path){
    Texture t;
    t.load(path);
    this->textures.push_back(&t);
}

void Renderer::setActiveVertexBuffer(int vertexBufferID){
    WHBLogPrintf("Set Active Vertex Buffer");
    this->activeVertexBuffer = vertexBufferID;
}

void Renderer::setActiveTexCoordBuffer(int texCoordBufferID){
    WHBLogPrintf("Set Active Tex Coord Buffer");
    this->activeTexCoordBuffer = texCoordBufferID;
}

void Renderer::setActiveShader(int shaderID){
    WHBLogPrintf("Set Active Shader Group");
    this->activeShaderGroup = shaderID;
}

void Renderer::setActiveTexture(int texID){
    this->activeTexture = texID;
}

void Renderer::prepare3DTV(){
    WHBLogPrintf("Prepare 3D(TV)");
    this->projection = glm::perspective(degToRad(45.0f), (float)1280 / (float)720, NEAR_PLANE, FAR_PLANE);
}

void Renderer::prepare2DTV(){
    WHBLogPrintf("Prepare 2D(TV)");
    this->projection = glm::ortho(0.0f, 1280.0f, 720.0f, 0.0f, -1.0f, 1.0f);
}

void Renderer::prepare3DDRC(){
    WHBLogPrintf("Prepare 3D(DRC)");
    this->projection = glm::perspective(degToRad(45.0f), (float)854 / (float)480, NEAR_PLANE, FAR_PLANE);
}

void Renderer::prepare2DDRC(){
    WHBLogPrintf("Prepare 2D(DRC)");
    this->projection = glm::ortho(0.0f, 854.0f, 480.0f, 0.0f, -1.0f, 1.0f);
}

void Renderer::startTV(){
    WHBLogPrintf("Start TV Render");
    WHBGfxBeginRenderTV();
}

void Renderer::startDRC(){
    WHBLogPrintf("Start DRC Render");
    WHBGfxBeginRenderDRC();
}

void Renderer::endTV(){
    WHBLogPrintf("End TV Render");
    WHBGfxFinishRenderTV();
}

void Renderer::endDRC(){
    WHBLogPrintf("End DRC Render");
    WHBGfxFinishRenderDRC();
}

void Renderer::renderTexture(){
    WHBLogPrintf("Render Textured Triangles");
    this->mvp = this->projection * this->view;
    this->mvp = this->mvp * this->model;
    GX2SetColorControl(GX2_LOGIC_OP_COPY, 0xFF, FALSE, TRUE);
    GX2SetBlendControl(GX2_RENDER_TARGET_0,
        /* RGB = [srcRGB * srcA] + [dstRGB * (1-srcA)] */
        GX2_BLEND_MODE_SRC_ALPHA, GX2_BLEND_MODE_INV_SRC_ALPHA,
        GX2_BLEND_COMBINE_MODE_ADD,
        TRUE,
        /* A = [srcA * 1] + [dstA * (1-srcA)] */
        GX2_BLEND_MODE_ONE, GX2_BLEND_MODE_INV_SRC_ALPHA,
        GX2_BLEND_COMBINE_MODE_ADD);
    WHBGfxClearColor(0.5f, 0.5f, 1.0f, 1.0f);
    GX2SetCullOnlyControl(GX2_FRONT_FACE_CCW, FALSE, TRUE);
    GX2SetFetchShader(&this->shaderGroups.at(this->activeShaderGroup)->fetchShader);
    GX2SetVertexShader(this->shaderGroups.at(this->activeShaderGroup)->vertexShader);
    GX2SetPixelShader(this->shaderGroups.at(this->activeShaderGroup)->pixelShader);
    GX2RSetAttributeBuffer(this->vertexBuffers.at(this->activeVertexBuffer), 0, this->vertexBuffers.at(this->activeVertexBuffer)->elemSize, 0);
    GX2RSetAttributeBuffer(this->texCoordBuffers.at(this->activeTexCoordBuffer), 1, this->vertexBuffers.at(this->activeVertexBuffer)->elemSize, 0);
    this->textures.at(this->activeTexture)->mapTo(0);
    GX2SetPixelSampler(&this->sampler, 0);
    GX2SetVertexUniformReg(this->shaderGroups.at(this->activeShaderGroup)->vertexShader->uniformVars[0].offset, 16, (uint32_t *)&this->mvp[0][0]);
    GX2DrawEx(GX2_PRIMITIVE_MODE_TRIANGLES, (64*64)*6, 0, 1);
}

void Renderer::renderLines(){
    WHBLogPrintf("Render Lines\n");
}