From a7b2355c6424fff9093d238c973fb09d801da934 Mon Sep 17 00:00:00 2001 From: Tavian Barnes Date: Thu, 2 Jul 2009 04:53:40 +0000 Subject: Provide interface to export canvas to openGL. --- libdimension/Makefile.am | 4 +- libdimension/dimension.h | 1 + libdimension/dimension/gl.h | 37 ++++++ libdimension/gl.c | 91 +++++++++++++ tests/Makefile.am | 26 ++-- tests/gl.c | 310 ++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 457 insertions(+), 12 deletions(-) create mode 100644 libdimension/dimension/gl.h create mode 100644 libdimension/gl.c create mode 100644 tests/gl.c diff --git a/libdimension/Makefile.am b/libdimension/Makefile.am index 16bf4a7..7a18535 100644 --- a/libdimension/Makefile.am +++ b/libdimension/Makefile.am @@ -25,6 +25,7 @@ nobase_include_HEADERS = dimension.h \ dimension/color.h \ dimension/error.h \ dimension/geometry.h \ + dimension/gl.h \ dimension/png.h \ dimension/progress.h \ dimension/object.h \ @@ -41,6 +42,7 @@ libdimension_la_SOURCES = $(nobase_include_HEADERS) \ color.c \ error.c \ geometry.c \ + gl.c \ inlines.c \ png.c \ progress.c \ @@ -49,4 +51,4 @@ libdimension_la_SOURCES = $(nobase_include_HEADERS) \ raytrace.c \ scene.c libdimension_la_LDFLAGS = -version-info 0:0:0 -libdimension_la_LIBADD = -lm -lpthread -lpng +libdimension_la_LIBADD = -lm -lpthread -lpng -lGL diff --git a/libdimension/dimension.h b/libdimension/dimension.h index 5734616..869b959 100644 --- a/libdimension/dimension.h +++ b/libdimension/dimension.h @@ -57,6 +57,7 @@ extern "C" { #include #include #include +#include #include #include #include diff --git a/libdimension/dimension/gl.h b/libdimension/dimension/gl.h new file mode 100644 index 0000000..e27c418 --- /dev/null +++ b/libdimension/dimension/gl.h @@ -0,0 +1,37 @@ +/************************************************************************* + * Copyright (C) 2008 Tavian Barnes * + * * + * This file is part of The Dimension Library. * + * * + * The Dimension Library is free software; you can redistribute it and/ * + * or modify it under the terms of the GNU Lesser General Public License * + * as published by the Free Software Foundation; either version 3 of the * + * License, or (at your option) any later version. * + * * + * The Dimension Library 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 * + * Lesser General Public License for more details. * + * * + * You should have received a copy of the GNU Lesser General Public * + * License along with this program. If not, see * + * . * + *************************************************************************/ + +/* + * Draw a canvas to a GL framebuffer with glDrawPixels, or read one with + * glReadPixels. Should be fast, so no _async() versions. + */ + +#ifndef DIMENSION_GL_H +#define DIMENSION_GL_H + +#include + +/* Write canvas to GL framebuffer. Returns 0 on success, nonzero on failure */ +int dmnsn_gl_write_canvas(const dmnsn_canvas *canvas); + +/* Read a canvas from a GL framebuffer. Returns NULL on failure. */ +dmnsn_canvas *dmnsn_gl_read_canvas(); + +#endif /* DIMENSION_GL_H */ diff --git a/libdimension/gl.c b/libdimension/gl.c new file mode 100644 index 0000000..3542a2d --- /dev/null +++ b/libdimension/gl.c @@ -0,0 +1,91 @@ +/************************************************************************* + * Copyright (C) 2008 Tavian Barnes * + * * + * This file is part of The Dimension Library. * + * * + * The Dimension Library is free software; you can redistribute it and/ * + * or modify it under the terms of the GNU Lesser General Public License * + * as published by the Free Software Foundation; either version 3 of the * + * License, or (at your option) any later version. * + * * + * The Dimension Library 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 * + * Lesser General Public License for more details. * + * * + * You should have received a copy of the GNU Lesser General Public * + * License along with this program. If not, see * + * . * + *************************************************************************/ + +#include "dimension.h" +#include + +/* Write canvas to GL framebuffer. Returns 0 on success, nonzero on failure */ +int +dmnsn_gl_write_canvas(const dmnsn_canvas *canvas) +{ + GLuint *pixels; /* Array of 32-bit ints in RGBA order */ + GLuint *pixel; + dmnsn_sRGB sRGB; + dmnsn_color color; + unsigned int x, y, width, height; + + width = canvas->x; + height = canvas->y; + + pixels = malloc(4*width*height*sizeof(GLuint)); + if (!pixels) { + return 1; + } + + for (y = 0; y < height; ++y) { + for (x = 0; x < width; ++x) { + pixel = pixels + 4*(y*width + x); + + color = dmnsn_get_pixel(canvas, x, y); + sRGB = dmnsn_sRGB_from_color(color); + + /* Saturate R, G, and B to [0, UINT32_MAX] */ + + if (sRGB.R <= 0.0) { + pixel[0] = 0; + } else if (sRGB.R >= 1.0) { + pixel[0] = UINT32_MAX; + } else { + pixel[0] = sRGB.R*UINT32_MAX; + } + + if (sRGB.G <= 0.0) { + pixel[1] = 0; + } else if (sRGB.G >= 1.0) { + pixel[1] = UINT32_MAX; + } else { + pixel[1] = sRGB.G*UINT32_MAX; + } + + if (sRGB.B <= 0.0) { + pixel[2] = 0; + } else if (sRGB.B >= 1.0) { + pixel[2] = UINT32_MAX; + } else { + pixel[2] = sRGB.B*UINT32_MAX; + } + + /* color.filter + color.trans is in [0.0, 1.0] by definition */ + pixel[3] = (color.filter + color.trans)*UINT32_MAX; + } + } + + glDrawPixels(width, height, GL_RGBA, GL_UNSIGNED_INT, pixels); + + free(pixels); + return 0; +} + +/* Read a canvas from a GL framebuffer. Returns NULL on failure. */ +dmnsn_canvas * +dmnsn_gl_read_canvas() +{ + return NULL; +} diff --git a/tests/Makefile.am b/tests/Makefile.am index 9e6fda4..6d496f6 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -24,7 +24,8 @@ check_PROGRAMS = warning-test \ png-test \ pngxx-test \ raytrace-test \ - raytracexx-test + raytracexx-test \ + gl-test TESTS = $(check_PROGRAMS) XFAIL_TESTS = error-test @@ -38,20 +39,23 @@ libdimensionxx_tests_la_SOURCES = testsxx.hpp \ testsxx.cpp libdimensionxx_tests_la_LIBADD = ../libdimensionxx/libdimensionxx.la -warning_test_SOURCES = warning.c -warning_test_LDADD = ./libdimension-tests.la +warning_test_SOURCES = warning.c +warning_test_LDADD = ./libdimension-tests.la -error_test_SOURCES = error.c -error_test_LDADD = ./libdimension-tests.la +error_test_SOURCES = error.c +error_test_LDADD = ./libdimension-tests.la -png_test_SOURCES = png.c -png_test_LDADD = ./libdimension-tests.la +png_test_SOURCES = png.c +png_test_LDADD = ./libdimension-tests.la -pngxx_test_SOURCES = pngxx.cpp -pngxx_test_LDADD = ./libdimensionxx-tests.la +pngxx_test_SOURCES = pngxx.cpp +pngxx_test_LDADD = ./libdimensionxx-tests.la -raytrace_test_SOURCES = raytrace.c -raytrace_test_LDADD = ./libdimension-tests.la +raytrace_test_SOURCES = raytrace.c +raytrace_test_LDADD = ./libdimension-tests.la raytracexx_test_SOURCES = raytracexx.cpp raytracexx_test_LDADD = ./libdimensionxx-tests.la + +gl_test_SOURCES = gl.c +gl_test_LDADD = ./libdimension-tests.la diff --git a/tests/gl.c b/tests/gl.c new file mode 100644 index 0000000..773a9aa --- /dev/null +++ b/tests/gl.c @@ -0,0 +1,310 @@ +/************************************************************************* + * Copyright (C) 2008 Tavian Barnes * + * * + * This file is part of The Dimension Test Suite. * + * * + * Dimension is free software; you can redistribute it and/or modify it * + * under the terms of the GNU Lesser General Public License as published * + * by the Free Software Foundation; either version 3 of the License, or * + * (at your option) any later version. * + * * + * Dimension 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 * + * Lesser General Public License for more details. * + * * + * You should have received a copy of the GNU Lesser General Public * + * License along with this program. If not, see * + * . * + *************************************************************************/ + +#include "tests.h" +#include +#include +#include +#include + +typedef struct { + Display *dpy; + Window win; + Colormap cmap; + GLXContext cx; + XEvent event; +} dmnsn_display; + +dmnsn_display *dmnsn_new_display(const dmnsn_canvas *canvas); +void dmnsn_delete_display(dmnsn_display *display); + +void dmnsn_display_frame(dmnsn_display *display); + +int +main() { + dmnsn_display *display; + dmnsn_progress *progress; + dmnsn_scene *scene; + dmnsn_object *sphere, *cube; + dmnsn_sRGB sRGB; + dmnsn_color color; + dmnsn_matrix trans; + unsigned int i; + + /* Set the resilience low for tests */ + dmnsn_set_resilience(DMNSN_SEVERITY_LOW); + + /* Allocate our new scene */ + scene = dmnsn_new_scene(); + if (!scene) { + fprintf(stderr, "--- Allocation of scene failed! ---\n"); + return EXIT_FAILURE; + } + + /* Allocate a canvas */ + scene->canvas = dmnsn_new_canvas(768, 480); + if (!scene->canvas) { + dmnsn_delete_scene(scene); + fprintf(stderr, "--- Allocation of canvas failed! ---\n"); + return EXIT_FAILURE; + } + + /* Set up the transformation matrix for the perspective camera */ + trans = dmnsn_scale_matrix( + dmnsn_vector_construct( + ((double)scene->canvas->x)/scene->canvas->y, 1.0, 1.0 + ) + ); + trans = dmnsn_matrix_mul( + dmnsn_translation_matrix(dmnsn_vector_construct(0.0, 0.0, -4.0)), + trans + ); + trans = dmnsn_matrix_mul( + dmnsn_rotation_matrix(dmnsn_vector_construct(0.0, 1.0, 0.0)), + trans + ); + + /* Create a perspective camera */ + scene->camera = dmnsn_new_perspective_camera(trans); + if (!scene->camera) { + dmnsn_delete_canvas(scene->canvas); + dmnsn_delete_scene(scene); + fprintf(stderr, "--- Allocation of camera failed! ---\n"); + return EXIT_FAILURE; + } + + /* Background color */ + sRGB.R = 0.0; + sRGB.G = 0.0; + sRGB.B = 0.1; + color = dmnsn_color_from_sRGB(sRGB); + color.filter = 0.1; + scene->background = color; + + /* Now make our objects */ + + sphere = dmnsn_new_sphere(); + if (!sphere) { + dmnsn_delete_perspective_camera(scene->camera); + dmnsn_delete_canvas(scene->canvas); + dmnsn_delete_scene(scene); + fprintf(stderr, "--- Allocation of sphere failed! ---\n"); + return EXIT_FAILURE; + } + + sphere->trans = dmnsn_matrix_inverse( + dmnsn_scale_matrix(dmnsn_vector_construct(1.25, 1.25, 1.25)) + ); + dmnsn_array_push(scene->objects, &sphere); + + cube = dmnsn_new_cube(); + if (!cube) { + dmnsn_delete_sphere(sphere); + dmnsn_delete_perspective_camera(scene->camera); + dmnsn_delete_canvas(scene->canvas); + dmnsn_delete_scene(scene); + fprintf(stderr, "--- Allocation of cube failed! ---\n"); + return EXIT_FAILURE; + } + + cube->trans = dmnsn_matrix_inverse( + dmnsn_rotation_matrix(dmnsn_vector_construct(0.75, 0.0, 0.0)) + ); + dmnsn_array_push(scene->objects, &cube); + + display = dmnsn_new_display(scene->canvas); + if (!display) { + dmnsn_delete_cube(cube); + dmnsn_delete_sphere(sphere); + dmnsn_delete_perspective_camera(scene->camera); + dmnsn_delete_canvas(scene->canvas); + dmnsn_delete_scene(scene); + fprintf(stderr, "--- Couldn't initialize X or GLX! ---\n"); + return EXIT_FAILURE; + } + + for (i = 0; i < 48; ++i) { + progress = dmnsn_raytrace_scene_async(scene); + if (!progress) { + dmnsn_delete_display(display); + dmnsn_delete_cube(cube); + dmnsn_delete_sphere(sphere); + dmnsn_delete_perspective_camera(scene->camera); + dmnsn_delete_canvas(scene->canvas); + dmnsn_delete_scene(scene); + fprintf(stderr, "--- Couldn't start raytracing worker thread! ---\n"); + return EXIT_FAILURE; + } + + progressbar("Raytracing scene: ", progress); + + if (dmnsn_finish_progress(progress) != 0) { + dmnsn_delete_display(display); + dmnsn_delete_cube(cube); + dmnsn_delete_sphere(sphere); + dmnsn_delete_perspective_camera(scene->camera); + dmnsn_delete_canvas(scene->canvas); + dmnsn_delete_scene(scene); + fprintf(stderr, "--- Raytracing failed! ---\n"); + return EXIT_FAILURE; + } + + if (dmnsn_gl_write_canvas(scene->canvas) != 0) { + dmnsn_delete_display(display); + dmnsn_delete_cube(cube); + dmnsn_delete_sphere(sphere); + dmnsn_delete_perspective_camera(scene->camera); + dmnsn_delete_canvas(scene->canvas); + dmnsn_delete_scene(scene); + fprintf(stderr, "--- Drawing to openGL failed! ---\n"); + return EXIT_FAILURE; + } + dmnsn_display_frame(display); + + /* Rotate the cube and camera for the next frame */ + + cube->trans = dmnsn_matrix_mul( + dmnsn_matrix_inverse( + dmnsn_rotation_matrix(dmnsn_vector_construct(0.025, 0.0, 0.0)) + ), + cube->trans + ); + + trans = dmnsn_matrix_mul( + dmnsn_rotation_matrix(dmnsn_vector_construct(0.0, -0.05, 0.0)), + trans + ); + dmnsn_set_perspective_camera_trans(scene->camera, trans); + } + + dmnsn_delete_display(display); + dmnsn_delete_cube(cube); + dmnsn_delete_sphere(sphere); + dmnsn_delete_perspective_camera(scene->camera); + dmnsn_delete_canvas(scene->canvas); + dmnsn_delete_scene(scene); + return EXIT_SUCCESS; +} + +static Bool +WaitForNotify(Display *d, XEvent *e, char *arg) +{ + return (e->type == MapNotify) && (e->xmap.window == (Window)arg); +} + +dmnsn_display * +dmnsn_new_display(const dmnsn_canvas *canvas) +{ + int attributeList[] = { + GLX_RGBA, + GLX_DOUBLEBUFFER, + GLX_RED_SIZE, 1, + GLX_GREEN_SIZE, 1, + GLX_BLUE_SIZE, 1, + None + }; + dmnsn_display *display; + XVisualInfo *vi; + XSetWindowAttributes swa; + + display = malloc(sizeof(dmnsn_display)); + if (!display) { + return NULL; + } + + /* Get an X connection */ + display->dpy = XOpenDisplay(0); + if (!display->dpy) { + free(display); + return NULL; + } + + /* Get an appropriate visual */ + vi = glXChooseVisual(display->dpy, DefaultScreen(display->dpy), + attributeList); + if (!vi) { + XCloseDisplay(display->dpy); + free(display); + return NULL; + } + + /* Create a GLX context */ + display->cx = glXCreateContext(display->dpy, vi, 0, GL_TRUE); + if (!display->cx) { + XCloseDisplay(display->dpy); + free(display); + return NULL; + } + + /* Create a color map */ + display->cmap = XCreateColormap(display->dpy, + RootWindow(display->dpy, vi->screen), + vi->visual, AllocNone); + if (!display->cmap) { + glXDestroyContext(display->dpy, display->cx); + XCloseDisplay(display->dpy); + free(display); + return NULL; + } + + /* Create a window */ + swa.colormap = display->cmap; + swa.border_pixel = 0; + swa.event_mask = StructureNotifyMask; + display->win = XCreateWindow(display->dpy, + RootWindow(display->dpy, vi->screen), + 0, 0, canvas->x, canvas->y, + 0, vi->depth, InputOutput, vi->visual, + CWBorderPixel|CWColormap|CWEventMask, &swa); + if (!display->win) { + XFreeColormap(display->dpy, display->cmap); + glXDestroyContext(display->dpy, display->cx); + XCloseDisplay(display->dpy); + free(display); + return NULL; + } + + XMapWindow(display->dpy, display->win); + XIfEvent(display->dpy, &display->event, WaitForNotify, (char*)display->win); + + /* Connect the context to the window */ + glXMakeCurrent(display->dpy, display->win, display->cx); + + return display; +} + +void +dmnsn_delete_display(dmnsn_display *display) +{ + if (display) { + XDestroyWindow(display->dpy, display->win); + XFreeColormap(display->dpy, display->cmap); + glXDestroyContext(display->dpy, display->cx); + XCloseDisplay(display->dpy); + free(display); + } +} + +void +dmnsn_display_frame(dmnsn_display *display) +{ + glFlush(); + glXSwapBuffers(display->dpy, display->win); +} -- cgit v1.2.3