+3. Building with SCons
+
+
+To build Mesa with SCons on Linux or Windows do
+
+
+ scons
+
+
+The build output will be placed in
+build/platform -machine -debug /..., where platform is for
+example linux or windows, machine is x86 or x86_64, optionally followed
+by -debug for debug builds.
+
+
+
+The sample programs are built seperately. To build them do
+
+ scons -C progs
+
+And the build output will be placed in progs/build/...
+
+
+
+To build Mesa with SCons for Windows on Linux using the MinGW crosscompiler toolchain do
+
+
+ scons platform=windows toolchain=crossmingw machine=x86 statetrackers=mesa drivers=softpipe,trace winsys=gdi
+ scons -C progs platform=windows toolchain=crossmingw machine=x86 -k
+
+
+This will create:
+
+
+build/windows-x86-debug/gallium/winsys/gdi/opengl32.dll — Mesa + Gallium + softpipe, binary compatible with Windows's opengl32.dll
+ build/windows-x86-debug/glut/glx/glut32.dll
+ progs/build/windows-x86-debug/wgl/wglinfo.exe
+ progs/build/windows-x86-debug/trivial/tri.exe
+ and many other samples in progs/build/windows-x86-debug/...
+
+
+Put them all in the same directory to test them.
+
+
+
-3. Other systems
+4. Other systems
Documentation for other environments (some may be very out of date):
diff --git a/docs/news.html b/docs/news.html
index 8cf2f91dd03..ee4a86c2a21 100644
--- a/docs/news.html
+++ b/docs/news.html
@@ -11,6 +11,21 @@
News
+June 23, 2009
+
+Mesa 7.4.4 is released.
+This is a stable release that fixes a regression in the i915/i965 drivers
+that slipped into the 7.4.3 release.
+
+
+
+June 19, 2009
+
+Mesa 7.4.3 is released.
+This is a stable release fixing bugs since the 7.4.2 release.
+
+
+
May 15, 2009
Mesa 7.4.2 is released.
diff --git a/docs/openvg.html b/docs/openvg.html
new file mode 100644
index 00000000000..442ee522f18
--- /dev/null
+++ b/docs/openvg.html
@@ -0,0 +1,68 @@
+
+
+
Mesa Release Notes
+
+
+
+
+
+
+
+OpenVG State Tracker
+
+
+The current version of the OpenVG state tracker implements OpenVG 1.0.
+
+
+More informations about OpenVG can be found at
+
+http://www.khronos.org/openvg/ .
+
+
+The OpenVG state tracker depends on the Gallium architecture and a working EGL implementation.
+
+
+
+Building the library
+
+Build Mesa3D with Gallium3D. Any build that builds Gallium3D libraries and EGL will suffice
+cd src/gallium/state_trackers/vega; make
+The last step will build libOpenVG library. You can add the libdir to LD_LIBRARY_PATH or install libOpenVG
+
+
+Sample build
+A sample build looks as follows:
+
+ make linux-x86-64-debug
+ cd src/gallium/state_trackers/vega
+ make
+ cd ../../../..
+ export LD_LIBRARY_PATH=$PWD/lib64
+ export EGL_DRIVER="egl_softpipe"
+
+
+OpenVG Demos
+
+
+To build the OpenVG demos:
+
+
+ cd progs/openvg
+ make
+
+
+To run a demo:
+
+
+ cd openvg/demos
+ ./lion
+
+
+
+Notes
+
+EGL_DRIVER environmental variable: forces usage of a specific EGL driver. Unless you force egl_softpipe the implementation will look for a DRI hardware accelerate driver and unless you have a Gallium driver that supports it, you'll see crashes
+
+
+
+
diff --git a/docs/relnotes-7.4.3.html b/docs/relnotes-7.4.3.html
new file mode 100644
index 00000000000..35b5dccbb0a
--- /dev/null
+++ b/docs/relnotes-7.4.3.html
@@ -0,0 +1,79 @@
+
+
+Mesa Release Notes
+
+
+
+
+
+
+
+Mesa 7.4.3 Release Notes / 19 June 2009
+
+
+Mesa 7.4.3 is a stable development release fixing bugs since the 7.4.2 release.
+
+
+Mesa 7.4.3 implements the OpenGL 2.1 API, but the version reported by
+glGetString(GL_VERSION) depends on the particular driver being used.
+Some drivers don't support all the features required in OpenGL 2.1.
+
+
+See the Compiling/Installing page for prerequisites
+for DRI hardware acceleration.
+
+
+
+MD5 checksums
+
+34c5a6c47ed51f31c4fa36e269831352 MesaLib-7.4.3.tar.gz
+70a983ba3deaa8bd63b18bbab283f698 MesaLib-7.4.3.tar.bz2
+34f21b3205b271d575030aa98a2dda51 MesaLib-7.4.3.zip
+56752b7adede212e6097afb10d0c0d59 MesaDemos-7.4.3.tar.gz
+8ffa51c4833b1e298300a005e2d7ca2a MesaDemos-7.4.3.tar.bz2
+0037d24d41400d6fb9800ae55b8c863f MesaDemos-7.4.3.zip
+20e24f6692c0c90e7e3b220f79c4108d MesaGLUT-7.4.3.tar.gz
+03a4beeef74fc5ef0b1d6d04710e5a8a MesaGLUT-7.4.3.tar.bz2
+273788230adbdb9d57371309adedcf5f MesaGLUT-7.4.3.zip
+
+
+
+Bug fixes
+
+Fixed texture object reference counting bug (bug 21756)
+ Allow depth/stencil textures to be attached to GL_STENCIL_ATTACHMENT point
+ (SF bug 2793846)
+ Added missing glGet case for GL_VERTEX_ARRAY_BINDING_APPLE
+ Fixed some OSMesa build issues
+ Fixed a vertex buffer object crash
+ Fixed broken glTexImage3D() when image type = GL_BITMAP
+ Fixed some GLSL preprocessor bugs
+ Fixed framebuffer mem leak in i945/i965 DRI drivers
+ Fixed texture coordinate repeat bug in swrast (bug 21872)
+ Fixed incorrect viewport clamping (lower bound is zero, not one)
+ GLX fix for glean's makeCurrent test case
+
+
+
+
+Driver Status
+
+
+Driver Status
+---------------------- ----------------------
+DRI drivers varies with the driver
+XMesa/GLX (on Xlib) implements OpenGL 2.1
+OSMesa (off-screen) implements OpenGL 2.1
+Windows/Win32 implements OpenGL 2.1
+Glide (3dfx Voodoo1/2) implements OpenGL 1.3
+SVGA unsupported
+Wind River UGL unsupported
+DJGPP unsupported
+GGI unsupported
+BeOS unsupported
+Allegro unsupported
+D3D unsupported
+
+
+
+
diff --git a/docs/relnotes-7.4.4.html b/docs/relnotes-7.4.4.html
new file mode 100644
index 00000000000..2a34568a7e4
--- /dev/null
+++ b/docs/relnotes-7.4.4.html
@@ -0,0 +1,68 @@
+
+
+Mesa Release Notes
+
+
+
+
+
+
+
+Mesa 7.4.4 Release Notes / 23 June 2009
+
+
+Mesa 7.4.4 is a stable development release fixing bugs since the 7.4.3 release.
+
+
+Mesa 7.4.4 implements the OpenGL 2.1 API, but the version reported by
+glGetString(GL_VERSION) depends on the particular driver being used.
+Some drivers don't support all the features required in OpenGL 2.1.
+
+
+See the Compiling/Installing page for prerequisites
+for DRI hardware acceleration.
+
+
+
+MD5 checksums
+
+0b56fe5a88ab0c3c5b2da5068f63f416 MesaLib-7.4.4.tar.gz
+b66528d314c574dccbe0ed963cac5e93 MesaLib-7.4.4.tar.bz2
+2818076f3ba23fa87fdfe4602a637a18 MesaLib-7.4.4.zip
+3e77b208386c47b18165bce5ae317e2c MesaDemos-7.4.4.tar.gz
+628142ec9a54cd28cc027e6ce26cff47 MesaDemos-7.4.4.tar.bz2
+d08a30d30ab7174859aa709cba6c726d MesaDemos-7.4.4.zip
+e6e91ba16e274d40cf3a97ad3218af01 MesaGLUT-7.4.4.tar.gz
+e14bbb52517e8121b31f1387515365ab MesaGLUT-7.4.4.tar.bz2
+f10ed20469753c2b3d68c99854f80fd4 MesaGLUT-7.4.4.zip
+
+
+
+Bug fixes
+
+Fixed i965/i915 segfault in screen destruction (bug 22408)
+
+
+
+
+Driver Status
+
+
+Driver Status
+---------------------- ----------------------
+DRI drivers varies with the driver
+XMesa/GLX (on Xlib) implements OpenGL 2.1
+OSMesa (off-screen) implements OpenGL 2.1
+Windows/Win32 implements OpenGL 2.1
+Glide (3dfx Voodoo1/2) implements OpenGL 1.3
+SVGA unsupported
+Wind River UGL unsupported
+DJGPP unsupported
+GGI unsupported
+BeOS unsupported
+Allegro unsupported
+D3D unsupported
+
+
+
+
diff --git a/docs/relnotes-7.5.html b/docs/relnotes-7.5.html
index 663626cb05a..5a67d3fb528 100644
--- a/docs/relnotes-7.5.html
+++ b/docs/relnotes-7.5.html
@@ -68,6 +68,10 @@ including GL_ATI_separate_stencil, GL_EXT_stencil_two_side and OpenGL 2.0
GL_EXT_texture_swizzle extension (software drivers, i965 driver)
Updated SPARC assembly optimizations (David S. Miller)
Initial support for separate compilation units in GLSL compiler.
+ Increased max number of generic GLSL varying variables to 16 (formerly 8).
+ GLSL linker now detects when too many varying variables are used.
+ Optimize-out redundant glMaterial and glShadeModel calls in display lists
+ Fixed gl_TextureMatrix[i][j] array indexing bug in GLSL compiler.
@@ -75,6 +79,7 @@ including GL_ATI_separate_stencil, GL_EXT_stencil_two_side and OpenGL 2.0
Lots of i965 driver bug fixes
Fixed some GLSL preprocessor bugs
+ GLSL: continue inside of a for-loop didn't work
diff --git a/docs/relnotes-7.6.html b/docs/relnotes-7.6.html
index f0e15f5024c..1e7ccf88bf2 100644
--- a/docs/relnotes-7.6.html
+++ b/docs/relnotes-7.6.html
@@ -37,7 +37,15 @@ tbd
OpenVG front-end (state tracker for Gallium).
This was written by Zack Rusin at Tungsten Graphics.
GL_APPLE_vertex_array_object for Gallium drivers and Intel DRI drivers.
+ GL_ARB_vertex_array_object for Gallium drivers, software drivers and
+ Intel DRI drivers.
GL_ARB_copy_buffer extension (supported in Gallium and swrast drivers)
+ GL_ARB_map_buffer_range extension (supported in Gallium and software drivers)
+ GL_EXT_provoking_vertex extension (supported in Gallium and software drivers)
+ Rewritten radeon/r200/r300 driver using a buffer manager
+ radeon/r200/r300 GL_EXT_framebuffer_object support when used with
+ kernel memory manager
+ r300 driver support for GL_EXT_vertex_array_bgra, GL_EXT_texture_sRGB
diff --git a/docs/relnotes.html b/docs/relnotes.html
index ad5b74bad3c..35a4c7385f7 100644
--- a/docs/relnotes.html
+++ b/docs/relnotes.html
@@ -8,13 +8,6 @@
Release Notes
-
-Mesa uses an even/odd version number scheme like the Linux kernel.
-Odd numbered versions (such as 6.5) designate new developmental releases.
-Even numbered versions (such as 6.4) designate stable releases.
-
-
-
The release notes summarize what's new or changed in each Mesa release.
@@ -22,6 +15,8 @@ The release notes summarize what's new or changed in each Mesa release.
7.6 release notes
7.5 release notes
+7.4.4 release notes
+7.4.3 release notes
7.4.2 release notes
7.4.1 release notes
7.4 release notes
diff --git a/include/GL/gl_mangle.h b/include/GL/gl_mangle.h
index 639d7bb7a40..54147f73382 100644
--- a/include/GL/gl_mangle.h
+++ b/include/GL/gl_mangle.h
@@ -53,6 +53,7 @@
#define glBeginFragmentShaderATI MANGLE(BeginFragmentShaderATI)
#define glBegin MANGLE(Begin)
#define glBeginOcclusionQueryNV MANGLE(BeginOcclusionQueryNV)
+#define glBeginPerfMonitorAMD MANGLE(BeginPerfMonitorAMD)
#define glBeginQueryARB MANGLE(BeginQueryARB)
#define glBeginQuery MANGLE(BeginQuery)
#define glBeginTransformFeedbackEXT MANGLE(BeginTransformFeedbackEXT)
@@ -257,6 +258,7 @@
#define glConvolutionParameteri MANGLE(ConvolutionParameteri)
#define glConvolutionParameterivEXT MANGLE(ConvolutionParameterivEXT)
#define glConvolutionParameteriv MANGLE(ConvolutionParameteriv)
+#define glCopyBufferSubData MANGLE(CopyBufferSubData)
#define glCopyColorSubTableEXT MANGLE(CopyColorSubTableEXT)
#define glCopyColorSubTable MANGLE(CopyColorSubTable)
#define glCopyColorTable MANGLE(CopyColorTable)
@@ -309,6 +311,7 @@
#define glDeleteLists MANGLE(DeleteLists)
#define glDeleteObjectARB MANGLE(DeleteObjectARB)
#define glDeleteOcclusionQueriesNV MANGLE(DeleteOcclusionQueriesNV)
+#define glDeletePerfMonitorsAMD MANGLE(DeletePerfMonitorsAMD)
#define glDeleteProgram MANGLE(DeleteProgram)
#define glDeleteProgramsARB MANGLE(DeleteProgramsARB)
#define glDeleteProgramsNV MANGLE(DeleteProgramsNV)
@@ -343,6 +346,7 @@
#define glDrawArraysEXT MANGLE(DrawArraysEXT)
#define glDrawArraysInstancedARB MANGLE(DrawArraysInstancedARB)
#define glDrawArraysInstancedEXT MANGLE(DrawArraysInstancedEXT)
+#define glDrawArraysInstanced MANGLE(DrawArraysInstanced)
#define glDrawArrays MANGLE(DrawArrays)
#define glDrawBuffer MANGLE(DrawBuffer)
#define glDrawBuffersARB MANGLE(DrawBuffersARB)
@@ -352,6 +356,7 @@
#define glDrawElementArrayATI MANGLE(DrawElementArrayATI)
#define glDrawElementsInstancedARB MANGLE(DrawElementsInstancedARB)
#define glDrawElementsInstancedEXT MANGLE(DrawElementsInstancedEXT)
+#define glDrawElementsInstanced MANGLE(DrawElementsInstanced)
#define glDrawElements MANGLE(DrawElements)
#define glDrawMeshArraysSUN MANGLE(DrawMeshArraysSUN)
#define glDrawPixels MANGLE(DrawPixels)
@@ -381,6 +386,7 @@
#define glEndList MANGLE(EndList)
#define glEnd MANGLE(End)
#define glEndOcclusionQueryNV MANGLE(EndOcclusionQueryNV)
+#define glEndPerfMonitorAMD MANGLE(EndPerfMonitorAMD)
#define glEndQueryARB MANGLE(EndQueryARB)
#define glEndQuery MANGLE(EndQuery)
#define glEndTransformFeedbackEXT MANGLE(EndTransformFeedbackEXT)
@@ -485,6 +491,7 @@
#define glGenFramebuffers MANGLE(GenFramebuffers)
#define glGenLists MANGLE(GenLists)
#define glGenOcclusionQueriesNV MANGLE(GenOcclusionQueriesNV)
+#define glGenPerfMonitorsAMD MANGLE(GenPerfMonitorsAMD)
#define glGenProgramsARB MANGLE(GenProgramsARB)
#define glGenProgramsNV MANGLE(GenProgramsNV)
#define glGenQueriesARB MANGLE(GenQueriesARB)
@@ -501,7 +508,11 @@
#define glGetActiveAttribARB MANGLE(GetActiveAttribARB)
#define glGetActiveAttrib MANGLE(GetActiveAttrib)
#define glGetActiveUniformARB MANGLE(GetActiveUniformARB)
+#define glGetActiveUniformBlockiv MANGLE(GetActiveUniformBlockiv)
+#define glGetActiveUniformBlockName MANGLE(GetActiveUniformBlockName)
#define glGetActiveUniform MANGLE(GetActiveUniform)
+#define glGetActiveUniformName MANGLE(GetActiveUniformName)
+#define glGetActiveUniformsiv MANGLE(GetActiveUniformsiv)
#define glGetActiveVaryingNV MANGLE(GetActiveVaryingNV)
#define glGetArrayObjectfvATI MANGLE(GetArrayObjectfvATI)
#define glGetArrayObjectivATI MANGLE(GetArrayObjectivATI)
@@ -634,6 +645,12 @@
#define glGetObjectParameterivARB MANGLE(GetObjectParameterivARB)
#define glGetOcclusionQueryivNV MANGLE(GetOcclusionQueryivNV)
#define glGetOcclusionQueryuivNV MANGLE(GetOcclusionQueryuivNV)
+#define glGetPerfMonitorCounterDataAMD MANGLE(GetPerfMonitorCounterDataAMD)
+#define glGetPerfMonitorCounterInfoAMD MANGLE(GetPerfMonitorCounterInfoAMD)
+#define glGetPerfMonitorCountersAMD MANGLE(GetPerfMonitorCountersAMD)
+#define glGetPerfMonitorCounterStringAMD MANGLE(GetPerfMonitorCounterStringAMD)
+#define glGetPerfMonitorGroupsAMD MANGLE(GetPerfMonitorGroupsAMD)
+#define glGetPerfMonitorGroupStringAMD MANGLE(GetPerfMonitorGroupStringAMD)
#define glGetPixelMapfv MANGLE(GetPixelMapfv)
#define glGetPixelMapuiv MANGLE(GetPixelMapuiv)
#define glGetPixelMapusv MANGLE(GetPixelMapusv)
@@ -709,9 +726,11 @@
#define glGetTransformFeedbackVaryingEXT MANGLE(GetTransformFeedbackVaryingEXT)
#define glGetTransformFeedbackVarying MANGLE(GetTransformFeedbackVarying)
#define glGetTransformFeedbackVaryingNV MANGLE(GetTransformFeedbackVaryingNV)
+#define glGetUniformBlockIndex MANGLE(GetUniformBlockIndex)
#define glGetUniformBufferSizeEXT MANGLE(GetUniformBufferSizeEXT)
#define glGetUniformfvARB MANGLE(GetUniformfvARB)
#define glGetUniformfv MANGLE(GetUniformfv)
+#define glGetUniformIndices MANGLE(GetUniformIndices)
#define glGetUniformivARB MANGLE(GetUniformivARB)
#define glGetUniformiv MANGLE(GetUniformiv)
#define glGetUniformLocationARB MANGLE(GetUniformLocationARB)
@@ -744,6 +763,10 @@
#define glGetVertexAttribPointervARB MANGLE(GetVertexAttribPointervARB)
#define glGetVertexAttribPointerv MANGLE(GetVertexAttribPointerv)
#define glGetVertexAttribPointervNV MANGLE(GetVertexAttribPointervNV)
+#define glGetVideoi64vNV MANGLE(GetVideoi64vNV)
+#define glGetVideoivNV MANGLE(GetVideoivNV)
+#define glGetVideoui64vNV MANGLE(GetVideoui64vNV)
+#define glGetVideouivNV MANGLE(GetVideouivNV)
#define glGlobalAlphaFactorbSUN MANGLE(GlobalAlphaFactorbSUN)
#define glGlobalAlphaFactordSUN MANGLE(GlobalAlphaFactordSUN)
#define glGlobalAlphaFactorfSUN MANGLE(GlobalAlphaFactorfSUN)
@@ -1096,6 +1119,9 @@
#define glPopClientAttrib MANGLE(PopClientAttrib)
#define glPopMatrix MANGLE(PopMatrix)
#define glPopName MANGLE(PopName)
+#define glPresentFrameDualFillNV MANGLE(PresentFrameDualFillNV)
+#define glPresentFrameKeyedNV MANGLE(PresentFrameKeyedNV)
+#define glPrimitiveRestartIndex MANGLE(PrimitiveRestartIndex)
#define glPrimitiveRestartIndexNV MANGLE(PrimitiveRestartIndexNV)
#define glPrimitiveRestartNV MANGLE(PrimitiveRestartNV)
#define glPrioritizeTexturesEXT MANGLE(PrioritizeTexturesEXT)
@@ -1173,6 +1199,7 @@
#define glProgramUniformMatrix4x2fvEXT MANGLE(ProgramUniformMatrix4x2fvEXT)
#define glProgramUniformMatrix4x3fvEXT MANGLE(ProgramUniformMatrix4x3fvEXT)
#define glProgramVertexLimitNV MANGLE(ProgramVertexLimitNV)
+#define glProvokingVertexEXT MANGLE(ProvokingVertexEXT)
#define glPushAttrib MANGLE(PushAttrib)
#define glPushClientAttribDefaultEXT MANGLE(PushClientAttribDefaultEXT)
#define glPushClientAttrib MANGLE(PushClientAttrib)
@@ -1301,6 +1328,7 @@
#define glSecondaryColorPointerListIBM MANGLE(SecondaryColorPointerListIBM)
#define glSecondaryColorPointer MANGLE(SecondaryColorPointer)
#define glSelectBuffer MANGLE(SelectBuffer)
+#define glSelectPerfMonitorCountersAMD MANGLE(SelectPerfMonitorCountersAMD)
#define glSeparableFilter2DEXT MANGLE(SeparableFilter2DEXT)
#define glSeparableFilter2D MANGLE(SeparableFilter2D)
#define glSetFenceAPPLE MANGLE(SetFenceAPPLE)
@@ -1345,11 +1373,14 @@
#define glTangent3svEXT MANGLE(Tangent3svEXT)
#define glTangentPointerEXT MANGLE(TangentPointerEXT)
#define glTbufferMask3DFX MANGLE(TbufferMask3DFX)
+#define glTessellationFactorAMD MANGLE(TessellationFactorAMD)
+#define glTessellationModeAMD MANGLE(TessellationModeAMD)
#define glTestFenceAPPLE MANGLE(TestFenceAPPLE)
#define glTestFenceNV MANGLE(TestFenceNV)
#define glTestObjectAPPLE MANGLE(TestObjectAPPLE)
#define glTexBufferARB MANGLE(TexBufferARB)
#define glTexBufferEXT MANGLE(TexBufferEXT)
+#define glTexBuffer MANGLE(TexBuffer)
#define glTexBumpParameterfvATI MANGLE(TexBumpParameterfvATI)
#define glTexBumpParameterivATI MANGLE(TexBumpParameterivATI)
#define glTexCoord1d MANGLE(TexCoord1d)
@@ -1515,6 +1546,7 @@
#define glUniform4ui MANGLE(Uniform4ui)
#define glUniform4uivEXT MANGLE(Uniform4uivEXT)
#define glUniform4uiv MANGLE(Uniform4uiv)
+#define glUniformBlockBinding MANGLE(UniformBlockBinding)
#define glUniformBufferEXT MANGLE(UniformBufferEXT)
#define glUniformMatrix2fvARB MANGLE(UniformMatrix2fvARB)
#define glUniformMatrix2fv MANGLE(UniformMatrix2fv)
@@ -1688,7 +1720,7 @@
#define glVertexAttrib4usvARB MANGLE(VertexAttrib4usvARB)
#define glVertexAttrib4usv MANGLE(VertexAttrib4usv)
#define glVertexAttribArrayObjectATI MANGLE(VertexAttribArrayObjectATI)
-#define glVertexAttribDivisor MANGLE(VertexAttribDivisor)
+#define glVertexAttribDivisorARB MANGLE(VertexAttribDivisorARB)
#define glVertexAttribI1iEXT MANGLE(VertexAttribI1iEXT)
#define glVertexAttribI1i MANGLE(VertexAttribI1i)
#define glVertexAttribI1ivEXT MANGLE(VertexAttribI1ivEXT)
diff --git a/include/GL/glew.h b/include/GL/glew.h
index 2014092e877..7932a1ce199 100644
--- a/include/GL/glew.h
+++ b/include/GL/glew.h
@@ -2702,7 +2702,7 @@ typedef GLenum (GLAPIENTRY * PFNGLCHECKFRAMEBUFFERSTATUSPROC) (GLenum target);
typedef void (GLAPIENTRY * PFNGLDELETEFRAMEBUFFERSPROC) (GLsizei n, const GLuint* framebuffers);
typedef void (GLAPIENTRY * PFNGLDELETERENDERBUFFERSPROC) (GLsizei n, const GLuint* renderbuffers);
typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERRENDERBUFFERPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURLAYERPROC) (GLenum target,GLenum attachment, GLuint texture,GLint level,GLint layer);
+typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURELAYERPROC) (GLenum target,GLenum attachment, GLuint texture,GLint level,GLint layer);
typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE1DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE2DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE3DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint layer);
@@ -2723,7 +2723,7 @@ typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC) (GLenum targ
#define glDeleteFramebuffers GLEW_GET_FUN(__glewDeleteFramebuffers)
#define glDeleteRenderbuffers GLEW_GET_FUN(__glewDeleteRenderbuffers)
#define glFramebufferRenderbuffer GLEW_GET_FUN(__glewFramebufferRenderbuffer)
-#define glFramebufferTexturLayer GLEW_GET_FUN(__glewFramebufferTexturLayer)
+#define glFramebufferTextureLayer GLEW_GET_FUN(__glewFramebufferTextureLayer)
#define glFramebufferTexture1D GLEW_GET_FUN(__glewFramebufferTexture1D)
#define glFramebufferTexture2D GLEW_GET_FUN(__glewFramebufferTexture2D)
#define glFramebufferTexture3D GLEW_GET_FUN(__glewFramebufferTexture3D)
@@ -10563,7 +10563,7 @@ GLEW_FUN_EXPORT PFNGLCHECKFRAMEBUFFERSTATUSPROC __glewCheckFramebufferStatus;
GLEW_FUN_EXPORT PFNGLDELETEFRAMEBUFFERSPROC __glewDeleteFramebuffers;
GLEW_FUN_EXPORT PFNGLDELETERENDERBUFFERSPROC __glewDeleteRenderbuffers;
GLEW_FUN_EXPORT PFNGLFRAMEBUFFERRENDERBUFFERPROC __glewFramebufferRenderbuffer;
-GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURLAYERPROC __glewFramebufferTexturLayer;
+GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURELAYERPROC __glewFramebufferTextureLayer;
GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE1DPROC __glewFramebufferTexture1D;
GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE2DPROC __glewFramebufferTexture2D;
GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE3DPROC __glewFramebufferTexture3D;
diff --git a/include/VG/openvg.h b/include/VG/openvg.h
new file mode 100644
index 00000000000..60167e45d67
--- /dev/null
+++ b/include/VG/openvg.h
@@ -0,0 +1,686 @@
+/* $Revision: 6822 $ on $Date:: 2008-10-30 05:14:19 -0400 #$ */
+
+/*------------------------------------------------------------------------
+ *
+ * OpenVG 1.0.1 Reference Implementation
+ * -------------------------------------
+ *
+ * Copyright (c) 2008 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and /or associated documentation files
+ * (the "Materials "), to deal in the Materials without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Materials,
+ * and to permit persons to whom the Materials are furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
+ * THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ *
+ *//**
+ * \file
+ * \brief OpenVG 1.0.1 API.
+ *//*-------------------------------------------------------------------*/
+
+#ifndef _OPENVG_H
+#define _OPENVG_H
+
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OPENVG_VERSION_1_0 1
+#define OPENVG_VERSION_1_0_1 1
+
+#ifndef VG_MAXSHORT
+#define VG_MAXSHORT 0x7FFF
+#endif
+
+#ifndef VG_MAXINT
+#define VG_MAXINT 0x7FFFFFFF
+#endif
+
+#ifndef VG_MAX_ENUM
+#define VG_MAX_ENUM 0x7FFFFFFF
+#endif
+
+typedef long VGHandle;
+
+typedef VGHandle VGPath;
+typedef VGHandle VGImage;
+typedef VGHandle VGPaint;
+
+#define VG_INVALID_HANDLE ((VGHandle)0)
+
+typedef enum {
+ VG_FALSE = 0,
+ VG_TRUE = 1,
+
+ VG_BOOLEAN_FORCE_SIZE = VG_MAX_ENUM
+} VGboolean;
+
+typedef enum {
+ VG_NO_ERROR = 0,
+ VG_BAD_HANDLE_ERROR = 0x1000,
+ VG_ILLEGAL_ARGUMENT_ERROR = 0x1001,
+ VG_OUT_OF_MEMORY_ERROR = 0x1002,
+ VG_PATH_CAPABILITY_ERROR = 0x1003,
+ VG_UNSUPPORTED_IMAGE_FORMAT_ERROR = 0x1004,
+ VG_UNSUPPORTED_PATH_FORMAT_ERROR = 0x1005,
+ VG_IMAGE_IN_USE_ERROR = 0x1006,
+ VG_NO_CONTEXT_ERROR = 0x1007,
+
+ VG_ERROR_CODE_FORCE_SIZE = VG_MAX_ENUM
+} VGErrorCode;
+
+typedef enum {
+ /* Mode settings */
+ VG_MATRIX_MODE = 0x1100,
+ VG_FILL_RULE = 0x1101,
+ VG_IMAGE_QUALITY = 0x1102,
+ VG_RENDERING_QUALITY = 0x1103,
+ VG_BLEND_MODE = 0x1104,
+ VG_IMAGE_MODE = 0x1105,
+
+ /* Scissoring rectangles */
+ VG_SCISSOR_RECTS = 0x1106,
+
+ /* Stroke parameters */
+ VG_STROKE_LINE_WIDTH = 0x1110,
+ VG_STROKE_CAP_STYLE = 0x1111,
+ VG_STROKE_JOIN_STYLE = 0x1112,
+ VG_STROKE_MITER_LIMIT = 0x1113,
+ VG_STROKE_DASH_PATTERN = 0x1114,
+ VG_STROKE_DASH_PHASE = 0x1115,
+ VG_STROKE_DASH_PHASE_RESET = 0x1116,
+
+ /* Edge fill color for VG_TILE_FILL tiling mode */
+ VG_TILE_FILL_COLOR = 0x1120,
+
+ /* Color for vgClear */
+ VG_CLEAR_COLOR = 0x1121,
+
+ /* Enable/disable alpha masking and scissoring */
+ VG_MASKING = 0x1130,
+ VG_SCISSORING = 0x1131,
+
+ /* Pixel layout information */
+ VG_PIXEL_LAYOUT = 0x1140,
+ VG_SCREEN_LAYOUT = 0x1141,
+
+ /* Source format selection for image filters */
+ VG_FILTER_FORMAT_LINEAR = 0x1150,
+ VG_FILTER_FORMAT_PREMULTIPLIED = 0x1151,
+
+ /* Destination write enable mask for image filters */
+ VG_FILTER_CHANNEL_MASK = 0x1152,
+
+ /* Implementation limits (read-only) */
+ VG_MAX_SCISSOR_RECTS = 0x1160,
+ VG_MAX_DASH_COUNT = 0x1161,
+ VG_MAX_KERNEL_SIZE = 0x1162,
+ VG_MAX_SEPARABLE_KERNEL_SIZE = 0x1163,
+ VG_MAX_COLOR_RAMP_STOPS = 0x1164,
+ VG_MAX_IMAGE_WIDTH = 0x1165,
+ VG_MAX_IMAGE_HEIGHT = 0x1166,
+ VG_MAX_IMAGE_PIXELS = 0x1167,
+ VG_MAX_IMAGE_BYTES = 0x1168,
+ VG_MAX_FLOAT = 0x1169,
+ VG_MAX_GAUSSIAN_STD_DEVIATION = 0x116A,
+
+ VG_PARAM_TYPE_FORCE_SIZE = VG_MAX_ENUM
+} VGParamType;
+
+typedef enum {
+ VG_RENDERING_QUALITY_NONANTIALIASED = 0x1200,
+ VG_RENDERING_QUALITY_FASTER = 0x1201,
+ VG_RENDERING_QUALITY_BETTER = 0x1202, /* Default */
+
+ VG_RENDERING_QUALITY_FORCE_SIZE = VG_MAX_ENUM
+} VGRenderingQuality;
+
+typedef enum {
+ VG_PIXEL_LAYOUT_UNKNOWN = 0x1300,
+ VG_PIXEL_LAYOUT_RGB_VERTICAL = 0x1301,
+ VG_PIXEL_LAYOUT_BGR_VERTICAL = 0x1302,
+ VG_PIXEL_LAYOUT_RGB_HORIZONTAL = 0x1303,
+ VG_PIXEL_LAYOUT_BGR_HORIZONTAL = 0x1304,
+
+ VG_PIXEL_LAYOUT_FORCE_SIZE = VG_MAX_ENUM
+} VGPixelLayout;
+
+typedef enum {
+ VG_MATRIX_PATH_USER_TO_SURFACE = 0x1400,
+ VG_MATRIX_IMAGE_USER_TO_SURFACE = 0x1401,
+ VG_MATRIX_FILL_PAINT_TO_USER = 0x1402,
+ VG_MATRIX_STROKE_PAINT_TO_USER = 0x1403,
+
+ VG_MATRIX_MODE_FORCE_SIZE = VG_MAX_ENUM
+} VGMatrixMode;
+
+typedef enum {
+ VG_CLEAR_MASK = 0x1500,
+ VG_FILL_MASK = 0x1501,
+ VG_SET_MASK = 0x1502,
+ VG_UNION_MASK = 0x1503,
+ VG_INTERSECT_MASK = 0x1504,
+ VG_SUBTRACT_MASK = 0x1505,
+
+ VG_MASK_OPERATION_FORCE_SIZE = VG_MAX_ENUM
+} VGMaskOperation;
+
+#define VG_PATH_FORMAT_STANDARD 0
+
+typedef enum {
+ VG_PATH_DATATYPE_S_8 = 0,
+ VG_PATH_DATATYPE_S_16 = 1,
+ VG_PATH_DATATYPE_S_32 = 2,
+ VG_PATH_DATATYPE_F = 3,
+
+ VG_PATH_DATATYPE_FORCE_SIZE = VG_MAX_ENUM
+} VGPathDatatype;
+
+typedef enum {
+ VG_ABSOLUTE = 0,
+ VG_RELATIVE = 1,
+
+ VG_PATH_ABS_REL_FORCE_SIZE = VG_MAX_ENUM
+} VGPathAbsRel;
+
+typedef enum {
+ VG_CLOSE_PATH = ( 0 << 1),
+ VG_MOVE_TO = ( 1 << 1),
+ VG_LINE_TO = ( 2 << 1),
+ VG_HLINE_TO = ( 3 << 1),
+ VG_VLINE_TO = ( 4 << 1),
+ VG_QUAD_TO = ( 5 << 1),
+ VG_CUBIC_TO = ( 6 << 1),
+ VG_SQUAD_TO = ( 7 << 1),
+ VG_SCUBIC_TO = ( 8 << 1),
+ VG_SCCWARC_TO = ( 9 << 1),
+ VG_SCWARC_TO = (10 << 1),
+ VG_LCCWARC_TO = (11 << 1),
+ VG_LCWARC_TO = (12 << 1),
+
+ VG_PATH_SEGMENT_FORCE_SIZE = VG_MAX_ENUM
+} VGPathSegment;
+
+typedef enum {
+ VG_MOVE_TO_ABS = VG_MOVE_TO | VG_ABSOLUTE,
+ VG_MOVE_TO_REL = VG_MOVE_TO | VG_RELATIVE,
+ VG_LINE_TO_ABS = VG_LINE_TO | VG_ABSOLUTE,
+ VG_LINE_TO_REL = VG_LINE_TO | VG_RELATIVE,
+ VG_HLINE_TO_ABS = VG_HLINE_TO | VG_ABSOLUTE,
+ VG_HLINE_TO_REL = VG_HLINE_TO | VG_RELATIVE,
+ VG_VLINE_TO_ABS = VG_VLINE_TO | VG_ABSOLUTE,
+ VG_VLINE_TO_REL = VG_VLINE_TO | VG_RELATIVE,
+ VG_QUAD_TO_ABS = VG_QUAD_TO | VG_ABSOLUTE,
+ VG_QUAD_TO_REL = VG_QUAD_TO | VG_RELATIVE,
+ VG_CUBIC_TO_ABS = VG_CUBIC_TO | VG_ABSOLUTE,
+ VG_CUBIC_TO_REL = VG_CUBIC_TO | VG_RELATIVE,
+ VG_SQUAD_TO_ABS = VG_SQUAD_TO | VG_ABSOLUTE,
+ VG_SQUAD_TO_REL = VG_SQUAD_TO | VG_RELATIVE,
+ VG_SCUBIC_TO_ABS = VG_SCUBIC_TO | VG_ABSOLUTE,
+ VG_SCUBIC_TO_REL = VG_SCUBIC_TO | VG_RELATIVE,
+ VG_SCCWARC_TO_ABS = VG_SCCWARC_TO | VG_ABSOLUTE,
+ VG_SCCWARC_TO_REL = VG_SCCWARC_TO | VG_RELATIVE,
+ VG_SCWARC_TO_ABS = VG_SCWARC_TO | VG_ABSOLUTE,
+ VG_SCWARC_TO_REL = VG_SCWARC_TO | VG_RELATIVE,
+ VG_LCCWARC_TO_ABS = VG_LCCWARC_TO | VG_ABSOLUTE,
+ VG_LCCWARC_TO_REL = VG_LCCWARC_TO | VG_RELATIVE,
+ VG_LCWARC_TO_ABS = VG_LCWARC_TO | VG_ABSOLUTE,
+ VG_LCWARC_TO_REL = VG_LCWARC_TO | VG_RELATIVE,
+
+ VG_PATH_COMMAND_FORCE_SIZE = VG_MAX_ENUM
+} VGPathCommand;
+
+typedef enum {
+ VG_PATH_CAPABILITY_APPEND_FROM = (1 << 0),
+ VG_PATH_CAPABILITY_APPEND_TO = (1 << 1),
+ VG_PATH_CAPABILITY_MODIFY = (1 << 2),
+ VG_PATH_CAPABILITY_TRANSFORM_FROM = (1 << 3),
+ VG_PATH_CAPABILITY_TRANSFORM_TO = (1 << 4),
+ VG_PATH_CAPABILITY_INTERPOLATE_FROM = (1 << 5),
+ VG_PATH_CAPABILITY_INTERPOLATE_TO = (1 << 6),
+ VG_PATH_CAPABILITY_PATH_LENGTH = (1 << 7),
+ VG_PATH_CAPABILITY_POINT_ALONG_PATH = (1 << 8),
+ VG_PATH_CAPABILITY_TANGENT_ALONG_PATH = (1 << 9),
+ VG_PATH_CAPABILITY_PATH_BOUNDS = (1 << 10),
+ VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS = (1 << 11),
+ VG_PATH_CAPABILITY_ALL = (1 << 12) - 1,
+
+ VG_PATH_CAPABILITIES_FORCE_SIZE = VG_MAX_ENUM
+} VGPathCapabilities;
+
+typedef enum {
+ VG_PATH_FORMAT = 0x1600,
+ VG_PATH_DATATYPE = 0x1601,
+ VG_PATH_SCALE = 0x1602,
+ VG_PATH_BIAS = 0x1603,
+ VG_PATH_NUM_SEGMENTS = 0x1604,
+ VG_PATH_NUM_COORDS = 0x1605,
+
+ VG_PATH_PARAM_TYPE_FORCE_SIZE = VG_MAX_ENUM
+} VGPathParamType;
+
+typedef enum {
+ VG_CAP_BUTT = 0x1700,
+ VG_CAP_ROUND = 0x1701,
+ VG_CAP_SQUARE = 0x1702,
+
+ VG_CAP_STYLE_FORCE_SIZE = VG_MAX_ENUM
+} VGCapStyle;
+
+typedef enum {
+ VG_JOIN_MITER = 0x1800,
+ VG_JOIN_ROUND = 0x1801,
+ VG_JOIN_BEVEL = 0x1802,
+
+ VG_JOIN_STYLE_FORCE_SIZE = VG_MAX_ENUM
+} VGJoinStyle;
+
+typedef enum {
+ VG_EVEN_ODD = 0x1900,
+ VG_NON_ZERO = 0x1901,
+
+ VG_FILL_RULE_FORCE_SIZE = VG_MAX_ENUM
+} VGFillRule;
+
+typedef enum {
+ VG_STROKE_PATH = (1 << 0),
+ VG_FILL_PATH = (1 << 1),
+
+ VG_PAINT_MODE_FORCE_SIZE = VG_MAX_ENUM
+} VGPaintMode;
+
+typedef enum {
+ /* Color paint parameters */
+ VG_PAINT_TYPE = 0x1A00,
+ VG_PAINT_COLOR = 0x1A01,
+ VG_PAINT_COLOR_RAMP_SPREAD_MODE = 0x1A02,
+ VG_PAINT_COLOR_RAMP_PREMULTIPLIED = 0x1A07,
+ VG_PAINT_COLOR_RAMP_STOPS = 0x1A03,
+
+ /* Linear gradient paint parameters */
+ VG_PAINT_LINEAR_GRADIENT = 0x1A04,
+
+ /* Radial gradient paint parameters */
+ VG_PAINT_RADIAL_GRADIENT = 0x1A05,
+
+ /* Pattern paint parameters */
+ VG_PAINT_PATTERN_TILING_MODE = 0x1A06,
+
+ VG_PAINT_PARAM_TYPE_FORCE_SIZE = VG_MAX_ENUM
+} VGPaintParamType;
+
+typedef enum {
+ VG_PAINT_TYPE_COLOR = 0x1B00,
+ VG_PAINT_TYPE_LINEAR_GRADIENT = 0x1B01,
+ VG_PAINT_TYPE_RADIAL_GRADIENT = 0x1B02,
+ VG_PAINT_TYPE_PATTERN = 0x1B03,
+
+ VG_PAINT_TYPE_FORCE_SIZE = VG_MAX_ENUM
+} VGPaintType;
+
+typedef enum {
+ VG_COLOR_RAMP_SPREAD_PAD = 0x1C00,
+ VG_COLOR_RAMP_SPREAD_REPEAT = 0x1C01,
+ VG_COLOR_RAMP_SPREAD_REFLECT = 0x1C02,
+
+ VG_COLOR_RAMP_SPREAD_MODE_FORCE_SIZE = VG_MAX_ENUM
+} VGColorRampSpreadMode;
+
+typedef enum {
+ VG_TILE_FILL = 0x1D00,
+ VG_TILE_PAD = 0x1D01,
+ VG_TILE_REPEAT = 0x1D02,
+ VG_TILE_REFLECT = 0x1D03,
+
+ VG_TILING_MODE_FORCE_SIZE = VG_MAX_ENUM
+} VGTilingMode;
+
+typedef enum {
+ /* RGB{A,X} channel ordering */
+ VG_sRGBX_8888 = 0,
+ VG_sRGBA_8888 = 1,
+ VG_sRGBA_8888_PRE = 2,
+ VG_sRGB_565 = 3,
+ VG_sRGBA_5551 = 4,
+ VG_sRGBA_4444 = 5,
+ VG_sL_8 = 6,
+ VG_lRGBX_8888 = 7,
+ VG_lRGBA_8888 = 8,
+ VG_lRGBA_8888_PRE = 9,
+ VG_lL_8 = 10,
+ VG_A_8 = 11,
+ VG_BW_1 = 12,
+
+ /* {A,X}RGB channel ordering */
+ VG_sXRGB_8888 = 0 | (1 << 6),
+ VG_sARGB_8888 = 1 | (1 << 6),
+ VG_sARGB_8888_PRE = 2 | (1 << 6),
+ VG_sARGB_1555 = 4 | (1 << 6),
+ VG_sARGB_4444 = 5 | (1 << 6),
+ VG_lXRGB_8888 = 7 | (1 << 6),
+ VG_lARGB_8888 = 8 | (1 << 6),
+ VG_lARGB_8888_PRE = 9 | (1 << 6),
+
+ /* BGR{A,X} channel ordering */
+ VG_sBGRX_8888 = 0 | (1 << 7),
+ VG_sBGRA_8888 = 1 | (1 << 7),
+ VG_sBGRA_8888_PRE = 2 | (1 << 7),
+ VG_sBGR_565 = 3 | (1 << 7),
+ VG_sBGRA_5551 = 4 | (1 << 7),
+ VG_sBGRA_4444 = 5 | (1 << 7),
+ VG_lBGRX_8888 = 7 | (1 << 7),
+ VG_lBGRA_8888 = 8 | (1 << 7),
+ VG_lBGRA_8888_PRE = 9 | (1 << 7),
+
+ /* {A,X}BGR channel ordering */
+ VG_sXBGR_8888 = 0 | (1 << 6) | (1 << 7),
+ VG_sABGR_8888 = 1 | (1 << 6) | (1 << 7),
+ VG_sABGR_8888_PRE = 2 | (1 << 6) | (1 << 7),
+ VG_sABGR_1555 = 4 | (1 << 6) | (1 << 7),
+ VG_sABGR_4444 = 5 | (1 << 6) | (1 << 7),
+ VG_lXBGR_8888 = 7 | (1 << 6) | (1 << 7),
+ VG_lABGR_8888 = 8 | (1 << 6) | (1 << 7),
+ VG_lABGR_8888_PRE = 9 | (1 << 6) | (1 << 7),
+
+ VG_IMAGE_FORMAT_FORCE_SIZE = VG_MAX_ENUM
+} VGImageFormat;
+
+typedef enum {
+ VG_IMAGE_QUALITY_NONANTIALIASED = (1 << 0),
+ VG_IMAGE_QUALITY_FASTER = (1 << 1),
+ VG_IMAGE_QUALITY_BETTER = (1 << 2),
+
+ VG_IMAGE_QUALITY_FORCE_SIZE = VG_MAX_ENUM
+} VGImageQuality;
+
+typedef enum {
+ VG_IMAGE_FORMAT = 0x1E00,
+ VG_IMAGE_WIDTH = 0x1E01,
+ VG_IMAGE_HEIGHT = 0x1E02,
+
+ VG_IMAGE_PARAM_TYPE_FORCE_SIZE = VG_MAX_ENUM
+} VGImageParamType;
+
+typedef enum {
+ VG_DRAW_IMAGE_NORMAL = 0x1F00,
+ VG_DRAW_IMAGE_MULTIPLY = 0x1F01,
+ VG_DRAW_IMAGE_STENCIL = 0x1F02,
+
+ VG_IMAGE_MODE_FORCE_SIZE = VG_MAX_ENUM
+} VGImageMode;
+
+typedef enum {
+ VG_RED = (1 << 3),
+ VG_GREEN = (1 << 2),
+ VG_BLUE = (1 << 1),
+ VG_ALPHA = (1 << 0),
+
+ VG_IMAGE_CHANNEL_FORCE_SIZE = VG_MAX_ENUM
+} VGImageChannel;
+
+typedef enum {
+ VG_BLEND_SRC = 0x2000,
+ VG_BLEND_SRC_OVER = 0x2001,
+ VG_BLEND_DST_OVER = 0x2002,
+ VG_BLEND_SRC_IN = 0x2003,
+ VG_BLEND_DST_IN = 0x2004,
+ VG_BLEND_MULTIPLY = 0x2005,
+ VG_BLEND_SCREEN = 0x2006,
+ VG_BLEND_DARKEN = 0x2007,
+ VG_BLEND_LIGHTEN = 0x2008,
+ VG_BLEND_ADDITIVE = 0x2009,
+
+ VG_BLEND_MODE_FORCE_SIZE = VG_MAX_ENUM
+} VGBlendMode;
+
+typedef enum {
+ VG_IMAGE_FORMAT_QUERY = 0x2100,
+ VG_PATH_DATATYPE_QUERY = 0x2101,
+
+ VG_HARDWARE_QUERY_TYPE_FORCE_SIZE = VG_MAX_ENUM
+} VGHardwareQueryType;
+
+typedef enum {
+ VG_HARDWARE_ACCELERATED = 0x2200,
+ VG_HARDWARE_UNACCELERATED = 0x2201,
+
+ VG_HARDWARE_QUERY_RESULT_FORCE_SIZE = VG_MAX_ENUM
+} VGHardwareQueryResult;
+
+typedef enum {
+ VG_VENDOR = 0x2300,
+ VG_RENDERER = 0x2301,
+ VG_VERSION = 0x2302,
+ VG_EXTENSIONS = 0x2303,
+
+ VG_STRING_ID_FORCE_SIZE = VG_MAX_ENUM
+} VGStringID;
+
+/* Function Prototypes */
+
+#ifndef VG_API_CALL
+# error VG_API_CALL must be defined
+#endif
+
+#ifndef VG_API_ENTRY
+# error VG_API_ENTRY must be defined
+#endif
+
+#ifndef VG_API_EXIT
+# error VG_API_EXIT must be defined
+#endif
+
+VG_API_CALL VGErrorCode VG_API_ENTRY vgGetError(void) VG_API_EXIT;
+
+VG_API_CALL void VG_API_ENTRY vgFlush(void) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgFinish(void) VG_API_EXIT;
+
+/* Getters and Setters */
+VG_API_CALL void VG_API_ENTRY vgSetf (VGParamType type, VGfloat value) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgSeti (VGParamType type, VGint value) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgSetfv(VGParamType type, VGint count,
+ const VGfloat * values) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgSetiv(VGParamType type, VGint count,
+ const VGint * values) VG_API_EXIT;
+
+VG_API_CALL VGfloat VG_API_ENTRY vgGetf(VGParamType type) VG_API_EXIT;
+VG_API_CALL VGint VG_API_ENTRY vgGeti(VGParamType type) VG_API_EXIT;
+VG_API_CALL VGint VG_API_ENTRY vgGetVectorSize(VGParamType type) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgGetfv(VGParamType type, VGint count, VGfloat * values) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgGetiv(VGParamType type, VGint count, VGint * values) VG_API_EXIT;
+
+VG_API_CALL void VG_API_ENTRY vgSetParameterf(VGHandle object,
+ VGint paramType,
+ VGfloat value) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgSetParameteri(VGHandle object,
+ VGint paramType,
+ VGint value) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgSetParameterfv(VGHandle object,
+ VGint paramType,
+ VGint count, const VGfloat * values) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgSetParameteriv(VGHandle object,
+ VGint paramType,
+ VGint count, const VGint * values) VG_API_EXIT;
+
+VG_API_CALL VGfloat VG_API_ENTRY vgGetParameterf(VGHandle object,
+ VGint paramType) VG_API_EXIT;
+VG_API_CALL VGint VG_API_ENTRY vgGetParameteri(VGHandle object,
+ VGint paramType);
+VG_API_CALL VGint VG_API_ENTRY vgGetParameterVectorSize(VGHandle object,
+ VGint paramType) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgGetParameterfv(VGHandle object,
+ VGint paramType,
+ VGint count, VGfloat * values) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgGetParameteriv(VGHandle object,
+ VGint paramType,
+ VGint count, VGint * values) VG_API_EXIT;
+
+/* Matrix Manipulation */
+VG_API_CALL void VG_API_ENTRY vgLoadIdentity(void) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgLoadMatrix(const VGfloat * m) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgGetMatrix(VGfloat * m) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgMultMatrix(const VGfloat * m) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgTranslate(VGfloat tx, VGfloat ty) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgScale(VGfloat sx, VGfloat sy) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgShear(VGfloat shx, VGfloat shy) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgRotate(VGfloat angle) VG_API_EXIT;
+
+/* Masking and Clearing */
+VG_API_CALL void VG_API_ENTRY vgMask(VGImage mask, VGMaskOperation operation,
+ VGint x, VGint y, VGint width, VGint height) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgClear(VGint x, VGint y, VGint width, VGint height) VG_API_EXIT;
+
+/* Paths */
+VG_API_CALL VGPath VG_API_ENTRY vgCreatePath(VGint pathFormat,
+ VGPathDatatype datatype,
+ VGfloat scale, VGfloat bias,
+ VGint segmentCapacityHint,
+ VGint coordCapacityHint,
+ VGbitfield capabilities) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgClearPath(VGPath path, VGbitfield capabilities) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgDestroyPath(VGPath path) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgRemovePathCapabilities(VGPath path,
+ VGbitfield capabilities) VG_API_EXIT;
+VG_API_CALL VGbitfield VG_API_ENTRY vgGetPathCapabilities(VGPath path) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgAppendPath(VGPath dstPath, VGPath srcPath) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgAppendPathData(VGPath dstPath,
+ VGint numSegments,
+ const VGubyte * pathSegments,
+ const void * pathData) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgModifyPathCoords(VGPath dstPath, VGint startIndex,
+ VGint numSegments,
+ const void * pathData) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgTransformPath(VGPath dstPath, VGPath srcPath) VG_API_EXIT;
+VG_API_CALL VGboolean VG_API_ENTRY vgInterpolatePath(VGPath dstPath,
+ VGPath startPath,
+ VGPath endPath,
+ VGfloat amount) VG_API_EXIT;
+VG_API_CALL VGfloat VG_API_ENTRY vgPathLength(VGPath path,
+ VGint startSegment, VGint numSegments) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgPointAlongPath(VGPath path,
+ VGint startSegment, VGint numSegments,
+ VGfloat distance,
+ VGfloat * x, VGfloat * y,
+ VGfloat * tangentX, VGfloat * tangentY) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgPathBounds(VGPath path,
+ VGfloat * minX, VGfloat * minY,
+ VGfloat * width, VGfloat * height) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgPathTransformedBounds(VGPath path,
+ VGfloat * minX, VGfloat * minY,
+ VGfloat * width, VGfloat * height) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgDrawPath(VGPath path, VGbitfield paintModes) VG_API_EXIT;
+
+/* Paint */
+VG_API_CALL VGPaint VG_API_ENTRY vgCreatePaint(void) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgDestroyPaint(VGPaint paint) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgSetPaint(VGPaint paint, VGbitfield paintModes) VG_API_EXIT;
+VG_API_CALL VGPaint VG_API_ENTRY vgGetPaint(VGPaintMode paintMode) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgSetColor(VGPaint paint, VGuint rgba) VG_API_EXIT;
+VG_API_CALL VGuint VG_API_ENTRY vgGetColor(VGPaint paint) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgPaintPattern(VGPaint paint, VGImage pattern) VG_API_EXIT;
+
+/* Images */
+VG_API_CALL VGImage VG_API_ENTRY vgCreateImage(VGImageFormat format,
+ VGint width, VGint height,
+ VGbitfield allowedQuality) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgDestroyImage(VGImage image) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgClearImage(VGImage image,
+ VGint x, VGint y, VGint width, VGint height) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgImageSubData(VGImage image,
+ const void * data, VGint dataStride,
+ VGImageFormat dataFormat,
+ VGint x, VGint y, VGint width, VGint height) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgGetImageSubData(VGImage image,
+ void * data, VGint dataStride,
+ VGImageFormat dataFormat,
+ VGint x, VGint y,
+ VGint width, VGint height) VG_API_EXIT;
+VG_API_CALL VGImage VG_API_ENTRY vgChildImage(VGImage parent,
+ VGint x, VGint y, VGint width, VGint height) VG_API_EXIT;
+VG_API_CALL VGImage VG_API_ENTRY vgGetParent(VGImage image) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgCopyImage(VGImage dst, VGint dx, VGint dy,
+ VGImage src, VGint sx, VGint sy,
+ VGint width, VGint height,
+ VGboolean dither) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgDrawImage(VGImage image) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgSetPixels(VGint dx, VGint dy,
+ VGImage src, VGint sx, VGint sy,
+ VGint width, VGint height) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgWritePixels(const void * data, VGint dataStride,
+ VGImageFormat dataFormat,
+ VGint dx, VGint dy,
+ VGint width, VGint height) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgGetPixels(VGImage dst, VGint dx, VGint dy,
+ VGint sx, VGint sy,
+ VGint width, VGint height) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgReadPixels(void * data, VGint dataStride,
+ VGImageFormat dataFormat,
+ VGint sx, VGint sy,
+ VGint width, VGint height) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgCopyPixels(VGint dx, VGint dy,
+ VGint sx, VGint sy,
+ VGint width, VGint height) VG_API_EXIT;
+
+/* Image Filters */
+VG_API_CALL void VG_API_ENTRY vgColorMatrix(VGImage dst, VGImage src,
+ const VGfloat * matrix) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgConvolve(VGImage dst, VGImage src,
+ VGint kernelWidth, VGint kernelHeight,
+ VGint shiftX, VGint shiftY,
+ const VGshort * kernel,
+ VGfloat scale,
+ VGfloat bias,
+ VGTilingMode tilingMode) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgSeparableConvolve(VGImage dst, VGImage src,
+ VGint kernelWidth,
+ VGint kernelHeight,
+ VGint shiftX, VGint shiftY,
+ const VGshort * kernelX,
+ const VGshort * kernelY,
+ VGfloat scale,
+ VGfloat bias,
+ VGTilingMode tilingMode) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgGaussianBlur(VGImage dst, VGImage src,
+ VGfloat stdDeviationX,
+ VGfloat stdDeviationY,
+ VGTilingMode tilingMode) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgLookup(VGImage dst, VGImage src,
+ const VGubyte * redLUT,
+ const VGubyte * greenLUT,
+ const VGubyte * blueLUT,
+ const VGubyte * alphaLUT,
+ VGboolean outputLinear,
+ VGboolean outputPremultiplied) VG_API_EXIT;
+VG_API_CALL void VG_API_ENTRY vgLookupSingle(VGImage dst, VGImage src,
+ const VGuint * lookupTable,
+ VGImageChannel sourceChannel,
+ VGboolean outputLinear,
+ VGboolean outputPremultiplied) VG_API_EXIT;
+
+/* Hardware Queries */
+VG_API_CALL VGHardwareQueryResult VG_API_ENTRY vgHardwareQuery(VGHardwareQueryType key,
+ VGint setting) VG_API_EXIT;
+
+/* Renderer and Extension Information */
+VG_API_CALL const VGubyte * VG_API_ENTRY vgGetString(VGStringID name) VG_API_EXIT;
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* _OPENVG_H */
diff --git a/include/VG/vgext.h b/include/VG/vgext.h
new file mode 100644
index 00000000000..97e3e779e19
--- /dev/null
+++ b/include/VG/vgext.h
@@ -0,0 +1,233 @@
+/* $Revision: 6810 $ on $Date:: 2008-10-29 10:31:37 -0400 #$ */
+
+/*------------------------------------------------------------------------
+ *
+ * VG extensions Reference Implementation
+ * -------------------------------------
+ *
+ * Copyright (c) 2008 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and /or associated documentation files
+ * (the "Materials "), to deal in the Materials without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Materials,
+ * and to permit persons to whom the Materials are furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
+ * THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ *
+ *//**
+ * \file
+ * \brief VG extensions
+ *//*-------------------------------------------------------------------*/
+
+
+
+#ifndef _VGEXT_H
+#define _VGEXT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include
+#include
+
+#ifndef VG_API_ENTRYP
+# define VG_API_ENTRYP VG_API_ENTRY*
+#endif
+
+#ifndef VGU_API_ENTRYP
+# define VGU_API_ENTRYP VGU_API_ENTRY*
+#endif
+
+/*-------------------------------------------------------------------------------
+ * KHR extensions
+ *------------------------------------------------------------------------------*/
+
+typedef enum {
+
+#ifndef VG_KHR_iterative_average_blur
+ VG_MAX_AVERAGE_BLUR_DIMENSION_KHR = 0x116B,
+ VG_AVERAGE_BLUR_DIMENSION_RESOLUTION_KHR = 0x116C,
+ VG_MAX_AVERAGE_BLUR_ITERATIONS_KHR = 0x116D,
+#endif
+
+ VG_PARAM_TYPE_KHR_FORCE_SIZE = VG_MAX_ENUM
+} VGParamTypeKHR;
+
+#ifndef VG_KHR_EGL_image
+#define VG_KHR_EGL_image 1
+/* VGEGLImageKHR is an opaque handle to an EGLImage */
+typedef void* VGeglImageKHR;
+
+#ifdef VG_VGEXT_PROTOTYPES
+VG_API_CALL VGImage VG_API_ENTRY vgCreateEGLImageTargetKHR(VGeglImageKHR image);
+#endif
+typedef VGImage (VG_API_ENTRYP PFNVGCREATEEGLIMAGETARGETKHRPROC) (VGeglImageKHR image);
+
+#endif
+
+
+#ifndef VG_KHR_iterative_average_blur
+#define VG_KHR_iterative_average_blur 1
+
+#ifdef VG_VGEXT_PROTOTYPES
+VG_API_CALL void vgIterativeAverageBlurKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGTilingMode tilingMode);
+#endif
+typedef void (VG_API_ENTRYP PFNVGITERATIVEAVERAGEBLURKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGTilingMode tilingMode);
+
+#endif
+
+
+#ifndef VG_KHR_advanced_blending
+#define VG_KHR_advanced_blending 1
+
+typedef enum {
+ VG_BLEND_OVERLAY_KHR = 0x2010,
+ VG_BLEND_HARDLIGHT_KHR = 0x2011,
+ VG_BLEND_SOFTLIGHT_SVG_KHR = 0x2012,
+ VG_BLEND_SOFTLIGHT_KHR = 0x2013,
+ VG_BLEND_COLORDODGE_KHR = 0x2014,
+ VG_BLEND_COLORBURN_KHR = 0x2015,
+ VG_BLEND_DIFFERENCE_KHR = 0x2016,
+ VG_BLEND_SUBTRACT_KHR = 0x2017,
+ VG_BLEND_INVERT_KHR = 0x2018,
+ VG_BLEND_EXCLUSION_KHR = 0x2019,
+ VG_BLEND_LINEARDODGE_KHR = 0x201a,
+ VG_BLEND_LINEARBURN_KHR = 0x201b,
+ VG_BLEND_VIVIDLIGHT_KHR = 0x201c,
+ VG_BLEND_LINEARLIGHT_KHR = 0x201d,
+ VG_BLEND_PINLIGHT_KHR = 0x201e,
+ VG_BLEND_HARDMIX_KHR = 0x201f,
+ VG_BLEND_CLEAR_KHR = 0x2020,
+ VG_BLEND_DST_KHR = 0x2021,
+ VG_BLEND_SRC_OUT_KHR = 0x2022,
+ VG_BLEND_DST_OUT_KHR = 0x2023,
+ VG_BLEND_SRC_ATOP_KHR = 0x2024,
+ VG_BLEND_DST_ATOP_KHR = 0x2025,
+ VG_BLEND_XOR_KHR = 0x2026,
+
+ VG_BLEND_MODE_KHR_FORCE_SIZE= VG_MAX_ENUM
+} VGBlendModeKHR;
+#endif
+
+#ifndef VG_KHR_parametric_filter
+#define VG_KHR_parametric_filter 1
+
+typedef enum {
+ VG_PF_OBJECT_VISIBLE_FLAG_KHR = (1 << 0),
+ VG_PF_KNOCKOUT_FLAG_KHR = (1 << 1),
+ VG_PF_OUTER_FLAG_KHR = (1 << 2),
+ VG_PF_INNER_FLAG_KHR = (1 << 3),
+
+ VG_PF_TYPE_KHR_FORCE_SIZE = VG_MAX_ENUM
+} VGPfTypeKHR;
+
+typedef enum {
+ VGU_IMAGE_IN_USE_ERROR = 0xF010,
+
+ VGU_ERROR_CODE_KHR_FORCE_SIZE = VG_MAX_ENUM
+} VGUErrorCodeKHR;
+
+#ifdef VG_VGEXT_PROTOTYPES
+VG_API_CALL void VG_API_ENTRY vgParametricFilterKHR(VGImage dst,VGImage src,VGImage blur,VGfloat strength,VGfloat offsetX,VGfloat offsetY,VGbitfield filterFlags,VGPaint highlightPaint,VGPaint shadowPaint);
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguDropShadowKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint shadowColorRGBA);
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguGlowKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint glowColorRGBA) ;
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguBevelKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint highlightColorRGBA,VGuint shadowColorRGBA);
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguGradientGlowKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint stopsCount,const VGfloat* glowColorRampStops);
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguGradientBevelKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint stopsCount,const VGfloat* bevelColorRampStops);
+#endif
+typedef void (VG_API_ENTRYP PFNVGPARAMETRICFILTERKHRPROC) (VGImage dst,VGImage src,VGImage blur,VGfloat strength,VGfloat offsetX,VGfloat offsetY,VGbitfield filterFlags,VGPaint highlightPaint,VGPaint shadowPaint);
+typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUDROPSHADOWKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint shadowColorRGBA);
+typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUGLOWKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint glowColorRGBA);
+typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUBEVELKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint highlightColorRGBA,VGuint shadowColorRGBA);
+typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUGRADIENTGLOWKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint stopsCount,const VGfloat* glowColorRampStops);
+typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUGRADIENTBEVELKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint stopsCount,const VGfloat* bevelColorRampStops);
+
+#endif
+
+
+/*-------------------------------------------------------------------------------
+ * NDS extensions
+ *------------------------------------------------------------------------------*/
+
+#ifndef VG_NDS_paint_generation
+#define VG_NDS_paint_generation 1
+
+typedef enum {
+ VG_PAINT_COLOR_RAMP_LINEAR_NDS = 0x1A10,
+ VG_COLOR_MATRIX_NDS = 0x1A11,
+ VG_PAINT_COLOR_TRANSFORM_LINEAR_NDS = 0x1A12,
+
+ VG_PAINT_PARAM_TYPE_NDS_FORCE_SIZE = VG_MAX_ENUM
+} VGPaintParamTypeNds;
+
+typedef enum {
+ VG_DRAW_IMAGE_COLOR_MATRIX_NDS = 0x1F10,
+
+ VG_IMAGE_MODE_NDS_FORCE_SIZE = VG_MAX_ENUM
+} VGImageModeNds;
+#endif
+
+
+#ifndef VG_NDS_projective_geometry
+#define VG_NDS_projective_geometry 1
+
+typedef enum {
+ VG_CLIP_MODE_NDS = 0x1180,
+ VG_CLIP_LINES_NDS = 0x1181,
+ VG_MAX_CLIP_LINES_NDS = 0x1182,
+
+ VG_PARAM_TYPE_NDS_FORCE_SIZE = VG_MAX_ENUM
+} VGParamTypeNds;
+
+typedef enum {
+ VG_CLIPMODE_NONE_NDS = 0x3000,
+ VG_CLIPMODE_CLIP_CLOSED_NDS = 0x3001,
+ VG_CLIPMODE_CLIP_OPEN_NDS = 0x3002,
+ VG_CLIPMODE_CULL_NDS = 0x3003,
+
+ VG_CLIPMODE_NDS_FORCE_SIZE = VG_MAX_ENUM
+} VGClipModeNds;
+
+typedef enum {
+ VG_RQUAD_TO_NDS = ( 13 << 1 ),
+ VG_RCUBIC_TO_NDS = ( 14 << 1 ),
+
+ VG_PATH_SEGMENT_NDS_FORCE_SIZE = VG_MAX_ENUM
+} VGPathSegmentNds;
+
+typedef enum {
+ VG_RQUAD_TO_ABS_NDS = (VG_RQUAD_TO_NDS | VG_ABSOLUTE),
+ VG_RQUAD_TO_REL_NDS = (VG_RQUAD_TO_NDS | VG_RELATIVE),
+ VG_RCUBIC_TO_ABS_NDS = (VG_RCUBIC_TO_NDS | VG_ABSOLUTE),
+ VG_RCUBIC_TO_REL_NDS = (VG_RCUBIC_TO_NDS | VG_RELATIVE),
+
+ VG_PATH_COMMAND_NDS_FORCE_SIZE = VG_MAX_ENUM
+} VGPathCommandNds;
+
+#ifdef VG_VGEXT_PROTOTYPES
+VG_API_CALL void VG_API_ENTRY vgProjectiveMatrixNDS(VGboolean enable) ;
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguTransformClipLineNDS(const VGfloat Ain,const VGfloat Bin,const VGfloat Cin,const VGfloat* matrix,const VGboolean inverse,VGfloat* Aout,VGfloat* Bout,VGfloat* Cout);
+#endif
+typedef void (VG_API_ENTRYP PFNVGPROJECTIVEMATRIXNDSPROC) (VGboolean enable) ;
+typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUTRANSFORMCLIPLINENDSPROC) (const VGfloat Ain,const VGfloat Bin,const VGfloat Cin,const VGfloat* matrix,const VGboolean inverse,VGfloat* Aout,VGfloat* Bout,VGfloat* Cout);
+
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* _VGEXT_H */
diff --git a/include/VG/vgplatform.h b/include/VG/vgplatform.h
new file mode 100644
index 00000000000..e4f269f6582
--- /dev/null
+++ b/include/VG/vgplatform.h
@@ -0,0 +1,106 @@
+/* $Revision: 6810 $ on $Date:: 2008-10-29 10:31:37 -0400 #$ */
+
+/*------------------------------------------------------------------------
+ *
+ * VG platform specific header Reference Implementation
+ * ----------------------------------------------------
+ *
+ * Copyright (c) 2008 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and /or associated documentation files
+ * (the "Materials "), to deal in the Materials without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Materials,
+ * and to permit persons to whom the Materials are furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
+ * THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ *
+ *//**
+ * \file
+ * \brief VG platform specific header
+ *//*-------------------------------------------------------------------*/
+
+#ifndef _VGPLATFORM_H
+#define _VGPLATFORM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef VG_API_CALL
+#if defined(OPENVG_STATIC_LIBRARY)
+# define VG_API_CALL
+#else
+# if defined(_WIN32) || defined(__VC32__) /* Win32 */
+# if defined (OPENVG_DLL_EXPORTS)
+# define VG_API_CALL __declspec(dllexport)
+# else
+# define VG_API_CALL __declspec(dllimport)
+# endif
+# else
+# define VG_API_CALL extern
+# endif /* defined(_WIN32) ||... */
+#endif /* defined OPENVG_STATIC_LIBRARY */
+#endif /* ifndef VG_API_CALL */
+
+#ifndef VGU_API_CALL
+#if defined(OPENVG_STATIC_LIBRARY)
+# define VGU_API_CALL
+#else
+# if defined(_WIN32) || defined(__VC32__) /* Win32 */
+# if defined (OPENVG_DLL_EXPORTS)
+# define VGU_API_CALL __declspec(dllexport)
+# else
+# define VGU_API_CALL __declspec(dllimport)
+# endif
+# else
+# define VGU_API_CALL extern
+# endif /* defined(_WIN32) ||... */
+#endif /* defined OPENVG_STATIC_LIBRARY */
+#endif /* ifndef VGU_API_CALL */
+
+
+#ifndef VG_API_ENTRY
+#define VG_API_ENTRY
+#endif
+
+#ifndef VG_API_EXIT
+#define VG_API_EXIT
+#endif
+
+#ifndef VGU_API_ENTRY
+#define VGU_API_ENTRY
+#endif
+
+#ifndef VGU_API_EXIT
+#define VGU_API_EXIT
+#endif
+
+typedef float VGfloat;
+typedef signed char VGbyte;
+typedef unsigned char VGubyte;
+typedef signed short VGshort;
+typedef signed int VGint;
+typedef unsigned int VGuint;
+typedef unsigned int VGbitfield;
+
+#ifndef VG_VGEXT_PROTOTYPES
+#define VG_VGEXT_PROTOTYPES
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* _VGPLATFORM_H */
diff --git a/include/VG/vgu.h b/include/VG/vgu.h
new file mode 100644
index 00000000000..2799684e5e7
--- /dev/null
+++ b/include/VG/vgu.h
@@ -0,0 +1,130 @@
+/* $Revision: 6810 $ on $Date:: 2008-10-29 10:31:37 -0400 #$ */
+
+/*------------------------------------------------------------------------
+ *
+ * VGU 1.0.1 Reference Implementation
+ * -------------------------------------
+ *
+ * Copyright (c) 2008 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and /or associated documentation files
+ * (the "Materials "), to deal in the Materials without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Materials,
+ * and to permit persons to whom the Materials are furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
+ * THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ *
+ *//**
+ * \file
+ * \brief VGU 1.0.1 API.
+ *//*-------------------------------------------------------------------*/
+
+#ifndef _VGU_H
+#define _VGU_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include
+
+#define VGU_VERSION_1_0 1
+
+#ifndef VGU_API_CALL
+# error VGU_API_CALL must be defined
+#endif
+
+#ifndef VGU_API_ENTRY
+# error VGU_API_ENTRY must be defined
+#endif
+
+#ifndef VGU_API_EXIT
+# error VGU_API_EXIT must be defined
+#endif
+
+
+typedef enum {
+ VGU_NO_ERROR = 0,
+ VGU_BAD_HANDLE_ERROR = 0xF000,
+ VGU_ILLEGAL_ARGUMENT_ERROR = 0xF001,
+ VGU_OUT_OF_MEMORY_ERROR = 0xF002,
+ VGU_PATH_CAPABILITY_ERROR = 0xF003,
+ VGU_BAD_WARP_ERROR = 0xF004,
+
+ VGU_ERROR_CODE_FORCE_SIZE = VG_MAX_ENUM
+} VGUErrorCode;
+
+typedef enum {
+ VGU_ARC_OPEN = 0xF100,
+ VGU_ARC_CHORD = 0xF101,
+ VGU_ARC_PIE = 0xF102,
+
+ VGU_ARC_TYPE_FORCE_SIZE = VG_MAX_ENUM
+} VGUArcType;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguLine(VGPath path,
+ VGfloat x0, VGfloat y0,
+ VGfloat x1, VGfloat y1) VGU_API_EXIT;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguPolygon(VGPath path,
+ const VGfloat * points, VGint count,
+ VGboolean closed) VGU_API_EXIT;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguRect(VGPath path,
+ VGfloat x, VGfloat y,
+ VGfloat width, VGfloat height) VGU_API_EXIT;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguRoundRect(VGPath path,
+ VGfloat x, VGfloat y,
+ VGfloat width, VGfloat height,
+ VGfloat arcWidth, VGfloat arcHeight) VGU_API_EXIT;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguEllipse(VGPath path,
+ VGfloat cx, VGfloat cy,
+ VGfloat width, VGfloat height) VGU_API_EXIT;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguArc(VGPath path,
+ VGfloat x, VGfloat y,
+ VGfloat width, VGfloat height,
+ VGfloat startAngle, VGfloat angleExtent,
+ VGUArcType arcType) VGU_API_EXIT;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguComputeWarpQuadToSquare(VGfloat sx0, VGfloat sy0,
+ VGfloat sx1, VGfloat sy1,
+ VGfloat sx2, VGfloat sy2,
+ VGfloat sx3, VGfloat sy3,
+ VGfloat * matrix) VGU_API_EXIT;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguComputeWarpSquareToQuad(VGfloat dx0, VGfloat dy0,
+ VGfloat dx1, VGfloat dy1,
+ VGfloat dx2, VGfloat dy2,
+ VGfloat dx3, VGfloat dy3,
+ VGfloat * matrix) VGU_API_EXIT;
+
+VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguComputeWarpQuadToQuad(VGfloat dx0, VGfloat dy0,
+ VGfloat dx1, VGfloat dy1,
+ VGfloat dx2, VGfloat dy2,
+ VGfloat dx3, VGfloat dy3,
+ VGfloat sx0, VGfloat sy0,
+ VGfloat sx1, VGfloat sy1,
+ VGfloat sx2, VGfloat sy2,
+ VGfloat sx3, VGfloat sy3,
+ VGfloat * matrix) VGU_API_EXIT;
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* #ifndef _VGU_H */
diff --git a/progs/SConscript b/progs/SConscript
index 71ebe5e0f37..620dd30e69c 100644
--- a/progs/SConscript
+++ b/progs/SConscript
@@ -1,6 +1,7 @@
SConscript([
'util/SConscript',
'demos/SConscript',
+ 'glsl/SConscript',
'redbook/SConscript',
'samples/SConscript',
'tests/SConscript',
diff --git a/progs/demos/Makefile b/progs/demos/Makefile
index c17595ec794..65fdbaaad8e 100644
--- a/progs/demos/Makefile
+++ b/progs/demos/Makefile
@@ -145,6 +145,13 @@ engine.o: engine.c trackball.h
$(APP_CC) -c -I$(INCDIR) $(CFLAGS) engine.c
+fbotexture: fbotexture.o
+ $(APP_CC) $(CFLAGS) $(LDFLAGS) fbotexture.o $(LIBS) -o $@
+
+fbotexture.o: fbotexture.c extfuncs.h
+ $(APP_CC) -c -I$(INCDIR) $(CFLAGS) fbotexture.c
+
+
fslight: fslight.o
$(APP_CC) $(CFLAGS) $(LDFLAGS) fslight.o $(LIBS) -o $@
diff --git a/progs/demos/cubemap.c b/progs/demos/cubemap.c
index 26db42aed5e..1f9f2905759 100644
--- a/progs/demos/cubemap.c
+++ b/progs/demos/cubemap.c
@@ -52,6 +52,7 @@ static GLboolean NoClear = GL_FALSE;
static GLint FrameParity = 0;
static GLenum FilterIndex = 0;
static GLint ClampIndex = 0;
+static GLboolean supportFBO = GL_FALSE;
static struct {
@@ -403,6 +404,10 @@ static void init_checkers( void )
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+ if (!supportFBO)
+ glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
+
+
/* make colored checkerboard cube faces */
for (f = 0; f < 6; f++) {
for (i = 0; i < CUBE_TEX_SIZE; i++) {
@@ -426,7 +431,8 @@ static void init_checkers( void )
GL_BGRA, GL_UNSIGNED_BYTE, image);
}
- glGenerateMipmapEXT(GL_TEXTURE_CUBE_MAP_ARB);
+ if (supportFBO)
+ glGenerateMipmapEXT(GL_TEXTURE_CUBE_MAP_ARB);
}
@@ -503,10 +509,13 @@ static void init( GLboolean useImageFiles )
exit(0);
}
- /* Needed for glGenerateMipmapEXT
+ /* Needed for glGenerateMipmapEXT / auto mipmapping
*/
- if (!strstr(exten, "GL_EXT_framebuffer_object")) {
- printf("Sorry, this demo requires GL_EXT_framebuffer_object\n");
+ if (strstr(exten, "GL_EXT_framebuffer_object")) {
+ supportFBO = GL_TRUE;
+ }
+ else if (!strstr(exten, "GL_SGIS_generate_mipmap")) {
+ printf("Sorry, this demo requires GL_EXT_framebuffer_object or GL_SGIS_generate_mipmap\n");
exit(0);
}
}
diff --git a/progs/demos/fbotexture.c b/progs/demos/fbotexture.c
index 50a4b00afce..3b36f755a04 100644
--- a/progs/demos/fbotexture.c
+++ b/progs/demos/fbotexture.c
@@ -9,13 +9,13 @@
*/
-#include
#include
#include
#include
#include
#include
#include
+#include "extfuncs.h"
/* For debug */
#define DEPTH 1
@@ -80,9 +80,9 @@ RenderTexture(void)
glTranslatef(0.0, 0.0, -15.0);
/* draw to texture image */
- glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, MyFB);
+ glBindFramebuffer_func(GL_FRAMEBUFFER_EXT, MyFB);
- status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
+ status = glCheckFramebufferStatus_func(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
printf("Framebuffer incomplete!!!\n");
}
@@ -171,7 +171,7 @@ RenderTexture(void)
#if DRAW
/* Bind normal framebuffer */
- glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+ glBindFramebuffer_func(GL_FRAMEBUFFER_EXT, 0);
#endif
CheckError(__LINE__);
@@ -252,12 +252,12 @@ static void
CleanUp(void)
{
#if DEPTH
- glDeleteRenderbuffersEXT(1, &DepthRB);
+ glDeleteRenderbuffers_func(1, &DepthRB);
#endif
#if STENCIL
- glDeleteRenderbuffersEXT(1, &StencilRB);
+ glDeleteRenderbuffers_func(1, &StencilRB);
#endif
- glDeleteFramebuffersEXT(1, &MyFB);
+ glDeleteFramebuffers_func(1, &MyFB);
glDeleteTextures(1, &TexObj);
@@ -318,14 +318,14 @@ AttachDepthAndStencilBuffers(GLuint fbo,
*depthRbOut = *stencilRbOut = 0;
- glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
+ glBindFramebuffer_func(GL_FRAMEBUFFER_EXT, fbo);
if (tryDepthStencil) {
GLuint rb;
- glGenRenderbuffersEXT(1, &rb);
- glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rb);
- glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT,
+ glGenRenderbuffers_func(1, &rb);
+ glBindRenderbuffer_func(GL_RENDERBUFFER_EXT, rb);
+ glRenderbufferStorage_func(GL_RENDERBUFFER_EXT,
GL_DEPTH24_STENCIL8_EXT,
width, height);
if (glGetError())
@@ -333,7 +333,7 @@ AttachDepthAndStencilBuffers(GLuint fbo,
if (bindDepthStencil) {
/* attach to both depth and stencil at once */
- glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,
+ glFramebufferRenderbuffer_func(GL_FRAMEBUFFER_EXT,
GL_DEPTH_STENCIL_ATTACHMENT,
GL_RENDERBUFFER_EXT, rb);
if (glGetError())
@@ -341,21 +341,21 @@ AttachDepthAndStencilBuffers(GLuint fbo,
}
else {
/* attach to depth attachment point */
- glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,
+ glFramebufferRenderbuffer_func(GL_FRAMEBUFFER_EXT,
GL_DEPTH_ATTACHMENT_EXT,
GL_RENDERBUFFER_EXT, rb);
if (glGetError())
return GL_FALSE;
/* and attach to stencil attachment point */
- glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,
+ glFramebufferRenderbuffer_func(GL_FRAMEBUFFER_EXT,
GL_STENCIL_ATTACHMENT_EXT,
GL_RENDERBUFFER_EXT, rb);
if (glGetError())
return GL_FALSE;
}
- status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
+ status = glCheckFramebufferStatus_func(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
return GL_FALSE;
@@ -367,22 +367,22 @@ AttachDepthAndStencilBuffers(GLuint fbo,
{
GLuint rb;
- glGenRenderbuffersEXT(1, &rb);
- glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rb);
- glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT,
+ glGenRenderbuffers_func(1, &rb);
+ glBindRenderbuffer_func(GL_RENDERBUFFER_EXT, rb);
+ glRenderbufferStorage_func(GL_RENDERBUFFER_EXT,
GL_DEPTH_COMPONENT,
width, height);
if (glGetError())
return GL_FALSE;
/* attach to depth attachment point */
- glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,
+ glFramebufferRenderbuffer_func(GL_FRAMEBUFFER_EXT,
GL_DEPTH_ATTACHMENT_EXT,
GL_RENDERBUFFER_EXT, rb);
if (glGetError())
return GL_FALSE;
- status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
+ status = glCheckFramebufferStatus_func(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
return GL_FALSE;
@@ -393,26 +393,26 @@ AttachDepthAndStencilBuffers(GLuint fbo,
{
GLuint rb;
- glGenRenderbuffersEXT(1, &rb);
- glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rb);
- glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT,
+ glGenRenderbuffers_func(1, &rb);
+ glBindRenderbuffer_func(GL_RENDERBUFFER_EXT, rb);
+ glRenderbufferStorage_func(GL_RENDERBUFFER_EXT,
GL_STENCIL_INDEX,
width, height);
if (glGetError())
return GL_FALSE;
/* attach to depth attachment point */
- glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,
+ glFramebufferRenderbuffer_func(GL_FRAMEBUFFER_EXT,
GL_STENCIL_ATTACHMENT_EXT,
GL_RENDERBUFFER_EXT, rb);
if (glGetError())
return GL_FALSE;
- status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
+ status = glCheckFramebufferStatus_func(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
- glDeleteRenderbuffersEXT(1, depthRbOut);
+ glDeleteRenderbuffers_func(1, depthRbOut);
*depthRbOut = 0;
- glDeleteRenderbuffersEXT(1, &rb);
+ glDeleteRenderbuffers_func(1, &rb);
return GL_FALSE;
}
@@ -463,6 +463,37 @@ ParseArgs(int argc, char *argv[])
}
+static void
+SetupFunctionPointers(void)
+{
+ GetExtensionFuncs();
+
+ if (Use_ARB_fbo) {
+ /* no-op: use the ARB functions as-is */
+ }
+ else {
+ /* set the ARB-flavor function pointers to point to the EXT functions */
+ glIsRenderbuffer_func = glIsRenderbufferEXT_func;
+ glBindRenderbuffer_func = glBindRenderbufferEXT_func;
+ glDeleteRenderbuffers_func = glDeleteRenderbuffersEXT_func;
+ glGenRenderbuffers_func = glGenRenderbuffersEXT_func;
+ glRenderbufferStorage_func = glRenderbufferStorageEXT_func;
+ glGetRenderbufferParameteriv_func = glGetRenderbufferParameterivEXT_func;
+ glIsFramebuffer_func = glIsFramebufferEXT_func;
+ glBindFramebuffer_func = glBindFramebufferEXT_func;
+ glDeleteFramebuffers_func = glDeleteFramebuffersEXT_func;
+ glGenFramebuffers_func = glGenFramebuffersEXT_func;
+ glCheckFramebufferStatus_func = glCheckFramebufferStatusEXT_func;
+ glFramebufferTexture1D_func = glFramebufferTexture1DEXT_func;
+ glFramebufferTexture2D_func = glFramebufferTexture2DEXT_func;
+ glFramebufferTexture3D_func = glFramebufferTexture3DEXT_func;
+ glFramebufferRenderbuffer_func = glFramebufferRenderbufferEXT_func;
+ glGetFramebufferAttachmentParameteriv_func = glGetFramebufferAttachmentParameterivEXT_func;
+ glGenerateMipmap_func = glGenerateMipmapEXT_func;
+ }
+}
+
+
/*
* Make FBO to render into given texture.
*/
@@ -472,10 +503,10 @@ MakeFBO_RenderTexture(GLuint TexObj)
GLuint fb;
GLint sizeFudge = 0;
- glGenFramebuffersEXT(1, &fb);
- glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
+ glGenFramebuffers_func(1, &fb);
+ glBindFramebuffer_func(GL_FRAMEBUFFER_EXT, fb);
/* Render color to texture */
- glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
+ glFramebufferTexture2D_func(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
TexTarget, TexObj, TextureLevel);
if (Use_ARB_fbo) {
@@ -512,26 +543,26 @@ MakeFBO_RenderTexture(GLuint TexObj)
{
GLint bits, w, h;
- glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, DepthRB);
- glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT,
+ glBindRenderbuffer_func(GL_RENDERBUFFER_EXT, DepthRB);
+ glGetRenderbufferParameteriv_func(GL_RENDERBUFFER_EXT,
GL_RENDERBUFFER_WIDTH_EXT, &w);
- glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT,
+ glGetRenderbufferParameteriv_func(GL_RENDERBUFFER_EXT,
GL_RENDERBUFFER_HEIGHT_EXT, &h);
printf("Color/Texture size: %d x %d\n", TexWidth, TexHeight);
printf("Depth buffer size: %d x %d\n", w, h);
- glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT,
+ glGetRenderbufferParameteriv_func(GL_RENDERBUFFER_EXT,
GL_RENDERBUFFER_DEPTH_SIZE_EXT, &bits);
printf("Depth renderbuffer size = %d bits\n", bits);
- glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, StencilRB);
- glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT,
+ glBindRenderbuffer_func(GL_RENDERBUFFER_EXT, StencilRB);
+ glGetRenderbufferParameteriv_func(GL_RENDERBUFFER_EXT,
GL_RENDERBUFFER_STENCIL_SIZE_EXT, &bits);
printf("Stencil renderbuffer size = %d bits\n", bits);
}
/* bind the regular framebuffer */
- glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+ glBindFramebuffer_func(GL_FRAMEBUFFER_EXT, 0);
return fb;
}
@@ -547,6 +578,8 @@ Init(void)
printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
+ SetupFunctionPointers();
+
/* lighting */
{
static const GLfloat mat[4] = { 1.0, 0.5, 0.5, 1.0 };
@@ -605,7 +638,6 @@ main(int argc, char *argv[])
glutInitWindowSize(Width, Height);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
Win = glutCreateWindow(argv[0]);
- glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutDisplayFunc(Display);
diff --git a/progs/demos/fslight.c b/progs/demos/fslight.c
index 41a13cc9f46..f0d76a4a06f 100644
--- a/progs/demos/fslight.c
+++ b/progs/demos/fslight.c
@@ -583,10 +583,14 @@ ParseOptions(int argc, char *argv[])
int i;
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-fs") == 0) {
- FragProgFile = argv[i+1];
+ FragProgFile = argv[++i];
}
else if (strcmp(argv[i], "-vs") == 0) {
- VertProgFile = argv[i+1];
+ VertProgFile = argv[++i];
+ }
+ else {
+ fprintf(stderr, "unknown option %s\n", argv[i]);
+ break;
}
}
}
diff --git a/progs/demos/isosurf.c b/progs/demos/isosurf.c
index e280d8f507c..2e9dff17261 100644
--- a/progs/demos/isosurf.c
+++ b/progs/demos/isosurf.c
@@ -514,12 +514,27 @@ static void draw_surface( unsigned int with_state )
break;
case (GLVERTEX|STRIPS):
- glBegin( GL_TRIANGLE_STRIP );
- for (i=0;i
#include
#include
+#include
#include
#include
-#include
#include "extfuncs.h"
#include "shaderutil.h"
@@ -248,6 +248,7 @@ main(int argc, char *argv[])
glutInitWindowSize(500, 500);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutSpecialFunc(SpecialKey);
diff --git a/progs/glsl/bitmap.c b/progs/glsl/bitmap.c
index d488ec6cb9f..08fac15c89d 100644
--- a/progs/glsl/bitmap.c
+++ b/progs/glsl/bitmap.c
@@ -9,6 +9,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -309,6 +310,7 @@ main(int argc, char *argv[])
glutInitWindowSize(WinWidth, WinHeight);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
Win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutSpecialFunc(SpecialKey);
diff --git a/progs/glsl/brick.c b/progs/glsl/brick.c
index 526ef0e2e36..607acd05977 100644
--- a/progs/glsl/brick.c
+++ b/progs/glsl/brick.c
@@ -9,6 +9,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -191,6 +192,7 @@ main(int argc, char *argv[])
glutInitWindowSize(400, 400);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutSpecialFunc(SpecialKey);
diff --git a/progs/glsl/bump.c b/progs/glsl/bump.c
index 0ea1f8331ff..c401e590f74 100644
--- a/progs/glsl/bump.c
+++ b/progs/glsl/bump.c
@@ -288,6 +288,7 @@ main(int argc, char *argv[])
glutInitWindowSize(400, 400);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutSpecialFunc(SpecialKey);
diff --git a/progs/glsl/convolutions.c b/progs/glsl/convolutions.c
index ac71c68235e..22ce7edcdc5 100644
--- a/progs/glsl/convolutions.c
+++ b/progs/glsl/convolutions.c
@@ -5,6 +5,8 @@
* Author: Zack Rusin
*/
+#include
+
#define GL_GLEXT_PROTOTYPES
#include "readtex.h"
@@ -455,6 +457,7 @@ int main(int argc, char **argv)
exit(1);
}
+ glewInit();
init();
glutReshapeFunc(reshape);
diff --git a/progs/glsl/deriv.c b/progs/glsl/deriv.c
index e69f0b82c45..3fd674c3310 100644
--- a/progs/glsl/deriv.c
+++ b/progs/glsl/deriv.c
@@ -13,6 +13,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -228,6 +229,7 @@ main(int argc, char *argv[])
glutInitWindowSize(200, 200);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutSpecialFunc(SpecialKey);
diff --git a/progs/glsl/fragcoord.c b/progs/glsl/fragcoord.c
index 0b7561f3e47..509ad47e7f6 100644
--- a/progs/glsl/fragcoord.c
+++ b/progs/glsl/fragcoord.c
@@ -12,6 +12,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -174,6 +175,7 @@ main(int argc, char *argv[])
glutInitWindowSize(WinWidth, WinHeight);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutDisplayFunc(Redisplay);
diff --git a/progs/glsl/identity.c b/progs/glsl/identity.c
index 37579eb3469..5ba7468cc44 100644
--- a/progs/glsl/identity.c
+++ b/progs/glsl/identity.c
@@ -9,6 +9,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -195,6 +196,7 @@ main(int argc, char *argv[])
glutInitWindowSize(200, 200);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutSpecialFunc(SpecialKey);
diff --git a/progs/glsl/linktest.c b/progs/glsl/linktest.c
index 988d0823418..fe5d1564e07 100644
--- a/progs/glsl/linktest.c
+++ b/progs/glsl/linktest.c
@@ -9,6 +9,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -245,6 +246,7 @@ main(int argc, char *argv[])
glutInitWindowSize(300, 300);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
Win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutDisplayFunc(Redisplay);
diff --git a/progs/glsl/mandelbrot.c b/progs/glsl/mandelbrot.c
index 24e19926655..eeea4eb52ae 100644
--- a/progs/glsl/mandelbrot.c
+++ b/progs/glsl/mandelbrot.c
@@ -9,6 +9,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -206,6 +207,7 @@ main(int argc, char *argv[])
glutInitWindowSize(400, 400);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutSpecialFunc(SpecialKey);
diff --git a/progs/glsl/multinoise.c b/progs/glsl/multinoise.c
index 2351863aff8..400511508e1 100644
--- a/progs/glsl/multinoise.c
+++ b/progs/glsl/multinoise.c
@@ -8,6 +8,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -270,6 +271,7 @@ main(int argc, char *argv[])
glutInitWindowSize(400, 400);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutSpecialFunc(SpecialKey);
diff --git a/progs/glsl/multitex.c b/progs/glsl/multitex.c
index 1a1c63aaf48..c6e0b10b49d 100644
--- a/progs/glsl/multitex.c
+++ b/progs/glsl/multitex.c
@@ -28,6 +28,7 @@
#include
#include
#include
+#include
#include "GL/glut.h"
#include "readtex.h"
#include "extfuncs.h"
@@ -139,7 +140,7 @@ DrawPolygonArray(void)
}
else {
glVertexPointer(2, GL_FLOAT, 0, vertPtr);
- glEnable(GL_VERTEX_ARRAY);
+ glEnableClientState(GL_VERTEX_ARRAY);
}
glVertexAttribPointer_func(TexCoord0_attr, 2, GL_FLOAT, GL_FALSE,
@@ -152,7 +153,7 @@ DrawPolygonArray(void)
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
- glBindBufferARB_func(GL_ARRAY_BUFFER_ARB, 0);
+ glBindBufferARB_func(GL_ARRAY_BUFFER_ARB, 0);
}
@@ -400,6 +401,7 @@ main(int argc, char *argv[])
glutInitWindowSize(500, 400);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow(Demo);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(key);
glutSpecialFunc(specialkey);
diff --git a/progs/glsl/noise.c b/progs/glsl/noise.c
index bd8f50036bf..83e4696fc99 100644
--- a/progs/glsl/noise.c
+++ b/progs/glsl/noise.c
@@ -8,6 +8,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -207,6 +208,7 @@ main(int argc, char *argv[])
glutInitWindowSize(400, 400);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutSpecialFunc(SpecialKey);
diff --git a/progs/glsl/pointcoord.c b/progs/glsl/pointcoord.c
index b240077c252..aa01e2166d7 100644
--- a/progs/glsl/pointcoord.c
+++ b/progs/glsl/pointcoord.c
@@ -10,6 +10,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -195,6 +196,7 @@ main(int argc, char *argv[])
glutInitWindowSize(WinWidth, WinHeight);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutDisplayFunc(Redisplay);
diff --git a/progs/glsl/points.c b/progs/glsl/points.c
index 392dc4db853..1b346228aa1 100644
--- a/progs/glsl/points.c
+++ b/progs/glsl/points.c
@@ -10,6 +10,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -248,6 +249,7 @@ main(int argc, char *argv[])
glutInitWindowSize(WinWidth, WinHeight);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
Win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutSpecialFunc(SpecialKey);
diff --git a/progs/glsl/reflect.vert b/progs/glsl/reflect.vert
index 402be38bf7b..e1f22def339 100644
--- a/progs/glsl/reflect.vert
+++ b/progs/glsl/reflect.vert
@@ -11,6 +11,7 @@ void main()
float two_n_dot_u = 2.0 * dot(n, u);
vec4 f;
f.xyz = u - n * two_n_dot_u;
+ f.w = 1.0;
// outputs
normal = n;
diff --git a/progs/glsl/samplers.c b/progs/glsl/samplers.c
index 3fb8577d5e3..cbb264dad17 100644
--- a/progs/glsl/samplers.c
+++ b/progs/glsl/samplers.c
@@ -39,6 +39,7 @@
#include
#include
#include
+#include
#include "GL/glut.h"
#include "readtex.h"
#include "extfuncs.h"
@@ -357,6 +358,7 @@ main(int argc, char *argv[])
glutInitWindowSize(500, 400);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow(Demo);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(key);
glutSpecialFunc(specialkey);
diff --git a/progs/glsl/shadow_sampler.c b/progs/glsl/shadow_sampler.c
index 2902b535522..673ad465ad8 100644
--- a/progs/glsl/shadow_sampler.c
+++ b/progs/glsl/shadow_sampler.c
@@ -10,6 +10,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -329,6 +330,7 @@ main(int argc, char *argv[])
glutInitWindowSize(400, 300);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutDisplayFunc(Redisplay);
diff --git a/progs/glsl/skinning.c b/progs/glsl/skinning.c
index 8a65d0667ce..d7b968fed05 100644
--- a/progs/glsl/skinning.c
+++ b/progs/glsl/skinning.c
@@ -12,6 +12,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -266,6 +267,7 @@ main(int argc, char *argv[])
glutInitWindowSize(500, 500);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutSpecialFunc(SpecialKey);
diff --git a/progs/glsl/texaaline.c b/progs/glsl/texaaline.c
index 0b3cc849586..6720941a6e1 100644
--- a/progs/glsl/texaaline.c
+++ b/progs/glsl/texaaline.c
@@ -11,6 +11,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -359,6 +360,7 @@ main(int argc, char *argv[])
glutInitWindowSize(WinWidth, WinHeight);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutDisplayFunc(Redisplay);
diff --git a/progs/glsl/texdemo1.c b/progs/glsl/texdemo1.c
index 96ddca1f32d..08a87a51525 100644
--- a/progs/glsl/texdemo1.c
+++ b/progs/glsl/texdemo1.c
@@ -28,6 +28,7 @@
#include
#include
#include
+#include
#include "GL/glut.h"
#include "readtex.h"
#include "extfuncs.h"
@@ -426,6 +427,7 @@ main(int argc, char *argv[])
glutInitWindowSize(500, 400);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
win = glutCreateWindow(Demo);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(key);
glutSpecialFunc(specialkey);
diff --git a/progs/glsl/toyball.c b/progs/glsl/toyball.c
index 37ad6bf2914..2b644acb6d4 100644
--- a/progs/glsl/toyball.c
+++ b/progs/glsl/toyball.c
@@ -9,6 +9,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -212,6 +213,7 @@ main(int argc, char *argv[])
glutInitWindowSize(400, 400);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutSpecialFunc(SpecialKey);
diff --git a/progs/glsl/trirast.c b/progs/glsl/trirast.c
index 89df64fc718..3d4decaa2fb 100644
--- a/progs/glsl/trirast.c
+++ b/progs/glsl/trirast.c
@@ -15,6 +15,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -247,6 +248,7 @@ main(int argc, char *argv[])
glutInitWindowSize(WinWidth, WinHeight);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutDisplayFunc(Redisplay);
diff --git a/progs/glsl/twoside.c b/progs/glsl/twoside.c
index 06488bd1759..9ebc4ec3607 100644
--- a/progs/glsl/twoside.c
+++ b/progs/glsl/twoside.c
@@ -12,6 +12,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -293,6 +294,7 @@ main(int argc, char *argv[])
glutInitWindowSize(WinWidth, WinHeight);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutDisplayFunc(Redisplay);
diff --git a/progs/glsl/vert-or-frag-only.c b/progs/glsl/vert-or-frag-only.c
index f6eedd8327c..8e1612aca46 100644
--- a/progs/glsl/vert-or-frag-only.c
+++ b/progs/glsl/vert-or-frag-only.c
@@ -11,6 +11,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -181,6 +182,7 @@ main(int argc, char *argv[])
glutInitWindowSize(400, 200);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
Win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutDisplayFunc(Redisplay);
diff --git a/progs/glsl/vert-tex.c b/progs/glsl/vert-tex.c
index 9d00a610540..b74bf50679f 100644
--- a/progs/glsl/vert-tex.c
+++ b/progs/glsl/vert-tex.c
@@ -9,6 +9,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -266,6 +267,7 @@ main(int argc, char *argv[])
glutInitWindowSize(500, 500);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
win = glutCreateWindow(argv[0]);
+ glewInit();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutSpecialFunc(SpecialKey);
diff --git a/progs/openvg/demos/Makefile b/progs/openvg/demos/Makefile
new file mode 100644
index 00000000000..6e15342c7ff
--- /dev/null
+++ b/progs/openvg/demos/Makefile
@@ -0,0 +1,39 @@
+# progs/vg/Makefile
+
+TOP = ../../..
+include $(TOP)/configs/current
+
+VG_LIBS=-lm -pthread -lEGL -lOpenVG
+INCLUDE_DIRS = -I$(TOP)/include
+
+PROGRAMS = \
+ lion \
+ sp
+
+.c.o:
+ $(CC) -c $(INCLUDE_DIRS) $(CFLAGS) $< -o $@
+
+
+
+default: $(PROGRAMS)
+
+lion: lion.o lion-render.o
+ $(CC) $(CFLAGS) lion.o lion-render.o -L$(TOP)/$(LIB_DIR) $(VG_LIBS) -o $@
+
+lion.o: lion.c lion-render.h $(HEADERS)
+ $(CC) -c $(CFLAGS) -I$(TOP)/include lion.c
+lion-render.o: lion-render.c lion-render.h $(HEADERS)
+ $(CC) -c $(CFLAGS) -I$(TOP)/include lion-render.c
+
+
+sp: sp.c eglcommon.o
+ $(CC) $(INCLUDE_DIRS) $(CFLAGS) $^ -L$(TOP)/$(LIB_DIR) $(LIBS) $(VG_LIBS) $(APP_LIB_DEPS) -o $@
+
+eglcommon.o: eglcommon.c $(HEADERS)
+ $(CC) -c $(INCLUDE_DIRS) $(CFLAGS) eglcommon.c
+
+
+clean:
+ rm -f *.o *~
+ rm -f *.so
+ rm -f $(PROGRAMS)
diff --git a/progs/openvg/demos/eglcommon.c b/progs/openvg/demos/eglcommon.c
new file mode 100644
index 00000000000..bacd5685d75
--- /dev/null
+++ b/progs/openvg/demos/eglcommon.c
@@ -0,0 +1,288 @@
+#include "eglcommon.h"
+
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include /* using full OpenGL for now */
+#include
+
+
+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 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/demos/eglcommon.h b/progs/openvg/demos/eglcommon.h
new file mode 100644
index 00000000000..958dae9f98d
--- /dev/null
+++ b/progs/openvg/demos/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/demos/lion-render.c b/progs/openvg/demos/lion-render.c
new file mode 100644
index 00000000000..f3f151f5522
--- /dev/null
+++ b/progs/openvg/demos/lion-render.c
@@ -0,0 +1,1573 @@
+#include "lion-render.h"
+
+#include
+#include
+
+#define ELEMENTS(x) (sizeof(x)/sizeof((x)[0]))
+
+static void init(struct lion *l, int i, VGint hexColor, const VGfloat *coords, int elems)
+{
+ static VGubyte cmds[128];
+ VGfloat color[4];
+ VGint j;
+
+ color[0] = ((hexColor >> 16) & 0xff) / 255.f;
+ color[1] = ((hexColor >> 8) & 0xff) / 255.f;
+ color[2] = ((hexColor >> 0) & 0xff) / 255.f;
+ color[3] = 1.0;
+
+ l->paths[i] = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f,
+ 0, 0, (unsigned int)VG_PATH_CAPABILITY_ALL);
+ l->fills[i] = vgCreatePaint();
+ vgSetParameterfv(l->fills[i], VG_PAINT_COLOR, 4, color);
+
+ cmds[0] = VG_MOVE_TO_ABS;
+ for (j = 1; j < elems; ++j) {
+ cmds[j] = VG_LINE_TO_ABS;
+ }
+
+ vgAppendPathData(l->paths[i], elems, cmds, coords);
+}
+
+static void poly0(struct lion *l)
+{
+ VGfloat color = 0xf2cc99;
+ static const VGfloat coords[] = {69,18, 82,8, 99,3, 118,5, 135,12, 149,21, 156,13, 165,9, 177,13, 183,28,
+ 180,50, 164,91, 155,107, 154,114, 151,121, 141,127, 139,136, 155,206, 157,251, 126,342,
+ 133,357, 128,376, 83,376, 75,368, 67,350, 61,350, 53,369, 4,369, 2,361, 5,354,
+ 12,342, 16,321, 4,257, 4,244, 7,218, 9,179, 26,127, 43,93, 32,77, 30,70,
+ 24,67, 16,49, 17,35, 18,23, 30,12, 40,7, 53,7, 62,12
+ };
+
+ init(l, 0, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly1(struct lion *l)
+{
+ VGfloat color = 0xe5b27f;
+ static const VGfloat coords[] = {142,79, 136,74, 138,82, 133,78, 133,84, 127,78, 128,85,
+ 124,80, 125,87, 119,82, 119,90, 125,99, 125,96, 128,100, 128,94,
+ 131,98, 132,93, 135,97, 136,93, 138,97, 139,94, 141,98, 143,94,
+ 144,85
+ };
+
+ init(l, 1, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly2(struct lion *l)
+{
+ VGfloat color = 0xeb8080;
+ static const VGfloat coords[] = {127,101, 132,100, 137,99, 144,101, 143,105, 135,110
+ };
+
+ init(l, 2, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly3(struct lion *l)
+{
+ VGfloat color = 0xf2cc99;
+ static const VGfloat coords[] = {178,229, 157,248, 139,296, 126,349, 137,356,
+ 158,357, 183,342, 212,332, 235,288, 235,261,
+ 228,252, 212,250, 188,251
+ };
+
+ init(l, 3, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly4(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {56,229, 48,241, 48,250, 57,281, 63,325, 71,338,
+ 81,315, 76,321, 79,311, 83,301, 75,308, 80,298,
+ 73,303, 76,296, 71,298, 74,292, 69,293, 74,284,
+ 78,278, 71,278, 74,274, 68,273, 70,268, 66,267,
+ 68,261, 60,266, 62,259, 65,253, 57,258, 59,251,
+ 55,254, 55,248, 60,237, 54,240, 58,234, 54,236
+ };
+
+ init(l, 4, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly5(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {74,363, 79,368, 81,368, 85,362, 89,363, 92,370, 96,373,
+ 101,372, 108,361, 110,371, 113,373, 116,371, 120,358, 122,363,
+ 123,371, 126,371, 129,367, 132,357, 135,361, 130,376, 127,377,
+ 94,378, 84,376, 76,371
+ };
+
+ init(l, 5, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly6(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {212,250, 219,251, 228,258, 236,270, 235,287, 225,304,
+ 205,332, 177,343, 171,352, 158,357, 166,352, 168,346,
+ 168,339, 165,333, 155,327, 155,323, 161,320, 165,316,
+ 169,316, 167,312, 171,313, 168,308, 173,309, 170,306,
+ 177,306, 175,308, 177,311, 174,311, 176,316, 171,315,
+ 174,319, 168,320, 168,323, 175,327, 179,332, 183,326,
+ 184,332, 189,323, 190,328, 194,320, 194,325, 199,316,
+ 201,320, 204,313, 206,316, 208,310, 211,305, 219,298,
+ 226,288, 229,279, 228,266, 224,259, 217,253
+ };
+
+ init(l, 6, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly7(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {151,205, 151,238, 149,252, 141,268, 128,282, 121,301,
+ 130,300, 126,313, 118,324, 116,337, 120,346, 133,352,
+ 133,340, 137,333, 145,329, 156,327, 153,319, 153,291,
+ 157,271, 170,259, 178,277, 193,250, 174,216
+ };
+
+ init(l, 7, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly8(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {78,127, 90,142, 95,155, 108,164, 125,167, 139,175,
+ 150,206, 152,191, 141,140, 121,148, 100,136
+ };
+
+ init(l, 8, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly9(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {21,58, 35,63, 38,68, 32,69, 42,74, 40,79, 47,80, 54,83,
+ 45,94, 34,81, 32,73, 24,66
+ };
+
+ init(l, 9, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly10(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {71,34, 67,34, 66,27, 59,24, 54,17, 48,17, 39,22,
+ 30,26, 28,31, 31,39, 38,46, 29,45, 36,54, 41,61,
+ 41,70, 50,69, 54,71, 55,58, 67,52, 76,43, 76,39,
+ 68,44
+ };
+
+ init(l, 10, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly11(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {139,74, 141,83, 143,89, 144,104, 148,104, 155,106,
+ 154,86, 157,77, 155,72, 150,77, 144,77
+ };
+
+ init(l, 11, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly12(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {105,44, 102,53, 108,58, 111,62, 112,55
+ };
+
+ init(l, 12, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly13(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {141,48, 141,54, 144,58, 139,62, 137,66, 136,59, 137,52
+ };
+
+ init(l, 13, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly14(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {98,135, 104,130, 105,134, 108,132, 108,135, 112,134,
+ 113,137, 116,136, 116,139, 119,139, 124,141, 128,140,
+ 133,138, 140,133, 139,140, 126,146, 104,144
+ };
+
+ init(l, 14, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly15(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {97,116, 103,119, 103,116, 111,118, 116,117, 122,114,
+ 127,107, 135,111, 142,107, 141,114, 145,118, 149,121,
+ 145,125, 140,124, 127,121, 113,125, 100,124
+ };
+
+ init(l, 15, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly16(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {147,33, 152,35, 157,34, 153,31, 160,31, 156,28, 161,28,
+ 159,24, 163,25, 163,21, 165,22, 170,23, 167,17, 172,21,
+ 174,18, 175,23, 176,22, 177,28, 177,33, 174,37, 176,39,
+ 174,44, 171,49, 168,53, 164,57, 159,68, 156,70, 154,60,
+ 150,51, 146,43, 144,35
+ };
+
+ init(l, 16, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly17(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {85,72, 89,74, 93,75, 100,76, 105,75, 102,79, 94,79, 88,76
+ };
+
+ init(l, 17, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly18(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {86,214, 79,221, 76,232, 82,225, 78,239, 82,234, 78,245,
+ 81,243, 79,255, 84,250, 84,267, 87,254, 90,271, 90,257,
+ 95,271, 93,256, 95,249, 92,252, 93,243, 89,253, 89,241,
+ 86,250, 87,236, 83,245, 87,231, 82,231, 90,219, 84,221
+ };
+
+ init(l, 18, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly19(struct lion *l)
+{
+ VGfloat color = 0xffcc7f;
+ static const VGfloat coords[] = {93,68, 96,72, 100,73, 106,72, 108,66, 105,63, 100,62
+ };
+
+ init(l, 19, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly20(struct lion *l)
+{
+ VGfloat color = 0xffcc7f;
+ static const VGfloat coords[] = {144,64, 142,68, 142,73, 146,74, 150,73, 154,64, 149,62
+ };
+
+ init(l, 20, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly21(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {57,91, 42,111, 52,105, 41,117, 53,112, 46,120, 53,116,
+ 50,124, 57,119, 55,127, 61,122, 60,130, 67,126, 66,134,
+ 71,129, 72,136, 77,130, 76,137, 80,133, 82,138, 86,135,
+ 96,135, 94,129, 86,124, 83,117, 77,123, 79,117, 73,120,
+ 75,112, 68,116, 71,111, 65,114, 69,107, 63,110, 68,102,
+ 61,107, 66,98, 61,103, 63,97, 57,99
+ };
+
+ init(l, 21, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly22(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {83,79, 76,79, 67,82, 75,83, 65,88, 76,87, 65,92, 76,91,
+ 68,96, 77,95, 70,99, 80,98, 72,104, 80,102, 76,108, 85,103,
+ 92,101, 87,98, 93,96, 86,94, 91,93, 85,91, 93,89, 99,89, 105,93,
+ 107,85, 102,82, 92,80
+ };
+
+ init(l, 22, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly23(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {109,77, 111,83, 109,89, 113,94, 117,90, 117,81, 114,78
+ };
+
+ init(l, 23, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly24(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {122,128, 127,126, 134,127, 136,129, 134,130, 130,128, 124,129
+ };
+
+ init(l, 24, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly25(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {78,27, 82,32, 80,33, 82,36, 78,37, 82,40, 78,42, 81,46, 76,47,
+ 78,49, 74,50, 82,52, 87,50, 83,48, 91,46, 86,45, 91,42, 88,40,
+ 92,37, 86,34, 90,31, 86,29, 89,26
+ };
+
+ init(l, 25, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly26(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {82,17, 92,20, 79,21, 90,25, 81,25, 94,28, 93,26, 101,30,
+ 101,26, 107,33, 108,28, 111,40, 113,34, 115,45, 117,39,
+ 119,54, 121,46, 124,58, 126,47, 129,59, 130,49, 134,58,
+ 133,44, 137,48, 133,37, 137,40, 133,32, 126,20, 135,26,
+ 132,19, 138,23, 135,17, 142,18, 132,11, 116,6, 94,6, 78,11,
+ 92,12, 80,14, 90,16
+ };
+
+ init(l, 26, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly27(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {142,234, 132,227, 124,223, 115,220, 110,225, 118,224, 127,229,
+ 135,236, 122,234, 115,237, 113,242, 121,238, 139,243, 121,245,
+ 111,254, 95,254, 102,244, 104,235, 110,229, 100,231, 104,224,
+ 113,216, 122,215, 132,217, 141,224, 145,230, 149,240
+ };
+
+ init(l, 27, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly28(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {115,252, 125,248, 137,249, 143,258, 134,255, 125,254
+ };
+
+ init(l, 28, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly29(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {114,212, 130,213, 140,219, 147,225, 144,214, 137,209, 128,207
+ };
+
+ init(l, 29, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly30(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {102,263, 108,258, 117,257, 131,258, 116,260, 109,265
+ };
+
+ init(l, 30, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly31(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {51,241, 35,224, 40,238, 23,224, 31,242, 19,239, 28,247, 17,246,
+ 25,250, 37,254, 39,263, 44,271, 47,294, 48,317, 51,328, 60,351,
+ 60,323, 53,262, 47,246
+ };
+
+ init(l, 31, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly32(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {2,364, 9,367, 14,366, 18,355, 20,364, 26,366, 31,357, 35,364,
+ 39,364, 42,357, 47,363, 53,360, 59,357, 54,369, 7,373
+ };
+
+ init(l, 32, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly33(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {7,349, 19,345, 25,339, 18,341, 23,333, 28,326, 23,326, 27,320,
+ 23,316, 25,311, 20,298, 15,277, 12,264, 9,249, 10,223, 3,248,
+ 5,261, 15,307, 17,326, 11,343
+ };
+
+ init(l, 33, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly34(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {11,226, 15,231, 25,236, 18,227
+ };
+
+ init(l, 34, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly35(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {13,214, 19,217, 32,227, 23,214, 16,208, 15,190, 24,148,
+ 31,121, 24,137, 14,170, 8,189
+ };
+
+ init(l, 35, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly36(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {202,254, 195,258, 199,260, 193,263, 197,263, 190,268,
+ 196,268, 191,273, 188,282, 200,272, 194,272, 201,266,
+ 197,265, 204,262, 200,258, 204,256
+ };
+
+ init(l, 36, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly37(struct lion *l)
+{
+ VGfloat color = 0x845433;
+ static const VGfloat coords[] = {151,213, 165,212, 179,225, 189,246, 187,262, 179,275,
+ 176,263, 177,247, 171,233, 163,230, 165,251, 157,264,
+ 146,298, 145,321, 133,326, 143,285, 154,260, 153,240
+ };
+
+ init(l, 37, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly38(struct lion *l)
+{
+ VGfloat color = 0x845433;
+ static const VGfloat coords[] = {91,132, 95,145, 97,154, 104,148, 107,155, 109,150, 111,158,
+ 115,152, 118,159, 120,153, 125,161, 126,155, 133,164, 132,154,
+ 137,163, 137,152, 142,163, 147,186, 152,192, 148,167, 141,143,
+ 124,145, 105,143
+ };
+
+ init(l, 38, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly39(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {31,57, 23,52, 26,51, 20,44, 23,42, 21,36, 22,29, 25,23,
+ 24,32, 30,43, 26,41, 30,50, 26,48
+ };
+
+ init(l, 39, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly40(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {147,21, 149,28, 155,21, 161,16, 167,14, 175,15, 173,11, 161,9
+ };
+
+ init(l, 40, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly41(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {181,39, 175,51, 169,57, 171,65, 165,68, 165,75, 160,76,
+ 162,91, 171,71, 180,51
+ };
+
+ init(l, 41, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly42(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {132,346, 139,348, 141,346, 142,341, 147,342, 143,355, 133,350
+ };
+
+ init(l, 42, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly43(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {146,355, 151,352, 155,348, 157,343, 160,349, 151,356, 147,357
+ };
+
+ init(l, 43, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly44(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {99,266, 100,281, 94,305, 86,322, 78,332, 72,346, 73,331, 91,291
+ };
+
+ init(l, 44, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly45(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {20,347, 32,342, 45,340, 54,345, 45,350, 42,353, 38,350,
+ 31,353, 29,356, 23,350, 19,353, 15,349
+ };
+
+ init(l, 45, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly46(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {78,344, 86,344, 92,349, 88,358, 84,352
+ };
+
+ init(l, 46, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly47(struct lion *l)
+{
+ VGfloat color = 0x9c826b;
+ static const VGfloat coords[] = {93,347, 104,344, 117,345, 124,354, 121,357, 116,351,
+ 112,351, 108,355, 102,351
+ };
+
+ init(l, 47, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly48(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {105,12, 111,18, 113,24, 113,29, 119,34, 116,23, 112,16
+ };
+
+ init(l, 48, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly49(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {122,27, 125,34, 127,43, 128,34, 125,29
+ };
+
+ init(l, 49, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly50(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {115,13, 122,19, 122,15, 113,10
+ };
+
+ init(l, 50, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly51(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {116,172, 107,182, 98,193, 98,183, 90,199, 89,189, 84,207,
+ 88,206, 87,215, 95,206, 93,219, 91,230, 98,216, 97,226,
+ 104,214, 112,209, 104,208, 113,202, 126,200, 139,207, 132,198,
+ 142,203, 134,192, 142,195, 134,187, 140,185, 130,181, 136,177,
+ 126,177, 125,171, 116,180
+ };
+
+ init(l, 51, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly52(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {74,220, 67,230, 67,221, 59,235, 63,233, 60,248, 70,232, 65,249,
+ 71,243, 67,256, 73,250, 69,262, 73,259, 71,267, 76,262, 72,271,
+ 78,270, 76,275, 82,274, 78,290, 86,279, 86,289, 92,274, 88,275,
+ 87,264, 82,270, 82,258, 77,257, 78,247, 73,246, 77,233, 72,236
+ };
+
+ init(l, 52, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly53(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {133,230, 147,242, 148,250, 145,254, 138,247, 129,246, 142,245,
+ 138,241, 128,237, 137,238
+ };
+
+ init(l, 53, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly54(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {133,261, 125,261, 116,263, 111,267, 125,265
+ };
+
+ init(l, 54, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly55(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {121,271, 109,273, 103,279, 99,305, 92,316, 85,327, 83,335,
+ 89,340, 97,341, 94,336, 101,336, 96,331, 103,330, 97,327, 108,325,
+ 99,322, 109,321, 100,318, 110,317, 105,314, 110,312, 107,310, 113,308,
+ 105,306, 114,303, 105,301, 115,298, 107,295, 115,294, 108,293, 117,291,
+ 109,289, 117,286, 109,286, 118,283, 112,281, 118,279, 114,278,
+ 119,276, 115,274
+ };
+
+ init(l, 55, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly56(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {79,364, 74,359, 74,353, 76,347, 80,351, 83,356, 82,360
+ };
+
+ init(l, 56, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly57(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {91,363, 93,356, 97,353, 103,355, 105,360, 103,366, 99,371, 94,368
+ };
+
+ init(l, 57, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly58(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {110,355, 114,353, 118,357, 117,363, 113,369, 111,362
+ };
+
+ init(l, 58, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly59(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {126,354, 123,358, 124,367, 126,369, 129,361, 129,357
+ };
+
+ init(l, 59, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly60(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {30,154, 24,166, 20,182, 23,194, 29,208, 37,218, 41,210, 41,223,
+ 46,214, 46,227, 52,216, 52,227, 61,216, 59,225, 68,213, 73,219,
+ 70,207, 77,212, 69,200, 77,202, 70,194, 78,197, 68,187, 76,182,
+ 64,182, 58,175, 58,185, 53,177, 50,186, 46,171, 44,182, 39,167,
+ 36,172, 36,162, 30,166
+ };
+
+ init(l, 60, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly61(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {44,130, 41,137, 45,136, 43,150, 48,142, 48,157, 53,150,
+ 52,164, 60,156, 61,169, 64,165, 66,175, 70,167, 74,176,
+ 77,168, 80,183, 85,172, 90,182, 93,174, 98,181, 99,173,
+ 104,175, 105,169, 114,168, 102,163, 95,157, 94,166, 90,154,
+ 87,162, 82,149, 75,159, 72,148, 68,155, 67,143, 62,148, 62,138,
+ 58,145, 56,133, 52,142, 52,128, 49,134, 47,125
+ };
+
+ init(l, 61, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly62(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {13,216, 19,219, 36,231, 22,223, 16,222, 22,227, 12,224, 13,220, 16,220
+ };
+
+ init(l, 62, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly63(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {10,231, 14,236, 25,239, 27,237, 19,234
+ };
+
+ init(l, 63, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly64(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {9,245, 14,242, 25,245, 13,245
+ };
+
+ init(l, 64, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly65(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {33,255, 26,253, 18,254, 25,256, 18,258, 27,260, 18,263,
+ 27,265, 19,267, 29,270, 21,272, 29,276, 21,278, 30,281,
+ 22,283, 31,287, 24,288, 32,292, 23,293, 34,298, 26,299,
+ 37,303, 32,305, 39,309, 33,309, 39,314, 34,314, 40,318,
+ 34,317, 40,321, 34,321, 41,326, 33,326, 40,330, 33,332,
+ 39,333, 33,337, 42,337, 54,341, 49,337, 52,335, 47,330,
+ 50,330, 45,325, 49,325, 45,321, 48,321, 45,316, 46,306,
+ 45,286, 43,274, 36,261
+ };
+
+ init(l, 65, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly66(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {7,358, 9,351, 14,351, 17,359, 11,364
+ };
+
+ init(l, 66, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly67(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {44,354, 49,351, 52,355, 49,361
+ };
+
+ init(l, 67, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly68(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {32,357, 37,353, 40,358, 36,361
+ };
+
+ init(l, 68, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly69(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {139,334, 145,330, 154,330, 158,334, 154,341, 152,348,
+ 145,350, 149,340, 147,336, 141,339, 139,345, 136,342,
+ 136,339
+ };
+
+ init(l, 69, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly70(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {208,259, 215,259, 212,255, 220,259, 224,263, 225,274, 224,283,
+ 220,292, 208,300, 206,308, 203,304, 199,315, 197,309, 195,318,
+ 193,313, 190,322, 190,316, 185,325, 182,318, 180,325, 172,321,
+ 178,320, 176,313, 186,312, 180,307, 188,307, 184,303, 191,302,
+ 186,299, 195,294, 187,290, 197,288, 192,286, 201,283, 194,280,
+ 203,277, 198,275, 207,271, 200,269, 209,265, 204,265, 212,262
+ };
+
+ init(l, 70, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly71(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {106,126, 106,131, 109,132, 111,134, 115,132, 115,135, 119,133, 118,137,
+ 123,137, 128,137, 133,134, 136,130, 136,127, 132,124, 118,128, 112,128,
+ 106,126, 106,126, 106,126
+ };
+
+ init(l, 71, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly72(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {107,114, 101,110, 98,102, 105,97, 111,98, 119,102, 121,108, 118,112, 113,115
+ };
+
+ init(l, 72, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly73(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {148,106, 145,110, 146,116, 150,118, 152,111, 151,107
+ };
+
+ init(l, 73, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly74(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {80,55, 70,52, 75,58, 63,57, 72,61, 57,61, 67,66, 57,67, 62,69, 54,71,
+ 61,73, 54,77, 63,78, 53,85, 60,84, 56,90, 69,84, 63,82, 75,76, 70,75,
+ 77,72, 72,71, 78,69, 72,66, 81,67, 78,64, 82,63, 80,60, 86,62
+ };
+
+ init(l, 74, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly75(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {87,56, 91,52, 96,50, 102,56, 98,56, 92,60
+ };
+
+ init(l, 75, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly76(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {85,68, 89,73, 98,76, 106,74, 96,73, 91,70
+ };
+
+ init(l, 76, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly77(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {115,57, 114,64, 111,64, 115,75, 122,81, 122,74, 126,79,
+ 126,74, 131,78, 130,72, 133,77, 131,68, 126,61, 119,57
+ };
+
+ init(l, 77, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly78(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {145,48, 143,53, 147,59, 151,59, 150,55
+ };
+
+ init(l, 78, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly79(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {26,22, 34,15, 43,10, 52,10, 59,16, 47,15, 32,22
+ };
+
+ init(l, 79, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly80(struct lion *l)
+{
+ VGfloat color = 0xffe5b2;
+ static const VGfloat coords[] = {160,19, 152,26, 149,34, 154,33, 152,30, 157,30, 155,26, 158,27,
+ 157,23, 161,23
+ };
+
+ init(l, 80, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly81(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {98,117, 105,122, 109,122, 105,117, 113,120, 121,120, 130,112, 128,108,
+ 123,103, 123,99, 128,101, 132,106, 135,109, 142,105, 142,101, 145,101,
+ 145,91, 148,101, 145,105, 136,112, 135,116, 143,124, 148,120, 150,122,
+ 142,128, 133,122, 121,125, 112,126, 103,125, 100,129, 96,124
+ };
+
+ init(l, 81, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly82(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {146,118, 152,118, 152,115, 149,115
+ };
+
+ init(l, 82, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly83(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {148,112, 154,111, 154,109, 149,109
+ };
+
+ init(l, 83, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly84(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {106,112, 108,115, 114,116, 118,114
+ };
+
+ init(l, 84, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly85(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {108,108, 111,110, 116,110, 119,108
+ };
+
+ init(l, 85, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly86(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {106,104, 109,105, 117,106, 115,104
+ };
+
+ init(l, 86, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly87(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {50,25, 41,26, 34,33, 39,43, 49,58, 36,51, 47,68, 55,69, 54,59,
+ 61,57, 74,46, 60,52, 67,42, 57,48, 61,40, 54,45, 60,36, 59,29,
+ 48,38, 52,30, 47,32
+ };
+
+ init(l, 87, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly88(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {147,34, 152,41, 155,49, 161,53, 157,47, 164,47, 158,43, 168,44,
+ 159,40, 164,37, 169,37, 164,33, 169,34, 165,28, 170,30, 170,25,
+ 173,29, 175,27, 176,32, 173,36, 175,39, 172,42, 172,46, 168,49,
+ 170,55, 162,57, 158,63, 155,58, 153,50, 149,46
+ };
+
+ init(l, 88, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly89(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {155,71, 159,80, 157,93, 157,102, 155,108, 150,101, 149,93,
+ 154,101, 152,91, 151,83, 155,79
+ };
+
+ init(l, 89, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly90(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {112,78, 115,81, 114,91, 112,87, 113,82
+ };
+
+ init(l, 90, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly91(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {78,28, 64,17, 58,11, 47,9, 36,10, 28,16, 21,26, 18,41,
+ 20,51, 23,61, 33,65, 28,68, 37,74, 36,81, 43,87, 48,90,
+ 43,100, 40,98, 39,90, 31,80, 30,72, 22,71, 17,61, 14,46,
+ 16,28, 23,17, 33,9, 45,6, 54,6, 65,12
+ };
+
+ init(l, 91, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly92(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {67,18, 76,9, 87,5, 101,2, 118,3, 135,8, 149,20, 149,26,
+ 144,19, 132,12, 121,9, 105,7, 89,8, 76,14, 70,20
+ };
+
+ init(l, 92, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly93(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {56,98, 48,106, 56,103, 47,112, 56,110, 52,115, 57,113, 52,121, 62,115,
+ 58,123, 65,119, 63,125, 69,121, 68,127, 74,125, 74,129, 79,128, 83,132,
+ 94,135, 93,129, 85,127, 81,122, 76,126, 75,121, 71,124, 71,117, 66,121,
+ 66,117, 62,117, 64,112, 60,113, 60,110, 57,111, 61,105, 57,107, 60,101,
+ 55,102
+ };
+
+ init(l, 93, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly94(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {101,132, 103,138, 106,134, 106,139, 112,136, 111,142, 115,139,
+ 114,143, 119,142, 125,145, 131,142, 135,138, 140,134, 140,129,
+ 143,135, 145,149, 150,171, 149,184, 145,165, 141,150, 136,147,
+ 132,151, 131,149, 126,152, 125,150, 121,152, 117,148, 111,152,
+ 110,148, 105,149, 104,145, 98,150, 96,138, 94,132, 94,130, 98,132
+ };
+
+ init(l, 94, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly95(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {41,94, 32,110, 23,132, 12,163, 6,190, 7,217, 5,236,
+ 3,247, 9,230, 12,211, 12,185, 18,160, 26,134, 35,110,
+ 43,99
+ };
+
+ init(l, 95, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly96(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {32,246, 41,250, 50,257, 52,267, 53,295, 53,323, 59,350,
+ 54,363, 51,365, 44,366, 42,360, 40,372, 54,372, 59,366,
+ 62,353, 71,352, 75,335, 73,330, 66,318, 68,302, 64,294,
+ 67,288, 63,286, 63,279, 59,275, 58,267, 56,262, 50,247,
+ 42,235, 44,246, 32,236, 35,244
+ };
+
+ init(l, 96, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly97(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {134,324, 146,320, 159,322, 173,327, 179,337, 179,349,
+ 172,355, 158,357, 170,350, 174,343, 170,333, 163,328, 152,326,
+ 134,329
+ };
+
+ init(l, 97, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly98(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {173,339, 183,334, 184,338, 191,329, 194,332, 199,323, 202,325,
+ 206,318, 209,320, 213,309, 221,303, 228,296, 232,289, 234,279,
+ 233,269, 230,262, 225,256, 219,253, 208,252, 198,252, 210,249,
+ 223,250, 232,257, 237,265, 238,277, 238,291, 232,305, 221,323,
+ 218,335, 212,342, 200,349, 178,348
+ };
+
+ init(l, 98, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly99(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {165,296, 158,301, 156,310, 156,323, 162,324, 159,318,
+ 162,308, 162,304
+ };
+
+ init(l, 99, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly100(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {99,252, 105,244, 107,234, 115,228, 121,228, 131,235,
+ 122,233, 113,235, 109,246, 121,239, 133,243, 121,243,
+ 110,251
+ };
+
+ init(l, 100, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly101(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {117,252, 124,247, 134,249, 136,253, 126,252
+ };
+
+ init(l, 101, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly102(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {117,218, 132,224, 144,233, 140,225, 132,219, 117,218,
+ 117,218, 117,218
+ };
+
+ init(l, 102, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly103(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {122,212, 134,214, 143,221, 141,213, 132,210
+ };
+
+ init(l, 103, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly104(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {69,352, 70,363, 76,373, 86,378, 97,379, 108,379, 120,377,
+ 128,378, 132,373, 135,361, 133,358, 132,366, 127,375, 121,374,
+ 121,362, 119,367, 117,374, 110,376, 110,362, 107,357, 106,371,
+ 104,375, 97,376, 90,375, 90,368, 86,362, 83,364, 86,369, 85,373,
+ 78,370, 73,362, 71,351
+ };
+
+ init(l, 104, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly105(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {100,360, 96,363, 99,369, 102,364
+ };
+
+ init(l, 105, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly106(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {115,360, 112,363, 114,369, 117,364
+ };
+
+ init(l, 106, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly107(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {127,362, 125,364, 126,369, 128,365
+ };
+
+ init(l, 107, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly108(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {5,255, 7,276, 11,304, 15,320, 13,334, 6,348, 2,353, 0,363,
+ 5,372, 12,374, 25,372, 38,372, 44,369, 42,367, 36,368, 31,369,
+ 30,360, 27,368, 20,370, 16,361, 15,368, 10,369, 3,366, 3,359, 6,352,
+ 11,348, 17,331, 19,316, 12,291, 9,274
+ };
+
+ init(l, 108, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly109(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {10,358, 7,362, 10,366, 11,362
+ };
+
+ init(l, 109, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly110(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {25,357, 22,360, 24,366, 27,360
+ };
+
+ init(l, 110, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly111(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {37,357, 34,361, 36,365, 38,361
+ };
+
+ init(l, 111, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly112(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {49,356, 46,359, 47,364, 50,360
+ };
+
+ init(l, 112, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly113(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {130,101, 132,102, 135,101, 139,102, 143,103,
+ 142,101, 137,100, 133,100
+ };
+
+ init(l, 113, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly114(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {106,48, 105,52, 108,56, 109,52
+ };
+
+ init(l, 114, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly115(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {139,52, 139,56, 140,60, 142,58, 141,56
+ };
+
+ init(l, 115, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly116(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {25,349, 29,351, 30,355, 33,350, 37,348, 42,351, 45,347,
+ 49,345, 44,343, 36,345
+ };
+
+ init(l, 116, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly117(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {98,347, 105,351, 107,354, 109,349, 115,349, 120,353, 118,349,
+ 113,346, 104,346
+ };
+
+ init(l, 117, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly118(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {83,348, 87,352, 87,357, 89,351, 87,348
+ };
+
+ init(l, 118, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly119(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {155,107, 163,107, 170,107, 186,108, 175,109, 155,109
+ };
+
+ init(l, 119, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly120(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {153,114, 162,113, 175,112, 192,114, 173,114, 154,115
+ };
+
+ init(l, 120, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly121(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {152,118, 164,120, 180,123, 197,129, 169,123, 151,120
+ };
+
+ init(l, 121, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly122(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {68,109, 87,106, 107,106, 106,108, 88,108
+ };
+
+ init(l, 122, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly123(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {105,111, 95,112, 79,114, 71,116, 85,115, 102,113
+ };
+
+ init(l, 123, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly124(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {108,101, 98,99, 87,99, 78,99, 93,100, 105,102
+ };
+
+ init(l, 124, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly125(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {85,63, 91,63, 97,60, 104,60, 108,62, 111,69, 112,75,
+ 110,74, 108,71, 103,73, 106,69, 105,65, 103,64, 103,67,
+ 102,70, 99,70, 97,66, 94,67, 97,72, 88,67, 84,66
+ };
+
+ init(l, 125, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly126(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {140,74, 141,66, 144,61, 150,61, 156,62, 153,70, 150,73,
+ 152,65, 150,65, 151,68, 149,71, 146,71, 144,66, 143,70,
+ 143,74
+ };
+
+ init(l, 126, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly127(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {146,20, 156,11, 163,9, 172,9, 178,14, 182,18, 184,32, 182,42,
+ 182,52, 177,58, 176,67, 171,76, 165,90, 157,105, 160,92, 164,85,
+ 168,78, 167,73, 173,66, 172,62, 175,59, 174,55, 177,53, 180,46,
+ 181,29, 179,21, 173,13, 166,11, 159,13, 153,18, 148,23
+ };
+
+ init(l, 127, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly128(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {150,187, 148,211, 150,233, 153,247, 148,267, 135,283, 125,299,
+ 136,292, 131,313, 122,328, 122,345, 129,352, 133,359, 133,367,
+ 137,359, 148,356, 140,350, 131,347, 129,340, 132,332, 140,328,
+ 137,322, 140,304, 154,265, 157,244, 155,223, 161,220, 175,229,
+ 186,247, 185,260, 176,275, 178,287, 185,277, 188,261, 196,253,
+ 189,236, 174,213
+ };
+
+ init(l, 128, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly129(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {147,338, 142,341, 143,345, 141,354, 147,343
+ };
+
+ init(l, 129, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly130(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {157,342, 156,349, 150,356, 157,353, 163,346, 162,342
+ };
+
+ init(l, 130, color, coords, ELEMENTS(coords)/2);
+}
+
+static void poly131(struct lion *l)
+{
+ VGfloat color = 0x000000;
+ static const VGfloat coords[] = {99,265, 96,284, 92,299, 73,339, 73,333, 87,300
+ };
+
+ init(l, 131, color, coords, ELEMENTS(coords)/2);
+}
+
+
+struct lion * lion_create(void)
+{
+ struct lion *l = calloc(1, sizeof(struct lion));
+
+ poly0(l);
+ poly1(l);
+ poly2(l);
+ poly3(l);
+ poly4(l);
+ poly5(l);
+ poly6(l);
+ poly7(l);
+ poly8(l);
+ poly9(l);
+
+ poly10(l);
+ poly11(l);
+ poly12(l);
+ poly13(l);
+ poly14(l);
+ poly15(l);
+ poly16(l);
+ poly17(l);
+ poly18(l);
+ poly19(l);
+
+ poly20(l);
+ poly21(l);
+ poly22(l);
+ poly23(l);
+ poly24(l);
+ poly25(l);
+ poly26(l);
+ poly27(l);
+ poly28(l);
+ poly29(l);
+
+ poly30(l);
+ poly31(l);
+ poly32(l);
+ poly33(l);
+ poly34(l);
+ poly35(l);
+ poly36(l);
+ poly37(l);
+ poly38(l);
+ poly39(l);
+
+ poly40(l);
+ poly41(l);
+ poly42(l);
+ poly43(l);
+ poly44(l);
+ poly45(l);
+ poly46(l);
+ poly47(l);
+ poly48(l);
+ poly49(l);
+
+ poly50(l);
+ poly51(l);
+ poly52(l);
+ poly53(l);
+ poly54(l);
+ poly55(l);
+ poly56(l);
+ poly57(l);
+ poly58(l);
+ poly59(l);
+
+ poly60(l);
+ poly61(l);
+ poly62(l);
+ poly63(l);
+ poly64(l);
+ poly65(l);
+ poly66(l);
+ poly67(l);
+ poly68(l);
+ poly69(l);
+
+ poly70(l);
+ poly71(l);
+ poly72(l);
+ poly73(l);
+ poly74(l);
+ poly75(l);
+ poly76(l);
+ poly77(l);
+ poly78(l);
+ poly79(l);
+
+ poly80(l);
+ poly81(l);
+ poly82(l);
+ poly83(l);
+ poly84(l);
+ poly85(l);
+ poly86(l);
+ poly87(l);
+ poly88(l);
+ poly89(l);
+
+ poly90(l);
+ poly91(l);
+ poly92(l);
+ poly93(l);
+ poly94(l);
+ poly95(l);
+ poly96(l);
+ poly97(l);
+ poly98(l);
+ poly99(l);
+
+ poly100(l);
+ poly101(l);
+ poly102(l);
+ poly103(l);
+ poly104(l);
+ poly105(l);
+ poly106(l);
+ poly107(l);
+ poly108(l);
+ poly109(l);
+
+ poly110(l);
+ poly111(l);
+ poly112(l);
+ poly113(l);
+ poly114(l);
+ poly115(l);
+ poly116(l);
+ poly117(l);
+ poly118(l);
+ poly119(l);
+
+ poly120(l);
+ poly121(l);
+ poly122(l);
+ poly123(l);
+ poly124(l);
+ poly125(l);
+ poly126(l);
+ poly127(l);
+ poly128(l);
+ poly129(l);
+
+ poly130(l);
+ poly131(l);
+
+ return l;
+}
+
+void lion_render(struct lion *l)
+{
+ VGint i;
+
+ for (i = 0; i < LION_SIZE; ++i) {
+ vgSetPaint(l->fills[i], VG_FILL_PATH);
+ vgDrawPath(l->paths[i], VG_FILL_PATH);
+ }
+}
+
+void lion_destroy(struct lion *l)
+{
+ VGint i;
+ for (i = 0; i < LION_SIZE; ++i) {
+ vgDestroyPaint(l->fills[i]);
+ vgDestroyPath(l->paths[i]);
+ }
+ free(l);
+}
diff --git a/progs/openvg/demos/lion-render.h b/progs/openvg/demos/lion-render.h
new file mode 100644
index 00000000000..c4c020b7edd
--- /dev/null
+++ b/progs/openvg/demos/lion-render.h
@@ -0,0 +1,16 @@
+#ifndef LION_RENDER_H
+#define LION_RENDER_H
+
+#include
+
+#define LION_SIZE 132
+struct lion {
+ VGPath paths[LION_SIZE];
+ VGPaint fills[LION_SIZE];
+};
+
+struct lion *lion_create(void);
+void lion_render(struct lion *l);
+void lion_destroy(struct lion *l);
+
+#endif
diff --git a/progs/openvg/demos/lion.c b/progs/openvg/demos/lion.c
new file mode 100644
index 00000000000..7224fed399d
--- /dev/null
+++ b/progs/openvg/demos/lion.c
@@ -0,0 +1,288 @@
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "lion-render.h"
+
+static VGint width, height;
+struct lion *lion = 0;
+VGfloat angle = 0;
+
+static void
+draw(void)
+{
+ vgClear(0, 0, width, height);
+
+ vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
+ vgLoadIdentity();
+ vgTranslate(width/2, height/2);
+ vgRotate(angle);
+ vgTranslate(-width/2, -height/2);
+
+ lion_render(lion);
+
+ ++angle;
+}
+
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+ width = w;
+ height = h;
+}
+
+
+static void
+init(void)
+{
+ float clear_color[4] = {1.0, 1.0, 1.0, 1.0};
+ vgSetfv(VG_CLEAR_COLOR, 4, clear_color);
+
+ lion = lion_create();
+}
+
+
+/*
+ * 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) {
+ XEvent event;
+
+ while (XPending(dpy) > 0) {
+ XNextEvent(dpy, &event);
+
+ switch (event.type) {
+ case Expose:
+ break;
+ case ConfigureNotify:
+ reshape(event.xconfigure.width, event.xconfigure.height);
+ break;
+ case KeyPress:
+ {
+ char buffer[10];
+ int r, code;
+ code = XLookupKeysym(&event.xkey, 0);
+ r = XLookupString(&event.xkey, buffer, sizeof(buffer),
+ NULL, NULL);
+ if (buffer[0] == 27) {
+ /* escape */
+ return;
+ }
+ }
+ break;
+ default:
+ ; /*no-op*/
+ }
+ }
+
+ draw();
+ eglSwapBuffers(egl_dpy, egl_surf);
+ }
+}
+
+
+static void
+usage(void)
+{
+ printf("Usage:\n");
+ printf(" -display set the display to run on\n");
+ printf(" -info display OpenGL renderer info\n");
+}
+
+int
+main(int argc, char *argv[])
+{
+ const int winWidth = 350, winHeight = 450;
+ 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;
+
+ 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;
+ }
+ else {
+ usage();
+ return -1;
+ }
+ }
+
+ 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,
+ "Lion 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));
+ }
+
+ init();
+
+ /* Set initial projection/viewing transformation.
+ * We can't be sure we'll get a ConfigureNotify event when the window
+ * first appears.
+ */
+ reshape(winWidth, winHeight);
+
+ event_loop(x_dpy, win, egl_dpy, egl_surf);
+
+ 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/demos/sp.c b/progs/openvg/demos/sp.c
new file mode 100644
index 00000000000..424ec47d69e
--- /dev/null
+++ b/progs/openvg/demos/sp.c
@@ -0,0 +1,537 @@
+#include "eglcommon.h"
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+
+#define ELEMENTS(x) (sizeof(x)/sizeof((x)[0]))
+
+struct object {
+ VGPath path;
+ VGPaint fill;
+ VGPaint stroke;
+ VGint draw_mode;
+ VGfloat matrix[9];
+ VGfloat stroke_width;
+};
+
+struct character {
+ struct object objects[32];
+ VGint num_objects;
+};
+VGfloat identity_matrix[] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
+
+struct character cartman;
+
+static void add_object_fill(const VGubyte *segments, VGint num_segments,
+ const VGfloat *coords,
+ VGuint color)
+{
+ struct object object;
+
+ object.path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
+ 1, 0, 0, 0, VG_PATH_CAPABILITY_ALL);
+ vgAppendPathData(object.path, num_segments, segments, coords);
+
+ object.fill = vgCreatePaint();
+ vgSetColor(object.fill, color);
+ memcpy(object.matrix, identity_matrix, 9 * sizeof(VGfloat));
+ object.draw_mode = VG_FILL_PATH;
+
+ cartman.objects[cartman.num_objects] = object;
+ ++cartman.num_objects;
+}
+
+
+static void add_object_stroke(const VGubyte *segments, VGint num_segments,
+ const VGfloat *coords,
+ VGuint color, VGfloat width)
+{
+ struct object object;
+
+ object.path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
+ 1, 0, 0, 0, VG_PATH_CAPABILITY_ALL);
+ vgAppendPathData(object.path, num_segments, segments, coords);
+
+ object.stroke = vgCreatePaint();
+ vgSetColor(object.stroke, color);
+ memcpy(object.matrix, identity_matrix, 9 * sizeof(VGfloat));
+ object.draw_mode = VG_STROKE_PATH;
+ object.stroke_width = width;
+
+ cartman.objects[cartman.num_objects] = object;
+ ++cartman.num_objects;
+}
+
+
+static void add_object_fillm(const VGubyte *segments, VGint num_segments,
+ const VGfloat *coords,
+ VGuint color,
+ VGfloat *matrix)
+{
+ struct object object;
+
+ object.path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
+ 1, 0, 0, 0, VG_PATH_CAPABILITY_ALL);
+ vgAppendPathData(object.path, num_segments, segments, coords);
+
+ object.fill = vgCreatePaint();
+ vgSetColor(object.fill, color);
+ memcpy(object.matrix, matrix, 9 * sizeof(VGfloat));
+ object.draw_mode = VG_FILL_PATH;
+
+ cartman.objects[cartman.num_objects] = object;
+ ++cartman.num_objects;
+}
+
+
+static void add_object_m(const VGubyte *segments, VGint num_segments,
+ const VGfloat *coords,
+ VGuint fill_color,
+ VGuint stroke_color, VGfloat stroke_width,
+ VGfloat *matrix)
+{
+ struct object object;
+
+ object.path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
+ 1, 0, 0, 0, VG_PATH_CAPABILITY_ALL);
+ vgAppendPathData(object.path, num_segments, segments, coords);
+ memcpy(object.matrix, matrix, 9 * sizeof(VGfloat));
+
+ object.fill = vgCreatePaint();
+ vgSetColor(object.fill, fill_color);
+ object.draw_mode = VG_FILL_PATH | VG_STROKE_PATH;
+
+ object.stroke = vgCreatePaint();
+ vgSetColor(object.stroke, stroke_color);
+ object.stroke_width = stroke_width;
+
+ cartman.objects[cartman.num_objects] = object;
+ ++cartman.num_objects;
+}
+
+static void init_character()
+{
+ {
+ const VGubyte segments[] = {VG_MOVE_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_CLOSE_PATH};
+ const VGfloat coords[] = {181.83267, 102.60408,
+ 181.83267,102.60408, 185.53793,114.5749, 186.5355,115.00243,
+ 187.53306,115.42996, 286.0073,115.00243, 286.0073,115.00243,
+ 286.0073,115.00243, 292.70526,103.45914, 290.85263,101.03648,
+ 289.00001,98.61381, 181.54765,102.31906, 181.83267,102.60408
+ };
+ VGuint color = 0x7c4e32ff;
+ add_object_fill(segments, ELEMENTS(segments),
+ coords, color);
+ }
+ {
+ const VGubyte segments[] = {
+ VG_MOVE_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_LINE_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_CLOSE_PATH
+ };
+ const VGfloat coords[] = {188.62208,50.604156,
+ 188.62208,50.604156, 176.73127,60.479579, 170.68509,69.548844,
+ 164.63892,78.618109, 175.11895,79.827344, 175.11895,79.827344,
+ 176.52973,98.368952,
+ 176.52973,98.368952, 189.83131,110.05823, 208.97754,110.25976,
+ 228.12377,110.46131, 244.24691,111.67054, 247.06846,110.25976,
+ 249.89,108.849, 258.95927,106.8336, 260.16851,105.01975,
+ 261.37774,103.2059, 296.84865,106.43053, 297.05019,91.919698,
+ 297.25172,77.408874, 306.11945,64.308824, 282.13628,51.611853,
+ 258.15311,38.914882, 189.2267,49.999539, 188.62208,50.604156
+ };
+
+ VGuint color = 0xe30000ff;
+ add_object_fill(segments, ELEMENTS(segments),
+ coords, color);
+ }
+ {
+ const VGubyte segments[] = {
+ VG_MOVE_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS,
+ VG_CLOSE_PATH
+ };
+ const VGfloat coords[] = {
+ 68.25, 78.875,
+ 68.25,93.296, 54.642,105, 37.875,105,
+ 21.108,105, 7.5,93.296, 7.5,78.875,
+ 7.5,64.454, 21.108,52.75, 37.875,52.75,
+ 54.642,52.75, 68.25,64.454, 68.25,78.875
+ };
+
+ VGuint color = 0xffe1c4ff;
+ VGfloat matrix[] = {
+ 1.6529, 0, 0,
+ 0, 1.582037, 0,
+ 172.9649,-90.0116, 1
+ };
+ add_object_fillm(segments, ELEMENTS(segments),
+ coords, color, matrix);
+ }
+ {
+ const VGubyte segments[] = {
+ VG_MOVE_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS, VG_CLOSE_PATH
+ };
+ const VGfloat coords[] = {
+ 170.14687,71.536958,
+ 173.53626,68.814326, 176.70232,68.971782, 180.55009,71.679467,
+ 184.39785,74.387153, 199.19294,80.036105, 191.52334,86.500482,
+ 189.02942,88.6025, 183.97032,85.787933, 180.26507,86.928011,
+ 178.8737,87.356121, 174.71827,89.783259, 171.8028,87.494856,
+ 166.95426,83.689139, 163.51779,76.861986, 170.14687,71.536958
+ };
+
+ VGuint color = 0xfff200ff;
+ add_object_fill(segments, ELEMENTS(segments),
+ coords, color);
+ }
+ {
+ const VGubyte segments[] = {
+ VG_MOVE_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS, VG_CLOSE_PATH
+ };
+ const VGfloat coords[] = {
+ 299.83075,66.834136,
+ 299.83075,66.834136, 287.85993,64.69649, 284.15467,72.962055,
+ 280.44942,81.227621, 280.1644,78.234916, 280.1644,79.374994,
+ 280.1644,80.515072, 278.16927,84.077816, 284.86722,83.792796,
+ 291.56518,83.507777, 291.99271,86.785501, 294.84291,86.642991,
+ 297.6931,86.500482, 303.536,85.645423, 303.67851,80.657582,
+ 303.82102,75.66974, 302.68094,65.551548, 299.83075,66.834136
+ };
+
+ VGuint color = 0xfff200ff;
+ add_object_fill(segments, ELEMENTS(segments),
+ coords, color);
+ }
+ {
+ const VGubyte segments[] = {
+ VG_MOVE_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS
+ };
+ const VGfloat coords[] = {
+ 240.83171,75.81225,
+ 240.83171,75.81225, 241.54426,88.495618, 242.25681,91.488323,
+ 242.96936,94.481028, 240.6892,108.01945, 240.83171,110.01459,
+ 240.97422,112.00973, 240.97422,111.01216, 240.97422,111.01216
+ };
+ VGuint color = 0x000000ff;
+ VGfloat swidth = 1.14007807;
+ add_object_stroke(segments, ELEMENTS(segments), coords, color, swidth);
+ }
+ {
+ const VGubyte segments[] = {
+ VG_MOVE_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_CLOSE_PATH
+ };
+ const VGfloat coords[] = {
+ 83.375, 95.5,
+ 83.375,96.121, 83.067,96.625, 82.6875,96.625,
+ 82.308,96.625, 82,96.121, 82,95.5,
+ 82,94.879, 82.308,94.375, 82.6875,94.375,
+ 83.066677,94.375, 83.374492,94.878024, 83.374999,95.498494,
+ 82.6875,95.5,
+ 83.375,95.5
+ };
+ VGuint fill_color = 0x000000ff;
+ VGuint stroke_color = 0x000000ff;
+ VGfloat swidth = 0.60000002;
+ VGfloat matrix1[] = {
+ 1.140078, 0, 0,
+ 0, 1.140078, 0,
+ 145.4927, -15.10897, 1
+ };
+ VGfloat matrix2[] = {
+ 1.140078,0, 0,
+ 0,1.140078, 0,
+ 144.2814,-27.93485, 1
+ };
+ VGfloat matrix3[] = {
+ 1.140078,0, 0,
+ 0,1.140078, 0,
+ 144.1388,-3.70819, 1
+ };
+ add_object_m(segments, ELEMENTS(segments), coords,
+ fill_color, stroke_color, swidth, matrix1);
+ add_object_m(segments, ELEMENTS(segments), coords,
+ fill_color, stroke_color, swidth, matrix2);
+ add_object_m(segments, ELEMENTS(segments), coords,
+ fill_color, stroke_color, swidth, matrix3);
+ }
+ {
+ const VGubyte segments[] = {
+ VG_MOVE_TO_ABS,
+ VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS,
+ VG_LINE_TO_ABS, VG_CLOSE_PATH
+ };
+ const VGfloat coords[] = {
+ 179.41001,115.28745,
+ 179.41001,115.28745, 207.48443,109.30204, 236.84144,115.14494,
+ 236.84144,115.14494, 274.74903,109.87208, 291.8502,115.42996,
+ 179.41001,115.28745
+ };
+
+ VGuint color = 0x000000ff;
+ add_object_fill(segments, ELEMENTS(segments),
+ coords, color);
+ }
+ {
+ const VGubyte segments[] = {
+ VG_MOVE_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_CLOSE_PATH
+ };
+ const VGfloat coords[] = {
+ 83.792156,68.157364,
+ 83.792156,69.669865, 82.72301,70.897403, 81.40567,70.897403,
+ 80.08833,70.897403, 79.019185,69.669865, 79.019185,68.157364,
+ 79.019185,66.644862, 80.08833,65.417325, 81.40567,65.417325,
+ 82.721887,65.417325, 83.790391,66.642485, 83.792153,68.153696,
+ 81.40567,68.157364,
+ 83.792156,68.157364
+ };
+ VGuint fill_color = 0x000000ff;
+ VGuint stroke_color = 0x000000ff;
+ VGfloat swidth = 0.52891117;
+ VGfloat matrix1[] = {
+ 1.140078,0, 0,
+ 0,1.140078, 0,
+ 145.2489,-15.58714, 1
+ };
+ add_object_m(segments, ELEMENTS(segments), coords,
+ fill_color, stroke_color, swidth, matrix1);
+ }
+ {
+ const VGubyte segments[] = {
+ VG_MOVE_TO_ABS, VG_CUBIC_TO_ABS
+ };
+ const VGfloat coords[] = {
+ 232.28113,66.976646,
+ 232.28113,66.976646, 237.98152,70.539389, 245.39202,66.549116
+ };
+ VGuint color = 0x000000ff;
+ VGfloat swidth = 0.60299999;
+ add_object_stroke(segments, ELEMENTS(segments), coords, color, swidth);
+ }
+ {
+ const VGubyte segments[] = {
+ VG_MOVE_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS, VG_CLOSE_PATH
+ };
+ const VGfloat coords[] = {
+ 185.96908,30.061986,
+ 185.96908,30.061986, 187.76995,14.508377, 203.23909,3.7427917,
+ 209.95028,-0.92779696, 219.37764,-4.9841866, 232.1078,-6.00046,
+ 246.13578,-7.1203411, 256.92106,-2.8560739, 264.81774,1.9451947,
+ 280.60485,11.543934, 284.31582,25.937274, 284.08015,26.526452,
+ 283.7266,27.410336, 240.83461,1.9346323, 185.96908,30.061986
+ };
+ VGuint color = 0x8ed8f8ff;
+ add_object_fill(segments, ELEMENTS(segments), coords, color);
+ }
+ {
+ const VGubyte segments[] = {
+ VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_CUBIC_TO_ABS,
+ VG_LINE_TO_ABS, VG_CUBIC_TO_ABS, VG_CLOSE_PATH
+ };
+ const VGfloat coords[] = {
+ 185.39542,32.061757,
+ 185.82295,29.211562,
+ 185.82295,29.211562, 234.70379,2.277219, 284.01217,25.078779,
+ 284.86722,27.643954,
+ 284.86722,27.643954, 236.69893,4.5573746, 185.39542,32.061757
+ };
+ VGuint color = 0xfff200ff;
+ add_object_fill(segments, ELEMENTS(segments), coords, color);
+ }
+
+ {
+ const VGubyte segments[] = {
+ VG_MOVE_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS, VG_CLOSE_PATH
+ };
+ const VGfloat coords[] = {
+ 219.74027,-5.917093,
+ 220.49206,-8.44929, 225.15564,-10.904934, 230.21473,-11.189954,
+ 235.27383,-11.474973, 243.27521,-13.287236, 249.21385,-5.724198,
+ 249.89961,-4.850868, 249.28247,-4.332166, 248.62298,-3.971398,
+ 247.79117,-3.516361, 247.13703,-3.392737, 246.16222,-3.408047,
+ 243.63973,-3.447664, 242.54183,-3.850701, 242.54183,-3.850701,
+ 242.54183,-3.850701, 238.78367,-1.737343, 236.20014,-3.565682,
+ 233.88436,-5.204544, 234.27626,-4.56325, 234.27626,-4.56325,
+ 234.27626,-4.56325, 232.33303,-2.975658, 230.85603,-2.995643,
+ 228.59433,-3.025282, 227.73672,-4.501857, 227.21966,-4.93027,
+ 226.76318,-4.932008, 226.50948,-4.491995, 226.50948,-4.491995,
+ 226.50948,-4.491995, 224.53199,-2.085883, 222.51431,-2.467064,
+ 221.48814,-2.66093, 218.91968,-3.15318, 219.74027,-5.917093
+ };
+ VGuint color = 0xfff200ff;
+ add_object_fill(segments, ELEMENTS(segments), coords, color);
+ }
+ {
+ const VGubyte segments[] = {
+ VG_MOVE_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS, VG_CLOSE_PATH
+ };
+ const VGfloat coords[] = {
+ 178.97347,166.06432,
+ 178.97347,181.2154, 168.0245,193.51193, 154.53381,193.51193,
+ 141.04312,193.51193, 130.09416,181.2154, 130.09416,166.06432,
+ 130.09416,150.91323, 141.04312,138.6167, 154.53381,138.6167,
+ 168.0245,138.6167, 178.97347,150.91323, 178.97347,166.06432
+ };
+ VGuint color = 0xffffffff;
+ VGfloat matrix1[] = {
+ 0.466614,-0.23492, 0,
+ 0.108683,0.436638, 0,
+ 134.5504,-0.901632, 1
+ };
+ VGfloat matrix2[] = {
+ -0.466614,-0.23492, 0,
+ -0.108683,0.436638, 0,
+ 338.4496,-0.512182, 1
+ };
+ add_object_fillm(segments, ELEMENTS(segments), coords, color, matrix1);
+ add_object_fillm(segments, ELEMENTS(segments), coords, color, matrix2);
+ }
+ {
+ const VGubyte segments[] = {
+ VG_MOVE_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS,
+ VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS, VG_CLOSE_PATH
+ };
+ const VGfloat coords[] = {
+ 123.82758,165.06168,
+ 123.82758,166.79125, 122.59232,168.19497, 121.07029,168.19497,
+ 119.54826,168.19497, 118.313,166.79125, 118.313,165.06168,
+ 118.313,163.3321, 119.54826,161.92839, 121.07029,161.92839,
+ 122.59232,161.92839, 123.82758,163.3321, 123.82758,165.06168
+ };
+ VGuint color = 0x000000ff;
+ VGfloat matrix1[] = {
+ 0.525719,0, 0,
+ 0,0.479931, 0,
+ 178.9702,-43.3532, 1
+ };
+ VGfloat matrix2[] = {
+ 0.525719,0, 0,
+ 0,0.479931, 0,
+ 165.258,-43.46162, 1
+ };
+ add_object_fillm(segments, ELEMENTS(segments), coords, color, matrix1);
+ add_object_fillm(segments, ELEMENTS(segments), coords, color, matrix2);
+ }
+ {
+ const VGubyte segments[] = {
+ VG_MOVE_TO_ABS, VG_CUBIC_TO_ABS, VG_CUBIC_TO_ABS
+ };
+ const VGfloat coords[] = {
+ 197.25,54.5,
+ 197.25,54.5, 211.75,71.5, 229.25,71.5,
+ 246.75,71.5, 261.74147,71.132714, 277.75,50.75
+ };
+ VGuint color = 0x000000ff;
+ VGfloat swidth = 0.60299999;
+ add_object_stroke(segments, ELEMENTS(segments), coords, color, swidth);
+ }
+}
+
+
+static void
+init(void)
+{
+ float clear_color[4] = {1.0, 1.0, 1.0, 1.0};
+ vgSetfv(VG_CLEAR_COLOR, 4, clear_color);
+
+ init_character();
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+static int
+key_press(unsigned key)
+{
+ switch(key) {
+ case XK_Right:
+
+ break;
+ case XK_Left:
+ break;
+ case XK_Up:
+ break;
+ case XK_Down:
+ break;
+ case 'a':
+ break;
+ case 's':
+ break;
+ default:
+ break;
+ }
+ return VG_FALSE;
+}
+
+static void
+draw(void)
+{
+ VGint i;
+ VGfloat save_matrix[9];
+
+ vgClear(0, 0, window_width(), window_height());
+
+ vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
+ vgLoadIdentity();
+ vgScale(2, 2);
+ vgTranslate(160, 60);
+ vgRotate(180);
+ vgTranslate(-160, -100);
+ vgGetMatrix(save_matrix);
+ for (i = 0; i < cartman.num_objects; ++i) {
+ struct object object = cartman.objects[i];
+ if ((object.draw_mode & VG_STROKE_PATH)) {
+ vgSetf(VG_STROKE_LINE_WIDTH, object.stroke_width);
+ vgSetPaint(object.stroke, VG_STROKE_PATH);
+ }
+ if ((object.draw_mode & VG_FILL_PATH))
+ vgSetPaint(object.fill, VG_FILL_PATH);
+ vgMultMatrix(object.matrix);
+ vgDrawPath(object.path, object.draw_mode);
+ vgLoadMatrix(save_matrix);
+ }
+
+ vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+ set_window_size(400, 400);
+ return run(argc, argv, init, reshape, draw, key_press);
+}
diff --git a/progs/openvg/trivial/Makefile b/progs/openvg/trivial/Makefile
new file mode 100644
index 00000000000..362360e5963
--- /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 -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 00000000000..db686bea6b0
--- /dev/null
+++ b/progs/openvg/trivial/arc.c
@@ -0,0 +1,139 @@
+#include "eglcommon.h"
+
+#include
+#include
+
+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 00000000000..cd84fe3ac00
--- /dev/null
+++ b/progs/openvg/trivial/cap.c
@@ -0,0 +1,75 @@
+#include "eglcommon.h"
+
+#include
+
+#include
+#include
+#include
+
+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 00000000000..efb6bf41820
--- /dev/null
+++ b/progs/openvg/trivial/clear.c
@@ -0,0 +1,42 @@
+#include "eglcommon.h"
+
+#include
+#include
+
+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 00000000000..81f7cb6fc9e
--- /dev/null
+++ b/progs/openvg/trivial/coord.c
@@ -0,0 +1,66 @@
+#include "eglcommon.h"
+
+#include
+
+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 00000000000..2e84ddbd4ea
--- /dev/null
+++ b/progs/openvg/trivial/dash.c
@@ -0,0 +1,95 @@
+#include "eglcommon.h"
+
+#include
+#include
+#include
+
+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 00000000000..bacd5685d75
--- /dev/null
+++ b/progs/openvg/trivial/eglcommon.c
@@ -0,0 +1,288 @@
+#include "eglcommon.h"
+
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include /* using full OpenGL for now */
+#include
+
+
+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 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 00000000000..958dae9f98d
--- /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 00000000000..4c7d4904f81
--- /dev/null
+++ b/progs/openvg/trivial/ellipse.c
@@ -0,0 +1,84 @@
+#include "eglcommon.h"
+
+#include
+
+#include
+#include
+
+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 00000000000..d96257a9335
--- /dev/null
+++ b/progs/openvg/trivial/filter.c
@@ -0,0 +1,107 @@
+#include "eglcommon.h"
+
+#include
+
+#include
+#include
+#include
+
+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 00000000000..b376263fe5c
--- /dev/null
+++ b/progs/openvg/trivial/gradorigin.c
@@ -0,0 +1,98 @@
+#include "eglcommon.h"
+
+#include
+
+#include
+#include
+
+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 00000000000..94e29818116
--- /dev/null
+++ b/progs/openvg/trivial/lineto.c
@@ -0,0 +1,56 @@
+#include "eglcommon.h"
+
+#include
+
+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 00000000000..bcaad1f1015
--- /dev/null
+++ b/progs/openvg/trivial/lingrad.c
@@ -0,0 +1,87 @@
+#include "eglcommon.h"
+
+#include
+
+#include
+#include
+
+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 00000000000..a103ba44888
--- /dev/null
+++ b/progs/openvg/trivial/lookup.c
@@ -0,0 +1,71 @@
+#include "eglcommon.h"
+
+#include
+
+#include
+#include
+#include
+
+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
+
+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 00000000000..fe6db39648c
--- /dev/null
+++ b/progs/openvg/trivial/mask4.c
@@ -0,0 +1,132 @@
+#include "eglcommon.h"
+
+#include
+#include
+#include
+#include
+#include
+
+#include
+
+//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 00000000000..5ce600f65aa
--- /dev/null
+++ b/progs/openvg/trivial/path3.c
@@ -0,0 +1,77 @@
+#include "eglcommon.h"
+
+#include
+#include
+#include
+#include
+#include