398 lines
13 KiB
C
398 lines
13 KiB
C
#include "epoxy/gl.h"
|
|
#include "glib.h"
|
|
#include "gtk/gtk.h"
|
|
|
|
#include "../core/raster.h"
|
|
#include "src/core/matrix.h"
|
|
#include "src/core/primitives.h"
|
|
#include "src/util/color.h"
|
|
#include "uicontroller.h"
|
|
#include "vektorcanvas.h"
|
|
#include <epoxy/gl_generated.h>
|
|
|
|
#define VKTR_CANVAS_WIDTH 400
|
|
#define VKTR_CANVAS_HEIGHT 400
|
|
#define VKTR_CANVAS_SIZE (VKTR_CANVAS_WIDTH * VKTR_CANVAS_HEIGHT * 4)
|
|
|
|
char* read_file(const char* path) {
|
|
FILE* f = fopen(path, "rb");
|
|
if (!f)
|
|
return NULL;
|
|
|
|
fseek(f, 0, SEEK_END);
|
|
long size = ftell(f);
|
|
fseek(f, 0, SEEK_SET);
|
|
|
|
char* buffer = malloc(size + 1);
|
|
fread(buffer, 1, size, f);
|
|
buffer[size] = '\0'; // null-terminate
|
|
fclose(f);
|
|
return buffer;
|
|
}
|
|
|
|
static GLuint standard_shader_program;
|
|
static GLuint selection_shader_program;
|
|
|
|
// shader uniforms
|
|
static GLuint shader_standard_uProjMatrixLoc;
|
|
|
|
static GLuint shader_selection_uProjMatrixLoc;
|
|
static GLuint shader_selection_uTimeLoc;
|
|
static GLuint shader_selection_uC1Loc;
|
|
static GLuint shader_selection_uC2Loc;
|
|
static GLuint shader_selection_uMinLoc;
|
|
static GLuint shader_selection_uMaxLoc;
|
|
|
|
static GLuint vao;
|
|
VertexBuffer vb;
|
|
static size_t shape_vertex_count = 0;
|
|
|
|
static GLuint compile_shader(GLenum type, const char* src) {
|
|
GLuint shader = glCreateShader(type);
|
|
glShaderSource(shader, 1, &src, NULL);
|
|
glCompileShader(shader);
|
|
|
|
GLint success;
|
|
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
|
|
if (!success) {
|
|
char info[512];
|
|
glGetShaderInfoLog(shader, 512, NULL, info);
|
|
g_error("Shader compile failed: %s", info);
|
|
}
|
|
return shader;
|
|
}
|
|
|
|
static GLuint create_shader_program(char* frag, char* vert) {
|
|
GLuint vertex = compile_shader(GL_VERTEX_SHADER, vert);
|
|
GLuint fragment = compile_shader(GL_FRAGMENT_SHADER, frag);
|
|
|
|
GLuint shader_program = glCreateProgram();
|
|
glAttachShader(shader_program, vertex);
|
|
glAttachShader(shader_program, fragment);
|
|
glLinkProgram(shader_program);
|
|
|
|
GLint success;
|
|
glGetProgramiv(shader_program, GL_LINK_STATUS, &success);
|
|
if (!success) {
|
|
char info[512];
|
|
glGetProgramInfoLog(shader_program, 512, NULL, info);
|
|
g_error("Shader link failed: %s", info);
|
|
}
|
|
|
|
glDeleteShader(vertex);
|
|
glDeleteShader(fragment);
|
|
|
|
return shader_program;
|
|
}
|
|
|
|
static void init_shader(void) {
|
|
char* vert_src = read_file("./shaders/triangle.vert.glsl");
|
|
char* frag_src = read_file("./shaders/triangle.frag.glsl");
|
|
char* selection_frag_src = read_file("./shaders/selection.frag.glsl");
|
|
|
|
if (!vert_src || !frag_src)
|
|
g_error("Failed to load shader files");
|
|
|
|
standard_shader_program = create_shader_program(frag_src, vert_src);
|
|
selection_shader_program =
|
|
create_shader_program(selection_frag_src, vert_src);
|
|
|
|
shader_standard_uProjMatrixLoc =
|
|
glGetUniformLocation(standard_shader_program, "uProjection");
|
|
shader_selection_uProjMatrixLoc =
|
|
glGetUniformLocation(selection_shader_program, "uProjection");
|
|
shader_selection_uTimeLoc =
|
|
glGetUniformLocation(selection_shader_program, "uTime");
|
|
shader_selection_uC1Loc =
|
|
glGetUniformLocation(selection_shader_program, "uColor1");
|
|
shader_selection_uC2Loc =
|
|
glGetUniformLocation(selection_shader_program, "uColor2");
|
|
|
|
shader_selection_uMinLoc =
|
|
glGetUniformLocation(selection_shader_program, "uMin");
|
|
shader_selection_uMaxLoc =
|
|
glGetUniformLocation(selection_shader_program, "uMax");
|
|
|
|
if (shader_selection_uMinLoc == -1 || shader_selection_uMaxLoc == -1)
|
|
g_warning("Selection shader: uMin/uMax uniform not found in shader!");
|
|
}
|
|
|
|
static void init_geometry(void) {
|
|
GLuint vbo;
|
|
|
|
glGenVertexArrays(1, &vao);
|
|
glBindVertexArray(vao);
|
|
|
|
glGenBuffers(1, &vbo);
|
|
glBindBuffer(GL_ARRAY_BUFFER, vbo);
|
|
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
|
|
(void*)offsetof(Vertex, coords));
|
|
|
|
glEnableVertexAttribArray(1);
|
|
glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Vertex),
|
|
(void*)offsetof(Vertex, color));
|
|
|
|
glBindVertexArray(0);
|
|
}
|
|
|
|
void vektor_canvas_geometry_changed(VektorCanvasRenderInfo* renderInfo) {
|
|
vb.count = 0;
|
|
vektor_vb_rasterize(&vb, renderInfo->shapes, renderInfo->zoom);
|
|
shape_vertex_count = vb.count;
|
|
|
|
if (renderInfo->selectedShape != NULL &&
|
|
*(renderInfo->selectedShape) != NULL) {
|
|
|
|
VektorShapeNode* selectedShape = *renderInfo->selectedShape;
|
|
|
|
// create handle quads if a shape is selected
|
|
for (size_t i = 0; i < selectedShape->base.handleCount; i++) {
|
|
V2 handle = selectedShape->base.handles[i];
|
|
VektorBBox handleBbox = vektor_shape_get_handle_bbox(handle);
|
|
vektor_vb_add_quad(&vb, handleBbox.min, handleBbox.max,
|
|
vektor_color_new(255, 255, 255, 255));
|
|
}
|
|
|
|
shape_vertex_count = vb.count;
|
|
|
|
// create selection quad if a shape is selected
|
|
VektorBBox bbox = vektor_primitive_get_bbox(selectedShape->base.primitive);
|
|
// expand it a little so it is not inset
|
|
bbox = vektor_bbox_expand(bbox, 0.03f);
|
|
|
|
vektor_vb_add_quad(&vb, bbox.min, bbox.max,
|
|
vektor_color_new(255, 255, 255, 255));
|
|
}
|
|
}
|
|
|
|
static gboolean render(GtkGLArea* a, GdkGLContext* ctx,
|
|
VektorCanvasRenderInfo* renderInfo) {
|
|
//vektor_canvas_geometry_changed(renderInfo);
|
|
|
|
|
|
|
|
glBufferData(GL_ARRAY_BUFFER, vb.count * sizeof(Vertex), vb.vertices,
|
|
GL_STATIC_DRAW);
|
|
|
|
// PASS 1 - draw shape vertices
|
|
glUseProgram(standard_shader_program);
|
|
|
|
// float projectionMatrix[16] = {1, 0, 0, 0, 0, 1, 0, 0,
|
|
// 0, 0, 1, 0, 0, 0, 0, 1};
|
|
glUniformMatrix4fv(shader_standard_uProjMatrixLoc, 1, GL_FALSE,
|
|
renderInfo->canvasTransform);
|
|
|
|
glBindVertexArray(vao);
|
|
glDisable(GL_CULL_FACE);
|
|
|
|
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
glDrawArrays(GL_TRIANGLES, 0, shape_vertex_count);
|
|
|
|
// PASS 2 - draw selection quads
|
|
if (vb.count > shape_vertex_count) {
|
|
float time =
|
|
(g_get_monotonic_time() - renderInfo->startupTime) / 10000000.0f;
|
|
|
|
// re-fetch bbox (we know a shape is selected)
|
|
VektorBBox bbox = vektor_primitive_get_bbox(
|
|
(*(renderInfo->selectedShape))->base.primitive);
|
|
bbox = vektor_bbox_expand(bbox, 0.03f);
|
|
|
|
glUseProgram(selection_shader_program);
|
|
|
|
glUniformMatrix4fv(shader_selection_uProjMatrixLoc, 1, GL_FALSE,
|
|
renderInfo->canvasTransform);
|
|
glUniform1f(shader_selection_uTimeLoc, time);
|
|
glUniform2f(shader_selection_uMinLoc, bbox.min.x, bbox.min.y);
|
|
glUniform2f(shader_selection_uMaxLoc, bbox.max.x, bbox.max.y);
|
|
glUniform4f(shader_selection_uC1Loc, 0, 0, 0, 0);
|
|
glUniform4f(shader_selection_uC2Loc, 0.46, 0.46, 1, 1);
|
|
|
|
glDrawArrays(GL_TRIANGLES, shape_vertex_count,
|
|
vb.count - shape_vertex_count);
|
|
}
|
|
|
|
glBindVertexArray(0);
|
|
glUseProgram(0);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void dump_gl_info(GtkGLArea* area) {
|
|
gtk_gl_area_make_current(area);
|
|
|
|
if (gtk_gl_area_get_error(area)) {
|
|
g_warning("Failed to make GL context current");
|
|
return;
|
|
}
|
|
|
|
const GLubyte* renderer = glGetString(GL_RENDERER);
|
|
const GLubyte* vendor = glGetString(GL_VENDOR);
|
|
const GLubyte* version = glGetString(GL_VERSION);
|
|
const GLubyte* shading = glGetString(GL_SHADING_LANGUAGE_VERSION);
|
|
|
|
g_debug("GL Vendor : %s", vendor);
|
|
g_debug("GL Renderer : %s", renderer);
|
|
g_debug("GL Version : %s", version);
|
|
g_debug("GLSL Version : %s", shading);
|
|
|
|
GLint n;
|
|
glGetIntegerv(GL_NUM_EXTENSIONS, &n);
|
|
g_debug("Supported extensions (%d):", n);
|
|
for (GLint i = 0; i < n; ++i) {
|
|
g_debug(" %s", glGetStringi(GL_EXTENSIONS, i));
|
|
}
|
|
}
|
|
|
|
static void realize(GtkGLArea* area, gpointer user_data) {
|
|
gtk_gl_area_make_current(area);
|
|
|
|
if (gtk_gl_area_get_error(area) != NULL)
|
|
return;
|
|
|
|
glEnable(GL_DEBUG_OUTPUT);
|
|
dump_gl_info(area);
|
|
init_shader();
|
|
init_geometry();
|
|
}
|
|
|
|
static void on_scroll(GtkEventControllerScroll* controller, double dx,
|
|
double dy, gpointer user_data) {
|
|
VektorCanvasRenderInfo* s = user_data;
|
|
|
|
GdkModifierType state = gtk_event_controller_get_current_event_state(
|
|
GTK_EVENT_CONTROLLER(controller));
|
|
|
|
// if (state & GDK_CONTROL_MASK) {
|
|
|
|
if (dy < 0)
|
|
s->zoom *= 1.1f;
|
|
else if (dy > 0)
|
|
s->zoom *= 0.9f;
|
|
|
|
M33 mat =
|
|
m33_mul(m33_translate(s->panX, s->panY),
|
|
m33_mul(m33_rotate(s->rotation), m33_scale(s->zoom, s->zoom)));
|
|
// M33 mat = m33_mul(m33_mul(m33_scale(s->zoom, s->zoom),
|
|
// m33_translate(s->panX, s->panY)),
|
|
// m33_rotate(s->rotation));
|
|
m33_to_gl4(mat, s->canvasTransform);
|
|
s->canvasMat = mat;
|
|
|
|
GtkWidget* widget =
|
|
gtk_event_controller_get_widget(GTK_EVENT_CONTROLLER(controller));
|
|
gtk_gl_area_queue_render(GTK_GL_AREA(widget));
|
|
// }
|
|
}
|
|
|
|
static void on_pan_begin(GtkGestureDrag* gesture, double start_x,
|
|
double start_y, gpointer user_data) {
|
|
VektorCanvasRenderInfo* s = user_data;
|
|
|
|
GdkModifierType state = gtk_event_controller_get_current_event_state(
|
|
GTK_EVENT_CONTROLLER(gesture));
|
|
|
|
if (!(state & GDK_SHIFT_MASK)) {
|
|
s->drag_start_x = s->panX;
|
|
s->drag_start_y = s->panY;
|
|
} else {
|
|
double x, y;
|
|
gtk_gesture_drag_get_start_point(gesture, &x, &y);
|
|
|
|
s->mouse_start_x = x;
|
|
s->mouse_start_y = y;
|
|
|
|
double cx = VKTR_CANVAS_WIDTH * 0.5;
|
|
double cy = VKTR_CANVAS_HEIGHT * 0.5;
|
|
|
|
double dx = x - cx;
|
|
double dy = y - cy;
|
|
|
|
s->dragStartAngle = atan2(dy, dx);
|
|
s->dragStartRotation = s->rotation;
|
|
}
|
|
}
|
|
|
|
static void on_pan_drag(GtkGestureDrag* gesture, double offset_x,
|
|
double offset_y, gpointer user_data) {
|
|
VektorCanvasRenderInfo* s = user_data;
|
|
|
|
GdkModifierType state = gtk_event_controller_get_current_event_state(
|
|
GTK_EVENT_CONTROLLER(gesture));
|
|
|
|
if (!(state & GDK_SHIFT_MASK)) {
|
|
s->panX = s->drag_start_x + offset_x / (80 * s->zoom);
|
|
s->panY = s->drag_start_y - offset_y / (80 * s->zoom);
|
|
|
|
M33 mat = m33_mul(
|
|
m33_translate(s->panX, s->panY),
|
|
m33_mul(m33_rotate(s->rotation), m33_scale(s->zoom, s->zoom)));
|
|
m33_to_gl4(mat, s->canvasTransform);
|
|
s->canvasMat = mat;
|
|
} else {
|
|
double x, y;
|
|
gtk_gesture_drag_get_offset(gesture, &x, &y);
|
|
|
|
double mx = s->mouse_start_x + x;
|
|
double my = s->mouse_start_y + y;
|
|
|
|
double cx = VKTR_CANVAS_WIDTH * 0.5;
|
|
double cy = VKTR_CANVAS_HEIGHT * 0.5;
|
|
|
|
double dx = mx - cx;
|
|
double dy = my - cy;
|
|
|
|
double angle = -atan2(dy, dx);
|
|
|
|
s->rotation = s->dragStartRotation + (angle - s->dragStartAngle);
|
|
|
|
M33 mat = m33_mul(
|
|
m33_translate(s->panX, s->panY),
|
|
m33_mul(m33_rotate(s->rotation), m33_scale(s->zoom, s->zoom)));
|
|
m33_to_gl4(mat, s->canvasTransform);
|
|
s->canvasMat = mat;
|
|
}
|
|
GtkWidget* widget =
|
|
gtk_event_controller_get_widget(GTK_EVENT_CONTROLLER(gesture));
|
|
gtk_gl_area_queue_render(GTK_GL_AREA(widget));
|
|
}
|
|
|
|
void vektor_canvas_init(VektorWidgetState* state, VektorCanvas* canvasOut,
|
|
VektorCanvasRenderInfo* renderInfo) {
|
|
canvasOut->canvasWidget = state->workspaceCanvas;
|
|
canvasOut->width = VKTR_CANVAS_WIDTH;
|
|
canvasOut->height = VKTR_CANVAS_HEIGHT;
|
|
canvasOut->canvasPixels = g_malloc0(VKTR_CANVAS_SIZE);
|
|
|
|
canvasOut->canvasPixelBytes =
|
|
g_bytes_new(canvasOut->canvasPixels, VKTR_CANVAS_SIZE);
|
|
canvasOut->canvasTexture = gdk_memory_texture_new(
|
|
VKTR_CANVAS_WIDTH, VKTR_CANVAS_HEIGHT, GDK_MEMORY_R8G8B8A8,
|
|
canvasOut->canvasPixelBytes, VKTR_CANVAS_WIDTH * 4);
|
|
|
|
g_signal_connect(canvasOut->canvasWidget, "realize", G_CALLBACK(realize),
|
|
NULL);
|
|
g_signal_connect(canvasOut->canvasWidget, "render", G_CALLBACK(render),
|
|
renderInfo);
|
|
|
|
GtkEventController* scroll =
|
|
gtk_event_controller_scroll_new(GTK_EVENT_CONTROLLER_SCROLL_VERTICAL);
|
|
|
|
gtk_widget_add_controller(GTK_WIDGET(canvasOut->canvasWidget), scroll);
|
|
|
|
g_signal_connect(scroll, "scroll", G_CALLBACK(on_scroll), renderInfo);
|
|
|
|
GtkGesture* pan = gtk_gesture_drag_new();
|
|
gtk_gesture_single_set_button(GTK_GESTURE_SINGLE(pan), GDK_BUTTON_MIDDLE);
|
|
|
|
gtk_widget_add_controller(GTK_WIDGET(canvasOut->canvasWidget),
|
|
GTK_EVENT_CONTROLLER(pan));
|
|
|
|
g_signal_connect(pan, "drag-begin", G_CALLBACK(on_pan_begin), renderInfo);
|
|
g_signal_connect(pan, "drag-update", G_CALLBACK(on_pan_drag), renderInfo);
|
|
}
|