example.hpp

Go to the documentation of this file.

#ifndef __OGLPLUS_EXAMPLE_EXAMPLE_1119071146_HPP__
#define __OGLPLUS_EXAMPLE_EXAMPLE_1119071146_HPP__

#include <set>
#include <memory>
#include <cassert>

#ifndef _NDEBUG
#include <iostream>
#endif

#ifdef _MSC_VER
#pragma warning ( disable : 4244 )
#pragma warning ( disable : 4305 )
#endif //_MSC_VER

namespace oglplus {

struct ExampleParams
{
    int argc;

    char ** argv;

    float quality;

    unsigned num_gpus;

    unsigned num_threads;

    unsigned max_threads;

    std::set<unsigned> compat_context_threads;

    ExampleParams(int argn, char ** args)
     : argc(argn)
     , argv(args)
     , quality(0.5f)
     , num_gpus(1)
     , num_threads(0)
     , max_threads(0)
    { }

    void Check(void)
    {
        assert(num_threads <= max_threads);
    }

    bool HighQuality(void) const
    {
        return quality > 0.9f;
    }
};

void setupExample(ExampleParams& params);

class ExampleTimePeriod
{
private:
    double _time;
public:
    ExampleTimePeriod(double time)
     : _time(time)
    {
        assert(_time >= 0.0);
    }

    double Seconds(void) const
    {
        return _time;
    }

    int Second(void) const
    {
        return int(Seconds()) % 60;
    }

    double Minutes(void) const
    {
        return _time / 60.0;
    }

    int Minute(void) const
    {
        return int(Minutes()) % 60;
    }

    double Hours(void) const
    {
        return _time / 3600.0;
    }

    int Hour(void) const
    {
        return int(Hours()) % 24;
    }

    double Days(void) const
    {
        return _time / (24*3600.0);
    }

    int Day(void) const
    {
        return int(Days());
    }
};

class ExampleClock
{
private:
    double _start, _past, _real_time, _curr_time, _prev_time, _pace; //[s]
public:
    ExampleClock(double start = 0.0)
     : _start(start)
     , _past(start)
     , _real_time(start)
     , _curr_time(start)
     , _prev_time(start)
     , _pace(1.0)
    { }

    void Update(double real_time)
    {
        _prev_time = _curr_time;
        _real_time = real_time;
        _curr_time = _past + (_real_time - _start) * _pace;
    }

    void Advance(double seconds)
    {
        _prev_time = _curr_time;
        _real_time += seconds;
        _curr_time = _past + (_real_time - _start) * _pace;
    }

    void Pace(double pace)
    {
        if(_pace != pace)
        {
            _start = _real_time;
            _past = _curr_time;
            _pace = pace;
        }
    }

    double Time(void) const
    {
        return this->Now().Seconds();
    }

    ExampleTimePeriod RealTime(void) const
    {
        return ExampleTimePeriod(_real_time);
    }

    ExampleTimePeriod Now(void) const
    {
        return ExampleTimePeriod(_curr_time);
    }

    ExampleTimePeriod Interval(void) const
    {
        return ExampleTimePeriod(_curr_time-_prev_time);
    }
};

class Example;

class ExampleThread
{
public:
    virtual ~ExampleThread(void)
    { }


    virtual void Cancel(void){ }

    virtual void Render(double /*time*/)
    {
        assert(!"Render must be overloaded by examples!");
    }

    virtual void Render(const ExampleClock& clock)
    {
        this->Render(clock.Now().Seconds());
    }

    virtual double RenderPart(
        unsigned /*part_no*/,
        const ExampleClock& clock
    )
    {
        this->Render(clock);
        return 1.0;
    }
};

std::unique_ptr<ExampleThread> makeExampleThread(
    Example& example,
    unsigned thread_id,
    const ExampleParams& params
);

class Example
{
public:
    virtual ~Example(void)
    { }


    virtual void PrepareThread(unsigned, ExampleThread&)
    {
    }


    virtual bool Continue(double duration)
    {
        return duration < 3.0; // [seconds]
    }


    virtual bool Continue(const ExampleClock& clock)
    {
        return this->Continue(clock.Now().Seconds());
    }

    virtual void Reshape(GLuint width, GLuint height) = 0;

    virtual void MouseMoveNormalized(float x, float y, float aspect)
    {
        (void)(x+y+aspect);
    }

    virtual void MouseMove(GLuint x, GLuint y, GLuint width, GLuint height)
    {
        return MouseMoveNormalized(
            (float(x) - width * 0.5f) / (width * 0.5f),
            (float(y) - height* 0.5f) / (height* 0.5f),
            float(width)/height
        );
    }

    virtual void Render(double /*time*/)
    {
        assert(!"Render must be overloaded by examples!");
    }

    virtual void Render(ExampleClock& clock)
    {
        this->Render(clock.Now().Seconds());
    }

    virtual double RenderPart(unsigned /*part_no*/, ExampleClock& clock)
    {
        this->Render(clock);
        return 1.0;
    }

    virtual double ScreenshotTime(void) const
    {
        return 1.0; // [s]
    }

    virtual double FrameTime(void) const
    {
        return 1.0/25.0;
    }

    virtual GLuint HeatUpFrames(void) const
    {
        return 5;
    }

    virtual double HeatUpTime(void) const
    {
        return ScreenshotTime()-HeatUpFrames()*FrameTime();
    }
};

std::unique_ptr<Example> makeExample(const ExampleParams& params);

} // namespace oglplus

#endif // include guard