PrimContext.hpp

Go to the documentation of this file.

/*
 * Author: Sven Gothel <sgothel@jausoft.com>
 * Copyright Gothel Software e.K.
 *
 * SPDX-License-Identifier: MIT
 *
 * This Source Code Form is subject to the terms of the MIT License
 * If a copy of the MIT was not distributed with this file,
 * you can obtain one at https://opensource.org/license/mit/.
 */
 
#ifndef GAMP_RENDER_GL_PRIM_PRIMCONTEXT_HPP_
#define GAMP_RENDER_GL_PRIM_PRIMCONTEXT_HPP_
 
#include <cstdio>
 
#include <gamp/render/gl/GLTypes.hpp>
#include <gamp/render/gl/data/GLArrayDataServer.hpp>
#include <gamp/render/gl/data/GLUniformData.hpp>
#include <gamp/render/gl/glsl/ShaderState.hpp>
 
using namespace jau::math;
using namespace jau::math::util;
 
using namespace gamp::wt;
using namespace gamp::wt::event;
using namespace gamp::render::gl::glsl;
using namespace gamp::render::gl::data;
 
class PrimitiveContext {
  private:
    ShaderState                m_st;
    PMVMat4f                   m_pmvMatrix;
    GLUniformSyncMatrices4fRef m_pmvMatrixUniform;
    GLUniformVec4fRef          m_colorUniform;  
    jau::math::Recti m_viewport;
    
  public:
    PrimitiveContext()
    : m_st(),
      m_pmvMatrix(PMVMat4f::INVERSE_PROJECTION | PMVMat4f::INVERSE_MODELVIEW | PMVMat4f::INVERSE_TRANSPOSED_MODELVIEW),
      m_pmvMatrixUniform(GLUniformSyncMatrices4f::create("pmvMatrix", m_pmvMatrix.getSyncPMvMviMvit())),  // P, Mv, Mvi and Mvit
      m_colorUniform(GLUniformVec4f::create("color", Vec4f(1,1,1,1)))
    {}
    
    bool init(const WindowRef& win, const jau::fraction_timespec& when) override {
        jau::fprintf_td(when.to_ms(), stdout, "RL::init: %s\n", toString().c_str());
        GL& gl = GL::downcast(win->renderContext());
 
        // m_st.setVerbose(true);
        ShaderCodeRef vp0 = ShaderCode::create(gl, GL_VERTEX_SHADER, "demos/glsl",
                                               "demos/glsl/bin", "gears");
        ShaderCodeRef fp0 = ShaderCode::create(gl, GL_FRAGMENT_SHADER, "demos/glsl",
                                               "demos/glsl/bin", "gears");
        if( !vp0 || !fp0 ) {
            jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d: %s\n", E_FILE_LINE, toString().c_str());
            win->dispose(when);
            return false;
        }
        vp0->defaultShaderCustomization(gl, true, true);
        fp0->defaultShaderCustomization(gl, true, true);
        ShaderProgramRef sp0 = ShaderProgram::create();
        if( !sp0->add(gl, vp0, true) || !sp0->add(gl, fp0, true) ) {
            jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d: %s\n", E_FILE_LINE, toString().c_str());
            sp0->destroy(gl);
            win->dispose(when);
            return false;
        }
        m_st.attachShaderProgram(gl, sp0, true);
 
        m_gear1.initGL(gl);
        m_gear2.initGL(gl);
        m_gear3.initGL(gl);
 
        // st.attachObject("pmvMatrix", pmvMatrix);
        m_st.ownUniform(gl, m_pmvMatrixUniform);
        m_st.pushUniform(gl, m_pmvMatrixUniform);
 
        GLUniformVec3fRef lightU = GLUniformVec3f::create("lightPos", lightPos);
        m_st.ownUniform(gl, lightU);
        m_st.pushUniform(gl, lightU);
 
        m_colorUniform = GLUniformVec4f::create("color", GearsObjectES2::red);
        m_st.ownUniform(gl, m_colorUniform);
        m_st.pushUniform(gl, m_colorUniform);
 
        if( m_clearBuffers ) {
            ::glClearColor(m_clearColor.x, m_clearColor.y, m_clearColor.z, m_clearColor.w);
        }
        m_initialized = sp0->inUse();
        m_st.useProgram(gl, false);
 
        if( m_initialized ) {
            win->addKeyListener(m_kl);
            win->addPointerListener(m_pl);
        } else {
            jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d: %s\n", E_FILE_LINE, toString().c_str());
            m_st.destroy(gl);
            win->dispose(when);
        }
        return m_initialized;
    }
    void dispose(const WindowRef& win, const jau::fraction_timespec& when) override {
        jau::fprintf_td(when.to_ms(), stdout, "RL::dispose: %s\n", toString().c_str());
        jau::fprintf_td(when.to_ms(), stdout, "RL::dispose: %s\n", win->toString().c_str());
        win->removeKeyListener(m_kl);
        win->removePointerListener(m_pl);
        GL& gl = GL::downcast(win->renderContext());
        m_st.useProgram(gl, false);
        m_gear1.dispose(gl);
        m_gear2.dispose(gl);
        m_gear3.dispose(gl);
        m_st.destroy(gl);
        m_initialized = false;
    }
 
    void reshape(const WindowRef& win, const jau::math::Recti& viewport, const jau::fraction_timespec& when) override {
        jau::fprintf_td(when.to_ms(), stdout, "RL::reshape: %s\n", toString().c_str());
        if( !m_initialized ) { return; }
        m_viewport = viewport;
        reshapeImpl(win, viewport, float(viewport.width()), float(viewport.height()), when);
    }
 
    void reshapeImpl(const WindowRef& win, const jau::math::Recti& viewport, float imageWidth, float imageHeight, const jau::fraction_timespec& when) {
        const bool msaa = false;  // gl.getContext().getGLDrawable().getChosenGLCapabilities().getSampleBuffers();
        jau::fprintf_td(when.to_ms(), stdout, "GearsES2.reshape %s of %fx%f, swapInterval %d, msaa %d, tileRendererInUse %d\n",
                        viewport.toString().c_str(), imageWidth, imageHeight, m_swapInterval, msaa, false);
        GL& gl = GL::downcast(win->renderContext());
        // compute projection parameters 'normal'
        float left, right, bottom, top;
        if( imageHeight > imageWidth ) {
            const float a = (float)imageHeight / (float)imageWidth;
            left          = -1.0f;
            right         = 1.0f;
            bottom        = -a;
            top           = a;
        } else {
            const float a = (float)imageWidth / (float)imageHeight;
            left          = -a;
            right         = a;
            bottom        = -1.0f;
            top           = 1.0f;
        }
        const float w = right - left;
        const float h = top - bottom;
 
        // compute projection parameters 'tiled'
        const float l = left   + float(viewport.x())      * w / imageWidth;
        const float r = l      + float(viewport.width())  * w / imageWidth;
        const float b = bottom + float(viewport.y())      * h / imageHeight;
        const float t = b      + float(viewport.height()) * h / imageHeight;
        {
            const float _w = r - l;
            const float _h = t - b;
            jau::fprintf_td(when.to_ms(), stdout, ">> GearsES2 angle %f, [l %f, r %f, b %f, t %f] %fx%f -> [l %f, r %f, b %f, t %f] %fx%f, v-flip %d",
                   m_teethAngle, left, right, bottom, top, w, h, l, r, b, t, _w, _h, m_flipVerticalInGLOrientation);
        }
 
        m_pmvMatrix.loadPIdentity();
        if( m_flipVerticalInGLOrientation && win->isBLOriented() ) {
            m_pmvMatrix.scaleP(1.0f, -1.0f, 1.0f);
        }
        m_pmvMatrix.frustumP(l, r, b, t, m_zNear, m_zFar);
 
        m_pmvMatrix.loadMvIdentity();
        m_pmvMatrix.translateMv(0.0f, 0.0f, -m_zViewDist);
 
        m_st.useProgram(gl, true);
        m_st.pushUniform(gl, m_pmvMatrixUniform);
        m_st.useProgram(gl, false);
    }
    
};
 
#endif // #define GAMP_RENDER_GL_PRIM_PRIMCONTEXT_HPP_