SolInSpace.cpp

Simple solar fragment-shader w/ core- and halo-radius.

Simple solar fragment-shader w/ core- and halo-radius.

/*
 * 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/.
 */
 
#include <gamp/Gamp.hpp>
 
#include <cstdio>
#include <cmath>
#include <memory>
 
#include <jau/basic_types.hpp>
#include <jau/float_types.hpp>
#include <jau/fraction_type.hpp>
#include <jau/io/file_util.hpp>
#include <jau/math/mat4f.hpp>
#include <jau/math/vec4f.hpp>
 
#include <gamp/Gamp.hpp>
#include <gamp/render/RenderContext.hpp>
 
#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>
 
#include "../demos/GLLauncher01.hpp"
#include "gamp/render/gl/GLCapabilities.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 Example : public RenderListener {
  private:
    constexpr static float defaultCoreRadius = 0.20f;
    constexpr static float animCoreRadiusHalfStep = 0.015f;
 
    Vec3f m_center = Vec3f(0, 0, 0);
    float m_radius = 1.00f;
 
    ShaderState m_st;
    Recti m_viewport;
    GLUniformSyncPMVMat4f m_pmvMatUni;
 
    GLUniformVec4f m_uWinCenter;
    GLUniformVec4f m_uCoreColor, m_uHaloColor, m_uBackColor;
    GLUniformScalarF32 m_uWinRadius, m_uCoreRadius, m_uSeam;
 
    bool m_initialized;
    jau::fraction_timespec m_tlast;
 
    class MyKeyListener : public KeyListener {
      public:
        MyKeyListener(Example &) { }
 
        void keyPressed(KeyEvent &e, const KeyboardTracker &kt) override {
            jau::fprintf_td(e.when().to_ms(), stdout, "KeyPressed: %s; keys %zu\n", e.toString().c_str(), kt.pressedKeyCodes().count());
            if (e.keySym() == VKeyCode::VK_ESCAPE) {
                WindowSRef win = e.source().lock();
                if (win) {
                    win->dispose(e.when());
                }
            } else if (e.keySym() == VKeyCode::VK_W) {
                WindowSRef win = e.source().lock();
                jau::fprintf_td(e.when().to_ms(), stdout, "Source: %s\n", win ? win->toString().c_str() : "null");
            }
        }
        void keyReleased(KeyEvent &e, const KeyboardTracker &kt) override {
            jau::fprintf_td(e.when().to_ms(), stdout, "KeyRelease: %s; keys %zu\n", e.toString().c_str(), kt.pressedKeyCodes().count());
        }
    };
    typedef std::shared_ptr<MyKeyListener> MyKeyListenerRef;
    MyKeyListenerRef m_kl;
 
  public:
 
    Example()
    : RenderListener(RenderListener::Private()),
      m_pmvMatUni("gcu_PMVMatrix"),
      m_uWinCenter("gcu_solInSpace.winCenter", Vec4f()),
      m_uCoreColor("gcu_solInSpace.coreColor", Vec4f(1.0f, 1.0f, 0.0f, 1.0f)),
      m_uHaloColor("gcu_solInSpace.haloColor", Vec4f(1.0f, 0.99f, 0.0f, 1.0f)),
      m_uBackColor("gcu_solInSpace.bgColor", Vec4f(0.0f, 0.0f, 0.0f, 0.5f)),
      m_uWinRadius("gcu_solInSpace.winRadius", 0),
      m_uCoreRadius("gcu_solInSpace.coreRadius", defaultCoreRadius),
      m_uSeam("gcu_solInSpace.seam", 0.005f),
      m_initialized(false),
      m_kl(std::make_shared<MyKeyListener>(*this))
    {
        m_st.manage(m_pmvMatUni);
 
        m_st.manage(m_uWinCenter);
        m_st.manage(m_uCoreColor);
        m_st.manage(m_uHaloColor);
        m_st.manage(m_uBackColor);
        m_st.manage(m_uWinRadius);
        m_st.manage(m_uCoreRadius);
        m_st.manage(m_uSeam);
    }
 
    Recti& viewport() noexcept { return m_viewport; }
    const Recti& viewport() const noexcept { return m_viewport; }
 
    PMVMat4f& pmv() noexcept { return m_pmvMatUni.pmv(); }
    const PMVMat4f& pmv() const noexcept { return m_pmvMatUni.pmv(); }
 
    bool init(const WindowSRef& win, const jau::fraction_timespec& when) override {
        ShaderCode::DEBUG_CODE = true;
        // ShaderState::VERBOSE_STATE = true;
        // ShaderState::DEBUG_STATE = true;
 
        jau::fprintf_td(when.to_ms(), stdout, "RL::init: %s\n", toString().c_str());
        m_tlast = when;
 
        GL& gl = GL::downcast(win->renderContext());
        ShaderCodeSRef vp0 = ShaderCode::create(gl, GL_VERTEX_SHADER, "demos/glsl",
                "demos/glsl/bin", "default");
        ShaderCodeSRef fp0 = ShaderCode::create(gl, GL_FRAGMENT_SHADER, "demos/glsl",
                "demos/glsl/bin", "SolInSpace");
        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);
        fp0->defaultShaderCustomization(gl);
        ShaderProgramSRef 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);
 
        // setup mgl_PMVMatrix
        PMVMat4f &pmv = m_pmvMatUni.pmv();
        pmv.getP().loadIdentity();
        pmv.getMv().loadIdentity();
 
        // ::glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
        // m_uBackColor->vec4f().set(1.0f, 1.0f, 1.0f, 0.5f);
        ::glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
        m_uBackColor.vec4f().set(0.0f, 0.0f, 0.0f, 0.5f);
 
        // Allocate Vertex Array
        GLFloatArrayDataServerSRef vertices = GLFloatArrayDataServer::createGLSL("gca_Vertex", 3, false, 4, GL_STATIC_DRAW);
        vertices->reserve(4); // reserve 4 elements (4x3 components) upfront, otherwise growIfNeeded is used
        vertices->put( { -m_radius,  m_radius, 0, // 1st vertex
                          m_radius,  m_radius, 0, // burst transfer, instead of 4x `put3f` for single vertice-value
                         -m_radius, -m_radius, 0,
                          m_radius, -m_radius, 0 } );
        m_st.manage(vertices);
        vertices->seal(gl, true);
 
        ::glEnable(GL_DEPTH_TEST);
 
        m_initialized = sp0->inUse();
        if( m_initialized ) {
            m_st.sendAllUniforms(gl);
        } 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);
        }
        m_st.useProgram(gl, false);
 
        win->addKeyListener(m_kl);
        return m_initialized;
    }
 
    void updateSolSpatial(GL &gl) {
        PMVMat4f &pmv = m_pmvMatUni.pmv();
        {
            Vec3f winCenter;
            pmv.mapObjToWin(m_center, m_viewport, winCenter);
            m_uWinCenter.vec4f().set(winCenter, 1.0f);
 
            const Vec3f p1 = m_center + Vec3f(m_radius,0,0);
            Vec3f winP1;
            pmv.mapObjToWin(p1, m_viewport, winP1);
            Vec3f winR = winP1 - winCenter;
            m_uWinRadius.scalar() = winR.length();
        }
        m_st.send(gl, m_uWinCenter);
        m_st.send(gl, m_uWinRadius);
    }
 
    void dispose(const WindowSRef& win, const jau::fraction_timespec& when) override {
        jau::fprintf_td(when.to_ms(), stdout, "RL::dispose: %s\n", toString().c_str());
        win->removeKeyListener(m_kl);
        m_st.destroy(GL::downcast(win->renderContext()));
        m_initialized = false;
    }
 
    void reshape(const WindowSRef& win, const jau::math::Recti& viewport, const jau::fraction_timespec& when) override {
        GL& gl = GL::downcast(win->renderContext());
        jau::fprintf_td(when.to_ms(), stdout, "RL::reshape: %s\n", toString().c_str());
        m_viewport = viewport;
 
        const float aspect = 1.0f;
        const float fovy_deg=45.0f;
        const float aspect2 = ( (float) m_viewport.width() / (float) m_viewport.height() ) / aspect;
        const float zNear=1.0f;
        const float zFar=100.0f;
        PMVMat4f &pmv = m_pmvMatUni.pmv();
        pmv.setToPerspective(jau::adeg_to_rad(fovy_deg), aspect2, zNear, zFar);
        pmv.getMv().loadIdentity();
        pmv.translateMv(0, 0, -3);
 
        m_st.useProgram(gl, true);
        m_st.send(gl, m_pmvMatUni);
        updateSolSpatial(gl);
        m_st.useProgram(gl, false);
    }
 
    bool m_once = true;
 
    void display(const WindowSRef& win, const jau::fraction_timespec& when) override {
        // jau::fprintf_td(when.to_ms(), stdout, "RL::display: %s, %s\n", toString().c_str(), win->toString().c_str());
        if( !m_initialized ) {
            return;
        }
        GL& gl = GL::downcast(win->renderContext());
        ::glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
        m_st.useProgram(gl, true);
        {
            static float dr_dir = 1;
            constexpr float dr_min = defaultCoreRadius * 1.0f-animCoreRadiusHalfStep;
            constexpr float dr_max = defaultCoreRadius * 1.0f+animCoreRadiusHalfStep;
            const float dt = (float)(when - m_tlast).to_ms() / 1000.0f;
            float r = m_uCoreRadius.scalar() + animCoreRadiusHalfStep * dt * dr_dir;
            if( r <= dr_min ) {
                dr_dir = 1;
                r = dr_min;
            } else if( r >= dr_max ) {
                dr_dir = -1;
                r = dr_max;
            }
            m_uCoreRadius.scalar() = r;
        }
        m_st.send(gl, m_uCoreRadius);
        if( m_once ) {
            std::cerr << "XXX: " << m_st << "\n";
            m_once = false;
        }
 
        if( true ) {
            ::glEnable(GL_BLEND);
            ::glBlendEquation(GL_FUNC_ADD); // default
            ::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        }
 
        // Draw a square
        ::glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
        m_st.useProgram(gl, false);
 
        m_tlast = when;
    }
 
    std::string toStringImpl() const noexcept override { return "SolInSpace"; }
};
 
int main(int argc, char *argv[]) // NOLINT(bugprone-exception-escape)
{
    return launch("SolInSpace",
                  GLLaunchProps{.profile=GLProfile(GLProfile::GLES2), .contextFlags=gamp::render::RenderContextFlags::verbose, .requestedCaps=GLCapabilities()},
                  std::make_shared<Example>(), argc, argv);
}