Обсуждение дальнейших уроков (14 стр) / Развитие сообщества / Форум / OpenGL community / GameDev.ru

Вопрос совместимости версий.

То есть согласно этой статье: http://usefulbytes.blogspot.ru/2009/04/opengl-3.html
в OGL 3 нет glVertex, glNormal и т.д. А так же стандартных матриц. И всё это теперь надо рассчитывать в самом приложении.
А почему бы не показать как? Например, в Рендермонке есть стандартный набор "подключаемых" переменных: position, texcoord, normal, tangent, binormal и т.д. + стандартные матрицы?
Например, тут пишут, что есть короткий вариант рассчёта тангента: http://stackoverflow.com/questions/5255806/how-to-calculate-tange… -and-binormal
(правда есть (при каких условиях) или всё же нет?)
А тут единственное место, которое удалось найти с примером рассчёта тангента (и всей TBN): http://3d-orange.com.ua/best-calculation-of-tbn/

Почему бы в какой либо статье не показать как это всё рассчитывать вне шейдера, на основе OGL (какие матрицы где брать, в какой последовательности пермножать), в приложении, как в шейдер OGL 3 теперь передавать?
+ Как при этом создать минимальную совместимость со старыми версиями. Чтобы код шейдеров к старым версиям работал в новых, или работал с минимальными изменениями (там, с glVertex на gl_Vertex или вообще без изменений).
А то даже в Рендермонке все примеры пока только к версиям OGL младше 3, получается.

И ещё было бы интересно по подробнее как будет осуществляться перход с 2 на 3 версию? Например, как тестировать 3 версию, если у тебя, к пример Win-ХРюша? Надо ли что-то доп-но ставить, где это брать и т.д.? Каких принципов при программировании на старых версиях нужно придерживаться (список правил или принципов + необх. элементов при соблюдении/использовании которых совместимость сохранится), чтобы не возникло пробелем с переносом на старых ш. новые иил новых на старые?

KpeHDeJIb
Постоялец

#199
3:01, 19 окт 2014

Kukuy
>в OGL 3 нет glVertex, glNormal и т.д. А так же стандартных матриц. И всё это теперь надо рассчитывать в самом приложении. А почему бы не показать как?
Все показано в уроках.

>Почему бы в какой либо статье не показать как это всё рассчитывать вне шейдера, на основе OGL (какие матрицы где брать, в какой последовательности пермножать), в приложении, как в шейдер OGL 3 теперь передавать?
TBN обычно рассчитывается в программе где делается normal map, потому что там есть вся информация для этого, восстанавливать TBN из одной только normal map уже в программе - можно, но не в общем случае, как минимум надо знать алгоритм по которому строилась normal map и еще не всегда получается точно такой результат как ожидаешь, но можно попробовать получить достаточно близкий. Есть в транке уроков небольшой пример (без описания) тут https://code.google.com/p/gl33lessons/source/browse/branches/bumpmapping/ (на название не смотри - код про normalmapping).

Ну и какое это имеет отношение к OpenGL? OpenGL для обработки данных и вывода их на экран, дальше все зависит от вашей фантазии. OpenGL про TBN ничего не знает, также как и про GI, другое дело что в нем есть способы это делать, а для некоторых популярных фишек даже встроенные возможности (shadowmapping например), но это скорее исключение из правил, все таки это GAPI, а не фреймворк какой-то.

>Например, в Рендермонке есть стандартный набор "подключаемых" переменных: position, texcoord, normal, tangent, binormal и т.д. + стандартные матрицы?
В версиях OpenGL 3+ это все лежит на программисте, в уроках как раз упор идет на передачу подобных параметров с использованием location, что позволяет унифицировать этот пример. В версии OpenGL 4+ пошли еще дальше, смотрите например примеры от g-truc http://www.g-truc.net/project-0026.html

>Как при этом создать минимальную совместимость со старыми версиями. Чтобы код шейдеров к старым версиям работал в новых, или работал с минимальными изменениями
Писать старый код, очевидно, в новых версиях не выпилили совместимость :)

>И ещё было бы интересно по подробнее как будет осуществляться перход с 2 на 3 версию?
Это весьма подробно описано как раз, читайте.

>Например, как тестировать 3 версию, если у тебя, к пример Win-ХРюша?
OpenGL это вам не DX, если есть поддержка в драйверах - хоть в Win95, все зависит только от драйвера.

>чтобы не возникло пробелем с переносом на старых ш. новые иил новых на старые
Опять же - пишите "старый" код и все норм.

Kukuy
Постоялец

#200
14:11, 19 окт 2014

KpeHDeJIb

- То бишь надо или новую видеокарту покупать или дрова на старую обновлять.
- А для получения двунаправленной совместимости лучше писать код по старому.
Тут ещё момент, что в VC++ 2005 по моему небыло ни windows.h ни заголовков OGL, всё это надо было качать и ставить отдельно (platform SDK, потом оказалось, что её переименовали в win SDK, потом оказалось, что она весит под 2 гб и т.д.) Поэтому опасения, что опять какие-нибудь новые заголовки (или ещё что-то) появятся, а где их взять никого не предупредят.

> Ну и какое это имеет отношение к OpenGL?

Допустим тангенты не имеют. А нормали? Ведь glNormal вроде как убрали. И glVertex. Значит? Что предполагается? Что их надо брать/рассчитывать где-то вовне, а потом передавать в шейдер? А если их надо, то почему бы и тангент не рассчитать "для полного комплекта" сущностей одного порядка (тем более, что бинормаль = cross (n, t); )

Такой ход мылей.

+ Глянул тут: http://www.gamedev.ru/community/ogl/articles/lesson02

Часть вопросов сняло. Ввиду отсутствия в Win заголовков OGL для версий старше OGL 1.1 используется динамическая загрузка библиотечных функций. Там же ссылка на *.h
Тогда примерно понятно. Тогда легко можно определить существует ли такая ф-ция в библиотеке. И если не существует, то использовать из младших версий.
Уроки хорошие.

KpeHDeJIb
Постоялец

#201
14:32, 19 окт 2014

Kukuy
>Допустим тангенты не имеют. А нормали? Ведь glNormal вроде как убрали. И glVertex. Значит? Что предполагается? Что их надо брать/рассчитывать где-то вовне, а потом передавать в шейдер?
Именно так, надо эти данные брать откуда-то и передавать в PPL. Можно их генерировать, можно загружать из файла, как вам угодно.

Odin P. Morgan
Постоялец

#202
0:06, 28 ноя 2014

Кстати в ogl 4.4 и 4.5 совместимость с более ранними версиями вернули?

Executor
Удалён

#203
16:11, 29 ноя 2014

Odin P. Morgan
> Кстати в ogl 4.4 и 4.5 совместимость с более ранними версиями вернули?

Ты про что?

cNoNim
Постоялец

#204
15:55, 7 янв 2015

такой вот вопрос...

скажем так... я щас реализовываю нечто вроде hello world
использующего OpenGL
суть затеи добиться максимальной кросс платформенности
планируется сделать так что бы оно запускалось как минимум на
Linux + OpenGL
Linux + Mesa OpenGL ES
Windows + OpenGL
Windows + ANGLE
Android + OpenGL ES
nacl + WebGL
asm.js + WebGL

в конечно итоге можно будет проверить и на маках и на яблофонах, но у меня оных нет

подобная кросс платформенность накладывает разумеется некоторые ограничения
т.е. основное целевое API OpenGL ES 2
ну и с некоторыми обвязками обеспечивается совместимость с OpenGL 2.1

все это реализовывается используя в основном лишь голый OpenGL
и кросс платформенный glfw

в качестве компилятора использую clang и использую фичи стандарта С++14 (наверняка будут проблемы с со сборкой под nacl и android но я думаю они решаемые)
в качестве основной IDE используется Clion
для тестирования на Android будет использоваться Android Studio

разработка ведется в Linux, но для тестирования в Windows буду собирать и ANGLE в том числе

собственно в чем вопрос, есть ли смысл оформлять решения всех проблем с которыми сталкиваюсь в форме каких либо статей или уроков?

по своему содержанию, стать и будут чем то походить на содержание уроков кренделя,
но больший акцент будет делать именно на проблемы совместимости
и настройку средств разработки

либо не маяться фигней, и в лудшем случае по итогу кинуть ссылку на репозиторий по окончанию затеи?

если все таки есть смысл заморачиваться с уроками,
то может быть все таки стоит использовать что нить более приближенное к народу, а не C++14?

пока по факту там получается много шаблонов вывода типов и прочей магии...

основной код получается пока каким то таким

+ Показать

− Скрыть

#include <array>
#include <utility>
#include <iostream>
#include <vector>

#include <glm/vec2.hpp>
#include <glm/vec3.hpp>

#define GLFW_INCLUDE_ES2
// #define GLFW_INCLUDE_GLCOREARB
// #define GL_GLEXT_PROTOTYPES

#include <GLFW/glfw3.h>

template<typename... T>
auto array(T &&... t) {
    return std::array<typename std::common_type<T...>::type, sizeof...(T)>{std::forward<T>(t)...};
}

#ifdef NDEBUG
#define info_log(object)
#else
template<typename T>
static void info_log(T object) {
    auto info_log_size = 0;
    if(glIsShader(object)) glGetShaderiv(object, GL_INFO_LOG_LENGTH, &info_log_size);
    else if(glIsProgram(object)) glGetProgramiv(object, GL_INFO_LOG_LENGTH, &info_log_size);
    else return;
    
    if (info_log_size > sizeof("")) {
        auto info_log = std::vector<char>(static_cast<unsigned long>(info_log_size));
        if(glIsShader(object)) glGetShaderInfoLog(object, static_cast<int>(info_log.size()), nullptr, info_log.data());
        else if(glIsProgram(object)) glGetProgramInfoLog(object, static_cast<int>(info_log.size()), nullptr, info_log.data());
        std::clog << "INFO:" << std::endl;
        std::clog << info_log.data() << std::endl;
    }
}
#endif

template<typename T, typename... S>
auto compile_shader(T type, S ... source) {
    auto shader = glCreateShader(type);
    auto sources = array(
#ifdef GL_ES_VERSION_2_0
        "#version 100\n",
#else
        "#version 120\n",
#endif
#ifdef GL_ES_VERSION_2_0
        (type == GL_FRAGMENT_SHADER) ?
        "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
        "precision highp float;\n"
        "#else\n"
        "precision mediump float;\n"
        "#endif\n"
        : "",
#else
        "#define lowp\n"
        "#define mediump\n"
        "#define highp\n",
#endif
        source...
    );
    glShaderSource(shader, sources.size(), sources.data(), nullptr);
    glCompileShader(shader);
    info_log(shader);
    auto compile_status = 0;
    glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_status);
    if (!compile_status) {
        std::cerr << "ERROR: Shader compilation failed" << std::endl;
        glDeleteShader(shader);
        shader = 0;
    }
    return shader;
};

template<typename R, typename... S>
auto link_program(R && attribs, S && ... shaders) {
    auto program = glCreateProgram();
    static auto attach = [](auto p, auto s) { glAttachShader(p, s); return s; };
    auto _ = { attach(program, std::forward<S>(shaders))... };
    auto location = 0u;
    for (auto attrib : attribs) {
        glBindAttribLocation(program, location++, attrib);
    }
    glLinkProgram(program);
    glValidateProgram(program);
    info_log(program);
    auto link_status = 0;
    glGetProgramiv(program, GL_LINK_STATUS, &link_status);
    if (!link_status) {
        std::cerr << "ERROR: Program link failed" << std::endl;
        glDeleteProgram(program);
        program = 0;
    }
    return program;
};

template<typename T, typename... E>
auto make_buffer(T type, E &&...e) {
    return std::make_pair(type, array(std::forward<E>(e)...));
}

template<typename... A>
auto bind_buffers(A ... a) {
    auto buffers = std::array<unsigned, sizeof...(A)>();
    glGenBuffers(static_cast<int>(buffers.size()), buffers.data());
    auto buffer_it = buffers.begin();
    auto buffer_data = [&buffer_it](auto type, auto buffer) {
        auto buffer_id = *(buffer_it++);
        glBindBuffer(type, buffer_id);
        glBufferData(type, sizeof(*buffer.begin()) * buffer.size(), buffer.data(), GL_STATIC_DRAW);
        glBindBuffer(type, 0);
        return buffer_id;
    };
    auto _ = { buffer_data(std::get<0>(a), std::get<1>(a))... };
    return buffers;
}

int main(int argc, char *argv[]) {
    using namespace glm;

    std::ios::sync_with_stdio(false);

    glfwSetErrorCallback([](auto error, auto description) {
        std::cerr << "ERROR: GLFW" << std::endl;
        std::cerr << error << " : " << description << std::endl;
    });

    if (!glfwInit()) return EXIT_FAILURE;
    atexit(glfwTerminate);

#ifdef GL_ES_VERSION_2_0
    glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
#endif
    glfwWindowHint(GLFW_RESIZABLE, false);

    auto window = glfwCreateWindow(640, 480, "untitled", nullptr, nullptr);
    if (!window) return EXIT_FAILURE;

    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);

    glfwMakeContextCurrent(window);

    glfwSetFramebufferSizeCallback(window, [](auto, auto w, auto h) {
        glViewport(0, 0, w, h);
    });

    glfwSetKeyCallback(window, [](auto  win, auto key, auto, auto action, auto) {
       if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) glfwSetWindowShouldClose(win, true);
    });

    glClearColor(1.0, 1.0, 1.0, 1.0);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    auto program = link_program(
            array("v_position", "v_color"),
            compile_shader(GL_VERTEX_SHADER,
                    "attribute vec2 v_position;",
                    "attribute vec3 v_color;",
                    "varying vec3 f_color;",
                    "void main(void) {",
                    "  gl_Position = vec4(v_position, 0.0, 1.0);",
                    "  f_color = v_color;",
                    "}" ),
            compile_shader(GL_FRAGMENT_SHADER,
                    "uniform float time;",
                    "varying vec3 f_color;",
                    "void main(void) {",
                    "  gl_FragColor = vec4(f_color.rgb, sin(time * 1.25663706144) / 2.0 + 0.5); ",
                    "}"));

    auto time = glGetUniformLocation(program, "time");
    struct attribute {
        vec2 v_position;
        vec3 v_color;
    };

    auto buffers = bind_buffers(
            make_buffer(GL_ARRAY_BUFFER,
                    attribute{ vec2(0.0f,  0.8f),   vec3(1.0f, 1.0f, 0.0f) },
                    attribute{ vec2(-0.8f, -0.8f),  vec3(0.0f, 0.0f, 1.0f) },
                    attribute{ vec2(0.8f, -0.8f),   vec3(1.0f, 0.0f, 0.0f) } ));

    glfwSetTime(0);

    while (!glfwWindowShouldClose(window)) {
        glClear(GL_COLOR_BUFFER_BIT);

        if (program) {
            glUseProgram(program);
            glUniform1f(time, static_cast<float>(glfwGetTime()));

            glEnableVertexAttribArray(0);
            glEnableVertexAttribArray(1);

            glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
            glVertexAttribPointer(0, 2, GL_FLOAT, 0, sizeof(attribute), nullptr);
            glVertexAttribPointer(1, 3, GL_FLOAT, 0, sizeof(attribute), reinterpret_cast<void *>(offsetof(attribute, v_color)));

            glDrawArrays(GL_TRIANGLES, 0, 3);

            glDisableVertexAttribArray(0);
            glDisableVertexAttribArray(1);
        }

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glDeleteProgram(program);
    glDeleteBuffers(buffers.size(), buffers.data());

    return EXIT_SUCCESS;
}

но не проблема переписать в более классическом стиле, даж на Си

$Андрей (/A\)$

/A\
Постоялец

#205
11:51, 8 янв 2015

cNoNim
> собственно в чем вопрос, есть ли смысл оформлять решения всех проблем с
> которыми сталкиваюсь в форме каких либо статей или уроков?
Для тех кто шарит хватит и репозитория, а те кто не шарят врятли станут что-то такое делать, так что не трать свое время на уроки, но простую статью с описанием проблем и решений можно и написать.

Elun
Постоялец

#206
21:17, 13 мар 2015

Так как code.google в недалёком будущем откинется, что меня расстраивает, неплохо было бы перенести файлы в другое место.

KpeHDeJIb
Постоялец

#207
21:33, 13 мар 2015

Elun
Уроки я перенесу в самое ближайшее время, на битбакет скорее всего, я еще подумаю.

ud1
Удалён

#208
16:58, 21 мар 2015

Попробовал экспортнуть на гитхаб https://github.com/ud1/gl33lessons
Код экспортнулся вроде, вики не вижу.

gammaker
Постоялец

#209
22:06, 21 мар 2015

cNoNim
> собственно в чем вопрос, есть ли смысл оформлять решения всех проблем с
> которыми сталкиваюсь в форме каких либо статей или уроков?
Очень интересно. Сам хочу сделать что-то подобное, но за нижнюю планку выбрал GLES 3.0. У меня движок интенсивно использует фичи GL 3.x, которые работать на GLES 2.0 не будут и которые невозможно переделать на GLES 2.0 с сохранением гибкости.
Я думаю, мне было бы достаточно описать, что где лежит и какую проблему решает. Если какая-то проблема не очень очевидна, то лучше описать поподробнее. А уроки для нубов не нужны, потому что, как уже писали здесь, нубы за такое и не возьмутся.

cNoNim
> то может быть все таки стоит использовать что нить более приближенное к народу,
> а не C++14?
> пока по факту там получается много шаблонов вывода типов и прочей магии...
Я думаю, сойдёт. Если совсем запутанные шаблоны с вариадиками, то лучше объяснить, что там происходит, хотя бы в комментариях.

Это по поводу кода. А вот насчёт использования разных IDE для разных платформ, особенно Android, компиляции версии для WebGL, желательно поподробней расписать.

cNoNim
> наверняка будут проблемы с со сборкой под nacl и android но я думаю они
> решаемые
Под Android вроде есть G++ 4.9 и последний Clang, так что вряд ли будут проблемы.