{
    "name": "example",
    "targetPath": "bin",
    "targetType": "executable",
    "sourcePaths": [ "src" ],
    "dependencies": { "des": ">=1.3.0" }
}

import des.app; // модуль предоставляет базовую работу с SDL: окна, события мыши, клавиатуры, джойстика, создание GL контекста и тд
import window; // будет разобран ниже
void main()
{
    auto app = new DesApp;
    // передаём делегат, создающий окно, спорное архитектурное решение, но оно имело обоснование
    app.addWindow({ return new MainWindow; });
    // основной цикл
    while( app.isRuning )
        app.step(); // обработка событий, отрисовка и всё остальное
}

module window;
import des.app;
import draw; // класс Sphere
import camera; // класс MCamera 

// класс главного окна
class MainWindow : DesWindow
{
protected:
    MCamera cam; // позволит осматривать объект с помощью мыши
    Sphere obj; // объект, который будет рисоваться

    /+ вызывается после конструктора, когда DesApp позаботится о создании OpenGL контекста
        здесь нужно проводить всю подготовительную работу: создавать объекты, настраивать GL, соединять сигналы
     +/
    override void prepare()
    {
        cam = new MCamera;

        obj = newEMM!Sphere( 1, 12, 12 ); // эта странная конструкция будет объяснена позже

        // соединяем сигналы с делегатами и функциями, которые потом оборачиваются в слоты
        connect( draw, { obj.draw( cam ); } );
        connect( key, &keyControl );
        // возлагаем ответственность за обработку мыши непосредственно на камеру
        connect( mouse, &(cam.mouseReaction) );

        // изменение соотношения сторон должно перестраивать перспективную матрицу
        connect( event.resized, (ivec2 sz)
        { cam.ratio = cast(float)sz.w / sz.h; } );
    }

    // функция обработки нажатия клавиш
    void keyControl( in KeyboardEvent ke )
    {
        if( ke.scan == ke.Scan.ESCAPE ) app.quit(); // каждое окно имеет доступ к экземпляру класса DesApp, в котором содержится
    }

public:
    // передаётся title окна, размер, и открывать ли окно в полноэкранном режиме
    this() { super( "example", ivec2(800,600), false ); }
}

module draw;

import std.math;

import des.math.linear; // вектора, матрицы
import des.util.stdext.algorithm; // amap это просто array( map ... )
import des.util.helpers; // appPath -- путь до исполняемого файла

import des.space; // камера, SpaceNode, построение перспективы

import des.gl; // работа с OpenGL

class Sphere : GLSimpleObject, SpaceNode
{
    /+ реализует интерфейс SpaceNode
        вставляет приватную матрицу трансформации self_mtr и реализует свойство matrix для доступа к ней
     +/
    mixin SpaceNodeHelper;

protected:

    // буферы с данными
    GLBuffer pos, ind;

    void prepareBuffers()
    {
        // получаем адрес атрибута в шейдере по имени
        auto loc = shader.getAttribLocations( "pos" );
        
        // методы createArrayBuffer и createIndexBuffer относятся только к GLSimpleObject, в GLObject их нет
        pos = createArrayBuffer; // здесь будут храниться точки
        ind = createIndexBuffer;  // а здесь порядок их отрисовки
        // выставляем связь между буфером и атрибутом в шейдере
        setAttribPointer( pos, loc[0], 3, GLType.FLOAT );

       // заполняем буфер точек

        vec3[] buf;

        vec3 sp( vec2 a, float R ) { return spheric(a) * R; }

        buf ~= amap!(a=>a+vec3(0,0,0))( amap!(a=>sp(a,R))( planeCoord( uivec2( resU, resV/2 ), vec2(0,PI*2), vec2(PI,PI/2) ) ) );
        buf ~= amap!(a=>a-vec3(0,0,0))( amap!(a=>sp(a,R*0.9))( planeCoord( uivec2( resU, resV/2 ), vec2(0,PI*2), vec2(PI/2,PI) ) ) );

        // передаём на карточку
        pos.setData( buf );
        
        // передаём на карточку
        ind.setData( triangleStripPlaneIndex( uivec2( resU+1, resV+2 ), uint.max ) );
    }

    // параметры полигональной сетки
    uint resU, resV;
    float R;

public:

    this( float r, uint u, uint v )
    {
        R = r;
        resU = u;
        resV = v;
        import std.file;
        super( newEMM!CommonShaderProgram( // создаём шейдер и добавляем его в список дочерних объектов
                parseShaderSource( // функция разбирает 1 файл на несколько шейдеров
                    readText( // стандартная функция
                        appPath( "..", "data", "object.glsl" ) // путь до шейдера относительно бинарного файла
                    ))));
        prepareBuffers();
    }

    void draw( Camera cam )
    {
        // выставляем цвет в шейдере
        shader.setUniform!col4( "col", col4(1,0,0,1) );

        glEnable( GL_PRIMITIVE_RESTART );
        glPrimitiveRestartIndex(uint.max);
        glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
        // вычисляем матрицу трансформации и передаём её в шейдер
        shader.setUniform!mat4( "prj", cam.projection.matrix * cam.resolve(this) );
        // собственно отрисовка
        drawElements( DrawMode.TRIANGLE_STRIP );
        glDisable( GL_PRIMITIVE_RESTART );
    }
}

// далее функции создания полигональной сетки

vec2[] planeCoord( uivec2 res, vec2 x_size=vec2(0,1), vec2 y_size=vec2(0,1) )
{
    vec2[] ret;

    float sx = (x_size[1] - x_size[0]) / res.u;
    float sy = (y_size[1] - y_size[0]) / res.v;

    foreach( y; 0 .. res.y+1 )
        foreach( x; 0 .. res.x+1 )
            ret ~= vec2( x_size[0] + sx * x, y_size[0] + sy * y );

    return ret;
}

vec3 spheric( in vec2 c ) pure
{ return vec3( cos(c.x) * sin(c.y), sin(c.x) * sin(c.y), cos(c.y) ); }

uint[] triangleStripPlaneIndex( uivec2 res, uint term )
{
    uint[] ret;
    foreach( y; 0 .. res.y-1 )
    {
        ret ~= [ y*res.x, (y+1)*res.x ];
        foreach( x; 1 .. res.x )
            ret ~= [ y*res.x+x, (y+1)*res.x+x ];
        ret ~= term;
    }
    return ret;
}

//### vert
#version 330
in vec4 pos;
uniform mat4 prj;
void main() { gl_Position = prj * pos; }
//### frag
#version 330
uniform vec4 col;
out vec4 color;
void main() { color = col; }

module camera;
import std.math;
import des.space; 
import des.app;

class MCamera : SimpleCamera
{
protected:
    vec3 orb;
    vec2 rot;

    float rotate_coef = 80.0f;
    float offset_coef = 50.0f;
    float y_angle_limit = PI_2 - 0.01;

public:
    this()
    {
        super();
        orb = vec3( 5, 1, 3 );
        look_tr.target = vec3(0,0,0);
        look_tr.up = vec3(0,0,1);
        near = 0.001;
        updatePos();
    }

    // обрабатываем события мыши
    void mouseReaction( in MouseEvent ev )
    {
        // колёсиком приближаем
        if( ev.type == MouseEvent.Type.WHEEL )
            moveFront( -ev.whe.y * 0.1 );

        if( ev.type == ev.Type.MOTION )
        {
            // на левую крутим вокруг центра
            if( ev.isPressed( ev.Button.LEFT ) )
            {
                auto frel = vec2( ev.rel ) * vec2(-1,1);
                auto angle = frel / rotate_coef;
                addRotate( angle );
            }
            // на среднюю перемещаемся параллельно плоскости экрана
            if( ev.isPressed( ev.Button.MIDDLE ) )
            {
                auto frel = vec2( ev.rel ) * vec2(-1,1);
                auto offset = frel / offset_coef * sqrt( orb.len );
                moveCenter( offset );
            }
        }
    }

protected:
    void moveFront( float dist )
    {
        orb += orb * dist;
        if( orb.len2 < 1 ) orb = orb.e;
        updatePos();
    }

    void addRotate( in vec2 angle )
    {
        rot = normRotate( rot + angle );
        orb = vec3( cos(rot.x) * cos(rot.y),
                    sin(rot.x) * cos(rot.y),
                    sin(rot.y) ) * orb.len;
        updatePos();
    }

    void moveCenter( in vec2 offset )
    {
        auto lo = (look_tr.matrix * vec4(offset,0,0)).xyz;
        look_tr.target += lo;
        updatePos();
    }

    void updatePos() { pos = orb + look_tr.target; }

    vec2 normRotate( in vec2 r )
    {
        vec2 ret = r;
        if( ret.y > y_angle_limit ) ret.y = y_angle_limit;
        if( ret.y < -y_angle_limit ) ret.y = -y_angle_limit;
        return ret;
    }
}