summaryrefslogtreecommitdiff
path: root/progs/openvg/trivial
diff options
context:
space:
mode:
Diffstat (limited to 'progs/openvg/trivial')
-rw-r--r--progs/openvg/trivial/Makefile127
-rw-r--r--progs/openvg/trivial/arc.c139
-rw-r--r--progs/openvg/trivial/cap.c75
-rw-r--r--progs/openvg/trivial/clear.c42
-rw-r--r--progs/openvg/trivial/coord.c66
-rw-r--r--progs/openvg/trivial/dash.c95
-rw-r--r--progs/openvg/trivial/eglcommon.c288
-rw-r--r--progs/openvg/trivial/eglcommon.h20
-rw-r--r--progs/openvg/trivial/ellipse.c84
-rw-r--r--progs/openvg/trivial/filter.c107
-rw-r--r--progs/openvg/trivial/gradorigin.c98
-rw-r--r--progs/openvg/trivial/lineto.c56
-rw-r--r--progs/openvg/trivial/lingrad.c87
-rw-r--r--progs/openvg/trivial/lookup.c71
-rw-r--r--progs/openvg/trivial/mask.c58
-rw-r--r--progs/openvg/trivial/mask4.c132
-rw-r--r--progs/openvg/trivial/path3.c77
-rw-r--r--progs/openvg/trivial/radialgrad.c99
-rw-r--r--progs/openvg/trivial/readpixels.c75
-rw-r--r--progs/openvg/trivial/roundedrect.c67
-rw-r--r--progs/openvg/trivial/star-nonzero.c55
-rw-r--r--progs/openvg/trivial/star-oddeven.c102
-rw-r--r--progs/openvg/trivial/stroke.c116
-rw-r--r--progs/openvg/trivial/stroke2.c207
-rw-r--r--progs/openvg/trivial/vguarc.c74
25 files changed, 2417 insertions, 0 deletions
diff --git a/progs/openvg/trivial/Makefile b/progs/openvg/trivial/Makefile
new file mode 100644
index 0000000000..fcb3484377
--- /dev/null
+++ b/progs/openvg/trivial/Makefile
@@ -0,0 +1,127 @@
+# These programs aren't intended to be included with the normal distro.
+# They're not too interesting but they're good for testing.
+
+TOP = ../../../
+include $(TOP)/configs/current
+
+INCLUDES = -I. -I$(TOP)/include
+LIBS=-L$(TOP)/$(LIB_DIR) -lm -lX11 -lEGL -lOpenVG -lpthread
+CFLAGS += $(INCLUDES)
+
+HEADERS=eglcommon.h
+
+PROGRAMS = \
+ arc \
+ cap \
+ clear \
+ coord \
+ dash \
+ ellipse \
+ filter \
+ gradorigin \
+ lineto \
+ lingrad \
+ lookup \
+ mask4 \
+ mask \
+ path3 \
+ radialgrad \
+ readpixels \
+ roundedrect \
+ star-nonzero \
+ star-oddeven \
+ stroke2 \
+ stroke \
+ vguarc
+
+
+.c.o:
+ $(CC) -c $(INCLUDE_DIRS) $(CFLAGS) $< -o $@
+
+
+
+default: $(PROGRAMS)
+
+
+arc: arc.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+cap: cap.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+clear: clear.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+coord: coord.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+dash: dash.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+ellipse: ellipse.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+filter: filter.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+gradorigin: gradorigin.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+image: image.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+lineto: lineto.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+lingrad: lingrad.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+lookup: lookup.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+mask: mask.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+mask4: mask4.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+path3: path3.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+pattern: pattern.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+radialgrad: radialgrad.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+readpixels: readpixels.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+roundedrect: roundedrect.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+star-nonzero: star-nonzero.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+star-oddeven: star-oddeven.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+stroke: stroke.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+stroke2: stroke2.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+vguarc: vguarc.c eglcommon.o
+ $(CC) $(CFLAGS) $^ $(LIBS) $(APP_LIB_DEPS) -o $@
+
+
+
+eglcommon.o: eglcommon.c $(HEADERS)
+ $(CC) -c $(CFLAGS) eglcommon.c
+
+
+clean:
+ rm -f *.o *~
+ rm -f *.so
+ rm -f $(PROGRAMS)
diff --git a/progs/openvg/trivial/arc.c b/progs/openvg/trivial/arc.c
new file mode 100644
index 0000000000..db686bea6b
--- /dev/null
+++ b/progs/openvg/trivial/arc.c
@@ -0,0 +1,139 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+#include <math.h>
+
+const VGfloat clear_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {1.0, 1.0, 1.0, 0.5};
+
+VGPath vgPath;
+
+static void ellipse(VGPath vgPath, VGfloat rx, VGfloat ry, VGfloat angle)
+{
+ static const VGubyte cmd[] =
+ { VG_MOVE_TO_ABS, VG_SCCWARC_TO_REL, VG_SCCWARC_TO_REL, VG_CLOSE_PATH };
+
+ VGfloat val[12];
+ VGfloat c = cos(angle) * rx;
+ VGfloat s = sin(angle) * rx;
+
+ val[0] = c;
+ val[1] = s;
+ val[2] = rx;
+ val[3] = ry;
+ val[4] = angle;
+ val[5] = -2.0f * c;
+ val[6] = -2.0f * s;
+ val[7] = rx;
+ val[8] = ry;
+ val[9] = angle;
+ val[10] = 2.0f * c;
+ val[11] = 2.0f * s;
+
+ vgClearPath(vgPath, VG_PATH_CAPABILITY_ALL);
+ vgAppendPathData(vgPath, sizeof(cmd), cmd, val);
+ vgDrawPath(vgPath, VG_FILL_PATH | VG_STROKE_PATH);
+}
+
+static void
+init(void)
+{
+ VGPaint vgPaint;
+
+ vgSetfv(VG_CLEAR_COLOR, 4, clear_color);
+ vgPath = vgCreatePath(VG_PATH_FORMAT_STANDARD,
+ VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0,
+ VG_PATH_CAPABILITY_ALL);
+
+ vgPaint = vgCreatePaint();
+ vgSetParameteri(vgPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
+ vgSetColor(vgPaint, 0x00ff00ff);
+ vgSetPaint(vgPaint, VG_FILL_PATH);
+
+ vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
+ vgSeti(VG_BLEND_MODE, VG_BLEND_SRC_OVER);
+ vgSetf(VG_STROKE_LINE_WIDTH, 2.0f);
+ vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_SQUARE);
+ vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_MITER);
+ vgSetf(VG_STROKE_MITER_LIMIT, 4.0f);
+ vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+static void
+draw(void)
+{
+ vgClear(0, 0, window_width(), window_height());
+
+#if 0
+ vgLoadIdentity();
+ vgTranslate(40.0f, 24.0f);
+ vgScale(0.61804f, 0.61804f);
+ vgShear(-1.0f, 0.0f);
+ vgDrawPath(vgPath, VG_FILL_PATH | VG_STROKE_PATH);
+#else
+
+ /* row 1, col 1: Identity transform. */
+
+ vgLoadIdentity();
+ vgTranslate(8.0f, 8.0f);
+ ellipse(vgPath, 4.0f, 4.0f, 0.0f);
+
+ /* row 1, col 2: 10^3 horizontal squeeze. */
+
+ vgLoadIdentity();
+ vgTranslate(24.0f, 8.0f);
+ vgScale(1.0e-3f, 1.0f);
+ ellipse(vgPath, 4.0e3f, 4.0f, 0.0f);
+
+ /* row 1, col 3: 10^6 horizontal squeeze. */
+
+ vgLoadIdentity();
+ vgTranslate(40.0f, 8.0f);
+ vgScale(1.0e-6f, 1.0f);
+ ellipse(vgPath, 4.0e6f, 4.0f, 0.0f);
+
+ /* row 1, col 4: 10^9 horizontal squeeze. */
+
+ vgLoadIdentity();
+ vgTranslate(56.0f, 8.0f);
+ vgScale(1.0e-9f, 1.0f);
+ ellipse(vgPath, 4.0e9f, 4.0f, 0.0f);
+
+ /* row 2, col 1: 10^3 vertical squeeze. */
+
+ vgLoadIdentity();
+ vgTranslate(8.0f, 24.0f);
+ vgScale(1.0f, 1.0e-3f);
+ ellipse(vgPath, 4.0f, 4.0e3f, 0.0f);
+
+ /* row 2, col 2: Shear 0. */
+
+ vgLoadIdentity();
+ vgTranslate(24.0f, 24.0f);
+ vgShear(0.0f, 0.0f);
+ ellipse(vgPath, 4.0f, 4.0f, 0.0f);
+
+ /* row 2, col 3: Horizontal shear -1. */
+
+ vgLoadIdentity();
+ vgTranslate(40.0f, 24.0f);
+ vgScale(0.61804f, 0.61804f);
+ vgShear(-1.0f, 0.0f);
+ ellipse(vgPath, 10.47213f, 4.0f, 31.717f);
+#endif
+ vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+ set_window_size(64, 64);
+ return run(argc, argv, init, reshape,
+ draw, 0);
+}
diff --git a/progs/openvg/trivial/cap.c b/progs/openvg/trivial/cap.c
new file mode 100644
index 0000000000..cd84fe3ac0
--- /dev/null
+++ b/progs/openvg/trivial/cap.c
@@ -0,0 +1,75 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void
+init(void)
+{
+
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+const int subtest = 0;
+static void
+draw(void)
+{
+ VGPath line;
+ VGPaint fillPaint;
+ VGubyte lineCommands[3] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS};
+ VGfloat lineCoords[] = {-2.0f,-1.0f, 0.0f,0.0f, -1.0f, -2.0f};
+ VGfloat clearColor[] = {0.0f, 0.0f, 0.0f, 1.0f};/* black color */
+ VGfloat fillColor[] = {1.0f, 1.0f, 1.0f, 1.0f};/* white color */
+ //VGfloat testRadius = 60.0f;
+ VGfloat testRadius = 10.0f;
+ int WINDSIZEX = window_width();
+ int WINDSIZEY = window_height();
+
+ line = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
+ 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
+ fillPaint = vgCreatePaint();
+
+ vgSetf(VG_STROKE_LINE_WIDTH, 1.0f);
+ //vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_ROUND);
+ vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
+ vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
+ //vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_BEVEL);
+
+ vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);
+
+ vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
+ vgLoadIdentity();
+ vgTranslate(60, 60);
+ vgScale(testRadius * 2, testRadius * 2);
+
+ vgAppendPathData(line, 3, lineCommands, lineCoords);
+
+ vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
+
+ vgSetPaint(fillPaint, VG_STROKE_PATH);
+
+ vgSetParameterfv(fillPaint, VG_PAINT_COLOR, 4, fillColor);
+ vgSetParameteri( fillPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
+
+ vgClear(0, 0, WINDSIZEX, WINDSIZEY);
+ vgDrawPath(line, VG_STROKE_PATH);
+
+ vgDestroyPath(line);
+ vgDestroyPaint(fillPaint);
+}
+
+
+int main(int argc, char **argv)
+{
+ set_window_size(100, 100);
+ return run(argc, argv, init, reshape,
+ draw, 0);
+}
diff --git a/progs/openvg/trivial/clear.c b/progs/openvg/trivial/clear.c
new file mode 100644
index 0000000000..efb6bf4182
--- /dev/null
+++ b/progs/openvg/trivial/clear.c
@@ -0,0 +1,42 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+#include <stdio.h>
+
+float red_color[4] = {1.0, 0.0, 0.0, 1.0};
+float blue_color[4] = {0.0, 0.0, 1.0, 1.0};
+
+static void
+init(void)
+{
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+ vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+ VGint scissor[4] = {100, 100, 25, 25};
+ vgSetfv(VG_CLEAR_COLOR, 4, red_color);
+ vgClear(0, 0, window_width(), window_height());
+
+ vgSetfv(VG_CLEAR_COLOR, 4, blue_color);
+ vgClear(50, 50, 50, 50);
+
+ //vgSetiv(VG_SCISSOR_RECTS, 4, scissor);
+ //vgSeti(VG_SCISSORING, VG_TRUE);
+ vgCopyPixels(100, 100, 50, 50, 50, 50);
+ vgClear(150, 150, 50, 50);
+}
+
+
+int main(int argc, char **argv)
+{
+ return run(argc, argv, init, reshape,
+ draw, 0);
+}
diff --git a/progs/openvg/trivial/coord.c b/progs/openvg/trivial/coord.c
new file mode 100644
index 0000000000..81f7cb6fc9
--- /dev/null
+++ b/progs/openvg/trivial/coord.c
@@ -0,0 +1,66 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {0.4, 0.1, 1.0, 1.0};
+
+VGPath path;
+VGPaint fill;
+
+
+static void
+init(void)
+{
+ /* Absent VG_CLOSE_PATH */
+ VGubyte commands[] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS,
+ VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS};
+ VGfloat clearColor[] = {1.0f, 1.0f, 1.0f, 1.0f};/* white color */
+ VGfloat fillColor[] = {1.0f, 0.0f, 0.0f, 1.0f};/* red color */
+ VGfloat coords[] = {-16.0f, -16.0f, 0.0f, -16.0f, 0.0f, 0.0f, -16.0f, 0.0f,
+ 0.0f, 0.0f, 16.0f, 0.0f, 16.0f, 16.0f, 0.0f, 16.0f};
+
+ vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
+ vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
+
+ vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
+ vgLoadIdentity();
+ vgTranslate(32.0f, 32.0f);
+
+ path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0,
+ VG_PATH_CAPABILITY_ALL);
+ if (path == VG_INVALID_HANDLE)
+ return;
+ fill = vgCreatePaint();
+ if (fill == VG_INVALID_HANDLE) {
+ vgDestroyPath(path);
+ return;
+ }
+ vgAppendPathData(path, 8, commands, coords);
+ vgSetPaint(fill, VG_FILL_PATH);
+ vgSetParameterfv(fill, VG_PAINT_COLOR, 4, fillColor);
+ vgSetParameteri(fill, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+static void
+draw(void)
+{
+ vgClear(0, 0, window_width(), window_height());
+ vgDrawPath(path, VG_FILL_PATH);
+
+ vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+ set_window_size(64, 64);
+ return run(argc, argv, init, reshape,
+ draw, 0);
+}
diff --git a/progs/openvg/trivial/dash.c b/progs/openvg/trivial/dash.c
new file mode 100644
index 0000000000..2e84ddbd4e
--- /dev/null
+++ b/progs/openvg/trivial/dash.c
@@ -0,0 +1,95 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+#include <X11/keysym.h>
+#include <stdio.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {0.4, 0.1, 1.0, 1.0};
+
+VGPath path;
+VGPaint fill;
+
+VGint cap_style = VG_CAP_BUTT;
+
+static void
+init(void)
+{
+ static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
+ VG_LINE_TO_ABS,
+ VG_LINE_TO_ABS
+ };
+#if 1
+ static const VGfloat coords[] = {100, 100, 150, 100,
+ 150, 200
+ };
+#else
+ static const VGfloat coords[] = {100, 20, 100, 220,
+ };
+#endif
+ VGfloat dash_pattern[2] = { 20.f, 20.f };
+ path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+ VG_PATH_CAPABILITY_APPEND_TO);
+ vgAppendPathData(path, 3, cmds, coords);
+
+ fill = vgCreatePaint();
+ vgSetParameterfv(fill, VG_PAINT_COLOR, 4, color);
+ vgSetPaint(fill, VG_FILL_PATH);
+
+ vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+ vgSetf(VG_STROKE_LINE_WIDTH, 20);
+ vgSeti(VG_STROKE_CAP_STYLE, cap_style);
+ vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
+ vgSetfv(VG_STROKE_DASH_PATTERN, 2, dash_pattern);
+ vgSetf(VG_STROKE_DASH_PHASE, 0.0f);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+ vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+ vgClear(0, 0, window_width(), window_height());
+ vgDrawPath(path, VG_STROKE_PATH);
+
+ vgFlush();
+}
+
+static int key_press(unsigned key)
+{
+ switch(key) {
+ case XK_c:
+ case XK_C:
+ ++cap_style;
+ if (cap_style > VG_CAP_SQUARE)
+ cap_style = VG_CAP_BUTT;
+ switch(cap_style) {
+ case VG_CAP_BUTT:
+ fprintf(stderr, "Cap style 'butt'\n");
+ break;
+ case VG_CAP_ROUND:
+ fprintf(stderr, "Cap style 'round'\n");
+ break;
+ case VG_CAP_SQUARE:
+ fprintf(stderr, "Cap style 'square'\n");
+ break;
+ }
+ vgSeti(VG_STROKE_CAP_STYLE, cap_style);
+ break;
+ default:
+ break;
+ }
+
+ return VG_TRUE;
+}
+
+int main(int argc, char **argv)
+{
+ return run(argc, argv, init, reshape,
+ draw, key_press);
+}
diff --git a/progs/openvg/trivial/eglcommon.c b/progs/openvg/trivial/eglcommon.c
new file mode 100644
index 0000000000..bacd5685d7
--- /dev/null
+++ b/progs/openvg/trivial/eglcommon.c
@@ -0,0 +1,288 @@
+#include "eglcommon.h"
+
+
+#include <assert.h>
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/keysym.h>
+#include <VG/openvg.h> /* using full OpenGL for now */
+#include <GLES/egl.h>
+
+
+static init_func init = 0;
+static draw_func draw = 0;
+static reshape_func reshape = 0;
+static key_func keyPress = 0;
+static VGint width = 300, height = 300;
+
+
+void set_window_size(int w, int h)
+{
+ width = w;
+ height = h;
+}
+
+/*
+ * Create an RGB, double-buffered X window.
+ * Return the window and context handles.
+ */
+static void
+make_x_window(Display *x_dpy, EGLDisplay egl_dpy,
+ const char *name,
+ int x, int y, int width, int height,
+ Window *winRet,
+ EGLContext *ctxRet,
+ EGLSurface *surfRet)
+{
+ static const EGLint attribs[] = {
+ EGL_RED_SIZE, 1,
+ EGL_GREEN_SIZE, 1,
+ EGL_BLUE_SIZE, 1,
+ EGL_NONE
+ };
+
+ int scrnum;
+ XSetWindowAttributes attr;
+ unsigned long mask;
+ Window root;
+ Window win;
+ XVisualInfo *visInfo, visTemplate;
+ int num_visuals;
+ EGLContext ctx;
+ EGLConfig config;
+ EGLint num_configs;
+ EGLint vid;
+
+ scrnum = DefaultScreen( x_dpy );
+ root = RootWindow( x_dpy, scrnum );
+
+ if (!eglChooseConfig( egl_dpy, attribs, &config, 1, &num_configs)) {
+ printf("Error: couldn't get an EGL visual config\n");
+ exit(1);
+ }
+
+ assert(config);
+ assert(num_configs > 0);
+
+ if (!eglGetConfigAttrib(egl_dpy, config, EGL_NATIVE_VISUAL_ID, &vid)) {
+ printf("Error: eglGetConfigAttrib() failed\n");
+ exit(1);
+ }
+
+ /* The X window visual must match the EGL config */
+ visTemplate.visualid = vid;
+ visInfo = XGetVisualInfo(x_dpy, VisualIDMask, &visTemplate, &num_visuals);
+ if (!visInfo) {
+ printf("Error: couldn't get X visual\n");
+ exit(1);
+ }
+
+ /* window attributes */
+ attr.background_pixel = 0;
+ attr.border_pixel = 0;
+ attr.colormap = XCreateColormap( x_dpy, root, visInfo->visual, AllocNone);
+ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
+ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
+
+ win = XCreateWindow( x_dpy, root, 0, 0, width, height,
+ 0, visInfo->depth, InputOutput,
+ visInfo->visual, mask, &attr );
+
+ /* set hints and properties */
+ {
+ XSizeHints sizehints;
+ sizehints.x = x;
+ sizehints.y = y;
+ sizehints.width = width;
+ sizehints.height = height;
+ sizehints.flags = USSize | USPosition;
+ XSetNormalHints(x_dpy, win, &sizehints);
+ XSetStandardProperties(x_dpy, win, name, name,
+ None, (char **)NULL, 0, &sizehints);
+ }
+
+ eglBindAPI(EGL_OPENVG_API);
+
+ ctx = eglCreateContext(egl_dpy, config, EGL_NO_CONTEXT, NULL );
+ if (!ctx) {
+ printf("Error: eglCreateContext failed\n");
+ exit(1);
+ }
+
+ *surfRet = eglCreateWindowSurface(egl_dpy, config, win, NULL);
+
+ if (!*surfRet) {
+ printf("Error: eglCreateWindowSurface failed\n");
+ exit(1);
+ }
+
+ XFree(visInfo);
+
+ *winRet = win;
+ *ctxRet = ctx;
+}
+
+static void
+event_loop(Display *dpy, Window win,
+ EGLDisplay egl_dpy, EGLSurface egl_surf)
+{
+ while (1) {
+ int redraw = 0;
+ XEvent event;
+
+ XNextEvent(dpy, &event);
+
+ switch (event.type) {
+ case Expose:
+ redraw = 1;
+ break;
+ case ConfigureNotify:
+ if (reshape) {
+ width = event.xconfigure.width;
+ height = event.xconfigure.height;
+ reshape(event.xconfigure.width, event.xconfigure.height);
+ }
+ break;
+ case KeyPress:
+ {
+ char buffer[10];
+ int r, code;
+ code = XLookupKeysym(&event.xkey, 0);
+ if (!keyPress || !keyPress(code)) {
+ r = XLookupString(&event.xkey, buffer, sizeof(buffer),
+ NULL, NULL);
+ if (buffer[0] == 27) {
+ /* escape */
+ return;
+ }
+ }
+ }
+ redraw = 1;
+ break;
+ default:
+ ; /*no-op*/
+ }
+
+ if (redraw) {
+ draw();
+ eglSwapBuffers(egl_dpy, egl_surf);
+ }
+ }
+}
+
+int window_width(void)
+{
+ return width;
+}
+
+int window_height(void)
+{
+ return height;
+}
+
+static void
+usage(void)
+{
+ printf("Usage:\n");
+ printf(" -display <displayname> set the display to run on\n");
+ printf(" -info display OpenGL renderer info\n");
+}
+
+int run(int argc, char **argv,
+ init_func init_f,
+ reshape_func resh_f,
+ draw_func draw_f,
+ key_func key_f)
+{
+ const int winWidth = width, winHeight = height;
+ Display *x_dpy;
+ Window win;
+ EGLSurface egl_surf;
+ EGLContext egl_ctx;
+ EGLDisplay egl_dpy;
+ char *dpyName = NULL;
+ GLboolean printInfo = GL_FALSE;
+ EGLint egl_major, egl_minor;
+ int i;
+ const char *s;
+
+ init = init_f;
+ draw = draw_f;
+ reshape = resh_f;
+ keyPress = key_f;
+
+ for (i = 1; i < argc; i++) {
+ if (strcmp(argv[i], "-display") == 0) {
+ dpyName = argv[i+1];
+ i++;
+ }
+ else if (strcmp(argv[i], "-info") == 0) {
+ printInfo = GL_TRUE;
+ }
+ }
+
+ x_dpy = XOpenDisplay(dpyName);
+ if (!x_dpy) {
+ printf("Error: couldn't open display %s\n",
+ dpyName ? dpyName : getenv("DISPLAY"));
+ return -1;
+ }
+
+ egl_dpy = eglGetDisplay(x_dpy);
+ if (!egl_dpy) {
+ printf("Error: eglGetDisplay() failed\n");
+ return -1;
+ }
+
+ if (!eglInitialize(egl_dpy, &egl_major, &egl_minor)) {
+ printf("Error: eglInitialize() failed\n");
+ return -1;
+ }
+
+ s = eglQueryString(egl_dpy, EGL_VERSION);
+ printf("EGL_VERSION = %s\n", s);
+
+ make_x_window(x_dpy, egl_dpy,
+ "OpenVG Example", 0, 0, winWidth, winHeight,
+ &win, &egl_ctx, &egl_surf);
+
+ XMapWindow(x_dpy, win);
+ if (!eglMakeCurrent(egl_dpy, egl_surf, egl_surf, egl_ctx)) {
+ printf("Error: eglMakeCurrent() failed\n");
+ return -1;
+ }
+
+ if (printInfo) {
+ printf("VG_RENDERER = %s\n", (char *) vgGetString(VG_RENDERER));
+ printf("VG_VERSION = %s\n", (char *) vgGetString(VG_VERSION));
+ printf("VG_VENDOR = %s\n", (char *) vgGetString(VG_VENDOR));
+ }
+
+ if (init)
+ init();
+
+ /* Set initial projection/viewing transformation.
+ * We can't be sure we'll get a ConfigureNotify event when the window
+ * first appears.
+ */
+ if (reshape)
+ reshape(winWidth, winHeight);
+
+ event_loop(x_dpy, win, egl_dpy, egl_surf);
+
+ eglMakeCurrent(egl_dpy, 0, 0, 0);
+ eglDestroyContext(egl_dpy, egl_ctx);
+ eglDestroySurface(egl_dpy, egl_surf);
+ eglTerminate(egl_dpy);
+
+
+ XDestroyWindow(x_dpy, win);
+ XCloseDisplay(x_dpy);
+
+ return 0;
+}
+
diff --git a/progs/openvg/trivial/eglcommon.h b/progs/openvg/trivial/eglcommon.h
new file mode 100644
index 0000000000..958dae9f98
--- /dev/null
+++ b/progs/openvg/trivial/eglcommon.h
@@ -0,0 +1,20 @@
+#ifndef EGLCOMMON_H
+#define EGLCOMMON_H
+
+typedef void (*init_func)();
+typedef void (*reshape_func)(int, int);
+typedef void (*draw_func)();
+typedef int (*key_func)(unsigned key);
+
+
+void set_window_size(int width, int height);
+int window_width(void);
+int window_height(void);
+
+int run(int argc, char **argv,
+ init_func init,
+ reshape_func resh,
+ draw_func draw,
+ key_func key);
+
+#endif
diff --git a/progs/openvg/trivial/ellipse.c b/progs/openvg/trivial/ellipse.c
new file mode 100644
index 0000000000..4c7d4904f8
--- /dev/null
+++ b/progs/openvg/trivial/ellipse.c
@@ -0,0 +1,84 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+#include <math.h>
+#include <stdlib.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {0.0, 0.0, 0.0, 1.0};
+
+VGPath path;
+VGPaint paint;
+
+static void
+init(void)
+{
+ VGfloat clearColor[] = {1.0f, 1.0f, 1.0f, 1.0f};/* white color */
+ VGfloat fillColor[] = {1.0f, 0.0f, 0.0f, 1.0f};/* red color */
+ static const VGubyte segments[4] = {VG_MOVE_TO_ABS,
+ VG_SCCWARC_TO_ABS,
+ VG_SCCWARC_TO_ABS,
+ VG_CLOSE_PATH};
+ VGfloat data[12];
+ const VGfloat cx = 0, cy=29, width=80, height=40;
+ const VGfloat hw = width * 0.5f;
+ const VGfloat hh = height * 0.5f;
+
+ data[0] = cx + hw;
+ data[1] = cy;
+ data[2] = hw;
+ data[3] = hh;
+ data[4] = 0;
+ data[5] = cx - hw;
+ data[6] = cy;
+ data[7] = hw;
+ data[8] = hh;
+ data[9] = 0;
+ data[10] = data[0];
+ data[11] = cy;
+
+ vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
+ vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
+
+
+ path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
+ 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
+ if (path == VG_INVALID_HANDLE) {
+ return;
+ }
+ paint = vgCreatePaint();
+ if (paint == VG_INVALID_HANDLE) {
+ vgDestroyPath(path);
+ return;
+ }
+
+ vgAppendPathData(path, 4, segments, data);
+ vgSetParameterfv(paint, VG_PAINT_COLOR, 4, fillColor);
+ vgSetParameteri( paint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
+ vgSetPaint(paint, VG_FILL_PATH);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+static void
+draw(void)
+{
+ vgClear(0, 0, window_width(), window_height());
+ vgLoadIdentity();
+ vgTranslate(50, 21);
+ vgDrawPath(path, VG_FILL_PATH);
+ vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+ set_window_size(100, 100);
+ return run(argc, argv, init, reshape,
+ draw, 0);
+}
diff --git a/progs/openvg/trivial/filter.c b/progs/openvg/trivial/filter.c
new file mode 100644
index 0000000000..d96257a933
--- /dev/null
+++ b/progs/openvg/trivial/filter.c
@@ -0,0 +1,107 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {1.0, 1.0, 1.0, 0.5};
+
+VGImage srcImg;
+VGImage dstImg;
+
+VGPaint fill;
+
+VGfloat bgCol[4] = {0.906f, 0.914f, 0.761f, 1.0f};
+
+static void
+init(void)
+{
+ VGfloat red[4];
+ VGfloat grey[4];
+ VGfloat orange[4];
+ VGfloat blue[4];
+ VGfloat black[4];
+ VGfloat white[4];
+ VGshort transKernel[49] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+ red[0] = 0.6710f;
+ red[1] = 0.1060f;
+ red[2] = 0.1330f;
+ red[3] = 1.0f;
+
+ grey[0] = 0.6347f;
+ grey[1] = 0.6561f;
+ grey[2] = 0.6057f;
+ grey[3] = 1.0f;
+
+ orange[0] = 1.0000f;
+ orange[1] = 0.8227f;
+ orange[2] = 0.5057f;
+ orange[3] = 1.0f;
+
+ blue[0] = 0.0000f;
+ blue[1] = 0.6908f;
+ blue[2] = 0.8595f;
+ blue[3] = 1.0f;
+
+ black[0] = 0;
+ black[1] = 0;
+ black[2] = 0;
+ black[3] = 1.0f;
+
+ white[0] = 1;
+ white[1] = 1;
+ white[2] = 1;
+ white[3] = 1.0f;
+
+ vgSetfv(VG_TILE_FILL_COLOR, 4, blue);
+
+ vgSeti(VG_FILTER_CHANNEL_MASK, 14);
+
+ /* Setup images */
+ srcImg = vgCreateImage(VG_sRGBA_8888, 32, 32,
+ VG_IMAGE_QUALITY_NONANTIALIASED);
+ dstImg = vgCreateImage(VG_sRGBA_8888, 32, 32,
+ VG_IMAGE_QUALITY_NONANTIALIASED);
+
+ vgSetfv(VG_CLEAR_COLOR, 4, black);
+ vgClearImage(srcImg, 0, 0, 32, 32);
+ vgSetfv(VG_CLEAR_COLOR, 4, red);
+ vgClearImage(srcImg, 3, 3, 27, 27);
+
+ vgSetfv(VG_CLEAR_COLOR, 4, orange);
+ vgClearImage(dstImg, 0, 0, 32, 32);
+
+ transKernel[8] = 1;
+ vgConvolve(dstImg, srcImg, 3, 3, 3, 0, transKernel,
+ 1, 0, VG_TILE_FILL);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+static void
+draw(void)
+{
+ vgSetfv(VG_CLEAR_COLOR, 4, bgCol);
+ vgClear(0, 0, window_width(), window_height());
+ vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
+ vgLoadIdentity();
+ vgTranslate(10, 10);
+ vgDrawImage(dstImg);
+ vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+ set_window_size(64, 64);
+ return run(argc, argv, init, reshape,
+ draw, 0);
+}
diff --git a/progs/openvg/trivial/gradorigin.c b/progs/openvg/trivial/gradorigin.c
new file mode 100644
index 0000000000..b376263fe5
--- /dev/null
+++ b/progs/openvg/trivial/gradorigin.c
@@ -0,0 +1,98 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+#include <stdio.h>
+#include <string.h>
+
+static const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+
+static VGPath path;
+static VGPaint fill;
+
+VGColorRampSpreadMode spread = VG_COLOR_RAMP_SPREAD_PAD;
+
+static void
+init(void)
+{
+ VGubyte commands[5] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_CLOSE_PATH};
+ VGfloat coords[8] = {0.0f,0.0f, 32.0f,0.0f, 32.0f,32.0f, 0.0f,32.0f };
+
+ VGfloat rampStop[20] = {-0.5f, 1.0f, 1.0f, 1.0f, 1.0f,
+ 0.25f, 1.0f, 0.0f, 0.0f, 1.0f,
+ 0.75f, 0.0f, 0.0f, 1.0f, 1.0f,
+ 1.5f, 0.0f, 0.0f, 0.0f, 0.0f};
+
+ VGfloat defaultColor[] = {1.0f, 1.0f, 1.0f, 1.0f};
+ VGfloat linearGradient[4] = {0.0f, 0.0f, 0.0f, 32.0f};
+
+ path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
+ 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
+ if (path == VG_INVALID_HANDLE)
+ return;
+
+ fill = vgCreatePaint();
+ if (fill == VG_INVALID_HANDLE) {
+ vgDestroyPath(path);
+ return;
+ }
+
+ vgSetfv(VG_CLEAR_COLOR, 4, defaultColor);
+ vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
+
+ vgAppendPathData(path, 5, commands, coords);
+
+ vgSetPaint(fill, VG_FILL_PATH);
+ vgSetParameteri(fill, VG_PAINT_TYPE, VG_PAINT_TYPE_LINEAR_GRADIENT);
+ vgSetParameteri(fill, VG_PAINT_COLOR_RAMP_SPREAD_MODE,
+ VG_COLOR_RAMP_SPREAD_REPEAT);
+ vgSetParameterfv(fill, VG_PAINT_LINEAR_GRADIENT, 4, linearGradient);
+ vgSetParameterfv(fill, VG_PAINT_COLOR_RAMP_STOPS, 20, rampStop);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+ vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+ vgClear(0, 0, window_width(), window_height());
+
+ vgDrawPath(path, VG_FILL_PATH);
+
+ vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+ if (argc > 1) {
+ const char *arg = argv[1];
+ if (!strcmp("-pad", arg))
+ spread = VG_COLOR_RAMP_SPREAD_PAD;
+ else if (!strcmp("-repeat", arg))
+ spread = VG_COLOR_RAMP_SPREAD_REPEAT;
+ else if (!strcmp("-reflect", arg))
+ spread = VG_COLOR_RAMP_SPREAD_REFLECT;
+ }
+
+ switch(spread) {
+ case VG_COLOR_RAMP_SPREAD_PAD:
+ printf("Using spread mode: pad\n");
+ break;
+ case VG_COLOR_RAMP_SPREAD_REPEAT:
+ printf("Using spread mode: repeat\n");
+ break;
+ case VG_COLOR_RAMP_SPREAD_REFLECT:
+ printf("Using spread mode: reflect\n");
+ }
+
+ set_window_size(200, 200);
+
+ return run(argc, argv, init, reshape,
+ draw, 0);
+}
diff --git a/progs/openvg/trivial/lineto.c b/progs/openvg/trivial/lineto.c
new file mode 100644
index 0000000000..94e2981811
--- /dev/null
+++ b/progs/openvg/trivial/lineto.c
@@ -0,0 +1,56 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {0.4, 0.1, 1.0, 1.0};
+
+VGPath path;
+VGPaint fill;
+
+
+static void
+init(void)
+{
+ static const VGubyte sqrCmds[5] = {VG_MOVE_TO_ABS, VG_HLINE_TO_ABS, VG_VLINE_TO_ABS, VG_HLINE_TO_ABS, VG_CLOSE_PATH};
+ static const VGfloat sqrCoords[5] = {50.0f, 50.0f, 250.0f, 250.0f, 50.0f};
+ path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+ VG_PATH_CAPABILITY_APPEND_TO);
+ vgAppendPathData(path, 5, sqrCmds, sqrCoords);
+
+ fill = vgCreatePaint();
+ vgSetParameterfv(fill, VG_PAINT_COLOR, 4, color);
+ vgSetPaint(fill, VG_FILL_PATH);
+
+ vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+ vgSetf(VG_STROKE_LINE_WIDTH, 10);
+ vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
+ vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
+ vgSetf(VG_STROKE_MITER_LIMIT, 4.0f);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+ vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+ vgClear(0, 0, window_width(), window_height());
+ vgSeti(VG_MATRIX_MODE, VG_MATRIX_STROKE_PAINT_TO_USER);
+ vgLoadIdentity();
+ vgScale(2.25, 2.25);
+ vgDrawPath(path, VG_STROKE_PATH);
+
+ vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+ return run(argc, argv, init, reshape,
+ draw, 0);
+}
diff --git a/progs/openvg/trivial/lingrad.c b/progs/openvg/trivial/lingrad.c
new file mode 100644
index 0000000000..bcaad1f101
--- /dev/null
+++ b/progs/openvg/trivial/lingrad.c
@@ -0,0 +1,87 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+#include <stdio.h>
+#include <string.h>
+
+static const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+
+static VGPath path;
+static VGPaint fill;
+
+VGColorRampSpreadMode spread = VG_COLOR_RAMP_SPREAD_PAD;
+
+static void
+init(void)
+{
+ static const VGubyte sqrCmds[5] = {VG_MOVE_TO_ABS, VG_HLINE_TO_ABS, VG_VLINE_TO_ABS, VG_HLINE_TO_ABS, VG_CLOSE_PATH};
+ static const VGfloat sqrCoords[5] = {0.0f, 0.0f, 400.0f, 400.0f, 0.0f};
+
+ VGfloat rampStop[] = {0.00f, 1.0f, 1.0f, 1.0f, 1.0f,
+ 0.33f, 1.0f, 0.0f, 0.0f, 1.0f,
+ 0.66f, 0.0f, 1.0f, 0.0f, 1.0f,
+ 1.00f, 0.0f, 0.0f, 1.0f, 1.0f};
+ VGfloat linearGradient[4] = {100.0f, 100.0f, 300.0f, 300.0f};
+
+ path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+ VG_PATH_CAPABILITY_APPEND_TO);
+ vgAppendPathData(path, 5, sqrCmds, sqrCoords);
+
+ fill = vgCreatePaint();
+ vgSetPaint(fill, VG_FILL_PATH);
+
+ vgSetParameteri(fill, VG_PAINT_TYPE, VG_PAINT_TYPE_LINEAR_GRADIENT);
+ vgSetParameteri(fill, VG_PAINT_COLOR_RAMP_SPREAD_MODE, spread);
+ vgSetParameterfv(fill, VG_PAINT_LINEAR_GRADIENT, 4, linearGradient);
+ vgSetParameterfv(fill, VG_PAINT_COLOR_RAMP_STOPS, 20, rampStop);
+
+ vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+ vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+ vgClear(0, 0, window_width(), window_height());
+
+ vgDrawPath(path, VG_FILL_PATH);
+
+ vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+ if (argc > 1) {
+ const char *arg = argv[1];
+ if (!strcmp("-pad", arg))
+ spread = VG_COLOR_RAMP_SPREAD_PAD;
+ else if (!strcmp("-repeat", arg))
+ spread = VG_COLOR_RAMP_SPREAD_REPEAT;
+ else if (!strcmp("-reflect", arg))
+ spread = VG_COLOR_RAMP_SPREAD_REFLECT;
+ }
+
+ switch(spread) {
+ case VG_COLOR_RAMP_SPREAD_PAD:
+ printf("Using spread mode: pad\n");
+ break;
+ case VG_COLOR_RAMP_SPREAD_REPEAT:
+ printf("Using spread mode: repeat\n");
+ break;
+ case VG_COLOR_RAMP_SPREAD_REFLECT:
+ printf("Using spread mode: reflect\n");
+ }
+
+ set_window_size(400, 400);
+
+ return run(argc, argv, init, reshape,
+ draw, 0);
+}
diff --git a/progs/openvg/trivial/lookup.c b/progs/openvg/trivial/lookup.c
new file mode 100644
index 0000000000..a103ba4488
--- /dev/null
+++ b/progs/openvg/trivial/lookup.c
@@ -0,0 +1,71 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {1.0, 1.0, 1.0, 0.5};
+VGfloat clearColor[] = {1.0f, 0.0f, 0.0f, 1.0f};/* red color */
+VGImage parent;
+
+VGPaint fill;
+
+static void
+init(void)
+{
+ VGImage child1, child2;
+ VGubyte *data;
+ VGuint LUT[256];
+ VGint i;
+
+ data = (VGubyte *)malloc(sizeof(VGubyte)*window_width()*window_height());
+
+ for (i=0;i<window_width()*window_height();i++) {
+ data[i] = 0x00;
+ }
+
+ for (i=0; i<256; i++) {
+ if ( i == 0 )
+ LUT[0] = 0xFFFFFFFF;
+ else
+ LUT[i] = 0xFF00FFFF;
+ }
+
+ parent = vgCreateImage( VG_A_8, 64, 64, VG_IMAGE_QUALITY_NONANTIALIASED );
+
+ vgImageSubData(parent, data, window_width(), VG_A_8, 0, 0,
+ window_width(), window_height());
+ child1 = vgChildImage(parent, 0, 0, 32, 64);
+ child2 = vgChildImage(parent, 32, 0, 32, 64);
+
+ vgLookupSingle(child2, child1, LUT, VG_GREEN, VG_FALSE, VG_TRUE);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+static void
+draw(void)
+{
+ vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
+ vgClear(0, 0, window_width(), window_height());
+ //vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
+ //vgLoadIdentity();
+ //vgTranslate(10, 10);
+ vgDrawImage(parent);
+ vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+ set_window_size(64, 64);
+ return run(argc, argv, init, reshape,
+ draw, 0);
+}
diff --git a/progs/openvg/trivial/mask.c b/progs/openvg/trivial/mask.c
new file mode 100644
index 0000000000..e5c00c5699
--- /dev/null
+++ b/progs/openvg/trivial/mask.c
@@ -0,0 +1,58 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {0.4, 0.1, 1.0, 1.0};
+
+VGPath path;
+VGPaint fill;
+
+
+static void
+init(void)
+{
+ static const VGubyte sqrCmds[5] = {VG_MOVE_TO_ABS, VG_HLINE_TO_ABS, VG_VLINE_TO_ABS, VG_HLINE_TO_ABS, VG_CLOSE_PATH};
+ static const VGfloat sqrCoords[5] = {50.0f, 50.0f, 250.0f, 250.0f, 50.0f};
+ path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+ VG_PATH_CAPABILITY_APPEND_TO);
+ vgAppendPathData(path, 5, sqrCmds, sqrCoords);
+
+ fill = vgCreatePaint();
+ vgSetParameterfv(fill, VG_PAINT_COLOR, 4, color);
+ vgSetPaint(fill, VG_FILL_PATH);
+
+ vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+ vgSetf(VG_STROKE_LINE_WIDTH, 10);
+ vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
+ vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
+ vgSetf(VG_STROKE_MITER_LIMIT, 4.0f);
+
+ vgSeti(VG_MASKING, VG_TRUE);
+
+ vgMask(VG_INVALID_HANDLE, VG_CLEAR_MASK,
+ 25, 25, 100, 100);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+ vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+ vgClear(0, 0, window_width(), window_height());
+ vgDrawPath(path, VG_FILL_PATH);
+
+ vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+ return run(argc, argv, init, reshape,
+ draw, 0);
+}
diff --git a/progs/openvg/trivial/mask4.c b/progs/openvg/trivial/mask4.c
new file mode 100644
index 0000000000..fe6db39648
--- /dev/null
+++ b/progs/openvg/trivial/mask4.c
@@ -0,0 +1,132 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+#include <VG/vgu.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+
+#include <X11/keysym.h>
+
+//VGint x_pos = -10, y_pos = -10;
+VGint x_pos = 0, y_pos = 4;
+VGint img_width = 120, img_height = 120;
+
+static void RectToPath(VGPath path, VGfloat x, VGfloat y, VGfloat width, VGfloat height)
+{
+ static const VGubyte segments[5] = {VG_MOVE_TO_ABS,
+ VG_HLINE_TO_ABS,
+ VG_VLINE_TO_ABS,
+ VG_HLINE_TO_ABS,
+ VG_CLOSE_PATH};
+ VGfloat data[5];
+
+ data[0] = x;
+ data[1] = y;
+ data[2] = x + width;
+ data[3] = y + height;
+ data[4] = x;
+
+ vgAppendPathData(path, 5, segments, data);
+}
+
+static void
+init(void)
+{
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+int key_press(unsigned key)
+{
+ switch(key) {
+ case XK_Right:
+ x_pos +=1;
+ break;
+ case XK_Left:
+ x_pos -=1;
+ break;
+ case XK_Up:
+ y_pos +=1;
+ break;
+ case XK_Down:
+ y_pos -=1;
+ break;
+ case 'a':
+ img_width -= 5;
+ img_height -= 5;
+ break;
+ case 's':
+ img_width += 5;
+ img_height += 5;
+ break;
+ default:
+ break;
+ }
+ fprintf(stderr, "Posi = %dx%d\n", x_pos, y_pos);
+ fprintf(stderr, "Size = %dx%d\n", img_width, img_height);
+ return VG_FALSE;
+}
+
+static void
+draw(void)
+{
+ VGint WINDSIZEX = window_width();
+ VGint WINDSIZEY = window_height();
+
+ VGPaint fill;
+ VGPath box;
+ VGfloat color[4] = {1.f, 0.f, 0.f, 1.f};
+ VGfloat bgCol[4] = {0.7f, 0.7f, 0.7f, 1.0f};
+ VGfloat transCol[4] = {0.f, 0.f, 0.f, 0.f};
+ VGImage image = vgCreateImage(VG_sRGBA_8888, img_width, img_height,
+ VG_IMAGE_QUALITY_NONANTIALIASED);
+
+ /* Background clear */
+ fill = vgCreatePaint();
+ vgSetParameterfv(fill, VG_PAINT_COLOR, 4, color);
+ vgSetPaint(fill, VG_FILL_PATH);
+
+ box = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
+ 1, 0, 0, 0, VG_PATH_CAPABILITY_ALL);
+ /* Rectangle to cover completely 16x16 pixel area. */
+ RectToPath(box, 0, 0, 64, 64);
+
+ vgSetfv(VG_CLEAR_COLOR, 4, transCol);
+ vgClearImage(image, 0, 0, img_width, img_height);
+ vgSetfv(VG_CLEAR_COLOR, 4, color);
+ vgClearImage(image, 10, 10, 12, 12);
+ //vgImageSubData(image, pukki_64x64_data, pukki_64x64_stride,
+ // VG_sRGBA_8888, 0, 0, 32, 32);
+ vgSeti(VG_MASKING, VG_TRUE);
+ vgLoadIdentity();
+
+ vgSetfv(VG_CLEAR_COLOR, 4, bgCol);
+ vgClear(0, 0, WINDSIZEX, WINDSIZEY);
+
+
+ vgMask(image, VG_FILL_MASK, 0, 0, window_width(), window_height());
+ vgMask(image, VG_SET_MASK, x_pos, y_pos, 100, 100);
+
+ vgDrawPath(box, VG_FILL_PATH);
+
+ //vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
+ //vgTranslate(-10, -10);
+ //vgDrawImage(image);
+
+
+ vgDestroyPaint(fill);
+ vgDestroyPath(box);
+}
+
+
+int main(int argc, char **argv)
+{
+ set_window_size(64, 64);
+ return run(argc, argv, init, reshape,
+ draw, key_press);
+}
diff --git a/progs/openvg/trivial/path3.c b/progs/openvg/trivial/path3.c
new file mode 100644
index 0000000000..5ce600f65a
--- /dev/null
+++ b/progs/openvg/trivial/path3.c
@@ -0,0 +1,77 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+#include <VG/vgu.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+
+static void
+init(void)
+{
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+
+static void
+draw(void)
+{
+ VGint WINDSIZEX = window_width();
+ VGint WINDSIZEY = window_height();
+ VGPath path;
+ VGPaint paint;
+
+ VGfloat clearColor[] = {1.0f, 1.0f, 1.0f, 0.0f};/* white color */
+ VGfloat fillColor[] = {1.0f, 0.0f, 0.0f, 1.0f};/* red color */
+
+#if 1
+ VGubyte commands[4] = {VG_MOVE_TO_ABS, VG_LCWARC_TO_ABS, VG_SCWARC_TO_ABS, VG_CLOSE_PATH};
+#else
+ VGubyte commands[4] = {VG_MOVE_TO_ABS, VG_SCCWARC_TO_ABS, VG_LCCWARC_TO_ABS,VG_CLOSE_PATH};
+#endif
+ VGfloat coords[] = {32.0f, 0.0f,
+ -32.0f, -32.0f, 0.0f, 64.0f, 32.0f,
+ -32.0f, -32.0f, 0.0f, 32.0f, 0.0f};
+
+
+ vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
+ vgClear(0, 0, WINDSIZEX, WINDSIZEY);
+ vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
+
+ vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
+ vgLoadIdentity();
+ //vgTranslate(32.0f, 32.0f);
+
+ path = vgCreatePath( VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
+ 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL );
+ if ( path == VG_INVALID_HANDLE ) {
+ return;
+ }
+ paint = vgCreatePaint();
+ if ( paint == VG_INVALID_HANDLE ) {
+ vgDestroyPath(path);
+ return;
+ }
+
+ vgAppendPathData(path, 4, commands, coords);
+ vgSetParameterfv(paint, VG_PAINT_COLOR, 4, fillColor);
+ vgSetParameteri( paint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
+ vgSetPaint(paint, VG_FILL_PATH);
+ vgDrawPath(path, VG_FILL_PATH);
+
+ vgDestroyPath(path);
+ vgDestroyPaint(paint);
+}
+
+
+int main(int argc, char **argv)
+{
+ set_window_size(64, 64);
+ return run(argc, argv, init, reshape,
+ draw, 0);
+}
diff --git a/progs/openvg/trivial/radialgrad.c b/progs/openvg/trivial/radialgrad.c
new file mode 100644
index 0000000000..cf3b1d522d
--- /dev/null
+++ b/progs/openvg/trivial/radialgrad.c
@@ -0,0 +1,99 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+#include <stdio.h>
+#include <string.h>
+
+static const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+
+static VGPath path;
+static VGPaint fill;
+
+
+VGfloat centeredGradient[5] = {200.0f, 200.0f, 200.0f, 200.0f, 100};
+VGfloat noncenteredGradient[5] = {200.0f, 200.0f, 250.0f, 250.0f, 100};
+VGfloat *radialGradient = centeredGradient;
+
+VGColorRampSpreadMode spread = VG_COLOR_RAMP_SPREAD_PAD;
+
+static void
+init(void)
+{
+ static const VGubyte sqrCmds[5] = {VG_MOVE_TO_ABS, VG_HLINE_TO_ABS, VG_VLINE_TO_ABS, VG_HLINE_TO_ABS, VG_CLOSE_PATH};
+ static const VGfloat sqrCoords[5] = {0.0f, 0.0f, 400.0f, 400.0f, 0.0f};
+
+ VGfloat rampStop[] = {0.00f, 1.0f, 1.0f, 1.0f, 1.0f,
+ 0.33f, 1.0f, 0.0f, 0.0f, 1.0f,
+ 0.66f, 0.0f, 1.0f, 0.0f, 1.0f,
+ 1.00f, 0.0f, 0.0f, 1.0f, 1.0f};
+
+ path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+ VG_PATH_CAPABILITY_APPEND_TO);
+ vgAppendPathData(path, 5, sqrCmds, sqrCoords);
+
+ fill = vgCreatePaint();
+ vgSetPaint(fill, VG_FILL_PATH);
+
+ vgSetParameteri(fill, VG_PAINT_TYPE, VG_PAINT_TYPE_RADIAL_GRADIENT);
+ vgSetParameteri(fill, VG_PAINT_COLOR_RAMP_SPREAD_MODE, spread);
+ vgSetParameterfv(fill, VG_PAINT_RADIAL_GRADIENT, 5, radialGradient);
+ vgSetParameterfv(fill, VG_PAINT_COLOR_RAMP_STOPS, 20, rampStop);
+
+ vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+ vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+ vgClear(0, 0, window_width(), window_height());
+
+ vgDrawPath(path, VG_FILL_PATH);
+
+ vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+ VGint i;
+ for (i = 1; i < argc; ++i) {
+ const char *arg = argv[i];
+ if (!strcmp("-pad", arg))
+ spread = VG_COLOR_RAMP_SPREAD_PAD;
+ else if (!strcmp("-repeat", arg))
+ spread = VG_COLOR_RAMP_SPREAD_REPEAT;
+ else if (!strcmp("-reflect", arg))
+ spread = VG_COLOR_RAMP_SPREAD_REFLECT;
+ else if (!strcmp("-center", arg)) {
+ printf("Centered radial gradient\n");
+ radialGradient = centeredGradient;
+ } else if (!strcmp("-noncenter", arg)) {
+ printf("Non centered radial gradient\n");
+ radialGradient = noncenteredGradient;
+ }
+ }
+
+ switch(spread) {
+ case VG_COLOR_RAMP_SPREAD_PAD:
+ printf("Using spread mode: pad\n");
+ break;
+ case VG_COLOR_RAMP_SPREAD_REPEAT:
+ printf("Using spread mode: repeat\n");
+ break;
+ case VG_COLOR_RAMP_SPREAD_REFLECT:
+ printf("Using spread mode: reflect\n");
+ }
+
+ set_window_size(400, 400);
+
+ return run(argc, argv, init, reshape,
+ draw, 0);
+}
diff --git a/progs/openvg/trivial/readpixels.c b/progs/openvg/trivial/readpixels.c
new file mode 100644
index 0000000000..c8e286db9a
--- /dev/null
+++ b/progs/openvg/trivial/readpixels.c
@@ -0,0 +1,75 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+float red_color[4] = {1.0, 0.0, 0.0, 1.0};
+float blue_color[4] = {0.0, 0.0, 1.0, 1.0};
+VGint *data;
+
+static void
+init(void)
+{
+ data = malloc(sizeof(VGint)*2048*2048);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+ vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+ static const VGint red_pixel = 255 << 24 | 255 << 16 | 0 << 8 | 0;
+ static const VGint blue_pixel = 255 << 24 | 0 << 16 | 0 << 8 | 255;
+ VGint i;
+
+ vgSetfv(VG_CLEAR_COLOR, 4, red_color);
+ vgClear(0, 0, window_width(), window_height());
+ vgFlush();
+
+ memset(data, 0, window_width() * window_height() * sizeof(VGint));
+
+ vgReadPixels(data, window_width() * sizeof(VGint),
+ VG_lARGB_8888,
+ 0, 0, window_width(), window_height());
+
+ fprintf(stderr, "Red 0 = 0x%x and at 600 = 0x%x\n",
+ data[0], data[600]);
+ for (i = 0; i < window_width() * window_height(); ++i) {
+ assert(data[i] == red_pixel);
+ }
+
+ vgSetfv(VG_CLEAR_COLOR, 4, blue_color);
+ vgClear(50, 50, 50, 50);
+ vgFlush();
+
+ memset(data, 0, window_width() * window_height() * sizeof(VGint));
+
+ vgReadPixels(data, 50 * sizeof(VGint),
+ VG_lARGB_8888,
+ 50, 50, 50, 50);
+
+ fprintf(stderr, "Blue 0 = 0x%x and at 100 = 0x%x\n",
+ data[0], data[100]);
+ for (i = 0; i < 50 * 50; ++i) {
+ assert(data[i] == blue_pixel);
+ }
+}
+
+
+int main(int argc, char **argv)
+{
+ int ret = run(argc, argv, init, reshape,
+ draw, 0);
+
+ free(data);
+ return ret;
+}
diff --git a/progs/openvg/trivial/roundedrect.c b/progs/openvg/trivial/roundedrect.c
new file mode 100644
index 0000000000..c80a4ed299
--- /dev/null
+++ b/progs/openvg/trivial/roundedrect.c
@@ -0,0 +1,67 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {0.9, 0.1, 0.1, 0.8};
+
+VGPath path;
+VGPaint fill;
+
+
+static void
+init(void)
+{
+ static const VGubyte sqrCmds[10] = {VG_MOVE_TO_ABS,
+ VG_LINE_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_LINE_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_LINE_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_LINE_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_CLOSE_PATH};
+ static const VGfloat sqrCoords[] = {
+ 45.885571, 62.857143,
+ 154.11442, 62.857143,
+ 162.1236, 62.857143, 168.57142, 70.260744, 168.57142, 79.457144,
+ 168.57142, 123.4,
+ 168.57142, 132.5964, 162.1236, 140, 154.11442, 140,
+ 45.885571, 140,
+ 37.876394, 140, 31.428572, 132.5964, 31.428572, 123.4,
+ 31.428572, 79.457144,
+ 31.428572, 70.260744, 37.876394,62.857143, 45.885571,62.857143
+ };
+ path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+ VG_PATH_CAPABILITY_APPEND_TO);
+ vgAppendPathData(path, 10, sqrCmds, sqrCoords);
+
+ fill = vgCreatePaint();
+ vgSetParameterfv(fill, VG_PAINT_COLOR, 4, color);
+ vgSetPaint(fill, VG_FILL_PATH);
+
+ vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+ vgSetf(VG_STROKE_LINE_WIDTH, 6);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+ vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+ vgClear(0, 0, window_width(), window_height());
+ vgDrawPath(path, VG_STROKE_PATH);
+}
+
+
+int main(int argc, char **argv)
+{
+ return run(argc, argv, init, reshape,
+ draw, 0);
+}
diff --git a/progs/openvg/trivial/star-nonzero.c b/progs/openvg/trivial/star-nonzero.c
new file mode 100644
index 0000000000..012fbd3929
--- /dev/null
+++ b/progs/openvg/trivial/star-nonzero.c
@@ -0,0 +1,55 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat green_color[4] = {0.0, 1.0, 0.0, 0.8};
+
+VGPath path;
+VGPaint fill;
+
+
+static void
+init(void)
+{
+ static const VGubyte cmds[6] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS,
+ VG_LINE_TO_ABS, VG_CLOSE_PATH};
+ static const VGfloat coords[] = { 0, 200,
+ 300, 200,
+ 50, 0,
+ 150, 300,
+ 250, 0};
+ path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+ VG_PATH_CAPABILITY_APPEND_TO);
+ vgAppendPathData(path, 6, cmds, coords);
+
+ fill = vgCreatePaint();
+ vgSetParameterfv(fill, VG_PAINT_COLOR, 4, green_color);
+ vgSetPaint(fill, VG_FILL_PATH);
+
+ vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+ vgSeti(VG_FILL_RULE, VG_NON_ZERO);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+ vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+ vgClear(0, 0, window_width(), window_height());
+ vgDrawPath(path, VG_FILL_PATH | VG_STROKE_PATH);
+
+ vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+ return run(argc, argv, init, reshape,
+ draw, 0);
+}
diff --git a/progs/openvg/trivial/star-oddeven.c b/progs/openvg/trivial/star-oddeven.c
new file mode 100644
index 0000000000..17311cf720
--- /dev/null
+++ b/progs/openvg/trivial/star-oddeven.c
@@ -0,0 +1,102 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat green_color[4] = {0.0, 1.0, 0.0, 0.8};
+const VGfloat black_color[4] = {0.0, 0.0, 0.0, 1.0};
+
+VGPath path;
+VGPaint fill;
+
+
+static void draw_point(VGfloat x, VGfloat y)
+{
+
+ static const VGubyte cmds[] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS,
+ VG_LINE_TO_ABS, VG_CLOSE_PATH};
+ const VGfloat coords[] = { x - 2, y - 2,
+ x + 2, y - 2,
+ x + 2, y + 2,
+ x - 2, y + 2};
+ VGPath path;
+ VGPaint fill;
+
+ path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+ VG_PATH_CAPABILITY_ALL);
+ vgAppendPathData(path, 5, cmds, coords);
+
+ fill = vgCreatePaint();
+ vgSetParameterfv(fill, VG_PAINT_COLOR, 4, black_color);
+ vgSetPaint(fill, VG_FILL_PATH);
+
+ vgDrawPath(path, VG_FILL_PATH);
+
+ vgDestroyPath(path);
+ vgDestroyPaint(fill);
+}
+
+static void draw_marks(VGPath path)
+{
+ VGfloat point[2], tangent[2];
+ int i = 0;
+
+ for (i = 0; i < 1300; i += 50) {
+ vgPointAlongPath(path, 0, 6, i,
+ point + 0, point + 1,
+ tangent + 0, tangent + 1);
+ draw_point(point[0], point[1]);
+ }
+}
+
+static void
+init(void)
+{
+ static const VGubyte cmds[6] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS,
+ VG_LINE_TO_ABS, VG_CLOSE_PATH};
+ static const VGfloat coords[] = { 0, 200,
+ 300, 200,
+ 50, 0,
+ 150, 300,
+ 250, 0};
+ path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+ VG_PATH_CAPABILITY_ALL);
+ vgAppendPathData(path, 6, cmds, coords);
+
+ fill = vgCreatePaint();
+ vgSetParameterfv(fill, VG_PAINT_COLOR, 4, green_color);
+ vgSetPaint(fill, VG_FILL_PATH);
+
+ vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+ vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+ VGfloat point[2], tangent[2];
+ int i = 0;
+
+ vgClear(0, 0, window_width(), window_height());
+
+ vgSetPaint(fill, VG_FILL_PATH);
+ vgDrawPath(path, VG_FILL_PATH);
+
+ draw_marks(path);
+
+
+ vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+ return run(argc, argv, init, reshape,
+ draw, 0);
+}
diff --git a/progs/openvg/trivial/stroke.c b/progs/openvg/trivial/stroke.c
new file mode 100644
index 0000000000..58ae5b7bc8
--- /dev/null
+++ b/progs/openvg/trivial/stroke.c
@@ -0,0 +1,116 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+#include <X11/keysym.h>
+#include <stdio.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {0.4, 0.1, 1.0, 1.0};
+
+VGPath path;
+VGPaint fill;
+
+VGint cap_style = VG_CAP_BUTT;
+VGint join_style = VG_JOIN_MITER;
+
+static void
+init(void)
+{
+#if 0
+ static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ };
+ static const VGfloat coords[] = {30, 30, 264, 0, 0, 264, 234, 234
+ };
+#else
+ static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
+ VG_LINE_TO_ABS,
+ VG_LINE_TO_ABS
+ };
+ static const VGfloat coords[] = {30, 30, 202, 30, 150, 224
+ };
+#endif
+ VGfloat dash_pattern[2] = { 20.f, 20.f };
+ path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+ VG_PATH_CAPABILITY_APPEND_TO);
+ vgAppendPathData(path, 3, cmds, coords);
+
+ fill = vgCreatePaint();
+ vgSetParameterfv(fill, VG_PAINT_COLOR, 4, color);
+ vgSetPaint(fill, VG_FILL_PATH);
+
+ vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+ vgSetf(VG_STROKE_LINE_WIDTH, 20);
+ vgSeti(VG_STROKE_CAP_STYLE, cap_style);
+ vgSeti(VG_STROKE_JOIN_STYLE, join_style);
+ vgSetfv(VG_STROKE_DASH_PATTERN, 2, dash_pattern);
+ vgSetf(VG_STROKE_DASH_PHASE, 0.0f);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+ vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+ vgClear(0, 0, window_width(), window_height());
+ vgDrawPath(path, VG_STROKE_PATH);
+
+ vgFlush();
+}
+
+static int key_press(unsigned key)
+{
+ switch(key) {
+ case XK_c:
+ case XK_C:
+ ++cap_style;
+ if (cap_style > VG_CAP_SQUARE)
+ cap_style = VG_CAP_BUTT;
+ switch(cap_style) {
+ case VG_CAP_BUTT:
+ fprintf(stderr, "Cap style 'butt'\n");
+ break;
+ case VG_CAP_ROUND:
+ fprintf(stderr, "Cap style 'round'\n");
+ break;
+ case VG_CAP_SQUARE:
+ fprintf(stderr, "Cap style 'square'\n");
+ break;
+ }
+ vgSeti(VG_STROKE_CAP_STYLE, cap_style);
+ break;
+ case XK_j:
+ case XK_J:
+ ++join_style;
+ if (join_style > VG_JOIN_BEVEL)
+ join_style = VG_JOIN_MITER;
+ switch(join_style) {
+ case VG_JOIN_MITER:
+ fprintf(stderr, "Join style 'miter'\n");
+ break;
+ case VG_JOIN_ROUND:
+ fprintf(stderr, "Join style 'round'\n");
+ break;
+ case VG_JOIN_BEVEL:
+ fprintf(stderr, "Join style 'bevel'\n");
+ break;
+ }
+ vgSeti(VG_STROKE_JOIN_STYLE, join_style);
+ break;
+ default:
+ break;
+ }
+
+ return VG_TRUE;
+}
+
+int main(int argc, char **argv)
+{
+ return run(argc, argv, init, reshape,
+ draw, key_press);
+}
diff --git a/progs/openvg/trivial/stroke2.c b/progs/openvg/trivial/stroke2.c
new file mode 100644
index 0000000000..ce950c1886
--- /dev/null
+++ b/progs/openvg/trivial/stroke2.c
@@ -0,0 +1,207 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+#include <X11/keysym.h>
+#include <stdio.h>
+
+VGPaint stroke;
+VGPath target;
+VGPath lines;
+
+VGfloat xform[9];
+VGfloat color1[4];
+VGfloat color2[4];
+VGfloat bgCol[4];
+
+static void
+init(void)
+{
+ VGubyte lineCmds[6];
+ VGfloat lineCoords[8];
+ VGfloat arcCoords[5];
+ VGubyte sccCmd[1];
+ VGubyte scCmd[1];
+ VGubyte lccCmd[1];
+ VGubyte lcCmd[1];
+ VGubyte moveCmd[1];
+ VGfloat moveCoords[2];
+ VGint i;
+
+ bgCol[0] = 1.0f;
+ bgCol[1] = 1.0f;
+ bgCol[2] = 1.0f;
+ bgCol[3] = 1.0f;
+
+ vgSetfv(VG_CLEAR_COLOR, 4, bgCol);
+ vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
+
+ stroke = vgCreatePaint();
+ /* Red */
+ color1[0] = 1.0f;
+ color1[1] = 0.0f;
+ color1[2] = 0.0f;
+ color1[3] = 1.0f;
+
+ /* Orange */
+ color2[0] = 1.0000f;
+ color2[1] = 1.0f;
+ color2[2] = 0.0f;
+ color2[3] = 1.0f;
+ vgSetPaint(stroke, VG_STROKE_PATH);
+
+ vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_SQUARE);
+
+ {
+ VGfloat temp[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
+ for (i = 0; i < 9; i++)
+ {
+ xform[i] = temp[i];
+ }
+ }
+ vgGetMatrix(xform);
+
+ target = vgCreatePath(VG_PATH_FORMAT_STANDARD,
+ VG_PATH_DATATYPE_F, 1, 0, 0, 0, VG_PATH_CAPABILITY_TRANSFORM_TO);
+
+#if 0
+ /* Line path */
+ {
+ VGubyte temp[6] = {VG_MOVE_TO_ABS, VG_VLINE_TO_REL,
+ VG_MOVE_TO_ABS, VG_VLINE_TO_REL,
+ VG_HLINE_TO_REL, VG_VLINE_TO_REL};
+ for (i = 0; i < 6; i++)
+ {
+ lineCmds[i] = temp[i];
+ }
+ }
+ {
+ VGfloat temp[8] = {0.5f, 0.8f, -0.6f, 0.28f, 0.6f, -0.4f, 0.44f, 0.4f};
+ for (i = 0; i < 8; i++)
+ {
+ lineCoords[i] = temp[i] * window_width();
+ }
+ }
+#else
+ {
+ VGfloat temp[5] = {0.35f, 0.15f, 29, 0.3f, 0.4f};
+ for (i = 0; i < 5; i++)
+ {
+ arcCoords[i] = temp[i] * window_width();
+ }
+ arcCoords[2] = 29;
+ }
+
+ {
+ VGubyte temp[1] = {VG_SCCWARC_TO_ABS};
+ for (i = 0; i < 1; i++)
+ {
+ sccCmd[i] = temp[i];
+ }
+ }
+ {
+ VGubyte temp[1] = {VG_SCWARC_TO_ABS};
+ for (i = 0; i < 1; i++)
+ {
+ scCmd[i] = temp[i];
+ }
+ }
+ {
+ VGubyte temp[1] = {VG_LCCWARC_TO_ABS};
+ for (i = 0; i < 1; i++)
+ {
+ lccCmd[i] = temp[i];
+ }
+ }
+ {
+ VGubyte temp[1] = {VG_LCWARC_TO_ABS};
+ for (i = 0; i < 1; i++)
+ {
+ lcCmd[i] = temp[i];
+ }
+ }
+
+ {
+ VGubyte temp[1] = {VG_MOVE_TO_ABS};
+ for (i = 0; i < 1; i++)
+ {
+ moveCmd[i] = temp[i];
+ }
+ }
+ {
+ VGfloat temp[2] = {0.7f, 0.6f};
+ for (i = 0; i < 2; i++)
+ {
+ moveCoords[i] = temp[i] * window_width();
+ }
+ }
+#endif
+
+ lines = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1,
+ 0, 0, 0,
+ VG_PATH_CAPABILITY_APPEND_TO|
+ VG_PATH_CAPABILITY_TRANSFORM_FROM);
+#if 0
+ vgAppendPathData(lines, 6, lineCmds, lineCoords);
+#else
+ vgAppendPathData(lines, 1, moveCmd, moveCoords);
+ vgAppendPathData(lines, 1, sccCmd, arcCoords);
+ vgAppendPathData(lines, 1, moveCmd, moveCoords);
+ vgAppendPathData(lines, 1, scCmd, arcCoords);
+ vgAppendPathData(lines, 1, moveCmd, moveCoords);
+ vgAppendPathData(lines, 1, lccCmd, arcCoords);
+ vgAppendPathData(lines, 1, moveCmd, moveCoords);
+ vgAppendPathData(lines, 1, lcCmd, arcCoords);
+#endif
+
+ vgLoadIdentity();
+ vgTranslate(0.25f * window_width(), 0.25f * window_height());
+ vgRotate(30);
+ vgTranslate(-0.25f * window_width(), -0.25f * window_height());
+ vgTransformPath(target, lines);}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+static void
+draw(void)
+{
+ vgClear(0, 0, window_width(), window_height());
+ vgLoadMatrix(xform);
+ vgLoadIdentity();
+ vgTranslate(0.25f * window_width(), 0.25f * window_height());
+ vgRotate(30);
+ vgTranslate(-0.25f * window_width(), -0.25f * window_height());
+ vgSetf(VG_STROKE_LINE_WIDTH, 7);
+ vgSetParameterfv(stroke, VG_PAINT_COLOR, 4, color1);
+ vgDrawPath(lines, VG_STROKE_PATH);
+
+ vgLoadMatrix(xform);
+ vgSetParameterfv(stroke, VG_PAINT_COLOR, 4, color2);
+ vgSetf(VG_STROKE_LINE_WIDTH, 3);
+ vgDrawPath(target, VG_STROKE_PATH);
+}
+
+static int key_press(unsigned key)
+{
+ switch(key) {
+ case XK_c:
+ case XK_C:
+ break;
+ case XK_j:
+ case XK_J:
+ break;
+ default:
+ break;
+ }
+
+ return VG_TRUE;
+}
+
+int main(int argc, char **argv)
+{
+ return run(argc, argv, init, reshape,
+ draw, key_press);
+}
diff --git a/progs/openvg/trivial/vguarc.c b/progs/openvg/trivial/vguarc.c
new file mode 100644
index 0000000000..8d971d5c09
--- /dev/null
+++ b/progs/openvg/trivial/vguarc.c
@@ -0,0 +1,74 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+#include <VG/vgu.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {0.4, 0.1, 1.0, 1.0};
+
+VGPath path;
+VGPaint paint;
+
+
+static void
+init(void)
+{
+ VGfloat clearColor[] = {0.0f, 0.0f, 0.0f, 1.0f};/* black color */
+ VGfloat greenColor[] = {0.0f, 1.0f, 0.0f, 1.0f};/* green color */
+ VGint arcType = VGU_ARC_OPEN;
+ VGfloat x, y, w, h, startAngle, angleExtent;
+
+ x = 150;
+ y = 150;
+ w = 150;
+ h = 150;
+#if 0
+ startAngle = -540.0f;
+ angleExtent = 270.0f;
+#else
+ startAngle = 270.0f;
+ angleExtent = 90.0f;
+#endif
+
+ paint = vgCreatePaint();
+
+ vgSetPaint(paint, VG_STROKE_PATH);
+ vgSetParameterfv(paint, VG_PAINT_COLOR, 4, greenColor);
+ vgSetParameteri( paint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
+ vgSetf(VG_STROKE_LINE_WIDTH, 6.0f);
+ vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
+ vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
+
+ path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
+ 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
+
+ vguArc(path, x, y, w, h, startAngle, angleExtent, arcType);
+
+ vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
+ vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_BEVEL);
+ vgSetf(VG_STROKE_MITER_LIMIT, 4.0f);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+ vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+ vgClear(0, 0, window_width(), window_height());
+ vgDrawPath(path, VG_STROKE_PATH);
+
+ vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+ // set_window_size(64, 63);
+ return run(argc, argv, init, reshape,
+ draw, 0);
+}