diff options
| -rw-r--r-- | .gitignore | 2 | ||||
| -rw-r--r-- | tests/libdimension/Makefile.am | 6 | ||||
| -rw-r--r-- | tests/libdimension/png.c | 155 | ||||
| -rw-r--r-- | tests/libdimension/tests.c | 350 | ||||
| -rw-r--r-- | tests/libdimension/tests.h | 74 |
5 files changed, 585 insertions, 2 deletions
@@ -39,7 +39,7 @@ Makefile.in # Files created by `make check' /tests/*/*-test -/tests/*.png +/tests/*/*.png # Files created by `make bench' /bench/*/bench-* diff --git a/tests/libdimension/Makefile.am b/tests/libdimension/Makefile.am index 393e338..f01fb1f 100644 --- a/tests/libdimension/Makefile.am +++ b/tests/libdimension/Makefile.am @@ -21,7 +21,8 @@ INCLUDES = -I$(top_srcdir)/libdimension check_PROGRAMS = error-test \ warning-test \ - kD_splay_tree-test + kD_splay_tree-test \ + png-test TESTS = $(check_PROGRAMS) XFAIL_TESTS = error-test @@ -33,3 +34,6 @@ warning_test_LDADD = $(top_srcdir)/libdimension/libdimension.la kD_splay_tree_test_SOURCES = kD_splay_tree.c kD_splay_tree_test_LDADD = $(top_srcdir)/libdimension/libdimension.la + +png_test_SOURCES = png.c tests.c tests.h +png_test_LDADD = $(top_srcdir)/libdimension/libdimension.la diff --git a/tests/libdimension/png.c b/tests/libdimension/png.c new file mode 100644 index 0000000..488cd56 --- /dev/null +++ b/tests/libdimension/png.c @@ -0,0 +1,155 @@ +/************************************************************************* + * Copyright (C) 2009 Tavian Barnes <tavianator@gmail.com> * + * * + * This file is part of The Dimension Test Suite. * + * * + * The Dimension Test Suite 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; either version 3 of the * + * License, or (at your option) any later version. * + * * + * The Dimension Test Suite 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 "tests.h" +#include <stdlib.h> +#include <stdio.h> + +int +main() { + dmnsn_progress *progress; + FILE *ifile, *ofile; + dmnsn_scene *scene; + dmnsn_canvas *canvas; + + /* Set the resilience low for tests */ + dmnsn_set_resilience(DMNSN_SEVERITY_LOW); + + /* Render the scene */ + { + /* Allocate our default scene */ + scene = dmnsn_new_default_scene(); + if (!scene) { + fprintf(stderr, "--- Allocation of default scene failed! ---\n"); + return EXIT_FAILURE; + } + + /* Optimize the canvas for PNG export */ + if (dmnsn_png_optimize_canvas(scene->canvas) != 0) { + dmnsn_delete_default_scene(scene); + fprintf(stderr, "--- Couldn't optimize canvas for PNG! ---\n"); + return EXIT_FAILURE; + } + + /* Render scene */ + + progress = dmnsn_raytrace_scene_async(scene); + if (!progress) { + dmnsn_delete_default_scene(scene); + fprintf(stderr, "--- Couldn't start raytracing worker thread! ---\n"); + return EXIT_FAILURE; + } + + dmnsn_progressbar("Raytracing scene: ", progress); + + if (dmnsn_finish_progress(progress) != 0) { + dmnsn_delete_default_scene(scene); + fprintf(stderr, "--- Raytracing failed! ---\n"); + return EXIT_FAILURE; + } + + /* Write the image to PNG */ + + ofile = fopen("png1.png", "wb"); + if (!ofile) { + dmnsn_delete_default_scene(scene); + fprintf(stderr, "--- Couldn't open 'png1.png' for writing! ---\n"); + return EXIT_FAILURE; + } + + progress = dmnsn_png_write_canvas_async(scene->canvas, ofile); + if (!progress) { + fclose(ofile); + dmnsn_delete_default_scene(scene); + fprintf(stderr, "--- Couldn't start PNG writing worker thread! ---\n"); + return EXIT_FAILURE; + } + + dmnsn_progressbar("Writing PNG file: ", progress); + + if (dmnsn_finish_progress(progress) != 0) { + fclose(ofile); + dmnsn_delete_default_scene(scene); + fprintf(stderr, "--- Writing canvas to PNG failed! ---\n"); + return EXIT_FAILURE; + } + + fclose(ofile); + dmnsn_delete_default_scene(scene); + } + + /* Now test PNG import/export */ + { + /* Read the image back from PNG */ + + ifile = fopen("png1.png", "rb"); + if (!ifile) { + fprintf(stderr, "--- Couldn't open 'png1.png' for reading! ---\n"); + return EXIT_FAILURE; + } + + progress = dmnsn_png_read_canvas_async(&canvas, ifile); + if (!progress) { + fclose(ifile); + fprintf(stderr, "--- Couldn't start PNG reading worker thread! ---\n"); + return EXIT_FAILURE; + } + + dmnsn_progressbar("Reading PNG file: ", progress); + + if (dmnsn_finish_progress(progress) != 0) { + fclose(ifile); + fprintf(stderr, "--- Reading canvas from PNG failed! ---\n"); + return EXIT_FAILURE; + } + + fclose(ifile); + + /* And write it back */ + + ofile = fopen("png2.png", "wb"); + if (!ofile) { + fprintf(stderr, "--- Couldn't open 'png2.png' for writing! ---\n"); + dmnsn_delete_canvas(canvas); + return EXIT_FAILURE; + } + + progress = dmnsn_png_write_canvas_async(canvas, ofile); + if (!progress) { + fclose(ofile); + dmnsn_delete_canvas(canvas); + fprintf(stderr, "--- Couldn't start PNG writing worker thread! ---\n"); + return EXIT_FAILURE; + } + + dmnsn_progressbar("Writing PNG file: ", progress); + + if (dmnsn_finish_progress(progress) != 0) { + fclose(ofile); + dmnsn_delete_canvas(canvas); + fprintf(stderr, "--- Writing canvas to PNG failed! ---\n"); + return EXIT_FAILURE; + } + + fclose(ofile); + dmnsn_delete_canvas(canvas); + } + + return EXIT_SUCCESS; +} diff --git a/tests/libdimension/tests.c b/tests/libdimension/tests.c new file mode 100644 index 0000000..f8c02de --- /dev/null +++ b/tests/libdimension/tests.c @@ -0,0 +1,350 @@ +/************************************************************************* + * Copyright (C) 2009 Tavian Barnes <tavianator@gmail.com> * + * * + * This file is part of The Dimension Test Suite. * + * * + * The Dimension Test Suite 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; either version 3 of the * + * License, or (at your option) any later version. * + * * + * The Dimension Test Suite 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 "tests.h" + +dmnsn_scene * +dmnsn_new_default_scene() +{ + dmnsn_scene *scene; + dmnsn_object *sphere, *cube; + dmnsn_matrix trans; + dmnsn_sRGB sRGB; + dmnsn_color color; + + /* Allocate a new scene */ + scene = dmnsn_new_scene(); + if (!scene) { + return NULL; + } + + /* 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; + + /* Allocate a canvas */ + scene->canvas = dmnsn_new_canvas(768, 480); + if (!scene->canvas) { + dmnsn_delete_scene(scene); + return NULL; + } + + /* 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(); + if (!scene->camera) { + dmnsn_delete_canvas(scene->canvas); + dmnsn_delete_scene(scene); + return NULL; + } + dmnsn_set_perspective_camera_trans(scene->camera, trans); + + /* Now make our objects */ + + sphere = dmnsn_new_sphere(); + if (!sphere) { + dmnsn_delete_camera(scene->camera); + dmnsn_delete_canvas(scene->canvas); + dmnsn_delete_scene(scene); + return NULL; + } + + sphere->texture = dmnsn_new_texture(); + if (!sphere->texture) { + dmnsn_delete_object(sphere); + dmnsn_delete_camera(scene->camera); + dmnsn_delete_canvas(scene->canvas); + dmnsn_delete_scene(scene); + return NULL; + } + + sphere->texture->pigment = dmnsn_new_solid_pigment(dmnsn_white); + if (!sphere->texture->pigment) { + dmnsn_delete_texture(sphere->texture); + dmnsn_delete_object(sphere); + dmnsn_delete_camera(scene->camera); + dmnsn_delete_canvas(scene->canvas); + dmnsn_delete_scene(scene); + return NULL; + } + + 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_pigment(sphere->texture->pigment); + dmnsn_delete_texture(sphere->texture); + dmnsn_delete_object(sphere); + dmnsn_delete_camera(scene->camera); + dmnsn_delete_canvas(scene->canvas); + dmnsn_delete_scene(scene); + return NULL; + } + + cube->trans = dmnsn_matrix_inverse( + dmnsn_rotation_matrix(dmnsn_vector_construct(0.75, 0.0, 0.0)) + ); + dmnsn_array_push(scene->objects, &cube); + + return scene; +} + +void +dmnsn_delete_default_scene(dmnsn_scene *scene) +{ + dmnsn_object *sphere, *cube; + dmnsn_array_get(scene->objects, 0, &sphere); + dmnsn_array_get(scene->objects, 1, &cube); + +// dmnsn_delete_pigment(cube->texture->pigment); + dmnsn_delete_texture(cube->texture); + dmnsn_delete_object(cube); + + dmnsn_delete_pigment(sphere->texture->pigment); + dmnsn_delete_texture(sphere->texture); + dmnsn_delete_object(sphere); + + dmnsn_delete_camera(scene->camera); + dmnsn_delete_canvas(scene->canvas); + dmnsn_delete_scene(scene); +} + +/* XIfEvent callback */ +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; + } + + XStoreName(display->dpy, display->win, "glX"); + + 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_flush(dmnsn_display *display) +{ + glFlush(); + glXSwapBuffers(display->dpy, display->win); +} + +/* Print a progress bar of the progress of `progress' */ +void +dmnsn_progressbar(const char *str, const dmnsn_progress *progress) +{ + dmnsn_progress *barprogress = dmnsn_progressbar_async(str, progress); + if (dmnsn_finish_progress(barprogress) != 0) { + dmnsn_error(DMNSN_SEVERITY_HIGH, + "Progress bar background thread failed."); + } +} + +typedef struct { + dmnsn_progress *barprogress; + const char *str; + const dmnsn_progress *progress; +} dmnsn_progressbar_payload; + +/* Progress bar thread callback */ +static void *dmnsn_progressbar_thread(void *ptr); + +/* Print a progress bar in the background */ +dmnsn_progress * +dmnsn_progressbar_async(const char *str, const dmnsn_progress *progress) +{ + dmnsn_progress *barprogress = dmnsn_new_progress(); + dmnsn_progressbar_payload *payload; + + if (barprogress) { + payload = malloc(sizeof(dmnsn_progressbar_payload)); + if (!payload) { + dmnsn_error(DMNSN_SEVERITY_HIGH, + "Couldn't allocate progress bar payload."); + } + + payload->barprogress = barprogress; + payload->str = str; + payload->progress = progress; + + /* Create the worker thread */ + if (pthread_create(&barprogress->thread, NULL, &dmnsn_progressbar_thread, + payload) != 0) + { + dmnsn_error(DMNSN_SEVERITY_HIGH, + "Couldn't start progress bar background thread."); + } + } + + return barprogress; +} + +/* Actual progress bar implementation */ +static int dmnsn_progressbar_impl(dmnsn_progress *barprogress, const char *str, + const dmnsn_progress *progress); + +/* Progress bar thread callback */ +static void * +dmnsn_progressbar_thread(void *ptr) +{ + dmnsn_progressbar_payload *payload = ptr; + int *retval = malloc(sizeof(int)); + if (retval) { + *retval = dmnsn_progressbar_impl(payload->barprogress, + payload->str, payload->progress); + } + dmnsn_done_progress(payload->barprogress); + free(payload); + return retval; +} + +/* Actual progress bar implementation */ +static int +dmnsn_progressbar_impl(dmnsn_progress *barprogress, + const char *str, const dmnsn_progress *progress) +{ + const unsigned int increments = 32; + unsigned int i; + + dmnsn_new_progress_element(barprogress, increments); + + printf("%s|", str); + fflush(stdout); + for (i = 0; i < increments; ++i) { + dmnsn_wait_progress(progress, ((double)(i + 1))/increments); + + printf("="); + fflush(stdout); + dmnsn_increment_progress(barprogress); + } + printf("|\n"); + fflush(stdout); + + return 0; +} diff --git a/tests/libdimension/tests.h b/tests/libdimension/tests.h new file mode 100644 index 0000000..19111c8 --- /dev/null +++ b/tests/libdimension/tests.h @@ -0,0 +1,74 @@ +/************************************************************************* + * Copyright (C) 2009 Tavian Barnes <tavianator@gmail.com> * + * * + * This file is part of The Dimension Test Suite. * + * * + * The Dimension Test Suite 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; either version 3 of the * + * License, or (at your option) any later version. * + * * + * The Dimension Test Suite 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/>. * + *************************************************************************/ + +#ifndef TESTS_H +#define TESTS_H + +#include "../libdimension/dimension.h" +#include <GL/glx.h> +#include <GL/gl.h> +#include <unistd.h> +#include <stdio.h> + +#ifdef __cplusplus +/* We've been included from a C++ file; mark everything here as extern "C" */ +extern "C" { +#endif + +/* + * Convenience + */ + +dmnsn_scene *dmnsn_new_default_scene(); +void dmnsn_delete_default_scene(dmnsn_scene *scene); + +/* + * Windowing + */ + +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); + +/* Flush the GL buffers */ +void dmnsn_display_flush(dmnsn_display *display); + +/* + * Asynchronicity + */ + +/* Print a progress bar of the progress of `progress' */ +void dmnsn_progressbar(const char *str, const dmnsn_progress *progress); +/* Print a progress bar asynchronously, convienently guaranteed to succeed if + it returns so our tests don't get cluttered up */ +dmnsn_progress *dmnsn_progressbar_async(const char *str, + const dmnsn_progress *progress); + +#ifdef __cplusplus +} +#endif + +#endif /* TESTS_H */ |