complex.cpp

Go to the documentation of this file.

// Summary: More complex demo program for flatland.
// Copyright: 2007  Philip Rideout.  All rights reserved.
// License: see bsd-license.txt

#include <ode/ode.h>
#include "demo.hpp"
#include "os.h"

using namespace Demo;
using Flatland::pi;
using Flatland::aabb;
using Flatland::ContactList;

class ComplexApp : public App
{
  public:
    ComplexApp(bool fullscreen);
    void InitWin();
    void InitGl();
    void Draw() const;
    void HandleEvents();
    void ProcessKeyState();
    void ToggleFullscreen();
    bool MouseMoved() const { return motion; }
    bool IsFullscreen() const { return fullscreen; }
    static int GetWidth(bool screen) { return screen ? osGetScreenWidth() : InitialWidth; }
    static int GetHeight(bool screen) { return screen ? osGetScreenHeight() : InitialHeight; }
    static const int InitialWidth = 1000;
    static const int InitialHeight = 600;
  private:
    void handle(const OS_Event &event);
    Texture helpTexture;
    Texture downTexture;
    Texture upTexture;
    Texture boostTexture;
    Texture wheelTexture;
    bool freeze;
    bool hover;
    bool pressed;
    bool fullscreen;
    bool motion;
    aabb scrollbox;
    vec2 scrolloffset;
    Wheel *wheel;
    Wheel *wheel2;
    dJointID motor;
    dJointID pendulumAnchor;
    dJointID bubbleAnchor;
    dJointID blockFeeder;
    dJointID squareWheelMotor;
    static void boostCallback(ContactList &contacts);
    static void pendulumCallback(ContactList &contacts);
    static void bubbleCallback(ContactList &contacts);
    static void feederCallback(ContactList &contacts);
};

/// Entry point.
int main(int argc, char** argv)
{
    // Instantiate the app object.
    const bool fullscreen = false;
    ComplexApp app(fullscreen);

    // Upper limit on draws per second.
    const float fps = 60;
    const unsigned int fDelay = (unsigned int) (1000.0f / fps);

    // Upper limit on simulation steps per second.
    const float sps = 1000;
    const unsigned int sDelay = (unsigned int) (1000.0f / sps);

    // Flags for upper limit on frames per second and steps per second.
    const bool capFps = true;
    const bool capSps = true;
    osWaitVsync(1);

    /// \note
    /// To capture movies with Fraps, set fps to 30 and comment out vsync.
    /// Don't forget to compress the movie with VirtualDub.

    // Simulation step size.
    const float delta = 0.25;

    // Delay before mouse cursor disappears when in fullscreen mode.
    const unsigned int mDelay = 2000;

    // Start the simulation loop. 
    unsigned int fTime, sTime, mTime;
    for (fTime = sTime = mTime = osGetMilliseconds();;)
    {
        // process all events
        app.HandleEvents();

        // obtain the current time
        unsigned int time = osGetMilliseconds();

        // draw the scene and do a page flip
        if (!capFps || time - fTime > fDelay)
        {
            app.Draw();
            osSwapBuffers();
            fTime = time;
        }

        // prevent the simulation from running too fast
        if (capSps && time - sTime < sDelay)
            continue;
        sTime = time;

        // update the simulation
        app.ProcessKeyState();
        app.Step(delta);
        app.UpdateCenter();

        // hide or show the mouse cursor if needed
        if (app.IsFullscreen())
        {
            if (app.MouseMoved())
            {
                mTime = time;
                if (!osShowCursor(OS_QUERY))
                    osShowCursor(OS_ENABLE);
            }
            else if (osShowCursor(OS_QUERY) && time - mTime > mDelay)
            {
                osShowCursor(OS_DISABLE);
            }
        }
    }

    return 0;
}

#define app (static_cast<ComplexApp&>(App::GetSingleton()))

/// Toggle fullscreen mode.  Stop and restart the graphics subsystems.
void ComplexApp::ToggleFullscreen()
{
    osQuit();
    fullscreen = !fullscreen;
    width = GetWidth(fullscreen);
    height = GetHeight(fullscreen);
    hover = false;
    InitWin();
    InitGl();
}

/// Handle all SDL events in the event queue.
void ComplexApp::HandleEvents()
{
    motion = false;
    OS_Event event;
    while (osPollEvent(&event))
        handle(event);
}

/// Handle a particular SDL event.
void ComplexApp::handle(const OS_Event &event)
{
    switch(event.type)
    {
        case OS_RESIZE:
            Resize(event.resize.width, event.resize.height);
            return;

        case OS_QUIT: exit(0);

        case OS_MOUSEBUTTONDOWN:
            pressed = hover && event.mouse.button == OS_BUTTON_LEFT;
            break;

        case OS_MOUSEBUTTONUP:
            if (event.mouse.button == OS_BUTTON_LEFT)
            {
                pressed = false;
                if (hover)
                    ToggleFullscreen();
            }
            break;

        case OS_MOUSEMOTION:
            if (osShowCursor(OS_QUERY))
            {
                hover = event.mouse.x < TextureWidth(upTexture) + 2;
                hover = hover && event.mouse.y < TextureHeight(upTexture);
            }
            pressed = hover && (event.mouse.button & OS_BUTTON_LEFT);
            motion = true;
            break;

        case OS_KEYDOWN:
            if (wheel && motor)
            {
                float speed = world.GetMotorVelocity(motor);
                if (speed > 0 && event.key.key == OSK_LEFT)
                {
                    world.SetMotorVelocity(motor, 0);
                    freeze = true;
                }
                else if (speed < 0 && event.key.key == OSK_RIGHT)
                {
                    world.SetMotorVelocity(motor, 0);
                    freeze = true;
                }
            }
            break;

        case OS_KEYUP:
            switch (event.key.key)
            {
                case 'x': case 'X': case 'q': case 'Q':
                case OSK_ESCAPE: exit(0); break;
                case OSK_LEFT: case OSK_RIGHT: freeze = false; break;
            }
            break;
    }
}

/// Handler for the keyboard state.
void ComplexApp::ProcessKeyState()
{
    if (osIsKeyDown(OSK_SHIFT))
    {
        const float d = 1;
        if (osIsKeyDown(OSK_LEFT)) scrolloffset.x -= d;
        else if (osIsKeyDown(OSK_RIGHT)) scrolloffset.x += d;
        else if (osIsKeyDown(OSK_UP)) scrolloffset.y -= d;
        else if (osIsKeyDown(OSK_DOWN)) scrolloffset.y += d;
    }
    else
    {
        scrolloffset = vec2(0, 0);
    }

    if (wheel && motor && !freeze && scrolloffset.x == 0 && scrolloffset.y == 0)
    {
        const float speed = world.GetMotorVelocity(motor);
        const float delta = 0.001f;
        const float max = 0.1f;

        if (osIsKeyDown(OSK_LEFT) && speed > -max)
            world.SetMotorVelocity(motor, speed - delta);
        else if (osIsKeyDown(OSK_RIGHT) && speed < max)
            world.SetMotorVelocity(motor, speed + delta);
    }

    if (wheel)
    {
        vec2 target = wheel->GetFlatlandObject()->GetGeometry().Center() - vec2(width / 2.0f, height * 0.75f);
        target += scrolloffset;

        if (target.x < scrollbox.left) target.x = scrollbox.left;
        if (target.x + width > scrollbox.right) target.x = scrollbox.right - width;
        if (target.y < scrollbox.top) target.y = scrollbox.top;
        if (target.y + height > scrollbox.bottom) target.y = scrollbox.bottom - height;

        SetTarget(target);
    }
}

void SetPastel(Object *object)
{
    float hue = 60;
    Color c(hue + (rand() % 90) - 45);
    object->Property().outlineColor = c;
    c.IncreaseBrightness(0.5);
    c.a = 0.9f;
    object->Property().fillColor = c;
}

void ComplexApp::Draw() const
{
    Clear();
    DrawScene();
    Blit(helpTexture, 500-128, 300-128);
    Blit(boostTexture, 1000, 3425);

    glLoadIdentity();
    if (osShowCursor(OS_QUERY))
        Blit(pressed ? downTexture : upTexture, 2, 0, Color(1,1,1,hover ? 1 : 0.25f));
}

/// Load textures.
void ComplexApp::InitGl()
{
    App::InitGl();

    helpTexture = LoadTexture("keys.rgba");
    downTexture = LoadTexture("down.rgba");
    upTexture = LoadTexture("up.rgba");
    boostTexture = LoadTexture("boost.rgba");
    wheelTexture = LoadTexture("wheel.rgba");
}

/// Create the window and the OpenGL context.
void ComplexApp::InitWin()
{
    osInit(InitialWidth, InitialHeight, fullscreen ? OS_FULLSCREEN : OS_RESIZABLE, 0);
}

/// Reaction callback for when the wheel touches the boost icon.
void ComplexApp::boostCallback(ContactList &contacts)
{
    if (contacts.Other() != app.wheel->GetFlatlandObject())
        return;

    if (app.world.GetMotorVelocity(app.motor) < 0)
        app.world.SetMotorVelocity(app.motor, -0.4f);
    if (app.world.GetMotorVelocity(app.motor) > 0)
        app.world.SetMotorVelocity(app.motor, 0.4f);
}

/// Reaction callback for when the wheel touches the cannonball.
void ComplexApp::pendulumCallback(ContactList &contacts)
{
    if (contacts.Other() != app.wheel->GetFlatlandObject() || !app.pendulumAnchor)
        return;

    app.world.DeleteJoint(app.pendulumAnchor);
    app.pendulumAnchor = 0;
}

/// Reaction callback for when the wheel touches the bubble.
void ComplexApp::bubbleCallback(ContactList &contacts)
{
    if (contacts.Other() != app.wheel->GetFlatlandObject() || !app.bubbleAnchor)
        return;

    app.world.DeleteJoint(app.bubbleAnchor);
    app.bubbleAnchor = 0;

    Flatland::Object &front = *app.wheel->GetFlatlandObject();
    Flatland::Object &back = *app.wheel2->GetFlatlandObject();
    front.Move();
    back.Move();
    vec2 start = front.GetGeometry().Center();
    vec2 end = back.GetGeometry().Center();
    Beam *beam = new Beam(start, end, 2);
    beam->GetFlatlandObject()->Property().collisionMask = 0;
    beam->GetFlatlandObject()->SetMass(0.01f);
    beam->Property().outlineThickness = 0;
    beam->Property().fillColor = Color(0.25f, 0.35f, 0.6f, 1);
    beam->InsertFront(app.space);

    app.world.Anchor(*beam->GetFlatlandObject(), front, start, 0, 0.01f);
    app.world.Anchor(*beam->GetFlatlandObject(), back, end, 0, 0.01f);
}

/// Reaction callback to start up the block feeder motor.
void ComplexApp::feederCallback(ContactList &contacts)
{
    if (contacts.Other() != app.wheel->GetFlatlandObject() && contacts.Other() != app.wheel2->GetFlatlandObject())
        return;

    app.world.SetMotorVelocity(app.blockFeeder, 0.035f);
    app.world.SetMotorVelocity(app.squareWheelMotor, -0.01f);
}

/// Initialize the app; construct the flatland scene.
ComplexApp::ComplexApp(bool full) : fullscreen(full), App(GetWidth(full), GetHeight(full))
{
    hover = false;
    freeze = false;
    pressed = false;
    wheel = 0;
    scrollbox = aabb(-250, -100, 5000, 5000);
    scrolloffset = vec2(0, 0);

    InitWin();
    InitGl();
    InitOde();

    Flatland::Object::Default().friction = 40;
    Demo::Object::Default().outlineThickness = 1;

    // Create the user-controlled wheel.
    float radius = 27;
    wheel = new Wheel(vec2(400, 475), radius);
    wheel->SetTexture(wheelTexture);
    wheel->GetFlatlandObject()->Property().frictionMask = 15;
    wheel->GetFlatlandObject()->Property().collisionMask = ~7;
    wheel->Insert(space);
    motor = world.AddMotor(*wheel->GetFlatlandObject());

    // Create the back wheel.
    float carLength = radius * 2.5f;
    vec2 center(3500, 890 - carLength);
    wheel2 = new Wheel(center, radius);
    wheel2->GetFlatlandObject()->SetMass(0.01f);
    wheel2->GetFlatlandObject()->Property().frictionMask = 7;
    wheel2->GetFlatlandObject()->Property().collisionMask = ~7;
    wheel2->SetTexture(wheelTexture);
    wheel2->Insert(space);
    Ball *bubble = new Ball(center, carLength);
    bubble->Property().outlineThickness = 3;
    bubble->Property().fillColor = Color(1,0,0,0.1f);
    bubble->GetFlatlandObject()->Property().collisionMask = 4;
    bubble->GetFlatlandObject()->Property().friction = dInfinity;
    bubble->GetFlatlandObject()->Property().callback = bubbleCallback;
    bubble->Insert(space);
    bubbleAnchor = Glue(bubble, wheel2);

    // Set up some colors for the terrains.
    Demo::Object::Default().outlineColor = Color::White;
    Demo::Object::Default().fillColor = Color(106/255.0f, 160/255.0f, 248/255.0f, 1);
    Demo::Object::Default().altFillColor = Color::White;

    // Northwest curl and ceiling
    Terrain *t = new Terrain(vec2(-250, 400), -100);
    for (float theta = 175; theta >= 0; theta -= 5)
        t->Add(vec2(50, 400) + vec2(300, 0).rotate(theta));
    t->Add(vec2(1000, 400));
    for (float theta = 230; theta <= 270; theta += 10)
        t->Add(vec2(1500, 750) + vec2(50, 0).rotate(theta));
    t->Add(vec2(2000, 800));
    for (float theta = 270; theta < 320; theta += 10)
        t->Add(vec2(2018, 750) + vec2(50, 0).rotate(theta));
    t->Add(vec2(2500, 400));
    t->Add(vec2(4100, 400));
    t->GetFlatlandObject()->Property().friction = dInfinity;
    t->Insert(space);

    // Starting terrain, with a rounded west edge
    t = new Terrain(vec2(0, 590), 1100);
    t->Add(vec2(950, 590));
    for (float theta = 80; theta >= 0; theta -= 10)
        t->Add(vec2(950, 640) + vec2(50, 0).rotate(theta));
    t->Insert(space);
    t->InsertEastBorder(space);
    space << new Line(vec2(1000, 900), vec2(1000, 3000));

    t = new Terrain(vec2(1000, 890), 1100);
    t->Add(vec2(1500, 890));
    t->Insert(space);

    t = new Terrain(vec2(2000, 890), 1100);
    t->Add(vec2(4000, 890));
    t->Insert(space);
    t->GetFlatlandObject()->Property().collisionMask = ~3;

    // Hang a rope between the two previous terrains.
    {
        Flatland::Object::PushProperties();
        Flatland::Object::Default().frictionMask = 7;
        vec2 start = vec2(1500, 890);
        vec2 end = vec2(2000, 890);
        float slack = 40;
        float length = end.x - start.x + slack;
        float tautness = 20000;
        float bottom = 1100;
        Rope *r = new Rope(start, end, length, tautness);
        r->Terrainify(bottom);
        r->Insert(space);
        Anchor(r->front(), start);
        Anchor(r->back(), end);
        Flatland::Object::PopProperties();
    }

    // Pendulum.
    {
        Flatland::Object::PushProperties();
        Object::PushProperties();

        Flatland::Object::Default().collisionMask = 3;
        Object::Default().fillColor = Color(0,0,0,1);
        Object::Default().outlineColor = Color(0.5f,0.7f,1,1);
        Object::Default().outlineThickness = 4;

        vec2 start = vec2(2720, 700);
        vec2 end = vec2(2670, 820);
        float thickness = 5;
        Beam *tether = new Beam(start, end, thickness);
        tether->Insert(space);

        float radius = 20;
        end = end + (end - start).hat() * radius;
        Flatland::Circle *cannonball = new Flatland::Circle(end, radius);
        tether->Add(cannonball);

        tether->GetFlatlandObject()->Property().callback = pendulumCallback;
        tether->GetFlatlandObject()->SetMass(100);
        tether->GetFlatlandObject()->Property().frictionMask = 0;

        Anchor(tether, start);
        pendulumAnchor = Anchor(tether, end);

        Flatland::Object::PopProperties();
        Object::PopProperties();
    }

    // Dominos
    for (int i = 0; i < 20; ++i)
    {
        Block *block = new Block(vec2(2750 + i * 30.0f, 890 - 15), 10, 30);
        Color c(60.0f + (rand() % 90) - 45);
        block->Property().outlineColor = c;
        c.IncreaseBrightness(0.5);
        c.a = 0.9f;
        block->Property().fillColor = c;
        block->GetFlatlandObject()->SetMass(40);
        block->GetFlatlandObject()->Property().frictionMask = 1 + i % 2;
        block->Insert(space);
    }

    // Catapult
    {
        vec2 center(1150, 750);
        float width = 200;
        float height = 5;
        vec2 hinge(center.x - width / 4, center.y);
        Catapult *c = new Catapult(center, width, height, hinge);
        c->Rotate(-22);
        c->Insert(space);
        c->InsertSouthEastAnchor(space);

        center += vec2(90, -50);
        Block *b = new Block(center, 10, 10);
        b->GetFlatlandObject()->SetMass(0.5);
        b->GetFlatlandObject()->Property().friction = dInfinity;
        b->Property().fillColor = Color::PaleYellow;
        b->Property().outlineColor = Color::PaleYellow;
        b->Insert(space);

        center.x -= 14;
        b = new Block(center, 10, 10);
        b->GetFlatlandObject()->SetMass(0.5);
        b->GetFlatlandObject()->Property().friction = dInfinity;
        b->Property().fillColor = Color::PaleYellow;
        b->Property().outlineColor = Color::PaleYellow;
        b->Insert(space);
    }

    // Block feeder blocks
    {
        Flatland::Object::PushProperties();
        Flatland::Object::Default().frictionMask = 1;
        Flatland::Object::Default().friction = 1;
        Flatland::Object::Default().density = 0.1f;
        float width = 90;
        float height = 50;
        Block *buffer1 = new Block(vec2(4050, 1300), width, height);
        SetPastel(buffer1);
        buffer1->Insert(space);
        Block *buffer2 = new Block(vec2(4050, 1000), width, height);
        SetPastel(buffer2);
        buffer2->Insert(space);
        Flatland::Object::PopProperties();

        buffer2->GetFlatlandObject()->Property().callback = feederCallback;

        Line *l = new Line(vec2(4000, 890), vec2(4000, 1620));
        l->GetFlatlandObject()->Property().frictionMask = 2;
        l->Insert(space);
    }

    // Roulette for square wheel, defined as the catenary y = -cosh(x) truncated by x = +/- asinh(1)
    t = 0;
    float dx = 5;
    float asinh1 = .881373587019543f;
    float xx = -asinh1;
    for (float x = 3000 + dx; x <= 4000; x += dx)
    {
        float y = 1570 + 50 * cosh(xx);
        if (!t)
            t = new Terrain(vec2(0, y), 1100);
        else
            t->Add(vec2(x, y));
        xx += 2 * asinh1 / 15;
        if (xx > asinh1)
            xx = -asinh1;
    }
    t->Insert(space);

    Block *b = new Block(vec2(3923, 1500), 92, 92);
    b->Property().fillColor = Color::Black;
    b->Insert(space);
    b->GetFlatlandObject()->Property().friction = dInfinity;
    squareWheelMotor = world.AddMotor(*b->GetFlatlandObject());

    // West block
    t = new Terrain(vec2(0, 590 - 100), 595, true, false);
    t->Add(vec2(20, 590 - 100));
    t->Property().altFillColor = t->Property().fillColor;
    t->Insert(space);

    t = new Terrain(vec2(1500, 2850), 2850);
    for (float x = 1510; x <= 4100; x += 10)
    {
        float y = 2500 - log10f((x - 1400) / 270) * 800;
        t->Add(vec2(x, y));
    }
    t->Insert(space);

    space << new Line(vec2(1000, 3000), vec2(1750, 3000));
    space << new Line(vec2(2500, 3000), vec2(3000, 3000));

    // Rope
    {
        Flatland::Object::PushProperties();
        Flatland::Object::Default().friction = dInfinity;
        Flatland::Object::Default().frictionMask = 7;
        Flatland::Object::Default().density = 5;
        vec2 start = vec2(1750, 3000);
        vec2 end = vec2(2500, 3000);
        float slack = 40;
        float length = end.x - start.x + slack;
        float tautness = 20000;
        Rope *r = new Rope(start, end, length, tautness);
        r->Property().outlineColor = Color::Red;
        r->Property().outlineThickness = 3;
        r->Insert(space);
        Anchor(r->front(), start);
        Anchor(r->back(), end);
        Flatland::Object::PopProperties();
    }

    // Southernmost, easternmost, westernmost terrain
    t = new Terrain(vec2(-250, 400), 5000);
    for (float x = 0.5f + 0.1f; x < 10; x += 0.1f)
    {
        float y = 5 / x;
        vec2 v;
        v.y = (y - 0.5f) / 9.5f;
        v.y = 1 - v.y;
        v.y = v.y * (3500 - 400) + 400;
        v.x = (x - 0.5f) / 9.5f;
        v.x = v.x * (1000 - -250) + -250;
        t->Add(v);
    }
    t->Add(vec2(1000, 3500));
    float dtheta = pi / 50;
    for (float theta = dtheta; theta < pi; theta += dtheta)
        t->Add(vec2(1000 + theta * 1500 / pi, 4000 + 500 * cosf(pi - theta)));
    t->Add(vec2(2500, 4500));
    t->Add(vec2(4050, 4500));
    for (float theta = -90 + 10; theta < 0; theta += 10)
        t->Add(vec2(4075, 4475) + vec2(25, 0).rotate(theta));
    t->Add(vec2(4100, -100));
    t->Add(vec2(5000, -100));
    t->GetFlatlandObject()->Property().friction = dInfinity;
    t->GetFlatlandObject()->Property().collisionMask = ~8;
    t->GetFlatlandObject()->Property().frictionMask = 4;
    t->Insert(space);

    // Speed boost
    Point *boost = new Point(vec2(1000 + 32, 3425 + 32));
    boost->GetFlatlandObject()->Property().callback = boostCallback;
    boost->GetFlatlandObject()->Property().collisionMask = 0;
    boost->Insert(space);
    Anchor(boost, vec2(1000 + 32, 3425 + 32));

    // Block feeder
    {
        Object::PushProperties();
        Object::Default().fillColor = Color::PaleRed;
        Object::Default().outlineColor = Color::Black;
        Object::Default().outlineThickness = 2;

        vec2 start(4300, 1670);
        vec2 end(4600, 1500);
        float length = 130;

        start -= vec2(170, 0);
        end -= vec2(170, 0);

        // Motor
        Wheel *w = new Wheel(end, 100);
        w->Insert(space);
        w->GetFlatlandObject()->Property().collisionMask = 0;
        Anchor(w, w->GetFlatlandObject()->GetGeometry().Center());
        blockFeeder = world.AddMotor(*w->GetFlatlandObject());

        Object::Default().outlineThickness = 4;

        // Pusher
        Beam *pusher = new Beam(start - vec2(length, 0), start, 50);
        pusher->GetFlatlandObject()->Property().collisionMask = 8;
        pusher->Insert(space);
        AnchorAxis(pusher, vec2(1, 0));

        // Transmission.
        end -= vec2(60, 0);
        Beam *transmission = new Beam(start, end, 20);
        transmission->Insert(space);
        transmission->GetFlatlandObject()->Property().collisionMask = 0;
        Anchor(transmission, w, end);
        Anchor(transmission, pusher, start);

        Object::PopProperties();
    }
}

---