source: trunk/orbital/orbital.cpp @ 1520 Tweet

//
// Orbital
//
// Copyright: (c) 2009-2012 Cédric Lecacheur <jordx@free.fr>
//            (c) 2009-2012 Benjamin Huet <huet.benjamin@gmail.com>
//            (c) 2012 Sam Hocevar <sam@hocevar.net>
//

#if defined HAVE_CONFIG_H
#   include "config.h"
#endif

#if defined _WIN32
#   include <direct.h>
#endif

#if defined _XBOX
#   define _USE_MATH_DEFINES /* for M_PI */
#   include <xtl.h>
#   undef near /* Fuck Microsoft */
#   undef far /* Fuck Microsoft again */
#elif defined _WIN32
#   define _USE_MATH_DEFINES /* for M_PI */
#   define WIN32_LEAN_AND_MEAN
#   include <windows.h>
#   undef near /* Fuck Microsoft */
#   undef far /* Fuck Microsoft again */
#else
#   include <cmath>
#endif

#if USE_SDL && defined __APPLE__
#   include <SDL_main.h>
#endif

#include "core.h"
#include "loldebug.h"

using namespace lol;

#include "orbital.h"

Orbital::Orbital(bool editor)
  : m_model(1.f),
    m_stick(0),
    m_angle(0.f),
    m_zoom(5.f),
    m_editor(editor)
{
#if 0
    int max_x = 20;
    int max_y = 20;
    for (int j = 0; j < max_x; j++)
    {
        for (int i = 0; i < max_y; i++)
        {
            m.Compile(((i + j) % 2) ? "sc.0,.1,.2,1,scb.0,.1,.2,1"
                                        : "sc.0,.0,.1,1,scb.0,.0,.1,1");
            m.Compile("ac4,2,44,40,0,0,ty-1,ad4,40,0,ry45");
            m.Scale(vec3(std::sqrt(0.5f)));
            m.Translate(vec3(   i * 44 - (44 * (max_x * 0.5f)), 0,
                                j * 44 - (44 * (max_y * 0.5f))));
            m.Flush();
        }
    }
#endif

#if 0
    /* Yellow sphere */
    m.Compile("sc1,1,0,1,asph10,30,20,24");
    m.Compile("t0,0,60,fl");

    /* Pink box */
    m.Compile("sc1,0,1,1,afcb10,10,10,1,rx45,rz45");
    m.Compile("t-20,20,0,fl");

    /* Large meteor */
    m.Compile("sc0,0,0.3,1,afcb30,30,30,5,ry45,rx45,afcb30,30,30,5");
    m.Compile("t40,40,0,fl");

    /* Orange/white alien */
    m.Compile("sc1,0.7,0,1,afcb12,3,10,0.4,tz3,sc1,1,1,1,afcb2,10,10,0.4");
    m.Compile("t0,40,-20,fl");
    //m.Compile("rx20,ry30,t0,40,-20,fl");

    /* Orange fire */
    m.Compile("sc1,1,0,1,scb1,0,0,0,at4,1,s1.5,1,4,tz-13,ad6,5.8,1");
    m.Compile("t-40,40,0,fl");

    /* Lasers */
    m.Compile("sc1,1,1,1,scb0,0,0,1,aq8,1,sx0.25,tx-3,sc1,0,0,1,scb0,0,0,1,aq8,1,tx4,sz50,sx0.3,tz-200,mx,as10,12,8,1,1,ty60,fl");
#endif

    //m_particlesystem = new ParticleSystem();
    //Ticker::Ref(m_particlesystem);

    m_small_stars = new StarField(100, 1.f, 20.f);
    Ticker::Ref(m_small_stars);
    m_large_stars = new StarField(100, 2.f, 10.f);
    Ticker::Ref(m_large_stars);

    /* Create a camera that matches the settings of XNA Orbital */
    m_camera = new Camera(vec3(0.f, 600.f, 50.f),
                          vec3(0.f, 0.f, 50.f),
                          vec3(0, 0, -1));
    m_camera->SetRotation(quat::fromeuler_yxz(0.f, -30.f, 0.f));
    m_camera->SetOrtho(1280.f / 3, 960.f / 3, -1000.f, 1000.f);
    Ticker::Ref(m_camera);

    if (m_editor)
    {
        /* Grey/red bonus */
        //m.Compile("[sc#9ac afcb7 4 7 0.6 sc#f04 afcb4 7 4 0.6]");
        #if 0
        m.Compile("sc#d91"
                  "[afcb30 3 3 .8]"
                  "sc#cca"
                  "[afcb10 10 10 1]"
                  "[afcb.4 .4 12 .4 tz3 tx8 mx]"
                  "[afcb.4 .4 12 .4 tz3 tx12 mx]"
                  "sc#69c9"
                  "[afcb5 8 8 1 ty3 tz3]");
         #endif
         m.Compile("sc#f00 scb#f00 [acg10 5 8 8 2 2 0 0 ch.4]");
    }
    else
    {
        /* Add tanks */
        for (int j = 0; j < 2; j++)
        for (int i = 0; i < 2; i++)
        {
            m_tanks << new Tank();
            m_tanks.Last()->m_position = vec3(i * 80.f, 0, j * 80.f + 120.f);
            m_tanks.Last()->SetTarget(vec3(i * 160.f - 200.f, 0, j * 160.f - 130.f));
            Ticker::Ref(m_tanks.Last());
        }

        //m_snakes.Push(new Snake(3));
        //Ticker::Ref(m_snakes.Last());
        //m_snakes.Push(new Snake(8));
        //Ticker::Ref(m_snakes.Last());
        m_snakes.Push(new Snake(33));
        Ticker::Ref(m_snakes.Last());

        /* Add players */
        for (int i = 0; i < 2; i++)
        {
            m_players << new Player(i);
            Ticker::Ref(m_players.Last());
        }
    }

        m_Lolnament = NULL;//new Lolnament();
        Ticker::Ref(m_Lolnament);

    m_ready = false;
}

void Orbital::TickGame(float seconds)
{
    WorldEntity::TickGame(seconds);

    if (Input::GetButtonState(27 /*SDLK_ESCAPE*/))
        Ticker::Shutdown();

#if 0
    if (m_auto_cam_timer > 0.0f)
        m_auto_cam_timer -= seconds;

    //Doing the query with actual values, cause I want to stay SDL-free for now.

    int HMovement = Input::GetButtonState(275 /*SDLK_RIGHT*/) - Input::GetButtonState(276 /*SDLK_LEFT*/);
    int VMovement = Input::GetButtonState(274 /*SDLK_DOWN*/) - Input::GetButtonState(273 /*SDLK_UP*/);
    int RMovement = Input::GetButtonState(280 /*SDLK_PAGEUP*/) - Input::GetButtonState(281 /*SDLK_PAGEDOWN*/);

    vec3 new_angular_velocity = vec3(0.0f);

    if (VMovement != 0 || HMovement != 0 || RMovement != 0)
    {
        new_angular_velocity = vec3(HMovement, VMovement, RMovement) * 50.0f;
        m_auto_cam_timer = 2.0f;
    }
    else if (m_auto_cam_timer <= 0.0f)
    {
        /* Order is yaw, pitch, roll */
        new_angular_velocity = clamp(-m_angle, vec3(40.f, -20.f, -40.f),
                                               vec3(40.f,  20.f,  40.f));
    }

    m_angular_velocity += (new_angular_velocity - m_angular_velocity)
                          * (seconds / (seconds + 0.3f));
    m_angle += m_angular_velocity * seconds;

    /* TODO: implement "vec3 % float" or "fmod(vec3, float)" */
    for (int n = 0; n < 3; n++)
    {
        if (m_angle[n] > 180.f)
            m_angle[n] -= 360.f;
        else if (m_angle[n] < -180.f)
            m_angle[n] += 360.f;
    }

    /* Yaw around Y, Pitch around X, Roll around Z. Since it's the camera
     * we want to move, use the inverse transform. */
    mat4 anim = mat4(1.f / quat::fromeuler_yxz(m_angle));
#endif

#if 0
    vec3 new_camera_pos = vec3(0,0,0);

    for (int i = 0; i < m_tanks.Count(); i++)
        new_camera_pos += m_tanks[i]->m_position;
    for (int i = 0; i < m_snakes.Count(); i++)
        new_camera_pos += m_snakes[i]->GetBarycenter();
    for (int i = 0; i < m_players.Count(); i++)
        new_camera_pos += m_players[i]->m_position;

    new_camera_pos /= (float)(m_players.Count() + m_tanks.Count() + m_snakes.Count());
    new_camera_pos += vec3(0.f, 0.f, -50.f);

    new_camera_pos = m_camera->GetTarget() + (new_camera_pos - m_camera->GetTarget()) * (seconds / (seconds + 0.15f));
    m_camera->SetPosition(new_camera_pos + vec3(0.f, 600.f, 0.f));
    m_camera->SetTarget(new_camera_pos);
#endif

    if (m_editor)
    {
        float rightleft = 0.f, updown = 0.f, inout = 0.f;

        if (!m_stick)
            m_stick = Input::TrackStick();
        if (m_stick && m_stick->GetAxisCount() >= 4)
        {
            rightleft += 1.f * m_stick->GetAxis(2);
            updown += -1.f * m_stick->GetAxis(3);
            inout += -1.f * m_stick->GetAxis(1);
        }

        if (rightleft * rightleft + updown * updown > 0.2f)
        {
            float angle = lol::atan2(updown, rightleft);
            angle = (int)(angle / ((float)M_PI / 4.f) + 8.5f) * ((float)M_PI / 4.f);
            rightleft = lol::cos(angle);
            updown = lol::sin(angle);
        }
        else
        {
            rightleft = updown = 0.f;
        }

        m_model = mat4::fromeuler_zyx(0.f, 5.f * rightleft, 5.f * updown)
                   * m_model;
        m_zoom *= 1.f + seconds * 0.8f * inout;
        if (m_zoom > 10.f) m_zoom = 10.f;
        else if (m_zoom < 0.1f) m_zoom = 0.1f;
        m_angle += 50.f * seconds;
    }
    else
    {
    }
}

void Orbital::TickDraw(float seconds)
{
    WorldEntity::TickDraw(seconds);

    if (!m_ready)
    {
        m.MeshConvert();

        /* FIXME: this object never cleans up */
        m_ready = true;
    }

    Video::SetClearColor(vec4(0.0f, 0.0f, 0.12f, 1.0f));

    if (m_editor)
    {
        mat4 anim1 = mat4::rotate(m_angle, vec3(1.f, 0.f, 0.f));
        mat4 anim2 = mat4::rotate(m_angle, vec3(0.f, 1.f, 0.f));
        mat4 anim3 = mat4::rotate(m_angle, vec3(0.f, 0.f, 1.f));

        m.Render(mat4::scale(vec3(m_zoom))
                  * mat4::translate(0.f, 10.f, 10.f)
                  * m_model);

        m.Render(mat4::translate(-150.f, -350.f, 0.f) * anim1);
        m.Render(mat4::translate(-150.f, -200.f, 0.f) * anim2);
        m.Render(mat4::translate(-150.f, -50.f, 0.f) * anim3);
        m.Render(mat4::translate(-150.f, 100.f, 0.f));
    }
}

Orbital::~Orbital()
{
    for (int i = 0; i < m_tanks.Count(); i++)
        Ticker::Unref(m_tanks[i]);
    for (int i = 0; i < m_players.Count(); i++)
        Ticker::Unref(m_players[i]);
    for (int i = 0; i < m_snakes.Count(); i++)
        Ticker::Unref(m_snakes[i]);
    if (m_stick)
        Input::UntrackStick(m_stick);
    //Ticker::Unref(m_particlesystem);
    Ticker::Unref(m_small_stars);
    Ticker::Unref(m_large_stars);
    Ticker::Unref(m_camera);
    Ticker::Unref(m_Lolnament);
}

int main(int argc, char **argv)
{
    //Application app("Orbital", ivec2(1280, 720), 60.0f);
    Application app("Orbital", ivec2(800, 600), 60.0f);

#if defined _MSC_VER && !defined _XBOX
    _chdir("..");
#elif defined _WIN32 && !defined _XBOX
    _chdir("../..");
#endif

    //new DebugFps(5, 5);
    new Orbital(argc > 1);
    app.ShowPointer(false);

    app.Run();

    return EXIT_SUCCESS;
}