Gamp v0.0.7-36-g24b1eb6
Gamp: Graphics, Audio, Multimedia and Processing
Loading...
Searching...
No Matches
GraphShapes01.cpp

This is the first C++ example demonstrating Graph resolution independent GPU curve rendering.

This is the first C++ example demonstrating Graph resolution independent GPU curve rendering.Multiple complex shapes are rotated with front- and back-face as well as per-pixel-lighting.

/*
* 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 <cstdio>
#include <cmath>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
#include <jau/darray.hpp>
#include <jau/debug.hpp>
#include <gamp/Gamp.hpp>
#include "../demos/graph/testshapes/Glyph05FreeSerifBoldItalic_ae.hpp"
#include "../demos/graph/testshapes/Glyph03FreeMonoRegular_M.hpp"
#include "../demos/GLLauncher01.hpp"
using namespace jau::math;
using namespace jau::math::util;
using namespace jau::math::geom;
using namespace gamp;
using namespace gamp::wt;
using namespace gamp::wt::event;
using namespace gamp::graph;
using namespace gamp::graph::tess;
using namespace gamp::render::gl::glsl;
using namespace gamp::render::gl::data;
u( GLUniformSyncMatrices4f::create("gcu_PMVMatrix", m.getSyncPMvMviMvit()) ) // P, Mv, Mvi and Mvit
{}
};
public:
struct GraphRendererProps {
bool m_isTwoPass = false;
bool m_pass1 = true;
bool m_hasFrustumClipping = false;
bool m_hasNormalChannel = false;
bool m_hasLight0 = true;
bool m_hasColorChannel = false;
bool m_hasColorTexture = false;
};
private:
ShaderState& m_st;
bool m_initialized;
public:
constexpr bool usesNormal() const noexcept { return m_props.m_hasLight0 || m_props.m_hasNormalChannel; }
constexpr GLsizei arrayCompsPerElement() const noexcept { return usesNormal()? 3*3 : 2*3; }
static constexpr bool DEBUG_MODE = true;
static constexpr std::string_view GLSL_PARAM_COMMENT_START = "\n// Gamp Graph Parameter Start\n";
static constexpr std::string_view GLSL_PARAM_COMMENT_END = "// Gamp Graph Parameter End\n\n";
static constexpr std::string_view GLSL_USE_COLOR_CHANNEL = "#define USE_COLOR_CHANNEL 1\n";
static constexpr std::string_view GLSL_USE_NORMAL_CHANNEL = "#define USE_NORMAL_CHANNEL 1\n";
static constexpr std::string_view GLSL_USE_LIGHT0 = "#define USE_LIGHT0 1\n";
static constexpr std::string_view GLSL_USE_COLOR_TEXTURE = "#define USE_COLOR_TEXTURE 1\n";
static constexpr std::string_view GLSL_USE_FRUSTUM_CLIPPING = "#define USE_FRUSTUM_CLIPPING 1\n";
static constexpr std::string_view GLSL_DEF_SAMPLE_COUNT = "#define SAMPLE_COUNT ";
static constexpr std::string_view GLSL_CONST_SAMPLE_COUNT = "const float sample_count = ";
static constexpr std::string_view GLSL_MAIN_BEGIN = "void main (void)\n{\n";
static constexpr std::string_view gcuTexture2D = "gcuTexture2D";
static constexpr std::string_view colTexLookupFuncName = "texture2D";
static constexpr std::string_view GLSL_USE_DISCARD = "#define USE_DISCARD 1\n";
static constexpr std::string_view shader_basename = "curverenderer01";
static constexpr std::string_view source_dir = "impl/graph/glsl";
static constexpr std::string_view bin_dir = "impl/graph/glsl/bin";
public:
GraphRenderer(ShaderState& st)
: m_st(st),
m_initialized(false)
{ }
constexpr bool initialized() const noexcept { return m_initialized; }
bool init(GL& gl, const jau::fraction_timespec& when) {
std::string vertexShaderName, fragmentShaderName;
vertexShaderName.append(shader_basename);
if( m_props.m_isTwoPass ) {
vertexShaderName.append("-pass").append(m_props.m_pass1 ? "1":"2");
} else {
vertexShaderName.append("-single");
}
fragmentShaderName.append(shader_basename).append("-segment-head");
ShaderCodeRef rsVp = ShaderCode::create(gl, GL_VERTEX_SHADER, source_dir, bin_dir, vertexShaderName);
ShaderCodeRef rsFp = ShaderCode::create(gl, GL_FRAGMENT_SHADER, source_dir, bin_dir, fragmentShaderName);
if( !rsVp || !rsFp ) {
jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
return false;
}
{
size_t posVp = rsVp->defaultShaderCustomization(gl, true, true);
size_t posFp = rsFp->defaultShaderCustomization(gl, true, true);
if( posVp == std::string::npos || posFp == std::string::npos ) {
jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
return false;
}
// GLSL append from here on
posFp = -1;
posVp = rsVp->insertShaderSource(0, posVp, GLSL_PARAM_COMMENT_START);
posFp = rsFp->insertShaderSource(0, posFp, GLSL_PARAM_COMMENT_START);
// if( !gl.getContext().hasRendererQuirk(GLRendererQuirks.GLSLBuggyDiscard) ) {
posFp = rsFp->insertShaderSource(0, posFp, GLSL_USE_DISCARD);
// }
if( m_props.m_hasFrustumClipping ) {
posVp = rsVp->insertShaderSource(0, posVp, GLSL_USE_FRUSTUM_CLIPPING);
posFp = rsFp->insertShaderSource(0, posFp, GLSL_USE_FRUSTUM_CLIPPING);
}
if( usesNormal() ) {
posVp = rsVp->insertShaderSource(0, posVp, GLSL_USE_NORMAL_CHANNEL);
posFp = rsFp->insertShaderSource(0, posFp, GLSL_USE_NORMAL_CHANNEL);
}
if( m_props.m_hasLight0 ) {
posVp = rsVp->insertShaderSource(0, posVp, GLSL_USE_LIGHT0);
posFp = rsFp->insertShaderSource(0, posFp, GLSL_USE_LIGHT0);
}
if( m_props.m_hasColorChannel ) {
posVp = rsVp->insertShaderSource(0, posVp, GLSL_USE_COLOR_CHANNEL);
posFp = rsFp->insertShaderSource(0, posFp, GLSL_USE_COLOR_CHANNEL);
}
if( m_props.m_hasColorTexture ) {
rsVp->insertShaderSource(0, posVp, GLSL_USE_COLOR_TEXTURE);
posFp = rsFp->insertShaderSource(0, posFp, GLSL_USE_COLOR_TEXTURE);
}
/*if( !pass1 ) {
posFp = rsFp->insertShaderSource(0, posFp, GLSL_DEF_SAMPLE_COUNT+sms.sampleCount+"\n");
posFp = rsFp->insertShaderSource(0, posFp, GLSL_CONST_SAMPLE_COUNT+sms.sampleCount+".0;\n");
} */
posVp = rsVp->insertShaderSource(0, posVp, GLSL_PARAM_COMMENT_END);
if( posVp == std::string::npos ) {
jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
return false;
}
posFp = rsFp->insertShaderSource(0, posFp, GLSL_PARAM_COMMENT_END);
posFp = rsFp->insertShaderSourceFile(0, posFp, string_t(source_dir).append("/constants.glsl"));
if( posFp == std::string::npos ) {
jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
return false;
}
posFp = rsFp->insertShaderSourceFile(0, posFp, string_t(source_dir).append("/uniforms.glsl"));
if( posFp == std::string::npos ) {
jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
return false;
}
posFp = rsFp->insertShaderSourceFile(0, posFp, string_t(source_dir).append("/varyings.glsl"));
if( posFp == std::string::npos ) {
jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
return false;
}
if( m_props.m_hasColorTexture || m_props.m_hasFrustumClipping ) {
posFp = rsFp->insertShaderSourceFile(0, posFp, string_t(source_dir).append("/functions.glsl"));
if( posFp == std::string::npos ) {
jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
return false;
}
}
/*if( hasColorTexture ) {
posFp = rsFp->insertShaderSource(0, posFp, "uniform "+colorTexSeq.getTextureSampler2DType()+" "+UniformNames.gcu_ColorTexUnit+";\n");
posFp = rsFp->insertShaderSource(0, posFp, colorTexSeq.getTextureLookupFragmentShaderImpl());
}*/
posFp = rsFp->insertShaderSource(0, posFp, GLSL_MAIN_BEGIN);
std::string passS = m_props.m_pass1 ? "-pass1-" : "-pass2-";
std::string shaderSegment = string_t(source_dir).append("/").append(shader_basename).append(passS).append("curve_simple").append(".glsl"); // sms.tech+sms.sub+".glsl";
if(DEBUG_MODE) {
jau::PLAIN_PRINT(true, "RegionRenderer.createShaderProgram.1: segment %s", shaderSegment.c_str());
}
posFp = rsFp->insertShaderSourceFile(0, posFp, shaderSegment);
if( posFp == std::string::npos ) {
jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
return false;
}
posFp = rsFp->insertShaderSource(0, posFp, "}\n");
if( posFp == std::string::npos ) {
jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
return false;
}
if( m_props.m_hasColorTexture ) {
rsFp->replaceInShaderSource(std::string(gcuTexture2D), std::string(colTexLookupFuncName));
}
}
ShaderProgramRef sp0 = ShaderProgram::create();
if( !sp0->add(gl, rsVp, true) || !sp0->add(gl, rsFp, true) ) {
jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
sp0->destroy(gl);
return false;
}
m_st.attachShaderProgram(gl, sp0, true);
m_st.pushAllUniforms(gl);
m_initialized = sp0->inUse();
if( !m_initialized ) {
jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
m_st.destroy(gl);
}
return m_initialized;
}
void useProgram(GL& gl, bool on) {
m_st.useProgram(gl, on);
}
};
class GraphRegion {
public:
typedef jau::darray<uint32_t, glmemsize_t> u32buffer_t;
private:
GraphRenderer& m_renderer;
ShaderState& m_st;
bool m_initialized;
int m_num_vertices, m_num_indices;
public:
GraphRegion(GraphRenderer& renderer, ShaderState& st)
: m_renderer(renderer), m_st(st),
m_initialized(m_renderer.initialized()),
m_array(GLFloatArrayDataServer::createGLSLInterleaved(m_renderer.arrayCompsPerElement(), false, 256, GL_STATIC_DRAW)),
m_indices(GLUIntArrayDataServer::createData(3, 256, GL_STATIC_DRAW, GL_ELEMENT_ARRAY_BUFFER)),
m_num_vertices(0), m_num_indices(0)
{
m_array->addGLSLSubArray("gca_Vertex", 3, GL_ARRAY_BUFFER);
m_array->addGLSLSubArray("gca_CurveParam", 3, GL_ARRAY_BUFFER);
if( m_renderer.usesNormal() ) {
m_array->addGLSLSubArray("gca_Normal", 3, GL_ARRAY_BUFFER);
}
m_st.ownAttribute(m_array, true);
// m_st.ownAttribute(m_indices, true);
}
constexpr bool initialized() const noexcept { return m_initialized; }
void seal(GL& gl, bool seal_) {
if( !m_initialized ) {
return;
}
m_array->seal(gl, seal_);
m_indices->seal(gl, seal_);
m_array->enableBuffer(gl, false);
m_indices->enableBuffer(gl, false);
}
void pushVertex(const Vertex& v, const Vec3f& normal) {
// jau::PLAIN_PRINT(true, "pushVertex.0[%d]: v %s]", m_num_vertices, v.toString().c_str());
m_array->put3f(v.coord());
m_array->put3f(v.texCoord());
if( m_renderer.usesNormal() ) {
m_array->put3f(normal);
}
++m_num_vertices;
}
void pushIndices(uint32_t i, uint32_t j, uint32_t k) {
// jau::PLAIN_PRINT(true, "pushIndices.0[%d]: %u, %u, %u]", m_num_indices, i, j, k);
m_indices->putN(i, j, k);
m_num_indices += 3;
}
void pushNewVerticesIdx(const Vertex& vertIn1, const Vertex& vertIn2, const Vertex& vertIn3, const Vec3f& normal) {
pushIndices(m_num_vertices, m_num_vertices+1, m_num_vertices+2);
pushVertex(vertIn1, normal);
pushVertex(vertIn2, normal);
pushVertex(vertIn3, normal);
}
void addOutlineShape(OutlineShape& shape) {
if( Graph::DEBUG_MODE ) {
jau::PLAIN_PRINT(true, "add.0 num[vertices %d, indices %d]", m_num_vertices, m_num_indices);
jau::PLAIN_PRINT(true, "add.0 array: %s", m_array->toString().c_str());
jau::PLAIN_PRINT(true, "add.0 indices: %s", m_indices->toString().c_str());
}
const TriangleRefList& trisIn = shape.getTriangles();
const VertexList& vertsIn = shape.getVertices();
if( Graph::DEBUG_MODE ) {
jau::PLAIN_PRINT(true, "add.0 triangles %u, vertices %u", trisIn.size(), vertsIn.size());
}
{
glmemsize_t verticeCount = (glmemsize_t)vertsIn.size() + shape.addedVertexCount();
glmemsize_t indexCount = (glmemsize_t)trisIn.size() * 3;
m_array->growIfNeeded(verticeCount * m_array->compsPerElem());
m_indices->growIfNeeded(indexCount * m_indices->compsPerElem());
}
uint32_t idxOffset = m_num_vertices;
if( vertsIn.size() >= 3 ) {
//
// Processing Vertices
//
for(const Vertex& v : vertsIn) {
pushVertex(v, shape.normal());
}
constexpr static uint32_t max_index = std::numeric_limits<uint32_t>::max() / sizeof(uint32_t);
OutlineShape::size_type trisIn_sz = trisIn.size();
for(OutlineShape::size_type i=0; i < trisIn_sz; ++i) {
const TriangleRef& triIn = trisIn[i];
// triEx.addVertexIndicesOffset(idxOffset);
// triangles.add( triEx );
Triangle::trivert_t& triInVertices = triIn->vertices();
uint32_t tv0Idx = triInVertices[0].id();
if ( max_index - idxOffset > tv0Idx ) {
// valid 'known' idx - move by offset
pushIndices(tv0Idx+idxOffset,
triInVertices[1].id()+idxOffset,
triInVertices[2].id()+idxOffset);
} else {
// FIXME: If exceeding max_indices, we would need to generate a new buffer w/ indices
pushNewVerticesIdx(triInVertices[0], triInVertices[1], triInVertices[2], shape.normal());
}
}
}
if( Graph::DEBUG_MODE ) {
jau::PLAIN_PRINT(true, "add.x num[vertices %d, indices %d]", m_num_vertices, m_num_indices);
jau::PLAIN_PRINT(true, "add.x array: %s", m_array->toString().c_str());
jau::PLAIN_PRINT(true, "add.x indices: %s", m_indices->toString().c_str());
}
}
void draw(GL &gl) {
if( !m_initialized ) {
return;
}
m_renderer.useProgram(gl, true);
m_array->enableBuffer(gl, true);
m_indices->bindBuffer(gl, true); // keeps VBO binding
::glEnable(GL_BLEND);
::glBlendEquation(GL_FUNC_ADD); // default
::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
::glDrawElements(GL_TRIANGLES, m_indices->elemCount() * m_indices->compsPerElem(), GL_UNSIGNED_INT, nullptr);
m_indices->bindBuffer(gl, false);
m_array->enableBuffer(gl, false);
// m_renderer.useProgram(gl, false);
}
};
class Shape;
typedef std::shared_ptr<Shape> ShapeRef;
class Shape {
private:
ShaderState& m_st;
PMVMat4fUniform& m_pmvMat;
OutlineShape m_oshape;
GLUtilTesselator::SegmentList m_segments;
Vec3f m_position;
Quat4f m_rotation;
Vec3f m_rotPivot;
Vec3f m_scale = Vec3f(1, 1, 1);
float m_zOffset;
GraphRenderer& m_renderer;
GraphRegion m_region;
Mat4f iMat;
Mat4f tmpMat;
bool iMatIdent = true;
bool iMatDirty = false;
struct Private{ explicit Private() = default; };
public:
Shape(Private, ShaderState &st, PMVMat4fUniform& pmvMatU, GraphRenderer& renderer)
: m_st(st), m_pmvMat(pmvMatU), m_oshape(3, 16),
m_renderer(renderer), m_region(m_renderer, m_st)
{
m_uColor = GLUniformVec4f::create("gcu_StaticColor", Vec4f(0, 0, 0, 1));
m_st.ownUniform(m_uColor, true);
}
static ShapeRef create(ShaderState &st, PMVMat4fUniform& pmvMatU, GraphRenderer& renderer) {
return std::make_shared<Shape>(Private(), st, pmvMatU, renderer);
}
constexpr const Vec3f& position() const noexcept { return m_position; }
constexpr Vec3f& position() noexcept { iMatDirty=true; return m_position; }
constexpr const float& zOffset() const noexcept { return m_zOffset; }
constexpr float& zOffset() noexcept { iMatDirty=true; return m_zOffset; }
constexpr const Quat4f& rotation() const noexcept { return m_rotation; }
constexpr Quat4f& rotation() noexcept { iMatDirty=true; return m_rotation; }
constexpr const Vec3f& rotationPivot() const noexcept { return m_rotPivot; }
constexpr Vec3f& rotationPivot() noexcept { iMatDirty=true; return m_rotPivot; }
constexpr const Vec3f& scale() const noexcept { return m_scale; }
constexpr Vec3f& scale() noexcept { iMatDirty=true; return m_scale; }
constexpr const OutlineShape& outlines() const noexcept { return m_oshape; }
constexpr OutlineShape& outlines() noexcept { return m_oshape; }
const Vec4f& color() const noexcept { return m_uColor->vec4f(); }
void setColor(const Vec4f& c) noexcept { m_uColor->vec4f()=c; }
void update(GL& gl) {
m_region.addOutlineShape(m_oshape);
m_region.seal(gl, true);
}
void draw(GL &gl) {
m_pmvMat.m.pushMv();
applyMatToMv(m_pmvMat.m);
m_st.pushUniform(gl, m_pmvMat.u); // automatic sync + update of Mvi + Mvit
m_st.pushUniform(gl, m_uColor);
m_region.draw(gl);
m_pmvMat.m.popMv();
}
private:
/**
* Applies the internal {@link Matrix4f} to the given {@link PMVMatrix4f#getMv() modelview matrix},
* i.e. {@code pmv.mulMv( getMat() )}.
* <p>
* Calls {@link #updateMat()} if dirty.
* </p>
* In case {@link #isMatIdentity()} is {@code true}, implementation is a no-operation.
* </p>
* @param pmv the matrix
* @see #isMatIdentity()
* @see #updateMat()
* @see #getMat()
* @see PMVMatrix4f#mulMv(Matrix4f)
*/
void applyMatToMv(PMVMat4f& pmvMat) noexcept {
if( iMatDirty ) {
updateMat();
}
if( !iMatIdent ) {
pmvMat.mulMv(iMat);
}
}
void updateMat() noexcept {
bool hasPos = !m_position.is_zero();
bool hasScale = m_scale != Vec3f::one;
bool hasRotate = !m_rotation.isIdentity();
bool hasRotPivot = false; // null != rotPivot;
const Vec3f& ctr = m_oshape.bounds().center();
bool sameScaleRotatePivot = hasScale && hasRotate && ( !hasRotPivot || m_rotPivot == ctr );
if( sameScaleRotatePivot ) {
iMatIdent = false;
iMat.setToTranslation(m_position); // identity + translate, scaled
// Scale shape from its center position and rotate around its center
iMat.translate(Vec3f(ctr).mul(m_scale)); // add-back center, scaled
iMat.rotate(m_rotation);
iMat.scale(m_scale);
iMat.translate(-ctr); // move to center
} else if( hasRotate || hasScale ) {
iMatIdent = false;
iMat.setToTranslation(m_position); // identity + translate, scaled
if( hasRotate ) {
if( hasRotPivot ) {
// Rotate shape around its scaled pivot
iMat.translate(Vec3f(m_rotPivot).mul(m_scale)); // pivot back from rot-pivot, scaled
iMat.rotate(m_rotation);
iMat.translate(Vec3f(-m_rotPivot).mul(m_scale)); // pivot to rot-pivot, scaled
} else {
// Rotate shape around its scaled center
iMat.translate(Vec3f(ctr).mul(m_scale)); // pivot back from center-pivot, scaled
iMat.rotate(m_rotation);
iMat.translate(Vec3f(-ctr).mul(m_scale)); // pivot to center-pivot, scaled
}
}
if( hasScale ) {
// Scale shape from its center position
iMat.translate(Vec3f(ctr).mul(m_scale)); // add-back center, scaled
iMat.scale(m_scale);
iMat.translate(Vec3f(-ctr).mul(m_scale)); // move to center
}
} else if( hasPos ) {
iMatIdent = false;
iMat.setToTranslation(m_position); // identity + translate, scaled
} else {
iMatIdent = true;
iMat.loadIdentity();
}
iMatDirty = false;
}
};
class GraphShapes01 : public RenderListener {
private:
constexpr static jau::math::Vec3f lightPos = jau::math::Vec3f(0.0f, 5.0f, 10.0f);
constexpr static float zNear= 1.0f;
constexpr static float zFar =100.0f;
ShaderState m_st;
Recti m_viewport;
bool m_initialized;
bool m_animating = true;
bool m_oneframe = false;
jau::fraction_timespec m_tlast;
PMVMat4fUniform m_pmvMat;
GraphRenderer m_renderer;
std::vector<ShapeRef> m_shapes;
public:
m_initialized(false), m_renderer(m_st)
{
}
Recti& viewport() noexcept { return m_viewport; }
const Recti& viewport() const noexcept { return m_viewport; }
PMVMat4f& pmv() noexcept { return m_pmvMat.m; }
const PMVMat4f& pmv() const noexcept { return m_pmvMat.m; }
bool animating() const noexcept { return m_animating; }
bool& animating() noexcept { return m_animating; }
void setOneFrame() noexcept { m_animating=false; m_oneframe=true; }
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());
m_tlast = when;
GL& gl = GL::downcast(win->renderContext());
// setup mgl_PMVMatrix
m_pmvMat.m.getP().loadIdentity();
m_pmvMat.m.getMv().loadIdentity();
m_st.ownUniform(m_pmvMat.u, true);
if( !m_renderer.init(gl, when) ) {
jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d: %s\n", E_FILE_LINE, toString().c_str());
win->dispose(when);
return false;
}
GLUniformVec3fRef lightU = GLUniformVec3f::create("gcu_LightPos", lightPos);
m_st.ownUniform(lightU, true);
m_st.pushAllUniforms(gl);
const float lineWidth = 1/2.5f;
const float dz = 0.005f;
if( true ) {
// Cross / Plus
const float width = 1.5f;
const float height = 1.5f;
float lwh = lineWidth/2.0f;
float twh = width/2.0f;
float thh = height/2.0f;
float ctrX = 0, ctrY = 0, ctrZ = dz;
ShapeRef frontShape = Shape::create(m_st, m_pmvMat, m_renderer);
m_shapes.push_back(frontShape);
OutlineShape& oshape = frontShape->outlines();
// CCW
oshape.moveTo(ctrX-lwh, ctrY+thh, ctrZ); // vert: left-top
oshape.lineTo(ctrX-lwh, ctrY+lwh, ctrZ);
oshape.lineTo(ctrX-twh, ctrY+lwh, ctrZ); // horz: left-top
oshape.lineTo(ctrX-twh, ctrY-lwh, ctrZ); // horz: left-bottom
oshape.lineTo(ctrX-lwh, ctrY-lwh, ctrZ);
oshape.lineTo(ctrX-lwh, ctrY-thh, ctrZ); // vert: left-bottom
oshape.lineTo(ctrX+lwh, ctrY-thh, ctrZ); // vert: right-bottom
oshape.lineTo(ctrX+lwh, ctrY-lwh, ctrZ);
oshape.lineTo(ctrX+twh, ctrY-lwh, ctrZ); // horz: right-bottom
oshape.lineTo(ctrX+twh, ctrY+lwh, ctrZ); // horz: right-top
oshape.lineTo(ctrX+lwh, ctrY+lwh, ctrZ);
oshape.lineTo(ctrX+lwh, ctrY+thh, ctrZ); // vert: right-top
oshape.lineTo(ctrX-lwh, ctrY+thh, ctrZ); // vert: left-top
oshape.closePath();
// shape1->seal(gl, true);
frontShape->update(gl);
frontShape->setColor(Vec4f(0.5f, 0.05f, 0.05f, 1));
frontShape->position().x = -2.0f;
ShapeRef backShape = Shape::create(m_st, m_pmvMat, m_renderer);
m_shapes.push_back(backShape);
backShape->outlines() = oshape.flipFace(); // -dz);
backShape->outlines().clearCache();
backShape->update(gl);
backShape->setColor(Vec4f(0.2f, 0.5f, 0.2f, 1));
backShape->position().x = -2.0f;
}
if( true) {
ShapeRef frontShape = Shape::create(m_st, m_pmvMat, m_renderer);
m_shapes.push_back(frontShape);
OutlineShape& oshape = frontShape->outlines();
oshape.moveTo(0.0f,-10.0f, 0);
oshape.lineTo(15.0f,-10.0f, 0);
oshape.quadTo(10.0f,5.0f,0, 15.0f,10.0f,0);
oshape.cubicTo(6.0f,15.0f,0, 5.0f,8.0f,0, 0.0f,10.0f,0);
oshape.closePath();
oshape.moveTo(5.0f,-5.0f,0);
oshape.quadTo(10.0f,-5.0f,0, 10.0f,0.0f,0);
oshape.quadTo(5.0f,0.0f,0, 5.0f,-5.0f,0);
oshape.closePath();
frontShape->update(gl);
frontShape->setColor(Vec4f(0.4f, 0.4f, 0.1f, 1));
frontShape->position().x = -1.0f;
frontShape->scale().x *= 0.1f;
frontShape->scale().y *= 0.1f;
ShapeRef backShape = Shape::create(m_st, m_pmvMat, m_renderer);
m_shapes.push_back(backShape);
backShape->outlines() = oshape.flipFace(-dz);
backShape->outlines().clearCache();
backShape->update(gl);
backShape->setColor(Vec4f(0.2f, 0.2f, 0.5f, 1));
backShape->position().x = -1.0f;
backShape->scale().x *= 0.1f;
backShape->scale().y *= 0.1f;
}
if ( true ) {
ShapeRef frontShape = Shape::create(m_st, m_pmvMat, m_renderer);
m_shapes.push_back(frontShape);
OutlineShape& oshape = frontShape->outlines();
frontShape->update(gl);
frontShape->setColor(Vec4f(0.05f, 0.05f, 0.5f, 1));
frontShape->position().x = 1.5f;
frontShape->position().y = -1.0f;
frontShape->scale().x *= 2.0f;
frontShape->scale().y *= 2.0f;
ShapeRef backShape = Shape::create(m_st, m_pmvMat, m_renderer);
m_shapes.push_back(backShape);
backShape->outlines() = oshape.flipFace(-dz);
backShape->outlines().clearCache();
backShape->update(gl);
backShape->setColor(Vec4f(0.4f, 0.4f, 0.1f, 1));
backShape->position().x = 1.5f;
backShape->position().y = -1.0f;
backShape->scale().x *= 2.0f;
backShape->scale().y *= 2.0f;
}
if ( true ) {
ShapeRef frontShape = Shape::create(m_st, m_pmvMat, m_renderer);
m_shapes.push_back(frontShape);
OutlineShape& oshape = frontShape->outlines();
frontShape->update(gl);
frontShape->setColor(Vec4f(0.05f, 0.5f, 0.05f, 1));
frontShape->position().x = 1.5f;
frontShape->position().y = 0.5f;
frontShape->scale().x *= 2.0f;
frontShape->scale().y *= 2.0f;
ShapeRef backShape = Shape::create(m_st, m_pmvMat, m_renderer);
m_shapes.push_back(backShape);
backShape->outlines() = oshape.flipFace(-dz);
backShape->outlines().clearCache();
backShape->update(gl);
backShape->setColor(Vec4f(0.5f, 0.1f, 0.1f, 1));
backShape->position().x = 1.5f;
backShape->position().y = 0.5f;
backShape->scale().x *= 2.0f;
backShape->scale().y *= 2.0f;
}
::glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
::glEnable(GL_DEPTH_TEST);
// ::glEnable(GL_CULL_FACE);
::glDisable(GL_CULL_FACE);
m_initialized = true;
if( !m_initialized ) {
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());
m_st.destroy(GL::downcast(win->renderContext()));
m_initialized = false;
}
void reshape(const WindowRef& 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;
m_pmvMat.m.getP().loadIdentity();
const float aspect = 1.0f;
const float fovy_deg=45.0f;
const float aspect2 = ( (float) m_viewport.width() / (float) m_viewport.height() ) / aspect;
m_pmvMat.m.perspectiveP(jau::adeg_to_rad(fovy_deg), aspect2, zNear, zFar);
m_st.useProgram(gl, true);
m_st.pushUniform(gl, m_pmvMat.u); // automatic sync + update of Mvi + Mvit
// m_st.useProgram(gl, false);
}
void display(const WindowRef& 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);
m_pmvMat.m.getMv().loadIdentity();
m_pmvMat.m.translateMv(0, 0, -5);
for(const ShapeRef& s : m_shapes) {
if( animating() || m_oneframe ) {
constexpr double angle_per_sec = 30;
const float rad = (float) ( (when - m_tlast).to_double() * angle_per_sec );
s->rotation().rotateByAngleY(jau::adeg_to_rad( rad ));
}
s->draw(gl);
}
m_oneframe = false;
// m_st.useProgram(gl, false);
m_tlast = when;
}
std::string toStringImpl() const noexcept override { return "GraphShapes01"; }
};
class Example : public GraphShapes01 {
private:
class MyKeyListener : public KeyListener {
private:
GraphShapes01& m_parent;
public:
MyKeyListener(GraphShapes01& p) : m_parent(p) {}
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().bitCount());
if( e.keySym() == VKeyCode::VK_ESCAPE ) {
WindowRef win = e.source().lock();
if( win ) {
win->dispose(e.when());
}
} else if( e.keySym() == VKeyCode::VK_PAUSE || e.keySym() == VKeyCode::VK_P ) {
m_parent.animating() = !m_parent.animating();
} else if( e.keySym() == VKeyCode::VK_PERIOD ) {
m_parent.setOneFrame();
} else if( e.keySym() == VKeyCode::VK_W ) {
WindowRef 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().bitCount());
}
};
typedef std::shared_ptr<MyKeyListener> MyKeyListenerRef;
MyKeyListenerRef m_kl;
public:
m_kl(std::make_shared<MyKeyListener>(*this)) { }
bool init(const WindowRef& win, const jau::fraction_timespec& when) override {
if( !GraphShapes01::init(win, when) ) {
return false;
}
win->addKeyListener(m_kl);
return true;
}
void dispose(const WindowRef& win, const jau::fraction_timespec& when) override {
win->removeKeyListener(m_kl);
}
};
int main(int argc, char *argv[]) // NOLINT(bugprone-exception-escape)
{
// ShaderCode::DEBUG_CODE = true;
return launch("GraphShapes01.cpp",
GLLaunchProps{GLProfile(GLProfile::GLES2), gamp::render::RenderContextFlags::verbose}, // | gamp::render::RenderContextFlags::debug},
std::make_shared<Example>(), argc, argv);
}
int launch(std::string_view sfile, const GLLaunchProps &props, const RenderListenerRef &demo, int argc, char *argv[])
int main(int argc, char *argv[])
Definition GearsES2.cpp:232
std::shared_ptr< Shape > ShapeRef
std::shared_ptr< Shape > ShapeRef
#define E_FILE_LINE
void dispose(const WindowRef &win, const jau::fraction_timespec &when) override
Notifies the listener to perform the release of all renderer resources per context,...
Definition GearsES2.cpp:225
static void addShapeToRegion(gamp::graph::OutlineShape &shape)
static void addShapeToRegion(gamp::graph::OutlineShape &shape)
constexpr bool initialized() const noexcept
void draw(GL &gl)
void addOutlineShape(OutlineShape &shape)
void pushVertex(const Vertex &v, const Vec3f &normal)
jau::darray< uint32_t, glmemsize_t > u32buffer_t
void pushNewVerticesIdx(const Vertex &vertIn1, const Vertex &vertIn2, const Vertex &vertIn3, const Vec3f &normal)
GraphRegion(GraphRenderer &renderer, ShaderState &st)
void pushIndices(uint32_t i, uint32_t j, uint32_t k)
void seal(GL &gl, bool seal_)
static constexpr std::string_view GLSL_USE_LIGHT0
static constexpr std::string_view GLSL_MAIN_BEGIN
static constexpr std::string_view gcuTexture2D
static constexpr std::string_view GLSL_PARAM_COMMENT_START
static constexpr std::string_view GLSL_USE_DISCARD
static constexpr std::string_view colTexLookupFuncName
static constexpr std::string_view bin_dir
static constexpr std::string_view GLSL_PARAM_COMMENT_END
constexpr GLsizei arrayCompsPerElement() const noexcept
static constexpr bool DEBUG_MODE
constexpr bool initialized() const noexcept
static constexpr std::string_view GLSL_DEF_SAMPLE_COUNT
static constexpr std::string_view GLSL_USE_COLOR_TEXTURE
constexpr bool usesNormal() const noexcept
static constexpr std::string_view source_dir
static constexpr std::string_view GLSL_USE_FRUSTUM_CLIPPING
static constexpr std::string_view GLSL_USE_COLOR_CHANNEL
static constexpr std::string_view GLSL_CONST_SAMPLE_COUNT
GraphRenderer(ShaderState &st)
static constexpr std::string_view shader_basename
void useProgram(GL &gl, bool on)
static constexpr std::string_view GLSL_USE_NORMAL_CHANNEL
void dispose(const WindowRef &win, const jau::fraction_timespec &when) override
Notifies the listener to perform the release of all renderer resources per context,...
void setOneFrame() noexcept
bool animating() const noexcept
std::string toStringImpl() const noexcept override
void display(const WindowRef &win, const jau::fraction_timespec &when) override
Called by the drawable to initiate rendering by the client.
PMVMat4f & pmv() noexcept
bool init(const WindowRef &win, const jau::fraction_timespec &when) override
Called by the drawable immediately after the render context is initialized.
Recti & viewport() noexcept
constexpr const float & zOffset() const noexcept
void setColor(const Vec4f &c) noexcept
Shape(Private, ShaderState &st, PMVMat4fUniform &pmvMatU, GraphRenderer &renderer)
static ShapeRef create(ShaderState &st, PMVMat4fUniform &pmvMatU, GraphRenderer &renderer)
void draw(GL &gl)
void update(GL &gl)
constexpr const Quat4f & rotation() const noexcept
constexpr const Vec3f & rotationPivot() const noexcept
constexpr const Vec3f & position() const noexcept
const Vec4f & color() const noexcept
constexpr const Vec3f & scale() const noexcept
constexpr const OutlineShape & outlines() const noexcept
constexpr size_type addedVertexCount() const noexcept
Return the number of newly added vertices during getTriangles(VerticesState) while transforming the o...
void clearCache() noexcept
Clears cached triangulated data, i.e.
const VertexList & getVertices()
Return list of concatenated vertices associated with all Outlines of this object.
void cubicTo(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3)
Add a cubic Bézier curve segment, intersecting the last point and the second given point x3/y3 (P3).
const TriangleRefList & getTriangles(VertexState destinationType=VertexState::quadratic_nurbs)
Triangulate the OutlineShape generating a list of triangles, while transformOutlines(VerticesState) b...
void quadTo(float x1, float y1, float z1, float x2, float y2, float z2)
Add a quadratic curve segment, intersecting the last point and the second given point x2/y2 (P2).
constexpr const Vec3f & normal() const noexcept
Normal vector, optionally used by tesselator to add (interleaved) normals.
void moveTo(float x, float y, float z)
Start a new position for the next line segment at given point x/y (P1).
void closePath()
Closes the current sub-path segment by drawing a straight line back to the coordinates of the last mo...
OutlineShape flipFace(float zoffset=0) const
Returns a copy of this instance with normal() and all outlines() vertices()'s z-axis sign-flipped,...
void lineTo(float x, float y, float z)
Add a line segment, intersecting the last point and the given point x/y (P1).
constexpr const Vec3f & texCoord() const noexcept
Definition PrimTypes.hpp:96
constexpr const Vec3f & coord() const noexcept
Definition PrimTypes.hpp:93
static GLContext & downcast(RenderContext *rc)
Downcast dereferenced given RenderContext* to GLContext&, throws exception if signature doesn't match...
Specifies the OpenGL profile.
Definition GLContext.hpp:41
static constexpr std::string_view GLES2
The embedded OpenGL profile ES 2.x, with x >= 0.
Definition GLContext.hpp:64
static std::shared_ptr< GLUniformSyncMatrices4f > create(const string_t &name, SyncMats4f &data)
constexpr RenderListener(Private) noexcept
Private ctor for shared_ptr<RenderListener> instance method w/o public ctor.
Definition Window.hpp:60
std::string toString() const noexcept
Definition Window.hpp:112
std::string toString() const noexcept
Definition KeyEvent.hpp:855
constexpr VKeyCode keySym() const noexcept
Returns the virtual key symbol reflecting the current keyboard layout.
Definition KeyEvent.hpp:798
virtual const PressedKeyCodes & pressedKeyCodes() const noexcept=0
constexpr const WindowWeakPtr & source() const noexcept
Definition Event.hpp:85
constexpr const jau::fraction_timespec & when() const noexcept
Definition Event.hpp:84
size_t bitCount() const noexcept
Definition bitfield.hpp:176
constexpr size_type size() const noexcept
Like std::vector::size().
Definition darray.hpp:1069
value_type x
Definition vec3f.hpp:69
static constexpr const value_type one
Definition vec3f.hpp:67
value_type y
Definition vec3f.hpp:70
static constexpr const uint32_t INVERSE_TRANSPOSED_MODELVIEW
Definition pmvmat4f.hpp:192
SyncMats4f & getSyncPMvMviMvit()
Returns SyncMatrices4f of 4 matrices within one FloatBuffer: P, Mv, Mvi and Mvit if requested.
Definition pmvmat4f.hpp:420
static constexpr const uint32_t INVERSE_PROJECTION
Definition pmvmat4f.hpp:194
static constexpr const uint32_t INVERSE_MODELVIEW
Definition pmvmat4f.hpp:190
constexpr T adeg_to_rad(const T arc_degree) noexcept
Converts arc-degree to radians.
@ std
Denotes a func::std_target_t.
GLArrayDataServer< float > GLFloatArrayDataServer
GLsizeiptr glmemsize_t
Compatible with ssize_t.
Definition GLBuffers.hpp:26
GLArrayDataServerRef< float > GLFloatArrayDataServerRef
GLArrayDataServer< uint32_t > GLUIntArrayDataServer
std::shared_ptr< GLUniformData > GLUniformDataRef
std::shared_ptr< GLUniformVec4f > GLUniformVec4fRef
GLArrayDataServerRef< uint32_t > GLUIntArrayDataServerRef
std::shared_ptr< GLUniformVec3f > GLUniformVec3fRef
std::shared_ptr< ShaderProgram > ShaderProgramRef
std::shared_ptr< ShaderCode > ShaderCodeRef
jau::darray< Vertex, uint32_t > VertexList
std::shared_ptr< Triangle > TriangleRef
jau::darray< TriangleRef, uint32_t > TriangleRefList
@ verbose
Verbose operations (debugging).
std::shared_ptr< Window > WindowRef
Definition Event.hpp:36
Matrix4< float > Mat4f
Definition mat4f.hpp:1973
Vector4F< float > Vec4f
Definition vec4f.hpp:375
Quaternion< float > Quat4f
RectI< int > Recti
Definition recti.hpp:139
Vector3F< float > Vec3f
Definition vec3f.hpp:436
PMVMatrix4< float > PMVMat4f
Gamp: Graphics, Audio, Multimedia and Processing Framework (Native C++, WebAssembly,...
Definition Gamp.hpp:29
void PLAIN_PRINT(const bool printPrefix, const char *format,...) noexcept
Use for unconditional plain messages, prefix '[elapsed_time] ' if printPrefix == true.
Definition debug.cpp:258
int fprintf_td(const uint64_t elapsed_ms, FILE *stream, const char *format,...) noexcept
Convenient fprintf() invocation, prepending the given elapsed_ms timestamp.
Definition debug.cpp:270
GLUniformDataRef u
constexpr uint64_t to_ms() const noexcept
Returns time in milliseconds.