source: project/wiki/eggref/4/gl-utils @ 31387

Last change on this file since 31387 was 31387, checked in by acharlton, 7 years ago

wiki/gl-utils: Update to 0.3.0

File size: 23.6 KB
Line 
1== gl-utils
2[[toc:]]
3Provides a higher level interface to OpenGL. The following modules are included:
4
5* gl-utils: Exports all of the modules in this egg
6* gl-utils-core: Convenience procedures for OpenGL, abstracting over common tasks
7* gl-utils-bytevector: OpenGL-safe R7RS style bytevectors with extended accessors
8* gl-utils-mesh: Convenient vertex array interface for creation, modification, and use
9* gl-utils-ply: [[http://paulbourke.net/dataformats/ply/|PLY]] file loading
10* gl-utils-srfi-4: OpenGL-safe numeric vectors
11
12
13=== Requirements
14* z3
15* matchable
16* miscmacros
17* srfi-42
18* opengl-glew
19* gl-math
20* make
21
22
23=== Documentation
24
25==== gl-utils-core
26<procedure> (check-error)</procedure>
27
28Performs {{get-error}} ({{glGetError}}) and prints the error type when an error is returned.
29
30<procedure> (make-shader TYPE SOURCE)</procedure>
31
32Creates and compiles a shader object given the shader's type (e.g. {{+vertex-shader+}}, {{+geometry-shader+}}, {{+fragment-shader+}}), and a string containing the GLSL source. Returns an integer representing the ID of the shader.
33
34<procedure> (make-program SHADER-LIST [PROGRAM-ID])</procedure>
35
36Creates and links a program object, given a list of shader objects (i.e. the integers returned by {{make-shader}}. Returns an integer representing the ID of the program.
37
38Accepts an optional {{PROGRAM-ID}} argument. If given, {{make-program}} will use this ID rather than generating a new one.
39
40<procedure> (gen-buffer)</procedure>
41<procedure> (gen-framebuffer)</procedure>
42<procedure> (gen-program-pipeline)</procedure>
43<procedure> (gen-query)</procedure>
44<procedure> (gen-renderbuffer)</procedure>
45<procedure> (gen-sampler)</procedure>
46<procedure> (gen-texture)</procedure>
47<procedure> (gen-transform-feedback)</procedure>
48<procedure> (gen-vertex-array)</procedure>
49
50Analogous to their pluralized counterparts, but only generates and returns one (integer) object.
51
52<procedure> (delete-buffer BUFFER)</procedure>
53<procedure> (delete-framebuffer FRAMEBUFFER)</procedure>
54<procedure> (delete-program-pipeline PROGRAM-PIPELINE)</procedure>
55<procedure> (delete-query QUERY)</procedure>
56<procedure> (delete-renderbuffer RENDERBUFFER)</procedure>
57<procedure> (delete-sampler SAMPLER)</procedure>
58<procedure> (delete-texture TEXTURE)</procedure>
59<procedure> (delete-transform-feedback TRANSFORM-FEEDBACK)</procedure>
60<procedure> (delete-vertex-array VERTEX-ARRAY)</procedure>
61
62Analogous to their pluralized counterparts, but only accepts and deletes one (integer) object.
63
64<macro> (with-buffer TYPE BUFFER BODY ...)</macro>
65<macro> (with-framebuffer FRAMEBUFFER BODY ...)</macro>
66<macro> (with-program-pipeline PROGRAM-PIPELINE BODY ...)</macro>
67<macro> (with-renderbuffer RENDERBUFFER BODY ...)</macro>
68<macro> (with-sampler UNIT SAMPLER BODY ...)</macro>
69<macro> (with-texture TYPE TEXTURE BODY ...)</macro>
70<macro> (with-transform-feedback TRANSFORM-FEEDBACK BODY ...)</macro>
71<macro> (with-vertex-array VERTEX-ARRAY BODY ...)</macro>
72
73Equivalent to binding the object, executing the body, then binding 0. E.g. {{(bind-texture TYPE TEXTURE) BODY ... (bind-texture TYPE 0)}}.
74
75<procedure> (set-texture-properties ID type: TYPE mag: MAG min: MIN wrap: WRAP wrap-s: WRAP-S wrap-t: WRAP-T wrap-r: WRAP-R)</procedure>
76
77Conveniently set the most common properties of the texture {{ID}}. {{TYPE}} is the texture type, defaulting to {{+texture-2d+}}. {{MAG}} and {{MIN}} are the texture magnify and minifying functions, which default to {{+linear+}}. {{WRAP-S}}, {{WRAP-T}}, and {{WRAP-R}} set the wrapping parameters which default to {{+repeat+}}. {{WRAP}} sets all three wrapping parameters to the same value.
78
79<procedure> (create-framebuffer WIDTH HEIGHT channels: CHANNELS type: TYPE)</procedure>
80
81Create a framebuffer with a texture and depth renderbuffer attached. The texture and renderbuffer are given the dimensions {{WITH}} and {{HEIGHT}}. {{CHANNELS}} is the number of channels that the texture has: 1, 2, 3, or 4, corresponding to {{+red+}}, {{+rg+}}, {{+rgb+, and}}+rgba+ respectively, defaulting to 4. {{TYPE}} is the type of the texture data which defaults to {{+unsigned-byte+}}. Returns three values: The framebuffer, the texture, and the renderbuffer.
82
83<procedure> (->pointer VECTOR)</procedure>
84
85Returns the pointer to a srfi-4 vector or blob.
86
87<procedure> (size VECTOR)</procedure>
88
89Returns the size, in bytes, of a srfi-4 vector or blob.
90
91<procedure> (type->bytes TYPE)</procedure>
92
93Returns the size of {{TYPE}} (as accepted by {{type->gl}}) in number of bytes.
94
95<procedure> (type->gl TYPE)</procedure>
96
97Converts the keyword {{TYPE}} into a OpenGL type enum value. Accepted types (grouped by synonyms) are:
98
99* {{char:}} {{int8:}} {{byte:}}
100* {{uchar:}} {{uint8:}} {{unsigned-byte:}}
101* {{short:}} {{int16:}}
102* {{ushort:}} {{uint16:}} {{unsigned-short:}}
103* {{int:}} {{int32:}} {{integer:}} {{integer32:}}
104* {{uint:}} {{uint32:}} {{unsigned-int:}} {{unsigned-int32:}} {{unsigned-integer:}} {{unsigned-integer32:}}
105* {{float:}} {{float32:}}
106* {{double:}} {{float64:}}
107
108
109==== gl-utils-bytevector
110r7rs style bytevectors with unsafe accessors. As in gl-utils-srfi4, bytevectors are created in non-garbage-collected memory. They will still be freed when no longer used.
111
112<procedure> (bytevector BYTE ...)</procedure>
113
114Returns a newly allocated bytevector containing its arguments.
115
116<procedure> (make-bytevector K [BYTE] [NONGC] [FINALIZE])</procedure>
117
118Return a newly-allocated bytevector of length {{K}}. If the optional fill {{BYTE}} is specified, it specifies the initial value for each slot in the bytevector.
119
120The optional arguments {{NONGC}} and {{FINALIZE}} define whether the vector should be allocated in a memory area not subject to garbage collection and whether the associated storage should be automatically freed (using finalization) when there are no references from Scheme variables and data. {{NONGC}} defaults to #t (the vector will be located in non-garbage-collected memory) and {{FINALIZE}} defaults to #t. Note that the {{FINALIZE}} argument is only used when {{NONGC}} is true.
121
122<procedure> (bytevector-length BYTEVECTOR)</procedure>
123
124Return the length in bytes of {{BYTEVECTOR}}.
125
126<procedure> (bytevector? BYTEVECTOR)</procedure>
127
128Returns true if {{BYTEVECTOR}} is a bytevector, false otherwise.
129
130<procedure> (bytevector-u8-set! BYTEVECTOR K UNSIGNED-BYTE)</procedure>
131<procedure> (bytevector-s8-set! BYTEVECTOR K BYTE)</procedure>
132<procedure> (bytevector-u16-set! BYTEVECTOR K UNSIGNED-SHORT)</procedure>
133<procedure> (bytevector-s16-set! BYTEVECTOR K SHORT)</procedure>
134<procedure> (bytevector-u32-set! BYTEVECTOR K UNSIGNED-INT)</procedure>
135<procedure> (bytevector-s32-set! BYTEVECTOR K INT)</procedure>
136<procedure> (bytevector-u64-set! BYTEVECTOR K UNSIGNED-LONG)</procedure>
137<procedure> (bytevector-s64-set! BYTEVECTOR K LONG)</procedure>
138<procedure> (bytevector-f32-set! BYTEVECTOR K FLOAT)</procedure>
139<procedure> (bytevector-f64-set! BYTEVECTOR K DOUBLE)</procedure>
140
141Sets the byte {{K}} of the given bytevector to be the value of the given fixnum or flonum. These functions are unsafe, so be sure {{K}} is a valid location in the bytevector.
142
143<procedure> (bytevector-u8-ref BYTEVECTOR K)</procedure>
144<procedure> (bytevector-s8-ref BYTEVECTOR K)</procedure>
145<procedure> (bytevector-u16-ref BYTEVECTOR K)</procedure>
146<procedure> (bytevector-s16-ref BYTEVECTOR K)</procedure>
147<procedure> (bytevector-u32-ref BYTEVECTOR K)</procedure>
148<procedure> (bytevector-s32-ref BYTEVECTOR K)</procedure>
149<procedure> (bytevector-u64-ref BYTEVECTOR K)</procedure>
150<procedure> (bytevector-s64-ref BYTEVECTOR K)</procedure>
151<procedure> (bytevector-f32-ref BYTEVECTOR K)</procedure>
152<procedure> (bytevector-f64-ref BYTEVECTOR K)</procedure>
153
154Returns the fixnum or flonum of the given size located at byte {{K}} of the given bytevector. These functions are unsafe, so be sure {{K}} is a valid location in the bytevector.
155
156<procedure> (bytevector–>pointer BYTEVECTOR)</procedure>
157
158Returns the pointer to {{BYTEVECTOR}}’s data.usage
159
160<procedure> (bytevector-append BYTEVECTOR . BYTEVECTORSS)</procedure>
161
162Returns a newly allocated bytevector whose elements are the concatenation of the elements in the given bytevectors. If only one argument is passed to {{bytevector-append}}, it is assumed that it is a list of bytevectors.
163
164<procedure> (bytevector-copy BYTEVECTOR [START] [END])</procedure>
165
166Returns a newly allocated copy of the elements of the given bytevector between {{START}} and {{END}}.
167
168<procedure> (bytevector-copy! TO AT FROM [START] [END])</procedure>
169
170Copies the elements of bytevector {{FROM}} between {{START}} and {{END}} to bytevector {{TO}}, starting at {{AT}}. It is an error if {{AT}} is less than zero or greater than the length of {{TO}}. It is also an error if {{(- (bytevector-length TO) AT)}} is less than {{(- END START)}}.
171
172
173==== gl-utils-mesh
174<procedure> (make-mesh vertices: VERTICES [indices: INDICES] [mode: MODE])</procedure>
175
176Create a new mesh. {{VERTICES}} is a list of key value pairs that specifies the mesh’s vertex data. It should be in the form:
177
178    (attributes: ATTRIBUTES [initial-elements: INITIAL-ELEMENTS] [n-vertices: N-VERTICES])
179
180{{ATTRIBUTES}} is a list in the form:
181
182    (NAME TYPE N [normalized: NORMALIZED])
183
184where {{NAME}} is the attribute name (as a symbol), {{TYPE}} is the type of the attribute as accepted by {{type->gl}}, {{N}} is the number of elements in the attribute, {{NORMALIZED}} is a boolean value indicating whether the attribute’s values should be normalized (defaulting to {{#f}}).
185
186{{INITIAL-ELEMENTS}} is either a bytevector or a list of {{(NAME . VALUE)}} pairs where name is the name of the attribute to set (as per the name given in {{ATTRIBUTES}}) and {{VALUE}} is the initial contents of that attribute. When a list is given and more than one attribute is given initial-elements, the {{VALUE}}s should represent the same number of vertices. Values associated with attributes that are {{NORMALIZED}} should be provided as float between {{0.0}} and {{1.0}} (for unsigned types) or {{-1.0}} and {{1.0}}, which are then normalized. If {{INITIAL-ELEMENTS}} is given as a bytevector, that bytevector is used as the entire mesh’s vertex data and {{N-VERTICES}} – the number of vertices – must be provided.
187
188{{INDICES}} is an optional list of key value pairs that specifies the mesh’s index data, if it exists. It should be in the form:
189
190    (type: TYPE [initial-elements: INITIAL-ELEMENTS] [n-indices: N-INDICES])
191
192{{TYPE}} is a type keyword (as accepted by {{type->gl}}) that must be a valid type for an element array buffer (i.e. an unsigned fixnum). {{INITIAL-ELEMENTS}} is either a bytevector or a list of values. If {{INITIAL-ELEMENTS}} is given as a bytevector,  {{N-INDICES}} – the number of indices – must be provided.
193
194{{MODE}} is the keyword (as accepted by {{mode->gl}}) that defines what the mesh is supposed to represent. Defaults to {{#:triangles}}.
195
196<record> (mesh VERTEX-ATTRIBUTES INDEX-TYPE VERTEX-DATA INDEX-DATA N-VERTICES N-INDICES VERTEX-BUFFER INDEX-BUFFER VAO STRIDE MODE USAGE)</record>
197
198The type of record returned by {{make-mesh}}. {{VERTEX-ATTRIBUTES}} is a list of {{vertex-attribute}} records. {{INDEX-TYPE}} is the type given to the {{indices:}} argument of {{make-mesh}}. {{VERTEX-DATA}} and {{INDEX-DATA}} are the bytevectors representing the vertex and index data. {{N-VERTICES}} and {{N-INDICES}} are the number of vertices and indices present in the data. {{VERTEX-BUFFER}}, {{INDEX-BUFFER}} and {{VAO}} are the vertex buffers and VAO created by {{mesh-make-vao!}}. {{STRIDE}} is the number of bytes between the start of consecutive vertices. {{MODE}} is the value of the {{mode:}} argument provided to {{make-mesh}}. {{USAGE}} is the buffer usage that is set with {{make-mesh-vao!}}.
199
200<record> (vertex-attribute name type number normalized)</record>
201
202The type of record returned by {{mesh-vertex-attributes}}. Getters for all of the fields are provided.
203
204<procedure> (mesh-make-vao! MESH LOCATIONS [USAGE])</procedure>
205
206Create a vertex attribute object (VAO) for {{MESH}}. {{LOCATIONS}} is a list of {{(ATTRIBUTE-NAME . LOCATION)}} pairs. {{USAGE}} is the buffer usage hint keyword as accepted by {{usage->gl}}, defaulting to {{#:static}}. Vertex buffer objects (VBOs) are created for the vertex and index data. The VAO binds these buffers, and sets the vertex attribute pointers of attributes for which locations have been given. If the usage is one of the static types, the vertex and index data of the mesh are deleted, as are the vertex and index buffers. The VBOs and VAO created by {{make-mesh-vao!}} are managed and should not be deleted.
207
208<procedure> (mesh-vertex-ref MESH ATTRIBUTE VERTEX)</procedure>
209
210Return a vector containing the values of the attribute named {{ATTRIBUTE}} corresponding to the {{VERTEX}}th vertex of the {{MESH}}. The result will be a srfi-4 numeric vector, corresponding to the type of the given attribute.
211
212<procedure> (mesh-vertex-set! MESH ATTRIBUTE VERTEX VALUE)</procedure>
213
214Set the {{VERTEX}}th vertex of the {{MESH}}’s attribute named {{ATTRIBUTE}} to the values provided by the srfi-4 numeric vector {{VALUE}}. {{VALUE}} must correspond to the type of the attribute, and should be the same length as the attribute. Using a {{VALUE}} that is too short is unsafe.
215
216If {{mesh-make-vao!}} has been called already, {{mesh-vertex-set!}} should be called inside a {{with-mesh}}. If {{mesh-make-vao!}} was called with a static usage, {{mesh-vertex-set!}} will result in an error, since there is no longer any vertex data to set.
217
218<procedure> (with-mesh MESH THUNK)</procedure>
219
220Calls {{THUNK}} with the VBO of the {{MESH}}’s vertex buffer bound. If the mesh has been modified by {{mesh-vertex-set!}}, the vertex buffer’s data will be updated before the VBO is unbound. When the usage hint given to {{mesh-make-vao!}} is dynamic, {{buffer-sub-data}} will be used to update the buffer data. When the usage hint is stream, {{buffer-data}} will be used.
221
222<procedure> (mesh-copy! TO AT FROM [START] [END])</procedure>
223
224Similar to {{bytevector-copy!}}, copies the vertices of mesh {{FROM}} between vertices {{START}} and {{END}} to mesh {{TO}}, starting at vertex {{AT}}.
225
226<procedure> (mesh-copy MESH)</procedure>
227
228Creates a fresh copy of {{MESH}}.
229
230<procedure> (mesh-append MESH . MESHES)</procedure>
231
232Creates a new mesh resulting from appending the vertices of the given meshes together. The indices are also appended and modified so they point to the same vertices. The attributes of all the meshes are assumed to be the same, otherwise bad things will probably happen. If only one argument is passed to {{mesh-append}} it is assumed that it is a list of meshes.
233
234<procedure> (mesh-transform! POSITION-NAME MESH TRANSFORM)</procedure>
235
236Destructively modifies the {{POSITION-NAME}} attribute of {{MESH}} by the [[http://wiki.call-cc.org/eggref/4/gl-math|gl-math]] matrix {{TRANSFORM}}. {{POSITION-NAME}} must be the name of a three element float attribute of {{MESH}}.
237
238<procedure> (mesh-transform-append POSITION-NAME MESH-TRANSFORM-PAIR . MESH-TRANSFORM-PAIRS)</procedure>
239
240Creates a new mesh resulting by appending all the given meshes together, then transforming the attribute named by {{POSITION-NAME}} by the given [[http://wiki.call-cc.org/eggref/4/gl-math|gl-math]] transform matrices. {{MESH-TRANSFORM-PAIR}} and {{MESH-TRANSFORM-PAIRS}} are {{(MESH . TRANFORM)}} pairs. {{POSITION-NAME}} must be the name of a three element float attribute of {{MESH}}. The attributes of all the meshes are assumed to be the same, otherwise bad things will probably happen. If only two arguments are passed to {{mesh-transform-append}} it is assumed that the second is a list of mesh/transform pairs.
241
242<procedure> (usage->gl USAGE)</procedure>
243
244Converts the keyword {{USAGE}} into a OpenGL usage enum value. Accepted usages (grouped by synonyms) are:
245
246* {{dynamic:}} {{dynamic-draw:}}
247* {{stream:}} {{stream-draw:}}
248* {{static:}} {{static-draw:}}
249* {{dynamic-read:}}
250* {{stream-read:}}
251* {{static-read:}}
252* {{dynamic-copy:}}
253* {{stream-copy:}}
254* {{static-copy:}}
255
256This line is here to prevent a Markdown parsing error :|
257
258<procedure> (mode->gl MODE)</procedure>
259
260Converts the keyword {{MODE}} into a OpenGL mode enum value. Accepted modes are:
261
262* {{points:}}
263* {{line-strip:}}
264* {{line-loop:}}
265* {{line-strip-adjacency:}}
266* {{lines-adjacency:}}
267* {{triangle-strip:}}
268* {{triangle-fan:}}
269* {{triangles:}}
270* {{triangle-strip-adjacency:}}
271* {{triangles-adjacency:}}
272* {{patches:}}
273
274
275==== gl-utils-ply
276<procedure> (load-ply FILE BUFFER-SPEC)</procedure>
277
278Loads a [[http://paulbourke.net/dataformats/ply/|PLY]] file. {{FILE}} is a path that may be pointing either to a gziped PLY file or a regular PLY file. {{BUFFER-SPEC}} is a list in the form {{((NAME VARS) ...)}} where {{NAME}} is the name of an element in the PLY file and {{VARS}} is either a list of property names or, in the case of a property list, a single name. Two values are returned: a list of bytevectors which correspond to the buffers named in {{BUFFER-SPEC}} and a list of the elements that are in the PLY file in the form of:
279
280    (element-name n-elements (property-name property-type))
281
282Or, when an element is a property list:
283
284    (element-name n-elements (property-name (list: list-length-type element-type)))
285
286The buffers returned are packed with the contents of the properties named in the {{BUFFER-SPEC}}. Thus, for a PLY file that has element {{vertex}} with properties {{float x}}, {{float y}}, {{float z}}, {{float confidence}}, {{uchar r}}, {{uchar g}}, and {{uchar b}}, as well as an element {{face}} with a property list {{uchar ushort vertex_index}}, the following {{BUFFER-SPEC}} could be used:
287
288    (load-ply "example.ply.gz" '((vertex: (x y z r g b)) (face: vertex_index)))
289
290This buffer spec would result in a list of two u8vectors being returned: one with the packed elements corresponding to properties {{x}}, {{y}}, {{z}}, {{r}}, {{g}}, and {{b}} (with the corresponding property types), and the second containing the vertex indices.
291
292<procedure> (load-ply-mesh FILE vertex: VERTEX face: FACE)</procedure>
293
294Similar to load-ply, but returns a mesh. {{FILE}} is a PLY file (which may be gziped). The PLY file must contain at least the elements {{vertex}} and {{face}} (other elements will be ignored). {{VERTEX}} is a list of {{(ATTRIBUTE-NAME PROPERTY-NAME ...)}} elements, which specifies which PLY properties are associate with which attribute, in which order. Attributes are all normalized. All properties named by each element of {{VERTEX}} must be of the same type. {{FACE}} is the name of the face property list.
295
296Again, for a PLY file that has element {{vertex}} with properties {{float x}}, {{float y}}, {{float z}}, {{float confidence}}, {{uchar r}}, {{uchar g}}, and {{uchar b}}, as well as a element {{face}} with a property list {{uchar ushort vertex_index}}, the following could be used:
297
298    (load-ply-mesh "example.ply" vertex: `((position x y z)
299                                          (color r g b))
300                                face: vertex_index)
301
302This would create a mesh with vertex attributes {{(position #:float 3)}} and {{(color #:unsigned-byte 3 normalized: #t)}} and the {{#:unsigned-short}} indices given by {{vertex_index}}.
303
304
305==== gl-utils-srfi4
306gl-utils-srfi4 reexports a version of [[http://api.call-cc.org/doc/srfi-4|srfi-4]] that gives preference to vectors being created in non-garbage collected memory. This is useful for use with OpenGL, since it is often desirable to pass vectors to OpenGL that will remain in one place. All srfi-4 functions not mentioned below are reexported without changes.
307
308The {{NNNvector}} and {{list->NNNvector}} constructors have been modified so that they return vectors in non-garbage collected memory. They will still be freed when no longer used.
309
310The {{make-NNNvector}} constructors act as their srfi-4 counterparts, except they return vectors in non-garbage collected memory by default. They will still be freed when non longer used.
311
312
313=== Examples
314This example depends on the [[http://wiki.call-cc.org/eggref/4/opengl-glew|opengl-glew]] egg, the [[http://wiki.call-cc.org/eggref/4/glfw3|glfw3]] egg for window and context creation, and the [[http://wiki.call-cc.org/eggref/4/gl-math|gl-math]] egg for matrix math.
315
316For more examples, check out the [[https://github.com/AlexCharlton/gl-utils/tree/master/examples|examples directory]].
317
318<enscript highlight="scheme">    
319(import chicken scheme)
320(use (prefix glfw3 glfw:) (prefix opengl-glew gl:) gl-math gl-utils)
321
322(define *vertex*
323#<<END
324#version 330
325in vec2 position;
326in vec3 color;
327out vec3 c;
328uniform mat4 MVP;
329
330void main(){
331   gl_Position = MVP * vec4(position, 0.0, 1.0);
332   c = color;
333}
334END
335)
336
337(define *fragment*
338#<<END
339#version 330
340in vec3 c;
341out vec4 fragColor;
342void main(){
343  fragColor = vec4(c, 1.0);
344}
345END
346)
347
348(define rect (make-mesh
349              vertices: '(attributes: ((position #:float 2)
350                                       (color #:unsigned-byte 3
351                                              normalized: #t))
352                          initial-elements: ((position . (-1 -1
353                                                           1 -1
354                                                           1  1
355                                                           -1  1))
356                                             (color . (255 0   0
357                                                       0   255 0
358                                                       0   0   255
359                                                       255 0   255))))
360              indices: '(type: #:ushort
361                         initial-elements: (0 1 2
362                                            0 2 3))))
363
364(define program (make-parameter #f))
365
366(define projection-matrix
367  (perspective 640 480 0.1 100 70))
368
369(define view-matrix
370  (look-at (make-point 1 0 3)
371           (make-point 0 0 0)
372           (make-point 0 1 0)))
373
374(define model-matrix (mat4-identity))
375
376(define (render)
377  (gl:use-program (program))
378  (gl:uniform-matrix4fv (gl:get-uniform-location (program) "MVP")
379                        1 #f
380                        (m* projection-matrix
381                            (m* view-matrix model-matrix)))
382  (gl:bind-vertex-array (mesh-vao rect))
383  (gl:draw-elements-base-vertex (mode->gl (mesh-mode rect))
384                                (mesh-n-indices rect)
385                                (type->gl (mesh-index-type rect))
386                                #f 0)
387
388  (check-error)
389  (gl:bind-vertex-array 0))
390
391(glfw:with-window (640 480 "Example" resizable: #f
392                       context-version-major: 3
393                       context-version-minor: 3)
394  (gl:init)
395
396  (print (gl:supported? "GL_ARB_framebuffer_object"))
397
398  (set! *vertex* (make-shader gl:+vertex-shader+ *vertex*))
399  (set! *fragment* (make-shader gl:+fragment-shader+ *fragment*))
400  (program (make-program (list *vertex* *fragment*)))
401
402  (mesh-make-vao! rect `((position . ,(gl:get-attrib-location
403                                       (program) "position"))
404                         (color . ,(gl:get-attrib-location
405                                    (program) "color"))))
406  (let loop ()
407    (glfw:swap-buffers (glfw:window))
408    (gl:clear (bitwise-ior gl:+color-buffer-bit+ gl:+depth-buffer-bit+))
409    (render)
410    (glfw:poll-events) ; Because of the context version, initializing GLEW results in a harmless invalid enum
411    (unless (glfw:window-should-close (glfw:window))
412      (loop))))
413</enscript>
414
415
416=== Version history
417
418==== Version 0.3.0
41911 September 2014
420
421* Merge {{mesh-attribute-locations-set!}} with {{mesh-make-vao!}}
422
423
424==== Version 0.2.0
42510 September 2014
426
427* Add gl-utils-bytevector module
428* Add gl-utils-mesh module
429* Remove now-unneeded (and broken) {{make-vao}}, {{make-ply-vao}}
430
431
432==== Version 0.1.2
4332 September 2014
434
435* Update example for gl-math 0.5
436
437'''Version 0.1.1'''
438* Initial release
439
440
441=== Source repository
442Source available on [[https://github.com/AlexCharlton/gl-utils|GitHub]].
443
444Bug reports and patches welcome! Bugs can be reported via GitHub or to alex.n.charlton at gmail.
445
446
447=== Author
448Alex Charlton
449
450
451=== License
452BSD
Note: See TracBrowser for help on using the repository browser.