/*
 * Copyright 2008, Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Alexandre Deckner <alex@zappotek.com>
 */

#include "RenderView.h"

#include "BitmapTexture.h"
#include "Camera.h"
#include "MeshInstance.h"
#include "StaticMesh.h"
#include "VideoFileTexture.h"

#include <GL/gl.h>
#include <GL/glu.h>

#include <TranslationKit.h>
#include <TranslationUtils.h>

#include <stdio.h>

RenderView::RenderView(BRect frame)
        :
        BGLView(frame, "renderView", B_FOLLOW_ALL, B_WILL_DRAW,
                BGL_RGB | BGL_DOUBLE | BGL_DEPTH),
        fMainCamera(NULL),
        fRenderThread(-1),
        fStopRendering(false),
        fRes(0, 0),
        fNextRes(0, 0),
        fLastFrameTime(0)
{
}


RenderView::~RenderView()
{
}


void
RenderView::AttachedToWindow()
{
        BGLView::AttachedToWindow();

        _CreateScene();
        _InitGL();
        if (_CreateRenderThread() != B_OK)
                printf("Error trying to start the render thread!\n");
}


void
RenderView::DetachedFromWindow()
{
        _StopRenderThread();
        _DeleteScene();

        BGLView::DetachedFromWindow();
}


uint32
RenderView::_CreateRenderThread()
{
        fRenderThread = spawn_thread(RenderView::_RenderThreadEntry, "renderThread",
                B_NORMAL_PRIORITY, this);

        if (fRenderThread < 0)
                return fRenderThread;

        return resume_thread(fRenderThread);
}


void
RenderView::_StopRenderThread()
{
        LockGL();
        fStopRendering = true;
        UnlockGL();

        if (fRenderThread >= 0)
                wait_for_thread(fRenderThread, NULL);
}


int32
RenderView::_RenderThreadEntry(void* pointer)
{
        return reinterpret_cast<RenderView*>(pointer)->_RenderLoop();
}


int32
RenderView::_RenderLoop()
{
        fLastFrameTime = system_time();

        while (_Render()) {
                snooze(10000);
        }
        return B_OK;
}


void RenderView::_InitGL(void)
{
        LockGL();

        float position[] = {0.0, 3.0, 6.0, 0.0};
        float local_view[] = {0.0, 0.0};

        glLightfv(GL_LIGHT0, GL_POSITION, position);
        glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, local_view);

        float white[3] = {1.0, 1.0, 1.0};

        glEnable(GL_LIGHT0);
        glLightfv(GL_LIGHT0, GL_SPECULAR, white);
        glLightfv(GL_LIGHT0, GL_DIFFUSE, white);
        glLightfv(GL_LIGHT0, GL_AMBIENT, white);

        glMaterialf(GL_FRONT, GL_SHININESS, 0.6 * 128.0);

        glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
        glEnable(GL_CULL_FACE);
        glEnable(GL_DEPTH_TEST);
        glEnable(GL_LIGHTING);
        glEnable(GL_TEXTURE_2D);

        fNextRes.Set(Bounds().Width(), Bounds().Height());
        _UpdateViewport();

        UnlockGL();
}


void
RenderView::_CreateScene()
{
        LockGL();

        Texture* texture = new BitmapTexture(
                BTranslationUtils::GetBitmap(B_PNG_FORMAT, "texture"));

        float spacing = 1.6f;
        float timeSpacing = 5.0f;
        float yOffset = -1.0f;
        float zOffset = -16;

        Mesh* mesh = new StaticMesh("LetterH");
        MeshInstance* instance = new MeshInstance(mesh, texture,
                Vector3(-3.6 * spacing, yOffset, zOffset),
                Quaternion(0, 0, 0, 1), 0.0f);
        fMeshInstances.push_back(instance);
        mesh->ReleaseReference();

        mesh = new StaticMesh("LetterA");
        instance = new MeshInstance(mesh, texture,
                Vector3(-1.6 * spacing, yOffset, zOffset),
                Quaternion(0, 0, 0, 1), 1.0f * timeSpacing);
        fMeshInstances.push_back(instance);
        mesh->ReleaseReference();

        mesh = new StaticMesh("LetterI");
        instance = new MeshInstance(mesh, texture,
                Vector3(0 * spacing, yOffset, zOffset),
                Quaternion(0, 0, 0, 1), 2.0f * timeSpacing);
        fMeshInstances.push_back(instance);
        mesh->ReleaseReference();

        mesh = new StaticMesh("LetterK");
        instance = new MeshInstance(mesh, texture,
                Vector3(1.5 * spacing, yOffset, zOffset),
                Quaternion(0, 0, 0, 1), 3.0f * timeSpacing);
        fMeshInstances.push_back(instance);
        mesh->ReleaseReference();

        mesh = new StaticMesh("LetterU");
        instance = new MeshInstance(mesh, texture,
                Vector3(3.4 * spacing, yOffset, zOffset),
                Quaternion(0, 0, 0, 1), 4.0f * timeSpacing);
        fMeshInstances.push_back(instance);
        mesh->ReleaseReference();
        texture->ReleaseReference();

        fMainCamera = new Camera(Vector3(0, 0, 0), Quaternion(0, 0, 0, 1), 50);

        UnlockGL();
}


void
RenderView::_DeleteScene()
{
        LockGL();

        MeshInstanceList::iterator it = fMeshInstances.begin();
        for (; it != fMeshInstances.end(); it++) {
                delete (*it);
        }
        fMeshInstances.clear();

        UnlockGL();
}


void
RenderView::_UpdateViewport()
{
        if (fNextRes != fRes && fNextRes.x >= 1.0 && fNextRes.y >= 1.0) {
                glViewport(0, 0, (GLint) fNextRes.x + 1, (GLint) fNextRes.y + 1);
                fRes = fNextRes;
                _UpdateCamera();
        }
}


void
RenderView::_UpdateCamera()
{
        // TODO: take camera orientation into account
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(fMainCamera->FieldOfView(), fNextRes.x / fNextRes.y,
                fMainCamera->Near(), fMainCamera->Far());
        glMatrixMode(GL_MODELVIEW);
}


bool
RenderView::_Render()
{
        LockGL();

        _UpdateViewport();

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glLoadIdentity();

        bigtime_t time = system_time();
        float deltaTime = 0.000001 * (float)(time - fLastFrameTime);
        fLastFrameTime = time;

        MeshInstanceList::iterator it = fMeshInstances.begin();
        for (; it != fMeshInstances.end(); it++) {
                (*it)->Update(deltaTime);
                (*it)->Render();
        }

        if (fStopRendering) {
                UnlockGL();
                return false;
        }
        SwapBuffers(false); // true = vsync
        UnlockGL();
        return true;
}


void
RenderView::FrameResized(float width, float height)
{
        LockGL();
        fNextRes.Set(width, height);
        UnlockGL();
        BGLView::FrameResized(width, height);
}


void
RenderView::ErrorCallback(unsigned long error)
{
        fprintf(stderr, "OpenGL error (%lu): %s\n", error, gluErrorString(error));
}