Tags

v3: Surface plot of f(x,y) with colormap in vertex shader

Computes the plot of a function $z=f(x,y)$ of two parameters.
Draw the surface, grid wireframe, and cloud of points, each
separately toggleable from UI.

The compute kernel (be it on CPU or GPU) rescales $z$ values to
be in the [-1.0, 1.0] range.  This means that the surface plot
of the function should fit in a [-1, 1]^3 cube, assuming that
all values are within expected range, at least for $x$ and $y$
in [-1, 1] range.

The function to draw is hardcoded in plot2d_common.hpp as `func(x,y)`,
and cannot be changed at runtime.  The min-max rescaling is implemented
by `rescaledValue()`.  The colormap code is embedded in the fragment
shader, as `colormap()` function in the 'glsl/plot2d.vert' shader.

It uses MATLAB_jet colormap (blue to red), using `colormap()` function
from https://github.com/kbinani/colormap-shaders without special
handling for values above 1.0 or below -1.0 (which is expected range
of $z$ values, after rescaling by `rescaledValue()`).

v3-rc2: Surface plot of f(x,y), with colormap in shader

Computes the plot of a function $z=f(x,y)$ of two parameters.
Draw the surface, grid wireframe, and cloud of points, each
separately toggleable from UI.

Heatmap of the function is not available for now.

The compute kernel (be it on CPU or GPU) rescales $z$ values to
be in the [0.0, 1.0] range (assuming given range; some of values
fall outside it, to show how colormap handles such values).

The function to draw is hardcoded in plot2d_common.hpp as `func(x,y)`,
and cannot be changed at runtime.  The min-max rescaling is implemented
by `rescaledValue()`.  The colormap code is embedded in the fragment
shader, as `colormap()` function in the 'glsl/plot2d.vert' shader.

Simple grayscale colormap (`vec4(x, x, x, 1.0)`) is used, with overflow
marking (blue, or vec4(0,0,1,1), for values smaller than expected
minimum value, and red, or vec4(1,0,0,1) for values above expected
maximum).

v3-rc1: Heatmap and surface plot of f(x,y) via texture

Computes the plot of a function $z=f(x,y)$ of two parameters,
generating float pixmap, which is then used as a texture to pass
those values to the shader, which then draws the result.

This is done both for heatmap (line in 'v2-heatmap-rescaledValue'),
and for the surface plot, the latter of which is shown as the
cloud of points (drawn using glDrawArrays()).

The compute kernel (be it on CPU or GPU) rescales $z$ values to
be in the [0.0, 1.0] range (assuming given range; some of values
fall outside it, to show how colormap handles such values).

The function to draw is hardcoded in plot2d_common.hpp as `func(x,y)`,
and cannot be changed at runtime.  The min-max rescaling is implemented
by `rescaledValue()`.  The colormap code is embedded in the fragment
shader, as `colormap()` function in the 'glsl/texture.frag' and in the
'glsl/plot2d.vert' shaders (duplicated code).

Simple grayscale colormap (`vec4(x, x, x, 1.0)`) is used, with overflow
marking (blue, or vec4(0,0,1,1), for values smaller than expected
minimum value, and red, or vec4(1,0,0,1) for values above expected
maximum).

v2: Heatmap of f(x,y) with colormap in fragment shader

Computes the heatmap plot of a function $z=f(x,y)$ of two parameters,
generating float pixmap, which is then used as a texture to pass
those values to the fragment shader, which then draws the result.
The compute kernel (be it on CPU or GPU) just rescales values to
the [0.0, 1.0] range.

The function to draw is hardcoded in plot2d_common.hpp as `func(x,y)`,
and cannot be changed at runtime.  The min-max rescaling is implemented
by `rescaledValue()`.  The colormap code is embedded in the fragment
shader, as `colormap()` function in the 'glsl/texture.frag' file.

Simple grayscale colormap (`vec4(x, x, x, 1.0)`) with overflow marking
(blue, or vec4(0,0,1,1), for values smaller than expected minimum value,
red, or vec4(1,0,0,1) for values above expected maximum) is used.

v1: Heatmap of f(x,y) with colormap in compute code

Computes the heatmap plot of a function $z=f(x,y)$ of two parameters,
generating RGBA pixmap, which is then used as a texture to draw the
result.  The compute kernel (be it on CPU or on GPU) is aware and knows
of the RGBA 8-bits per channel pixel format (unsigned char per channel).

The function to draw is hardcoded in plot2d_common.hpp as `func(x,y)`,
and cannot be changed at runtime.  Similarly, colormap is hardcoded
inside `plotPixel()` function, which also implements min-max rescaling.

Simple grayscale colormap (R = G = B = 255*rescaled value, A = 255) with
overflow marking (blue for values smaller than expected minimum value,
red for values above expected maximum) is used.

This code borrows from 'func2d.cu', 'gpu_bitmap_static.cu' and
'gpu_bitmap_anim.cu' from the func2d-glut [1][] project.

[1]: https://gitlab.com/programowanie-gpu/func2d-glut

Before removing rotating cube from OpenGL examples

Various OpenGL tutorials show how one can work with OpenGL by generating
the image of a rotating cube, possibly with image textures, possibly
with some lighting model.

The removal of the cube in next commit represents first step towards
making the application display 3d plort of f(x,y) function.

Incorporate "Cube OpenGL ES 2.0 example" from Qt 6.4

Include features that are present in the "Cube OpenGL ES 2.0 example"
part of the Qt 6.4 documentation for the Qt OpenGL module:

  https://doc.qt.io/qt-6/qtopengl-cube-example.html
  https://code.qt.io/cgit/qt/qtbase.git/tree/examples/opengl/cube?h=6.4

Those features include rotating the cube (via model transformation
matrix) with the mouse, use indexed drawing method glDrawElements() at
least for the cube itself, extracting drawing polygons of shapes in
various *GeometryEngine classes, and painting each face of the cube with
a different image in the image of 6-sided dice.

Examples from "OpenGL Tutorial" by Digia (2013)

This series of commits implements all examples from "OpenGL Tutorial,
Release 1.0" by Digia, Qt Learning from February 28, 2013; examples use
Qt5 and QGLWidget.

http://ftp.fau.de/qtproject/learning/developerguides/qtopengltutorial/

Relevant parts from the table of contents of this tutorial:

  3 Using OpenGL in your Qt Application
    3.1 Hello OpenGL
    3.2 Rendering in 3D
    3.3 Coloring
    3.4 Texture Mapping
    3.5 Lighting
    3.6 Buffer Object