Hi,
I think I need to have more LISP experience to get the idea how it works :-) As far as I see, when a function like cl:vertex-pointer is called, the arguments are automatically converted to native arrays. Perhaps it's one of the features of the new CFFI library.
Could you tell a few words about the things which happen behind the scenes?
And how do you make sure that the native array does not get garbage-collected / moved / re-used until the next call to the ...-pointer function?
------
As for my patch, it is quite simple and does not require new CFFI. While the drawback is that it does not support interleaved arrays. On the other hand, I do not see any reason why they could be useful in LISP as their complexity seems to overweight the benefit.
- According to the OpenGL specification, there are 9 types of pointers which can be used for batch-drawing with the functions like glDrawElements. Also there are 9 client states. And it is important that the arrays have to be available since their declaration to OpenGL using the functions like glVertexPointer up to the moment when they are already used and are not going to be used any more. - On LISP side the the arrays can be specified either as an array (1D or 2D, depending on the case) or as a sequence (which is treated like a 1D array). Theoretically it is possible to support a 2D list-based structure or a native representation. That is not yet implemented and can be easily added.
My implementation maintains 9 native arrays. Each time a ....pointer function is called, the array is populated from the supplied data structure. There is no need to specify the "width" of the data. It is retrieved from the source data directly.
The array is maintained until the moment it is declared that it not going to be used or the program terminates. This guarantees its availability to the OpenGL subsystem.
....-pointer functions are called either with a data structure or with "nil" as a parameter. If it is "nil", the respective client state is disabled. If not, the state is enabled and the data structure is mapped to the native array (the array is resized when necessary) and then advertised to OpenGL using functions like glColorPointer. So, there is no need to maintain the client state manually.
So, the code for aapoly demo from the Red Book (method "draw") looks like this:
(let ((colors (make-array '(8 4) :initial-contents '((0.0 0.0 0.0 1.0) (1.0 0.0 0.0 1.0) (0.0 0.0 1.0 1.0) (1.0 1.0 0.0 1.0) (0.0 0.0 1.0 1.0) (1.0 0.0 1.0 1.0) (0.0 1.0 1.0 1.0) (1.0 1.0 1.0 1.0)))) (indices (make-array '(6 4) :initial-contents '((4 5 6 7) (2 3 7 6) (0 4 7 3) (0 1 5 4) (1 5 6 2) (0 3 2 1)))) (verticles (make-array '(8 3) :initial-contents `((,x0 ,y0 ,z0) (,x1 ,y0 ,z0) (,x1 ,y1 ,z0) (,x0 ,y1 ,z0) (,x0 ,y0 ,z1) (,x1 ,y0 ,z1) (,x1 ,y1 ,z1) (,x0 ,y1 ,z1)))))
(gl:vertex-pointer verticles :float) (gl:color-pointer colors :float) (gl:draw-elements :quads indices) (gl:color-pointer) (gl:vertex-pointer))
Thank you, Denis Rtveliashvili
On 02/05/07, Denys Rtveliashvili rtvd@mail.ru wrote:
I created a patch for adding a support for Vertex Arrays in cl-opengl.
There's been some work on that already. I've been meaning to announce this branch on this list, so here it goes. There's a cl-opengl-thomas branch in http://common-lisp.net/~loliveira/darcs/, which, among other things, includes some work on vertex arrays, including a macro for defining array layouts. It depends on the cffi-newtypes tree which you can find in that same directory.
Please have a look at that branch and let us know what you think, how that relates to your work, etc...
Thanks.
-- Luís Oliveira http://student.dei.uc.pt/~lmoliv/ _______________________________________________ cl-opengl-devel mailing list cl-opengl-devel@common-lisp.net http://common-lisp.net/cgi-bin/mailman/listinfo/cl-opengl-devel