--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Shark.cpp Sun Nov 26 16:27:50 2023 +0100
@@ -0,0 +1,438 @@
+/**
+ * ShaderShark
+ * Copyright © 2023 František Kučera (Frantovo.cz, GlobalCode.info)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "Shark.h"
+
+Shark::Shark(const Configuration& configuration) :
+cfg(configuration) {
+}
+
+Shark::~Shark() {
+}
+
+void Shark::run() {
+ Display* dpy = XOpenDisplay(NULL);
+
+ if (dpy == NULL) throw std::logic_error("Unable to connect to X server");
+
+ GLint att[] = {GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None};
+ XVisualInfo* vi = glXChooseVisual(dpy, 0, att);
+ Window root = DefaultRootWindow(dpy);
+ Window parent = cfg.rootWindow ? cfg.rootWindow : root;
+
+ XSetWindowAttributes swa;
+ swa.colormap = XCreateColormap(dpy, parent, vi->visual, AllocNone);
+ swa.event_mask = ExposureMask | KeyPressMask | PointerMotionMask
+ | ButtonPressMask
+ | StructureNotifyMask;
+
+ bool full = false;
+ unsigned int width = 1600;
+ unsigned int height = 1200;
+ if (parent != root) {
+ XWindowAttributes parentAttr;
+ XGetWindowAttributes(dpy, parent, &parentAttr);
+ width = parentAttr.width;
+ height = parentAttr.height;
+ }
+
+ Window win = XCreateWindow(
+ dpy, parent, 0, 0, width, height, 0,
+ vi->depth, InputOutput, vi->visual,
+ CWColormap | CWEventMask, &swa);
+
+ XMapWindow(dpy, win);
+ XStoreName(dpy, win, "ShaderShark");
+ setX11PID(dpy, win);
+ // XSetWindowBackground(dpy, win, 0) vs. glClearColor()
+
+ GLXContext glc = glXCreateContext(dpy, vi, NULL, GL_TRUE);
+ glXMakeCurrent(dpy, win, glc);
+
+ // Load GLSL shaders:
+ GLuint shaderProgram = loadShaders();
+ loadVertices();
+ loadTextures(shaderProgram);
+
+ auto toggleFullscreen = [&]() {
+ full = setFullscreen(dpy, win, !full);
+ };
+
+ auto resetView = [&]() {
+ ctx = initialCtx;
+ ctx.updateCameraFrontAndUp();
+ };
+
+ // root can reize our window
+ // or we can listen to root resize and then resize our window ourselves
+ bool listenToRootResizes = true;
+ if (listenToRootResizes) XSelectInput(dpy, parent, StructureNotifyMask);
+
+ bool keepRunningX11 = true;
+ int x11fd = XConnectionNumber(dpy);
+ EPoll epoll;
+ epoll.add(x11fd);
+ try {
+ epoll.add(setNonBlocking(STDIN_FILENO));
+ } catch (const EPoll::Exception& e) {
+ logOutput << "Will not monitor events on STDIN: " << e.what() << "\n";
+ }
+
+ // rended the 3D scene even before the first event:
+ runShaders(shaderProgram);
+ glXSwapBuffers(dpy, win);
+
+ for (XEvent xev; keepRunningX11;) {
+ int epollEventCount = epoll.wait();
+ //std::cout << "trace: epoll.wait() = " << epollEventCount << std::endl;
+ for (int epollEvent = 0; epollEvent < epollEventCount; epollEvent++) {
+ if (epoll[epollEvent].data.fd == x11fd) {
+ if (!XPending(dpy)) {
+ // otherwise STDIN events are held until the first X11 event
+ logOutput << "trace: no pending X11 event" << std::endl;
+ break;
+ }
+ XWindowAttributes gwa;
+ XNextEvent(dpy, &xev);
+ bool redraw = false;
+
+ if (xev.type == Expose) {
+ std::cout << "XEvent: Expose" << std::endl;
+ XGetWindowAttributes(dpy, win, &gwa);
+ glViewport(0, 0, gwa.width, gwa.height);
+ redraw = true;
+ } else if (xev.type == KeyPress) {
+ DecodedKey key = decodeKeycode(dpy, xev.xkey.keycode);
+ std::cout << "XEvent: KeyPress:"
+ << " keycode=" << key.code
+ << " key=" << key.name
+ << std::endl;
+
+ const float cSp = 0.05f; // camera speed
+ const float aSp = 5.f; // angle speed
+
+ if (key.matches(XK_q, XK_Escape)) keepRunningX11 = false;
+ else if (key.matches(XK_Left, XK_s)) ctx.turnLeft(aSp);
+ else if (key.matches(XK_Right, XK_f)) ctx.turnRight(aSp);
+ else if (key.matches(XK_Up, XK_e)) ctx.moveForward(cSp);
+ else if (key.matches(XK_Down, XK_d)) ctx.moveBackward(cSp);
+ else if (key.matches(XK_w)) ctx.rollLeft(aSp);
+ else if (key.matches(XK_r)) ctx.rollRight(aSp);
+ else if (key.matches(XK_t)) ctx.turnUp(aSp);
+ else if (key.matches(XK_g)) ctx.turnDown(aSp);
+ else if (key.matches(XK_m)) ctx.moveLeft(cSp);
+ else if (key.matches(XK_comma)) ctx.moveRight(cSp);
+ else if (key.matches(XK_l)) ctx.moveUp(cSp);
+ else if (key.matches(XK_period)) ctx.moveDown(cSp);
+ else if (key.matches(XK_j)) ctx.moveLeft(cSp * 5);
+ else if (key.matches(XK_k)) ctx.moveRight(cSp * 5);
+ else if (key.matches(XK_u)) ctx.moveLeft(cSp * 10);
+ else if (key.matches(XK_i)) ctx.moveRight(cSp * 10);
+ else if (key.matches(XK_x)) resetView();
+ else if (key.matches(XK_F11, XK_y)) toggleFullscreen();
+ redraw = true;
+ } else if (xev.type == ButtonPress) {
+ std::cout << "XEvent: ButtonPress:"
+ << " button=" << xev.xbutton.button
+ << std::endl;
+ if (xev.xbutton.button == 1);
+ else if (xev.xbutton.button == 4) ctx.adjustFov(+1.0);
+ else if (xev.xbutton.button == 5) ctx.adjustFov(-1.0);
+ else if (xev.xbutton.button == 8) resetView();
+ else if (xev.xbutton.button == 9) keepRunningX11 = false;
+ redraw = true;
+ } else if (xev.type == MotionNotify) {
+ // printCursorInfo(xev.xmotion);
+ } else if (xev.type == ConfigureNotify) {
+ std::cout << "XEvent: ConfigureNotify:"
+ << " window=" << xev.xconfigure.window
+ << " height=" << xev.xconfigure.height
+ << " width=" << xev.xconfigure.width
+ << std::endl;
+ if (listenToRootResizes
+ && xev.xconfigure.window == parent) {
+ XResizeWindow(dpy, win,
+ xev.xconfigure.width, xev.xconfigure.height);
+ }
+ } else if (xev.type == UnmapNotify) {
+ std::cout << "XEvent: UnmapNotify" << std::endl;
+ } else if (xev.type == DestroyNotify) {
+ std::cout << "XEvent: DestroyNotify → finish" << std::endl;
+ break;
+ } else {
+ std::cout << "XEvent: type=" << xev.type << std::endl;
+ }
+
+ if (redraw) {
+ runShaders(shaderProgram);
+ glXSwapBuffers(dpy, win);
+ }
+ } else if (epoll[epollEvent].data.fd == STDIN_FILENO) {
+ int epollFD = epoll[epollEvent].data.fd;
+ logOutput << "other event: fd=" << epollFD << " data=";
+ for (char ch; read(epollFD, &ch, 1) > 0;) {
+ std::stringstream msg;
+ msg
+ << std::hex
+ << std::setfill('0')
+ << std::setw(2)
+ << (int) ch;
+ logOutput << msg.str();
+ }
+ logOutput << std::endl;
+
+ } else {
+ logOutput
+ << "error: event on an unexpected FD: "
+ << epoll[epollEvent].data.fd
+ << std::endl;
+ }
+ }
+ }
+
+ XFree(vi);
+ // for (auto page : pdfTextures) glDeleteTextures(1, &page.texture);
+
+ glXMakeCurrent(dpy, None, NULL);
+ glXDestroyContext(dpy, glc);
+ XDestroyWindow(dpy, win);
+ XCloseDisplay(dpy);
+}
+
+void Shark::runShaders(GLuint program) {
+ std::cerr << "GLSL: runShaders(" << program << ")" << std::endl;
+ std::cerr << "background color: " << cfg.backgroundColor << std::endl;
+ glUseProgram(program);
+ checkError(&std::cerr);
+
+ glClearColor(
+ (cfg.backgroundColor >> 16 & 0xFF) / 256.,
+ (cfg.backgroundColor >> 8 & 0xFF) / 256.,
+ (cfg.backgroundColor & 0xFF) / 256.,
+ 1.0);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ GLint viewport[4];
+ glGetIntegerv(GL_VIEWPORT, viewport);
+ GLfloat width = viewport[2];
+ GLfloat height = viewport[3];
+
+ glm::mat4 projection = glm::perspective(
+ glm::radians(ctx.fov),
+ width / height,
+ 0.1f, 100.0f);
+ glUniformMatrix4fv(ProgAttr.projection, 1, GL_FALSE, &projection[0][0]);
+
+ glm::mat4 view = glm::lookAt(
+ ctx.cameraPos,
+ ctx.cameraPos + ctx.cameraFront,
+ ctx.cameraUp);
+ glUniformMatrix4fv(ProgAttr.view, 1, GL_FALSE, &view[0][0]);
+
+ // glBindVertexArray(vao);
+
+ glm::mat4 model = glm::mat4(1.0f); // identity matrix
+ // model = glm::translate(model, glm::vec3(0., 0., 0.));
+ // float angle = 20.0f;
+ // glm::vec3 xxx = glm::vec3(1.0f, 0.3f, 0.5f);
+ // model = glm::rotate(model, glm::radians(angle), xxx);
+ glUniformMatrix4fv(ProgAttr.model, 1, GL_FALSE, &model[0][0]);
+
+ glDrawArrays(GL_TRIANGLES, 0, 2 * 3); // viz loadVertices() kde plníme data
+ std::cerr << "GLSL: glDrawArrays()" << std::endl;
+}
+
+void Shark::log(LogLevel level, std::string message) {
+ ::log(logOutput, level, message);
+}
+
+int Shark::setNonBlocking(int fd) {
+ int flags = fcntl(fd, F_GETFL, 0);
+ fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+ return fd;
+}
+
+void Shark::loadVertices() {
+ const std::vector<GLfloat> vertices = {
+ // Vertex XYZ Texture XY
+ -0.80f * TEX.ratio, +0.80f, +0.0, /**/ 0.0, 0.0,
+ +0.80f * TEX.ratio, +0.80f, +0.0, /**/ 1.0, 0.0,
+ -0.80f * TEX.ratio, -0.80f, +0.0, /**/ 0.0, 1.0,
+
+ -0.80f * TEX.ratio, -0.80f, +0.0, /**/ 0.0, 1.0,
+ +0.80f * TEX.ratio, -0.80f, +0.0, /**/ 1.0, 1.0,
+ +0.80f * TEX.ratio, +0.80f, +0.0, /**/ 1.0, 0.0,
+
+ // viz glDrawArrays(), kde vybereme počátek a počet hodnot
+ };
+
+ // Vertex data:
+ glVertexAttribPointer(ProgAttr.vertexXYZ, 3, // vertex items
+ GL_FLOAT, GL_FALSE, 5 * sizeof (float),
+ (void*) 0);
+ glEnableVertexAttribArray(ProgAttr.vertexXYZ);
+
+ // Texture positions:
+ glVertexAttribPointer(ProgAttr.textureXY, 2, // texture items
+ GL_FLOAT, GL_FALSE, 5 * sizeof (float),
+ (void*) (3 * sizeof (float)));
+ glEnableVertexAttribArray(ProgAttr.textureXY);
+
+ glBufferData(GL_ARRAY_BUFFER,
+ vertices.size() * sizeof (vertices[0]),
+ vertices.data(),
+ GL_STATIC_DRAW);
+ // GL_STATIC_DRAW:
+ // The vertex data will be uploaded once
+ // and drawn many times(e.g. the world).
+ // GL_DYNAMIC_DRAW:
+ // The vertex data will be created once, changed from
+ // time to time, but drawn many times more than that.
+ // GL_STREAM_DRAW:
+ // The vertex data will be uploaded once and drawn once.
+
+ // see also glBindBuffer(GL_ARRAY_BUFFER, vbo); where we set current VBO
+}
+
+GLuint Shark::loadTexture(const std::string& fileName, int width, int height) {
+ MappedFile file(fileName);
+ if (file.getSize() == width * height * 4) {
+ GLuint textureID;
+ glGenTextures(1, &textureID);
+ glBindTexture(GL_TEXTURE_2D, textureID);
+ auto GLT2D = GL_TEXTURE_2D;
+ glTexImage2D(GLT2D, 0, GL_RGBA,
+ width, height,
+ 0, GL_RGBA, GL_UNSIGNED_BYTE,
+ file.getData());
+ glTexParameteri(GLT2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ glTexParameteri(GLT2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+ glTexParameteri(GLT2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glTexParameteri(GLT2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+ glGenerateMipmap(GLT2D);
+ std::cerr << "loadTexture(\"" << fileName.c_str() << "\", "
+ << width << ", " << height << ") = " << textureID << std::endl;
+ checkError(&std::cerr);
+ return textureID;
+ } else {
+ throw std::invalid_argument("wrong texture file size");
+ }
+}
+
+void Shark::loadTextures(GLuint shaderProgram) {
+ for (const Configuration::Texture& tex : cfg.textures) {
+ GLuint jazz = loadTexture(tex.fileName, TEX.width, TEX.height);
+ // FIXME: decode PNG, JPEG etc. formats
+ // FIXME: read width and height from the file
+ // TODO: review texture loading and binding
+ // works even without this - default texture
+ // glUniform1i(ProgAttr.jazz, jazz);
+ // checkError(&std::cerr);
+ }
+}
+
+GLuint Shark::loadShaders() {
+ try {
+ // Vertex Array Object (VAO)
+ GLuint vao;
+ glGenVertexArrays(1, &vao);
+ glBindVertexArray(vao);
+ // VAO - something like context for bound data/variables
+ // We can switch multiple VAOs. VAO can contain multiple VBOs.
+ // See also https://stackoverflow.com/questions/11821336/
+ // what-are-vertex-array-objects
+
+ // Vertex Buffer Object (VBO):
+ GLuint vbo;
+ glGenBuffers(1, &vbo);
+ glBindBuffer(GL_ARRAY_BUFFER, vbo);
+
+ std::vector<std::string> fileNames = {
+ "shaders/first.vert",
+ "shaders/first.frag",
+ };
+
+ std::vector<GLuint> shaders;
+
+ GLuint program = glCreateProgram();
+
+ // glBindFragDataLocation(program, 0, "outColor");
+ // glBindAttribLocation(program, LOC.input, "vertices");
+
+ for (const std::string& fileName : fileNames) {
+ MappedFile file(fileName);
+ GLuint shader = glCreateShader(toShaderType(fileName));
+ auto fileData = file.getData();
+ GLint fileSize = file.getSize();
+ glShaderSource(shader, 1, &fileData, &fileSize);
+ glCompileShader(shader);
+
+ GLint compileStatus;
+ glGetShaderiv(shader, GL_COMPILE_STATUS, &compileStatus);
+ std::cerr << "GLSL shader compile status: "
+ << compileStatus
+ << (compileStatus == GL_TRUE ? " = OK" : " = ERROR")
+ << std::endl;
+
+ if (compileStatus != GL_TRUE) {
+ char error[512];
+ glGetShaderInfoLog(shader, sizeof (error), NULL, error);
+ std::cerr << "GLSL shader error: " << error;
+ throw std::logic_error("GLSL: shader failed to compile");
+ }
+
+ glAttachShader(program, shader);
+ shaders.push_back(shader);
+ std::cerr << "GLSL loaded: " << fileName.c_str() << std::endl;
+ }
+
+ // GLSL compiler does very efficient / aggressive optimization.
+ // Attributes and uniforms that are not used in the shader are deleted.
+ // And even if we e.g. read color from a texture and overwrite it,
+ // the variable is still deleted and considered „inactive“.
+ // Functions glGetAttribLocation() and glGetUniformLocation() return -1.
+
+ glLinkProgram(program);
+
+ ProgAttr.vertexXYZ = glGetAttribLocation(program, "vertices");
+ ProgAttr.textureXY = glGetAttribLocation(program, "textureCoordinates");
+ ProgAttr.model = glGetUniformLocation(program, "model");
+ ProgAttr.view = glGetUniformLocation(program, "view");
+ ProgAttr.projection = glGetUniformLocation(program, "projection");
+ ProgAttr.jazz = glGetUniformLocation(program, "jazz");
+ ProgAttr.color = glGetFragDataLocation(program, "outColor");
+ glBindFragDataLocation(program, ProgAttr.color, "outColor");
+ // listVariables(program);
+ GLint linkStatus;
+ glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
+ if (linkStatus != GL_TRUE) {
+ char error[512];
+ glGetProgramInfoLog(program, sizeof (error), NULL, error);
+ std::cerr << "GLSL program error: " << error;
+ throw std::logic_error("GLSL: program failed to link");
+ }
+ std::cerr << "GLSL shader count: " << shaders.size() << std::endl;
+
+ return program;
+ } catch (const std::exception& e) {
+ std::cerr << "Error while loading shaders: " << e.what() << std::endl;
+ } catch (...) {
+ std::cerr << "Error while loading shaders: unknown" << std::endl;
+ }
+ throw std::logic_error("GLSL: loadShaders() failed");
+}
+