;;; GL ;;; ;;; Copyright (C) 2004 Philippe Brochard (hocwp@free.fr) ;;; ;;; #date#: Tue Feb 1 20:18:57 2005 ;;; ;;; The authors grant you the rights to distribute ;;; and use this software as governed by the terms ;;; of the Lisp Lesser GNU Public License ;;; (http://opensource.franz.com/preamble.html), ;;; known as the LLGPL. (in-package :GL) (export '(__glu_h__ GLU_EXT_object_space_tess GLU_EXT_nurbs_tessellator GLU_FALSE GLU_TRUE GLU_VERSION_1_1 GLU_VERSION_1_2 GLU_VERSION_1_3 GLU_VERSION GLU_EXTENSIONS GLU_INVALID_ENUM GLU_INVALID_VALUE GLU_OUT_OF_MEMORY GLU_INVALID_OPERATION GLU_OUTLINE_POLYGON GLU_OUTLINE_PATCH GLU_NURBS_ERROR GLU_ERROR GLU_NURBS_BEGIN GLU_NURBS_BEGIN_EXT GLU_NURBS_VERTEX GLU_NURBS_VERTEX_EXT GLU_NURBS_NORMAL GLU_NURBS_NORMAL_EXT GLU_NURBS_COLOR GLU_NURBS_COLOR_EXT GLU_NURBS_TEXTURE_COORD GLU_NURBS_TEX_COORD_EXT GLU_NURBS_END GLU_NURBS_END_EXT GLU_NURBS_BEGIN_DATA GLU_NURBS_BEGIN_DATA_EXT GLU_NURBS_VERTEX_DATA GLU_NURBS_VERTEX_DATA_EXT GLU_NURBS_NORMAL_DATA GLU_NURBS_NORMAL_DATA_EXT GLU_NURBS_COLOR_DATA GLU_NURBS_COLOR_DATA_EXT GLU_NURBS_TEXTURE_COORD_DATA GLU_NURBS_TEX_COORD_DATA_EXT GLU_NURBS_END_DATA GLU_NURBS_END_DATA_EXT GLU_NURBS_ERROR1 GLU_NURBS_ERROR2 GLU_NURBS_ERROR3 GLU_NURBS_ERROR4 GLU_NURBS_ERROR5 GLU_NURBS_ERROR6 GLU_NURBS_ERROR7 GLU_NURBS_ERROR8 GLU_NURBS_ERROR9 GLU_NURBS_ERROR10 GLU_NURBS_ERROR11 GLU_NURBS_ERROR12 GLU_NURBS_ERROR13 GLU_NURBS_ERROR14 GLU_NURBS_ERROR15 GLU_NURBS_ERROR16 GLU_NURBS_ERROR17 GLU_NURBS_ERROR18 GLU_NURBS_ERROR19 GLU_NURBS_ERROR20 GLU_NURBS_ERROR21 GLU_NURBS_ERROR22 GLU_NURBS_ERROR23 GLU_NURBS_ERROR24 GLU_NURBS_ERROR25 GLU_NURBS_ERROR26 GLU_NURBS_ERROR27 GLU_NURBS_ERROR28 GLU_NURBS_ERROR29 GLU_NURBS_ERROR30 GLU_NURBS_ERROR31 GLU_NURBS_ERROR32 GLU_NURBS_ERROR33 GLU_NURBS_ERROR34 GLU_NURBS_ERROR35 GLU_NURBS_ERROR36 GLU_NURBS_ERROR37 GLU_AUTO_LOAD_MATRIX GLU_CULLING GLU_SAMPLING_TOLERANCE GLU_DISPLAY_MODE GLU_PARAMETRIC_TOLERANCE GLU_SAMPLING_METHOD GLU_U_STEP GLU_V_STEP GLU_NURBS_MODE GLU_NURBS_MODE_EXT GLU_NURBS_TESSELLATOR GLU_NURBS_TESSELLATOR_EXT GLU_NURBS_RENDERER GLU_NURBS_RENDERER_EXT GLU_OBJECT_PARAMETRIC_ERROR GLU_OBJECT_PARAMETRIC_ERROR_EXT GLU_OBJECT_PATH_LENGTH GLU_OBJECT_PATH_LENGTH_EXT GLU_PATH_LENGTH GLU_PARAMETRIC_ERROR GLU_DOMAIN_DISTANCE GLU_MAP1_TRIM_2 GLU_MAP1_TRIM_3 GLU_POINT GLU_LINE GLU_FILL GLU_SILHOUETTE GLU_SMOOTH GLU_FLAT GLU_NONE GLU_OUTSIDE GLU_INSIDE GLU_TESS_BEGIN GLU_BEGIN GLU_TESS_VERTEX GLU_VERTEX GLU_TESS_END GLU_END GLU_TESS_ERROR GLU_TESS_EDGE_FLAG GLU_EDGE_FLAG GLU_TESS_COMBINE GLU_TESS_BEGIN_DATA GLU_TESS_VERTEX_DATA GLU_TESS_END_DATA GLU_TESS_ERROR_DATA GLU_TESS_EDGE_FLAG_DATA GLU_TESS_COMBINE_DATA GLU_CW GLU_CCW GLU_INTERIOR GLU_EXTERIOR GLU_UNKNOWN GLU_TESS_WINDING_RULE GLU_TESS_BOUNDARY_ONLY GLU_TESS_TOLERANCE GLU_TESS_ERROR1 GLU_TESS_ERROR2 GLU_TESS_ERROR3 GLU_TESS_ERROR4 GLU_TESS_ERROR5 GLU_TESS_ERROR6 GLU_TESS_ERROR7 GLU_TESS_ERROR8 GLU_TESS_MISSING_BEGIN_POLYGON GLU_TESS_MISSING_BEGIN_CONTOUR GLU_TESS_MISSING_END_POLYGON GLU_TESS_MISSING_END_CONTOUR GLU_TESS_COORD_TOO_LARGE GLU_TESS_NEED_COMBINE_CALLBACK GLU_TESS_WINDING_ODD GLU_TESS_WINDING_NONZERO GLU_TESS_WINDING_POSITIVE GLU_TESS_WINDING_NEGATIVE GLU_TESS_WINDING_ABS_GEQ_TWO GLUnurbs ;;make-GLUnurbs GLUquadric ;;make-GLUquadric GLUtesselator ;;make-GLUtesselator GLUnurbsObj GLUquadricObj GLUtesselatorObj GLUtriangulatorObj GLU_TESS_MAX_COORD _GLUfuncptr gluBeginCurve gluBeginPolygon gluBeginSurface gluBeginTrim gluBuild1DMipmapLevels gluBuild1DMipmaps gluBuild2DMipmapLevels gluBuild2DMipmaps gluBuild3DMipmapLevels gluBuild3DMipmaps gluCheckExtension gluCylinder gluDeleteNurbsRenderer gluDeleteQuadric gluDeleteTess gluDisk gluEndCurve gluEndPolygon gluEndSurface gluEndTrim gluErrorString gluGetNurbsProperty gluGetString gluGetTessProperty gluLoadSamplingMatrices gluLookAt gluNewNurbsRenderer gluNewQuadric gluNewTess gluNextContour gluNurbsCallback gluNurbsCallbackData gluNurbsCallbackDataEXT gluNurbsCurve gluNurbsProperty gluNurbsSurface gluOrtho2D gluPartialDisk gluPerspective gluPickMatrix gluProject gluPwlCurve gluQuadricCallback gluQuadricDrawStyle gluQuadricNormals gluQuadricOrientation gluQuadricTexture gluScaleImage gluSphere gluTessBeginContour gluTessBeginPolygon gluTessCallback gluTessEndContour gluTessEndPolygon gluTessNormal gluTessProperty gluTessVertex gluUnProject gluUnProject4)) (uffi:load-foreign-library "/usr/lib/libGLU.so" :module "/usr/lib/libGLU.so" :supporting-libraries '("c")) ;;; COMMENT: /* $XFree86: xc/include/GL/glu.h,v 1.2 2001/04/03 02:18:39 dawes Exp $ */ ;;; COMMENT: /* ** License Applicability. Except to the extent portions of this file are ** made subject to an alternative license as permitted in the SGI Free ** Software License B, Version 1.1 (the "License"), the contents of this ** file are subject only to the provisions of the License. You may not use ** this file except in compliance with the License. You may obtain a copy ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: ** ** http://oss.sgi.com/projects/FreeB ** ** Note that, as provided in the License, the Software is distributed on an ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. ** ** Original Code. The Original Code is: OpenGL Sample Implementation, ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. ** Copyright in any portions created by third parties is as indicated ** elsewhere herein. All Rights Reserved. ** ** Additional Notice Provisions: This software was created using the ** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has ** not been independently verified as being compliant with the OpenGL(R) ** version 1.2.1 Specification. */ ;;; DEFINE: #ifndef __glu_h__ ;; **IGNORED**: #ifndef __glu_h__ ;;; DEFINE: #define __glu_h__ (defconstant __glu_h__ NIL) ;;; DEFINE: #include ;; **IGNORED**: #include ;;; DEFINE: #ifdef __cplusplus ;; **IGNORED**: #ifdef __cplusplus ;;; CODE: "C" { ;; **IGNORED**: "C" { ;;; DEFINE: #endif ;; **IGNORED**: #endif ;;; COMMENT: //*************************************************************/ ;;; COMMENT: /* Extensions */ ;;; DEFINE: #define GLU_EXT_object_space_tess 1 (defconstant GLU_EXT_object_space_tess 1) ;;; DEFINE: #define GLU_EXT_nurbs_tessellator 1 (defconstant GLU_EXT_nurbs_tessellator 1) ;;; COMMENT: /* Boolean */ ;;; DEFINE: #define GLU_FALSE 0 (defconstant GLU_FALSE 0) ;;; DEFINE: #define GLU_TRUE 1 (defconstant GLU_TRUE 1) ;;; COMMENT: /* Version */ ;;; DEFINE: #define GLU_VERSION_1_1 1 (defconstant GLU_VERSION_1_1 1) ;;; DEFINE: #define GLU_VERSION_1_2 1 (defconstant GLU_VERSION_1_2 1) ;;; DEFINE: #define GLU_VERSION_1_3 1 (defconstant GLU_VERSION_1_3 1) ;;; COMMENT: /* StringName */ ;;; DEFINE: #define GLU_VERSION 100800 (defconstant GLU_VERSION 100800) ;;; DEFINE: #define GLU_EXTENSIONS 100801 (defconstant GLU_EXTENSIONS 100801) ;;; COMMENT: /* ErrorCode */ ;;; DEFINE: #define GLU_INVALID_ENUM 100900 (defconstant GLU_INVALID_ENUM 100900) ;;; DEFINE: #define GLU_INVALID_VALUE 100901 (defconstant GLU_INVALID_VALUE 100901) ;;; DEFINE: #define GLU_OUT_OF_MEMORY 100902 (defconstant GLU_OUT_OF_MEMORY 100902) ;;; DEFINE: #define GLU_INVALID_OPERATION 100904 (defconstant GLU_INVALID_OPERATION 100904) ;;; COMMENT: /* NurbsDisplay */ ;;; COMMENT: /* GLU_FILL */ ;;; DEFINE: #define GLU_OUTLINE_POLYGON 100240 (defconstant GLU_OUTLINE_POLYGON 100240) ;;; DEFINE: #define GLU_OUTLINE_PATCH 100241 (defconstant GLU_OUTLINE_PATCH 100241) ;;; COMMENT: /* NurbsCallback */ ;;; DEFINE: #define GLU_NURBS_ERROR 100103 (defconstant GLU_NURBS_ERROR 100103) ;;; DEFINE: #define GLU_ERROR 100103 (defconstant GLU_ERROR 100103) ;;; DEFINE: #define GLU_NURBS_BEGIN 100164 (defconstant GLU_NURBS_BEGIN 100164) ;;; DEFINE: #define GLU_NURBS_BEGIN_EXT 100164 (defconstant GLU_NURBS_BEGIN_EXT 100164) ;;; DEFINE: #define GLU_NURBS_VERTEX 100165 (defconstant GLU_NURBS_VERTEX 100165) ;;; DEFINE: #define GLU_NURBS_VERTEX_EXT 100165 (defconstant GLU_NURBS_VERTEX_EXT 100165) ;;; DEFINE: #define GLU_NURBS_NORMAL 100166 (defconstant GLU_NURBS_NORMAL 100166) ;;; DEFINE: #define GLU_NURBS_NORMAL_EXT 100166 (defconstant GLU_NURBS_NORMAL_EXT 100166) ;;; DEFINE: #define GLU_NURBS_COLOR 100167 (defconstant GLU_NURBS_COLOR 100167) ;;; DEFINE: #define GLU_NURBS_COLOR_EXT 100167 (defconstant GLU_NURBS_COLOR_EXT 100167) ;;; DEFINE: #define GLU_NURBS_TEXTURE_COORD 100168 (defconstant GLU_NURBS_TEXTURE_COORD 100168) ;;; DEFINE: #define GLU_NURBS_TEX_COORD_EXT 100168 (defconstant GLU_NURBS_TEX_COORD_EXT 100168) ;;; DEFINE: #define GLU_NURBS_END 100169 (defconstant GLU_NURBS_END 100169) ;;; DEFINE: #define GLU_NURBS_END_EXT 100169 (defconstant GLU_NURBS_END_EXT 100169) ;;; DEFINE: #define GLU_NURBS_BEGIN_DATA 100170 (defconstant GLU_NURBS_BEGIN_DATA 100170) ;;; DEFINE: #define GLU_NURBS_BEGIN_DATA_EXT 100170 (defconstant GLU_NURBS_BEGIN_DATA_EXT 100170) ;;; DEFINE: #define GLU_NURBS_VERTEX_DATA 100171 (defconstant GLU_NURBS_VERTEX_DATA 100171) ;;; DEFINE: #define GLU_NURBS_VERTEX_DATA_EXT 100171 (defconstant GLU_NURBS_VERTEX_DATA_EXT 100171) ;;; DEFINE: #define GLU_NURBS_NORMAL_DATA 100172 (defconstant GLU_NURBS_NORMAL_DATA 100172) ;;; DEFINE: #define GLU_NURBS_NORMAL_DATA_EXT 100172 (defconstant GLU_NURBS_NORMAL_DATA_EXT 100172) ;;; DEFINE: #define GLU_NURBS_COLOR_DATA 100173 (defconstant GLU_NURBS_COLOR_DATA 100173) ;;; DEFINE: #define GLU_NURBS_COLOR_DATA_EXT 100173 (defconstant GLU_NURBS_COLOR_DATA_EXT 100173) ;;; DEFINE: #define GLU_NURBS_TEXTURE_COORD_DATA 100174 (defconstant GLU_NURBS_TEXTURE_COORD_DATA 100174) ;;; DEFINE: #define GLU_NURBS_TEX_COORD_DATA_EXT 100174 (defconstant GLU_NURBS_TEX_COORD_DATA_EXT 100174) ;;; DEFINE: #define GLU_NURBS_END_DATA 100175 (defconstant GLU_NURBS_END_DATA 100175) ;;; DEFINE: #define GLU_NURBS_END_DATA_EXT 100175 (defconstant GLU_NURBS_END_DATA_EXT 100175) ;;; COMMENT: /* NurbsError */ ;;; DEFINE: #define GLU_NURBS_ERROR1 100251 (defconstant GLU_NURBS_ERROR1 100251) ;;; DEFINE: #define GLU_NURBS_ERROR2 100252 (defconstant GLU_NURBS_ERROR2 100252) ;;; DEFINE: #define GLU_NURBS_ERROR3 100253 (defconstant GLU_NURBS_ERROR3 100253) ;;; DEFINE: #define GLU_NURBS_ERROR4 100254 (defconstant GLU_NURBS_ERROR4 100254) ;;; DEFINE: #define GLU_NURBS_ERROR5 100255 (defconstant GLU_NURBS_ERROR5 100255) ;;; DEFINE: #define GLU_NURBS_ERROR6 100256 (defconstant GLU_NURBS_ERROR6 100256) ;;; DEFINE: #define GLU_NURBS_ERROR7 100257 (defconstant GLU_NURBS_ERROR7 100257) ;;; DEFINE: #define GLU_NURBS_ERROR8 100258 (defconstant GLU_NURBS_ERROR8 100258) ;;; DEFINE: #define GLU_NURBS_ERROR9 100259 (defconstant GLU_NURBS_ERROR9 100259) ;;; DEFINE: #define GLU_NURBS_ERROR10 100260 (defconstant GLU_NURBS_ERROR10 100260) ;;; DEFINE: #define GLU_NURBS_ERROR11 100261 (defconstant GLU_NURBS_ERROR11 100261) ;;; DEFINE: #define GLU_NURBS_ERROR12 100262 (defconstant GLU_NURBS_ERROR12 100262) ;;; DEFINE: #define GLU_NURBS_ERROR13 100263 (defconstant GLU_NURBS_ERROR13 100263) ;;; DEFINE: #define GLU_NURBS_ERROR14 100264 (defconstant GLU_NURBS_ERROR14 100264) ;;; DEFINE: #define GLU_NURBS_ERROR15 100265 (defconstant GLU_NURBS_ERROR15 100265) ;;; DEFINE: #define GLU_NURBS_ERROR16 100266 (defconstant GLU_NURBS_ERROR16 100266) ;;; DEFINE: #define GLU_NURBS_ERROR17 100267 (defconstant GLU_NURBS_ERROR17 100267) ;;; DEFINE: #define GLU_NURBS_ERROR18 100268 (defconstant GLU_NURBS_ERROR18 100268) ;;; DEFINE: #define GLU_NURBS_ERROR19 100269 (defconstant GLU_NURBS_ERROR19 100269) ;;; DEFINE: #define GLU_NURBS_ERROR20 100270 (defconstant GLU_NURBS_ERROR20 100270) ;;; DEFINE: #define GLU_NURBS_ERROR21 100271 (defconstant GLU_NURBS_ERROR21 100271) ;;; DEFINE: #define GLU_NURBS_ERROR22 100272 (defconstant GLU_NURBS_ERROR22 100272) ;;; DEFINE: #define GLU_NURBS_ERROR23 100273 (defconstant GLU_NURBS_ERROR23 100273) ;;; DEFINE: #define GLU_NURBS_ERROR24 100274 (defconstant GLU_NURBS_ERROR24 100274) ;;; DEFINE: #define GLU_NURBS_ERROR25 100275 (defconstant GLU_NURBS_ERROR25 100275) ;;; DEFINE: #define GLU_NURBS_ERROR26 100276 (defconstant GLU_NURBS_ERROR26 100276) ;;; DEFINE: #define GLU_NURBS_ERROR27 100277 (defconstant GLU_NURBS_ERROR27 100277) ;;; DEFINE: #define GLU_NURBS_ERROR28 100278 (defconstant GLU_NURBS_ERROR28 100278) ;;; DEFINE: #define GLU_NURBS_ERROR29 100279 (defconstant GLU_NURBS_ERROR29 100279) ;;; DEFINE: #define GLU_NURBS_ERROR30 100280 (defconstant GLU_NURBS_ERROR30 100280) ;;; DEFINE: #define GLU_NURBS_ERROR31 100281 (defconstant GLU_NURBS_ERROR31 100281) ;;; DEFINE: #define GLU_NURBS_ERROR32 100282 (defconstant GLU_NURBS_ERROR32 100282) ;;; DEFINE: #define GLU_NURBS_ERROR33 100283 (defconstant GLU_NURBS_ERROR33 100283) ;;; DEFINE: #define GLU_NURBS_ERROR34 100284 (defconstant GLU_NURBS_ERROR34 100284) ;;; DEFINE: #define GLU_NURBS_ERROR35 100285 (defconstant GLU_NURBS_ERROR35 100285) ;;; DEFINE: #define GLU_NURBS_ERROR36 100286 (defconstant GLU_NURBS_ERROR36 100286) ;;; DEFINE: #define GLU_NURBS_ERROR37 100287 (defconstant GLU_NURBS_ERROR37 100287) ;;; COMMENT: /* NurbsProperty */ ;;; DEFINE: #define GLU_AUTO_LOAD_MATRIX 100200 (defconstant GLU_AUTO_LOAD_MATRIX 100200) ;;; DEFINE: #define GLU_CULLING 100201 (defconstant GLU_CULLING 100201) ;;; DEFINE: #define GLU_SAMPLING_TOLERANCE 100203 (defconstant GLU_SAMPLING_TOLERANCE 100203) ;;; DEFINE: #define GLU_DISPLAY_MODE 100204 (defconstant GLU_DISPLAY_MODE 100204) ;;; DEFINE: #define GLU_PARAMETRIC_TOLERANCE 100202 (defconstant GLU_PARAMETRIC_TOLERANCE 100202) ;;; DEFINE: #define GLU_SAMPLING_METHOD 100205 (defconstant GLU_SAMPLING_METHOD 100205) ;;; DEFINE: #define GLU_U_STEP 100206 (defconstant GLU_U_STEP 100206) ;;; DEFINE: #define GLU_V_STEP 100207 (defconstant GLU_V_STEP 100207) ;;; DEFINE: #define GLU_NURBS_MODE 100160 (defconstant GLU_NURBS_MODE 100160) ;;; DEFINE: #define GLU_NURBS_MODE_EXT 100160 (defconstant GLU_NURBS_MODE_EXT 100160) ;;; DEFINE: #define GLU_NURBS_TESSELLATOR 100161 (defconstant GLU_NURBS_TESSELLATOR 100161) ;;; DEFINE: #define GLU_NURBS_TESSELLATOR_EXT 100161 (defconstant GLU_NURBS_TESSELLATOR_EXT 100161) ;;; DEFINE: #define GLU_NURBS_RENDERER 100162 (defconstant GLU_NURBS_RENDERER 100162) ;;; DEFINE: #define GLU_NURBS_RENDERER_EXT 100162 (defconstant GLU_NURBS_RENDERER_EXT 100162) ;;; COMMENT: /* NurbsSampling */ ;;; DEFINE: #define GLU_OBJECT_PARAMETRIC_ERROR 100208 (defconstant GLU_OBJECT_PARAMETRIC_ERROR 100208) ;;; DEFINE: #define GLU_OBJECT_PARAMETRIC_ERROR_EXT 100208 (defconstant GLU_OBJECT_PARAMETRIC_ERROR_EXT 100208) ;;; DEFINE: #define GLU_OBJECT_PATH_LENGTH 100209 (defconstant GLU_OBJECT_PATH_LENGTH 100209) ;;; DEFINE: #define GLU_OBJECT_PATH_LENGTH_EXT 100209 (defconstant GLU_OBJECT_PATH_LENGTH_EXT 100209) ;;; DEFINE: #define GLU_PATH_LENGTH 100215 (defconstant GLU_PATH_LENGTH 100215) ;;; DEFINE: #define GLU_PARAMETRIC_ERROR 100216 (defconstant GLU_PARAMETRIC_ERROR 100216) ;;; DEFINE: #define GLU_DOMAIN_DISTANCE 100217 (defconstant GLU_DOMAIN_DISTANCE 100217) ;;; COMMENT: /* NurbsTrim */ ;;; DEFINE: #define GLU_MAP1_TRIM_2 100210 (defconstant GLU_MAP1_TRIM_2 100210) ;;; DEFINE: #define GLU_MAP1_TRIM_3 100211 (defconstant GLU_MAP1_TRIM_3 100211) ;;; COMMENT: /* QuadricDrawStyle */ ;;; DEFINE: #define GLU_POINT 100010 (defconstant GLU_POINT 100010) ;;; DEFINE: #define GLU_LINE 100011 (defconstant GLU_LINE 100011) ;;; DEFINE: #define GLU_FILL 100012 (defconstant GLU_FILL 100012) ;;; DEFINE: #define GLU_SILHOUETTE 100013 (defconstant GLU_SILHOUETTE 100013) ;;; COMMENT: /* QuadricCallback */ ;;; COMMENT: /* GLU_ERROR */ ;;; COMMENT: /* QuadricNormal */ ;;; DEFINE: #define GLU_SMOOTH 100000 (defconstant GLU_SMOOTH 100000) ;;; DEFINE: #define GLU_FLAT 100001 (defconstant GLU_FLAT 100001) ;;; DEFINE: #define GLU_NONE 100002 (defconstant GLU_NONE 100002) ;;; COMMENT: /* QuadricOrientation */ ;;; DEFINE: #define GLU_OUTSIDE 100020 (defconstant GLU_OUTSIDE 100020) ;;; DEFINE: #define GLU_INSIDE 100021 (defconstant GLU_INSIDE 100021) ;;; COMMENT: /* TessCallback */ ;;; DEFINE: #define GLU_TESS_BEGIN 100100 (defconstant GLU_TESS_BEGIN 100100) ;;; DEFINE: #define GLU_BEGIN 100100 (defconstant GLU_BEGIN 100100) ;;; DEFINE: #define GLU_TESS_VERTEX 100101 (defconstant GLU_TESS_VERTEX 100101) ;;; DEFINE: #define GLU_VERTEX 100101 (defconstant GLU_VERTEX 100101) ;;; DEFINE: #define GLU_TESS_END 100102 (defconstant GLU_TESS_END 100102) ;;; DEFINE: #define GLU_END 100102 (defconstant GLU_END 100102) ;;; DEFINE: #define GLU_TESS_ERROR 100103 (defconstant GLU_TESS_ERROR 100103) ;;; DEFINE: #define GLU_TESS_EDGE_FLAG 100104 (defconstant GLU_TESS_EDGE_FLAG 100104) ;;; DEFINE: #define GLU_EDGE_FLAG 100104 (defconstant GLU_EDGE_FLAG 100104) ;;; DEFINE: #define GLU_TESS_COMBINE 100105 (defconstant GLU_TESS_COMBINE 100105) ;;; DEFINE: #define GLU_TESS_BEGIN_DATA 100106 (defconstant GLU_TESS_BEGIN_DATA 100106) ;;; DEFINE: #define GLU_TESS_VERTEX_DATA 100107 (defconstant GLU_TESS_VERTEX_DATA 100107) ;;; DEFINE: #define GLU_TESS_END_DATA 100108 (defconstant GLU_TESS_END_DATA 100108) ;;; DEFINE: #define GLU_TESS_ERROR_DATA 100109 (defconstant GLU_TESS_ERROR_DATA 100109) ;;; DEFINE: #define GLU_TESS_EDGE_FLAG_DATA 100110 (defconstant GLU_TESS_EDGE_FLAG_DATA 100110) ;;; DEFINE: #define GLU_TESS_COMBINE_DATA 100111 (defconstant GLU_TESS_COMBINE_DATA 100111) ;;; COMMENT: /* TessContour */ ;;; DEFINE: #define GLU_CW 100120 (defconstant GLU_CW 100120) ;;; DEFINE: #define GLU_CCW 100121 (defconstant GLU_CCW 100121) ;;; DEFINE: #define GLU_INTERIOR 100122 (defconstant GLU_INTERIOR 100122) ;;; DEFINE: #define GLU_EXTERIOR 100123 (defconstant GLU_EXTERIOR 100123) ;;; DEFINE: #define GLU_UNKNOWN 100124 (defconstant GLU_UNKNOWN 100124) ;;; COMMENT: /* TessProperty */ ;;; DEFINE: #define GLU_TESS_WINDING_RULE 100140 (defconstant GLU_TESS_WINDING_RULE 100140) ;;; DEFINE: #define GLU_TESS_BOUNDARY_ONLY 100141 (defconstant GLU_TESS_BOUNDARY_ONLY 100141) ;;; DEFINE: #define GLU_TESS_TOLERANCE 100142 (defconstant GLU_TESS_TOLERANCE 100142) ;;; COMMENT: /* TessError */ ;;; DEFINE: #define GLU_TESS_ERROR1 100151 (defconstant GLU_TESS_ERROR1 100151) ;;; DEFINE: #define GLU_TESS_ERROR2 100152 (defconstant GLU_TESS_ERROR2 100152) ;;; DEFINE: #define GLU_TESS_ERROR3 100153 (defconstant GLU_TESS_ERROR3 100153) ;;; DEFINE: #define GLU_TESS_ERROR4 100154 (defconstant GLU_TESS_ERROR4 100154) ;;; DEFINE: #define GLU_TESS_ERROR5 100155 (defconstant GLU_TESS_ERROR5 100155) ;;; DEFINE: #define GLU_TESS_ERROR6 100156 (defconstant GLU_TESS_ERROR6 100156) ;;; DEFINE: #define GLU_TESS_ERROR7 100157 (defconstant GLU_TESS_ERROR7 100157) ;;; DEFINE: #define GLU_TESS_ERROR8 100158 (defconstant GLU_TESS_ERROR8 100158) ;;; DEFINE: #define GLU_TESS_MISSING_BEGIN_POLYGON 100151 (defconstant GLU_TESS_MISSING_BEGIN_POLYGON 100151) ;;; DEFINE: #define GLU_TESS_MISSING_BEGIN_CONTOUR 100152 (defconstant GLU_TESS_MISSING_BEGIN_CONTOUR 100152) ;;; DEFINE: #define GLU_TESS_MISSING_END_POLYGON 100153 (defconstant GLU_TESS_MISSING_END_POLYGON 100153) ;;; DEFINE: #define GLU_TESS_MISSING_END_CONTOUR 100154 (defconstant GLU_TESS_MISSING_END_CONTOUR 100154) ;;; DEFINE: #define GLU_TESS_COORD_TOO_LARGE 100155 (defconstant GLU_TESS_COORD_TOO_LARGE 100155) ;;; DEFINE: #define GLU_TESS_NEED_COMBINE_CALLBACK 100156 (defconstant GLU_TESS_NEED_COMBINE_CALLBACK 100156) ;;; COMMENT: /* TessWinding */ ;;; DEFINE: #define GLU_TESS_WINDING_ODD 100130 (defconstant GLU_TESS_WINDING_ODD 100130) ;;; DEFINE: #define GLU_TESS_WINDING_NONZERO 100131 (defconstant GLU_TESS_WINDING_NONZERO 100131) ;;; DEFINE: #define GLU_TESS_WINDING_POSITIVE 100132 (defconstant GLU_TESS_WINDING_POSITIVE 100132) ;;; DEFINE: #define GLU_TESS_WINDING_NEGATIVE 100133 (defconstant GLU_TESS_WINDING_NEGATIVE 100133) ;;; DEFINE: #define GLU_TESS_WINDING_ABS_GEQ_TWO 100134 (defconstant GLU_TESS_WINDING_ABS_GEQ_TWO 100134) ;;; COMMENT: /*************************************************************/ ;;; DEFINE: #ifdef __cplusplus ;; **IGNORED**: #ifdef __cplusplus ;;; CODE: class GLUnurbs; ;; **IGNORED**: class GLUnurbs; ;;; CODE: class GLUquadric; ;; **IGNORED**: class GLUquadric; ;;; CODE: class GLUtesselator; ;; **IGNORED**: class GLUtesselator; ;;; DEFINE: #else ;; **IGNORED**: #else ;;; CODE: typedef struct GLUnurbs GLUnurbs; (progn (uffi:def-struct GLUnurbs)) ;; (defun make-GLUnurbs (&key) ;; (let ((s (uffi:allocate-foreign-object 'GLUnurbs))) ;; s))) ;;; CODE: typedef struct GLUquadric GLUquadric; (progn (uffi:def-struct GLUquadric)) ;; (defun make-GLUquadric (&key) ;; (let ((s (uffi:allocate-foreign-object 'GLUquadric))) ;; s))) ;;; CODE: typedef struct GLUtesselator GLUtesselator; (progn (uffi:def-struct GLUtesselator)) ;; (defun make-GLUtesselator (&key) ;; (let ((s (uffi:allocate-foreign-object 'GLUtesselator))) ;; s))) ;;; DEFINE: #endif ;; **IGNORED**: #endif ;;; CODE: typedef struct GLUnurbs GLUnurbsObj; (uffi:def-foreign-type GLUnurbsObj GLUnurbs) ;;; CODE: typedef struct GLUquadric GLUquadricObj; (uffi:def-foreign-type GLUquadricObj GLUquadric) ;;; CODE: typedef struct GLUtesselator GLUtesselatorObj; (uffi:def-foreign-type GLUtesselatorObj GLUtesselator) ;;; CODE: typedef struct GLUtesselator GLUtriangulatorObj; (uffi:def-foreign-type GLUtriangulatorObj GLUtesselator) ;;; DEFINE: #define GLU_TESS_MAX_COORD 1.0d150 (defconstant GLU_TESS_MAX_COORD 1.0d150) ;;; COMMENT: /* Internal convenience typedefs */ ;;; CODE: typedef GLvoid (*_GLUfuncptr)(GLvoid); (uffi:def-foreign-type _GLUfuncptr (* (function GLvoid GLvoid))) ;;; CODE: void gluBeginCurve (GLUnurbs* nurb); (uffi:def-function ("gluBeginCurve" gluBeginCurve) ( (nurb (* GLUnurbs))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluBeginPolygon (GLUtesselator* tess); (uffi:def-function ("gluBeginPolygon" gluBeginPolygon) ( (tess (* GLUtesselator))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluBeginSurface (GLUnurbs* nurb); (uffi:def-function ("gluBeginSurface" gluBeginSurface) ( (nurb (* GLUnurbs))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluBeginTrim (GLUnurbs* nurb); (uffi:def-function ("gluBeginTrim" gluBeginTrim) ( (nurb (* GLUnurbs))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: GLint gluBuild1DMipmapLevels (GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, void *data); (uffi:def-function ("gluBuild1DMipmapLevels" gluBuild1DMipmapLevels) ( (target GLenum) (internalFormat GLint) (width GLsizei) (format GLenum) (type GLenum) (level GLint) (base GLint) (max GLint) (data :pointer-void)) :returning GLint :module "/usr/lib/libGLU.so") ;;; CODE: GLint gluBuild1DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, void *data); (uffi:def-function ("gluBuild1DMipmaps" gluBuild1DMipmaps) ( (target GLenum) (internalFormat GLint) (width GLsizei) (format GLenum) (type GLenum) (data :pointer-void)) :returning GLint :module "/usr/lib/libGLU.so") ;;; CODE: GLint gluBuild2DMipmapLevels (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, void *data); (uffi:def-function ("gluBuild2DMipmapLevels" gluBuild2DMipmapLevels) ( (target GLenum) (internalFormat GLint) (width GLsizei) (height GLsizei) (format GLenum) (type GLenum) (level GLint) (base GLint) (max GLint) (data :pointer-void)) :returning GLint :module "/usr/lib/libGLU.so") ;;; CODE: GLint gluBuild2DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, void *data); (uffi:def-function ("gluBuild2DMipmaps" gluBuild2DMipmaps) ( (target GLenum) (internalFormat GLint) (width GLsizei) (height GLsizei) (format GLenum) (type GLenum) (data :pointer-void)) :returning GLint :module "/usr/lib/libGLU.so") ;;; CODE: GLint gluBuild3DMipmapLevels (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, void *data); (uffi:def-function ("gluBuild3DMipmapLevels" gluBuild3DMipmapLevels) ( (target GLenum) (internalFormat GLint) (width GLsizei) (height GLsizei) (depth GLsizei) (format GLenum) (type GLenum) (level GLint) (base GLint) (max GLint) (data :pointer-void)) :returning GLint :module "/usr/lib/libGLU.so") ;;; CODE: GLint gluBuild3DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, void *data); (uffi:def-function ("gluBuild3DMipmaps" gluBuild3DMipmaps) ( (target GLenum) (internalFormat GLint) (width GLsizei) (height GLsizei) (depth GLsizei) (format GLenum) (type GLenum) (data :pointer-void)) :returning GLint :module "/usr/lib/libGLU.so") ;;; CODE: GLboolean gluCheckExtension ( GLubyte *extName, GLubyte *extString); (uffi:def-function ("gluCheckExtension" gluCheckExtension) ( (extName (* GLubyte)) (extString (* GLubyte))) :returning GLboolean :module "/usr/lib/libGLU.so") ;;; CODE: void gluCylinder (GLUquadric* quad, GLdouble base, GLdouble top, GLdouble height, GLint slices, GLint stacks); (uffi:def-function ("gluCylinder" gluCylinder) ( (quad (* GLUquadric)) (base GLdouble) (top GLdouble) (height GLdouble) (slices GLint) (stacks GLint)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluDeleteNurbsRenderer (GLUnurbs* nurb); (uffi:def-function ("gluDeleteNurbsRenderer" gluDeleteNurbsRenderer) ( (nurb (* GLUnurbs))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluDeleteQuadric (GLUquadric* quad); (uffi:def-function ("gluDeleteQuadric" gluDeleteQuadric) ( (quad (* GLUquadric))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluDeleteTess (GLUtesselator* tess); (uffi:def-function ("gluDeleteTess" gluDeleteTess) ( (tess (* GLUtesselator))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluDisk (GLUquadric* quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops); (uffi:def-function ("gluDisk" gluDisk) ( (quad (* GLUquadric)) (inner GLdouble) (outer GLdouble) (slices GLint) (loops GLint)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluEndCurve (GLUnurbs* nurb); (uffi:def-function ("gluEndCurve" gluEndCurve) ( (nurb (* GLUnurbs))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluEndPolygon (GLUtesselator* tess); (uffi:def-function ("gluEndPolygon" gluEndPolygon) ( (tess (* GLUtesselator))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluEndSurface (GLUnurbs* nurb); (uffi:def-function ("gluEndSurface" gluEndSurface) ( (nurb (* GLUnurbs))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluEndTrim (GLUnurbs* nurb); (uffi:def-function ("gluEndTrim" gluEndTrim) ( (nurb (* GLUnurbs))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: GLubyte * gluErrorString (GLenum error); (uffi:def-function ("gluErrorString" gluErrorString) ( (error GLenum)) :returning (* GLubyte) :module "/usr/lib/libGLU.so") ;;; CODE: void gluGetNurbsProperty (GLUnurbs* nurb, GLenum property, GLfloat* data); (uffi:def-function ("gluGetNurbsProperty" gluGetNurbsProperty) ( (nurb (* GLUnurbs)) (property GLenum) (data (* GLfloat))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: GLubyte * gluGetString (GLenum name); (uffi:def-function ("gluGetString" gluGetString) ( (name GLenum)) :returning (* GLubyte) :module "/usr/lib/libGLU.so") ;;; CODE: void gluGetTessProperty (GLUtesselator* tess, GLenum which, GLdouble* data); (uffi:def-function ("gluGetTessProperty" gluGetTessProperty) ( (tess (* GLUtesselator)) (which GLenum) (data (* GLdouble))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluLoadSamplingMatrices (GLUnurbs* nurb, GLfloat *model, GLfloat *perspective, GLint *view); (uffi:def-function ("gluLoadSamplingMatrices" gluLoadSamplingMatrices) ( (nurb (* GLUnurbs)) (model (* GLfloat)) (perspective (* GLfloat)) (view (* GLint))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluLookAt (GLdouble eyeX, GLdouble eyeY, GLdouble eyeZ, GLdouble centerX, GLdouble centerY, GLdouble centerZ, GLdouble upX, GLdouble upY, GLdouble upZ); (uffi:def-function ("gluLookAt" gluLookAt) ( (eyeX GLdouble) (eyeY GLdouble) (eyeZ GLdouble) (centerX GLdouble) (centerY GLdouble) (centerZ GLdouble) (upX GLdouble) (upY GLdouble) (upZ GLdouble)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: GLUnurbs* gluNewNurbsRenderer (void); (uffi:def-function ("gluNewNurbsRenderer" gluNewNurbsRenderer) () :returning (* GLUnurbs) :module "/usr/lib/libGLU.so") ;;; CODE: GLUquadric* gluNewQuadric (void); (uffi:def-function ("gluNewQuadric" gluNewQuadric) () :returning (* GLUquadric) :module "/usr/lib/libGLU.so") ;;; CODE: GLUtesselator* gluNewTess (void); (uffi:def-function ("gluNewTess" gluNewTess) () :returning (* GLUtesselator) :module "/usr/lib/libGLU.so") ;;; CODE: void gluNextContour (GLUtesselator* tess, GLenum type); (uffi:def-function ("gluNextContour" gluNextContour) ( (tess (* GLUtesselator)) (type GLenum)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluNurbsCallback (GLUnurbs* nurb, GLenum which, _GLUfuncptr CallBackFunc); (uffi:def-function ("gluNurbsCallback" gluNurbsCallback) ( (nurb (* GLUnurbs)) (which GLenum) (CallBackFunc _GLUfuncptr)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluNurbsCallbackData (GLUnurbs* nurb, GLvoid* userData); (uffi:def-function ("gluNurbsCallbackData" gluNurbsCallbackData) ( (nurb (* GLUnurbs)) (userData (* GLvoid))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluNurbsCallbackDataEXT (GLUnurbs* nurb, GLvoid* userData); (uffi:def-function ("gluNurbsCallbackDataEXT" gluNurbsCallbackDataEXT) ( (nurb (* GLUnurbs)) (userData (* GLvoid))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluNurbsCurve (GLUnurbs* nurb, GLint knotCount, GLfloat *knots, GLint stride, GLfloat *control, GLint order, GLenum type); (uffi:def-function ("gluNurbsCurve" gluNurbsCurve) ( (nurb (* GLUnurbs)) (knotCount GLint) (knots (* GLfloat)) (stride GLint) (control (* GLfloat)) (order GLint) (type GLenum)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluNurbsProperty (GLUnurbs* nurb, GLenum property, GLfloat value); (uffi:def-function ("gluNurbsProperty" gluNurbsProperty) ( (nurb (* GLUnurbs)) (property GLenum) (value GLfloat)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluNurbsSurface (GLUnurbs* nurb, GLint sKnotCount, GLfloat* sKnots, GLint tKnotCount, GLfloat* tKnots, GLint sStride, GLint tStride, GLfloat* control, GLint sOrder, GLint tOrder, GLenum type); (uffi:def-function ("gluNurbsSurface" gluNurbsSurface) ( (nurb (* GLUnurbs)) (sKnotCount GLint) (sKnots (* GLfloat)) (tKnotCount GLint) (tKnots (* GLfloat)) (sStride GLint) (tStride GLint) (control (* GLfloat)) (sOrder GLint) (tOrder GLint) (type GLenum)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluOrtho2D (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top); (uffi:def-function ("gluOrtho2D" gluOrtho2D) ( (left GLdouble) (right GLdouble) (bottom GLdouble) (top GLdouble)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluPartialDisk (GLUquadric* quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops, GLdouble start, GLdouble sweep); (uffi:def-function ("gluPartialDisk" gluPartialDisk) ( (quad (* GLUquadric)) (inner GLdouble) (outer GLdouble) (slices GLint) (loops GLint) (start GLdouble) (sweep GLdouble)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluPerspective (GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar); (uffi:def-function ("gluPerspective" gluPerspective) ( (fovy GLdouble) (aspect GLdouble) (zNear GLdouble) (zFar GLdouble)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluPickMatrix (GLdouble x, GLdouble y, GLdouble delX, GLdouble delY, GLint *viewport); (uffi:def-function ("gluPickMatrix" gluPickMatrix) ( (x GLdouble) (y GLdouble) (delX GLdouble) (delY GLdouble) (viewport (* GLint))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: GLint gluProject (GLdouble objX, GLdouble objY, GLdouble objZ, GLdouble *model, GLdouble *proj, GLint *view, GLdouble* winX, GLdouble* winY, GLdouble* winZ); (uffi:def-function ("gluProject" gluProject) ( (objX GLdouble) (objY GLdouble) (objZ GLdouble) (model (* GLdouble)) (proj (* GLdouble)) (view (* GLint)) (winX (* GLdouble)) (winY (* GLdouble)) (winZ (* GLdouble))) :returning GLint :module "/usr/lib/libGLU.so") ;;; CODE: void gluPwlCurve (GLUnurbs* nurb, GLint count, GLfloat* data, GLint stride, GLenum type); (uffi:def-function ("gluPwlCurve" gluPwlCurve) ( (nurb (* GLUnurbs)) (count GLint) (data (* GLfloat)) (stride GLint) (type GLenum)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluQuadricCallback (GLUquadric* quad, GLenum which, _GLUfuncptr CallBackFunc); (uffi:def-function ("gluQuadricCallback" gluQuadricCallback) ( (quad (* GLUquadric)) (which GLenum) (CallBackFunc _GLUfuncptr)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluQuadricDrawStyle (GLUquadric* quad, GLenum draw); (uffi:def-function ("gluQuadricDrawStyle" gluQuadricDrawStyle) ( (quad (* GLUquadric)) (draw GLenum)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluQuadricNormals (GLUquadric* quad, GLenum normal); (uffi:def-function ("gluQuadricNormals" gluQuadricNormals) ( (quad (* GLUquadric)) (normal GLenum)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluQuadricOrientation (GLUquadric* quad, GLenum orientation); (uffi:def-function ("gluQuadricOrientation" gluQuadricOrientation) ( (quad (* GLUquadric)) (orientation GLenum)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluQuadricTexture (GLUquadric* quad, GLboolean texture); (uffi:def-function ("gluQuadricTexture" gluQuadricTexture) ( (quad (* GLUquadric)) (texture GLboolean)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: GLint gluScaleImage (GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, void *dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid* dataOut); (uffi:def-function ("gluScaleImage" gluScaleImage) ( (format GLenum) (wIn GLsizei) (hIn GLsizei) (typeIn GLenum) (dataIn :pointer-void) (wOut GLsizei) (hOut GLsizei) (typeOut GLenum) (dataOut (* GLvoid))) :returning GLint :module "/usr/lib/libGLU.so") ;;; CODE: void gluSphere (GLUquadric* quad, GLdouble radius, GLint slices, GLint stacks); (uffi:def-function ("gluSphere" gluSphere) ( (quad (* GLUquadric)) (radius GLdouble) (slices GLint) (stacks GLint)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluTessBeginContour (GLUtesselator* tess); (uffi:def-function ("gluTessBeginContour" gluTessBeginContour) ( (tess (* GLUtesselator))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluTessBeginPolygon (GLUtesselator* tess, GLvoid* data); (uffi:def-function ("gluTessBeginPolygon" gluTessBeginPolygon) ( (tess (* GLUtesselator)) (data (* GLvoid))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluTessCallback (GLUtesselator* tess, GLenum which, _GLUfuncptr CallBackFunc); (uffi:def-function ("gluTessCallback" gluTessCallback) ( (tess (* GLUtesselator)) (which GLenum) (CallBackFunc _GLUfuncptr)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluTessEndContour (GLUtesselator* tess); (uffi:def-function ("gluTessEndContour" gluTessEndContour) ( (tess (* GLUtesselator))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluTessEndPolygon (GLUtesselator* tess); (uffi:def-function ("gluTessEndPolygon" gluTessEndPolygon) ( (tess (* GLUtesselator))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluTessNormal (GLUtesselator* tess, GLdouble valueX, GLdouble valueY, GLdouble valueZ); (uffi:def-function ("gluTessNormal" gluTessNormal) ( (tess (* GLUtesselator)) (valueX GLdouble) (valueY GLdouble) (valueZ GLdouble)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluTessProperty (GLUtesselator* tess, GLenum which, GLdouble data); (uffi:def-function ("gluTessProperty" gluTessProperty) ( (tess (* GLUtesselator)) (which GLenum) (data GLdouble)) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: void gluTessVertex (GLUtesselator* tess, GLdouble *location, GLvoid* data); (uffi:def-function ("gluTessVertex" gluTessVertex) ( (tess (* GLUtesselator)) (location (* GLdouble)) (data (* GLvoid))) :returning :void :module "/usr/lib/libGLU.so") ;;; CODE: GLint gluUnProject (GLdouble winX, GLdouble winY, GLdouble winZ, GLdouble *model, GLdouble *proj, GLint *view, GLdouble* objX, GLdouble* objY, GLdouble* objZ); (uffi:def-function ("gluUnProject" gluUnProject) ( (winX GLdouble) (winY GLdouble) (winZ GLdouble) (model (* GLdouble)) (proj (* GLdouble)) (view (* GLint)) (objX (* GLdouble)) (objY (* GLdouble)) (objZ (* GLdouble))) :returning GLint :module "/usr/lib/libGLU.so") ;;; CODE: GLint gluUnProject4 (GLdouble winX, GLdouble winY, GLdouble winZ, GLdouble clipW, GLdouble *model, GLdouble *proj, GLint *view, GLdouble near, GLdouble far, GLdouble* objX, GLdouble* objY, GLdouble* objZ, GLdouble* objW); (uffi:def-function ("gluUnProject4" gluUnProject4) ( (winX GLdouble) (winY GLdouble) (winZ GLdouble) (clipW GLdouble) (model (* GLdouble)) (proj (* GLdouble)) (view (* GLint)) (near GLdouble) (far GLdouble) (objX (* GLdouble)) (objY (* GLdouble)) (objZ (* GLdouble)) (objW (* GLdouble))) :returning GLint :module "/usr/lib/libGLU.so") ;;; DEFINE: #ifdef __cplusplus ;; **IGNORED**: #ifdef __cplusplus ;;; CODE: } ;; **IGNORED**: } ;;; DEFINE: #endif ;; **IGNORED**: #endif ;;; COMMENT: /* __glu_h__ */ ;;; DEFINE: #endif ;; **IGNORED**: #endif