source: GTP/branches/IllumWPdeliver2008dec/IlluminationWP/demos/Standalone/Hierarchical Systems Demo [OpenGL]/RESOURCES/include/glh/glh_obs.h @ 3255

Revision 3255, 16.1 KB checked in by szirmay, 15 years ago (diff)
Line 
1/*
2    glh - is a platform-indepenedent C++ OpenGL helper library
3
4
5    Copyright (c) 2000 Cass Everitt
6        Copyright (c) 2000 NVIDIA Corporation
7    All rights reserved.
8
9    Redistribution and use in source and binary forms, with or
10        without modification, are permitted provided that the following
11        conditions are met:
12
13     * Redistributions of source code must retain the above
14           copyright notice, this list of conditions and the following
15           disclaimer.
16
17     * Redistributions in binary form must reproduce the above
18           copyright notice, this list of conditions and the following
19           disclaimer in the documentation and/or other materials
20           provided with the distribution.
21
22     * The names of contributors to this software may not be used
23           to endorse or promote products derived from this software
24           without specific prior written permission.
25
26       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
27           ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
28           LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
29           FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
30           REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
31           INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
32           BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
33           LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
34           CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35           LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
36           ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37           POSSIBILITY OF SUCH DAMAGE.
38
39
40    Cass Everitt - cass@r3.nu
41*/
42
43// This is a file for simple GL helper classes...
44
45#ifndef GLH_OBS_H
46#define GLH_OBS_H
47
48#ifdef _WIN32
49# include <windows.h>
50#endif
51
52#ifdef MACOS
53#include <OpenGL/gl.h>
54#include <OpenGL/glext.h>
55#else
56#include <GL/gl.h>
57#include <GL/glext.h>
58#endif
59
60#include <glh/glh_extensions.h>
61
62#include <glh/glh_linear.h>
63
64namespace glh
65{
66        class display_list
67        {
68        public:
69        // set managed to true if you want the class to cleanup objects in the destructor
70                display_list(bool managed = false)
71                        : valid(false), manageObjects(managed) {}
72               
73                virtual ~display_list()
74                {
75            if (manageObjects)
76                del();
77        }
78               
79                void call_list()
80                { if(valid) glCallList(dlist); }
81               
82                void new_list(GLenum mode)
83                { if(!valid) gen(); glNewList(dlist, mode); }
84               
85                void end_list()
86                { glEndList(); }
87               
88                void del()
89                { if(valid) glDeleteLists(dlist, 1); valid = false; }
90               
91                bool is_valid() const { return valid; }
92               
93        private:
94               
95                void gen() { dlist = glGenLists(1); valid=true; }
96               
97                bool valid;
98        bool manageObjects;
99                GLuint dlist;
100        };
101       
102        class lazy_build_display_list
103        {
104        public:
105        // set managed to true if you want the class to cleanup objects in the destructor
106                lazy_build_display_list(void (* builder)() = 0, bool managed = false)
107                        : valid(false), manageObjects(managed), needs_rebuild(true), build_func(builder) {}
108               
109                virtual ~lazy_build_display_list()
110                {
111            if (manageObjects)
112                del();
113        }
114
115                void set_build_func( void (* builder)())
116                { build_func = builder; }
117
118                void call_list()
119                {
120                        if(! valid) gen();
121                        if(needs_rebuild) rebuild_list();
122                        glCallList(dlist);
123                }
124               
125                void del()
126                { if(valid) glDeleteLists(dlist, 1); valid = false; needs_rebuild = true;}
127               
128                bool is_valid() const { return valid; }
129
130                // something changed, so rebuild list before next call_list()
131                void rebuild() { needs_rebuild = true; }
132               
133        private:
134               
135                void gen() { dlist = glGenLists(1); valid=true; }
136                void rebuild_list()
137                {
138                        glNewList(dlist, GL_COMPILE);
139                        if(build_func) (* build_func)(); // call list building routine
140                        glEndList();
141                }
142               
143                bool valid;
144        bool manageObjects;
145                bool needs_rebuild;
146                GLuint dlist;
147                void (* build_func)();
148        };
149       
150       
151        class tex_object
152        {
153        public:
154        // set managed to true if you want the class to cleanup objects in the destructor
155                tex_object(GLenum tgt, bool managed)
156                        : target(tgt), valid(false), manageObjects(managed) {}
157               
158                virtual ~tex_object()
159        {
160            if (manageObjects)
161                del();
162        }
163               
164                void bind()
165                { if(!valid) gen(); glBindTexture(target, texture); }
166               
167                // convenience methods
168
169#ifdef MACOS
170                void parameter(GLenum pname, int i)
171                { glTexParameteri(target, pname, i); }
172#endif
173
174                void parameter(GLenum pname, GLint i)
175                { glTexParameteri(target, pname, i); }
176
177                void parameter(GLenum pname, GLfloat f)
178                { glTexParameterf(target, pname, f); }
179
180                void parameter(GLenum pname, GLint * ip)
181                { glTexParameteriv(target, pname, ip); }
182
183                void parameter(GLenum pname, GLfloat * fp)
184                { glTexParameterfv(target, pname, fp); }
185
186                void enable() { glEnable(target); }
187                void disable() { glDisable(target); }
188
189
190        void del()
191        { if(valid) glDeleteTextures(1, &texture); valid = false; }
192        bool is_valid() const { return valid; }
193               
194                void gen() { glGenTextures(1, &texture); valid=true; }
195               
196                GLenum target;
197                bool valid;
198        bool manageObjects;
199                GLuint texture;
200        };
201       
202        class tex_object_1D : public tex_object
203        { public: tex_object_1D(bool managed = false) : tex_object(GL_TEXTURE_1D, managed) {} };
204       
205        class tex_object_2D : public tex_object
206        { public: tex_object_2D(bool managed = false) : tex_object(GL_TEXTURE_2D, managed) {} };
207
208    class tex_object_3D : public tex_object
209        { public: tex_object_3D(bool managed = false) : tex_object(GL_TEXTURE_3D, managed) {} };
210
211
212# ifdef GL_ARB_texture_cube_map
213        class tex_object_cube_map : public tex_object
214        { public: tex_object_cube_map(bool managed = false) : tex_object(GL_TEXTURE_CUBE_MAP_ARB, managed) {} };
215# elif GL_EXT_texture_cube_map
216        class tex_object_cube_map : public tex_object
217        { public: tex_object_cube_map(bool managed = false) : tex_object(GL_TEXTURE_CUBE_MAP_EXT, managed) {} };
218# endif
219
220#if defined(GL_EXT_texture_rectangle)
221        class tex_object_rectangle : public tex_object
222        { public: tex_object_rectangle(bool managed = false) : tex_object(GL_TEXTURE_RECTANGLE_EXT, managed) {} };
223#elif defined(GL_NV_texture_rectangle)
224        class tex_object_rectangle : public tex_object
225        { public: tex_object_rectangle(bool managed = false) : tex_object(GL_TEXTURE_RECTANGLE_NV, managed) {} };
226#endif
227
228
229# ifdef GL_NV_vertex_program
230        class vertex_program_base
231        {
232        public:
233        // set managed to true if you want the class to cleanup objects in the destructor
234                vertex_program_base(GLenum tgt, bool managed)
235                        : valid(false), manageObjects(managed), target(tgt) {}
236               
237                virtual ~vertex_program_base()
238        {
239            if (manageObjects)
240                del();
241        }
242               
243                void bind()
244                { if(!valid) gen(); glBindProgramNV(target, program); }
245               
246                void unbind()
247                { glBindProgramNV(target, 0); }
248               
249                void load(GLuint size, const GLubyte * prog_text)
250                {
251                        if(!valid) gen();
252                        glLoadProgramNV(target, program, size, prog_text);
253                        GLint errpos;
254                        glGetIntegerv(GL_PROGRAM_ERROR_POSITION_NV, &errpos);
255                        if(errpos != -1)
256                        {
257                                fprintf(stderr, "program error:\n");
258                                int bgn = errpos - 10;
259                                bgn < 0 ? 0 : bgn;
260                                const char * c = (const char *)(prog_text + bgn);
261                                for(int i = 0; i < 30; i++)
262                                {
263                                        if(bgn+i >= int(size-1))
264                                                break;
265                                        fprintf(stderr, "%c", *c++);
266                                }
267                                fprintf(stderr, "\n");
268                        }
269                }
270
271                void load(GLuint size, const char * prog_text)
272                {
273                        if(!valid) gen();
274                        glLoadProgramNV(target, program, size, (const GLubyte *) prog_text);
275                        GLint errpos;
276                        glGetIntegerv(GL_PROGRAM_ERROR_POSITION_NV, &errpos);
277                        if(errpos != -1)
278                        {
279                                fprintf(stderr, "program error:\n");
280                                int bgn = errpos - 10;
281                                //bgn < 0 ? 0 : bgn;
282                                const char * c = (const char *)(prog_text + bgn);
283                                for(int i = 0; i < 30; i++)
284                                {
285                                        if(bgn+i >= int(size-1))
286                                                break;
287                                        fprintf(stderr, "%c", *c++);
288                                }
289                                fprintf(stderr, "\n");
290                        }
291                }
292
293                void load(const char * prog_text)
294                { load((GLuint)strlen(prog_text), prog_text); }
295
296
297                void del()
298                { if(valid) glDeleteProgramsNV(1, &program); valid = false; }
299               
300                bool is_valid() const { return valid; }
301               
302        private:
303               
304                void gen() { glGenProgramsNV(1, &program); valid=true; }
305               
306                bool valid;
307        bool manageObjects;
308                GLenum target;
309                GLuint program;
310        };
311
312        class vertex_program : public vertex_program_base
313        {
314        public:
315                vertex_program(bool managed = false)
316                        : vertex_program_base(GL_VERTEX_PROGRAM_NV, managed) {}
317        };             
318
319        class vertex_state_program : public vertex_program_base
320        {
321        public:
322                vertex_state_program(bool managed = false)
323                        : vertex_program_base(GL_VERTEX_STATE_PROGRAM_NV, managed) {}
324        };
325
326        class lazy_load_vertex_program : public vertex_program_base
327        {
328                public:
329                lazy_load_vertex_program(void (*vp_loader)() = 0, bool managed = false)
330                        : vertex_program_base(GL_VERTEX_PROGRAM_NV, managed), needs_load(true), loader(vp_loader) {}
331
332                void bind()
333                {
334                        vertex_program_base::bind();
335                        if(needs_load && loader)
336                        {
337                                (* loader)();
338                                needs_load = false;
339                        }
340                }
341
342                void reload() { needs_load = true; }
343
344                private:
345                        bool needs_load;
346                        void (* loader)();
347        };             
348
349
350#endif
351
352# ifdef GL_ARB_vertex_program
353        class arb_vertex_program_base
354        {
355        public:
356        // set managed to true if you want the class to cleanup objects in the destructor
357                arb_vertex_program_base(GLenum tgt, bool managed)
358                        : valid(false), manageObjects(managed), target(tgt) {}
359               
360                virtual ~arb_vertex_program_base()
361        {
362            if (manageObjects)
363                del();
364        }
365               
366                void bind()
367                { if(!valid) gen(); glBindProgramARB(target, program); }
368               
369                void unbind()
370                { glBindProgramARB(target, 0); }
371               
372                void load(GLuint size, const GLubyte * prog_text)
373                {
374                        if(!valid) gen();
375                        bind();
376                        glProgramStringARB(target, GL_PROGRAM_FORMAT_ASCII_ARB, size, prog_text);
377                        GLint errpos;
378                        glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errpos);
379                        if(errpos != -1)
380                        {
381                                fprintf(stderr, "program error:\n");
382                                int bgn = errpos - 10;
383                                bgn < 0 ? 0 : bgn;
384                                const char * c = (const char *)(prog_text + bgn);
385                                for(int i = 0; i < 30; i++)
386                                {
387                                        if(bgn+i >= int(size-1))
388                                                break;
389                                        fprintf(stderr, "%c", *c++);
390                                }
391                                fprintf(stderr, "\n");
392                        }
393                }
394
395                void load(GLuint size, const char * prog_text)
396                {
397                        if(!valid) gen();
398                        bind();
399                        glProgramStringARB(target, GL_PROGRAM_FORMAT_ASCII_ARB, size, prog_text);
400                        GLint errpos;
401                        glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errpos);
402                        if(errpos != -1)
403                        {
404                                fprintf(stderr, "program error:\n");
405                                int bgn = errpos - 10;
406                                //bgn < 0 ? 0 : bgn;
407                                const char * c = (const char *)(prog_text + bgn);
408                                for(int i = 0; i < 30; i++)
409                                {
410                                        if(bgn+i >= int(size-1))
411                                                break;
412                                        fprintf(stderr, "%c", *c++);
413                                }
414                                fprintf(stderr, "\n");
415                        }
416                }
417
418                void load(const char * prog_text)
419                { load((GLuint)strlen(prog_text), prog_text); }
420
421
422                void del() { if(valid) glDeleteProgramsARB(1, &program); valid = false; }
423               
424                bool is_valid() const { return valid; }
425               
426        private:
427               
428                void gen() { glGenProgramsARB(1, &program); valid=true; }
429               
430                bool valid;
431        bool manageObjects;
432                GLenum target;
433                GLuint program;
434        };
435
436        class arb_vertex_program : public arb_vertex_program_base
437        {
438        public:
439                arb_vertex_program(bool managed = false)
440                        : arb_vertex_program_base(GL_VERTEX_PROGRAM_ARB, managed) {}
441        };             
442
443        class lazy_load_arb_vertex_program : public arb_vertex_program_base
444        {
445                public:
446                lazy_load_arb_vertex_program(void (*vp_loader)() = 0, bool managed = false)
447                        : arb_vertex_program_base(GL_VERTEX_PROGRAM_ARB, managed), needs_load(true), loader(vp_loader) {}
448
449                void bind()
450                {
451                        arb_vertex_program_base::bind();
452                        if(needs_load && loader)
453                        {
454                                (* loader)();
455                                needs_load = false;
456                        }
457                }
458
459                void reload() { needs_load = true; }
460
461                private:
462                        bool needs_load;
463                        void (* loader)();
464        };             
465
466#endif
467
468# ifdef GL_NV_fragment_program
469
470        class fragment_program
471        {
472        public:
473        // set managed to true if you want the class to cleanup objects in the destructor
474                fragment_program(bool managed = false)
475                        : valid(false), manageObjects(managed) {}
476               
477                virtual ~fragment_program()
478        {
479            if (manageObjects)
480                del();
481        }
482               
483                void bind()
484                { if(!valid) gen(); glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, program); }
485               
486                void load(GLuint size, const GLubyte * prog_text)
487                {
488                        if(!valid) gen();
489                        glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, program, size, prog_text);
490                        GLint errpos;
491                        glGetIntegerv(GL_PROGRAM_ERROR_POSITION_NV, &errpos);
492                        if(errpos != -1)
493                        {
494                                fprintf(stderr, "program error:\n");
495                                int bgn = errpos - 10;
496                                bgn < 0 ? 0 : bgn;
497                                const char * c = (const char *)(prog_text + bgn);
498                                for(int i = 0; i < 30; i++)
499                                {
500                                        if(bgn+i >= int(size-1))
501                                                break;
502                                        fprintf(stderr, "%c", *c++);
503                                }
504                                fprintf(stderr, "\n");
505                        }
506                }
507
508                void load(GLuint size, const char * prog_text)
509                {
510                        if(!valid) gen();
511                        glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, program, size, (const GLubyte *) prog_text);
512                        GLint errpos;
513                        glGetIntegerv(GL_PROGRAM_ERROR_POSITION_NV, &errpos);
514                        if(errpos != -1)
515                        {
516                                fprintf(stderr, "program error:\n");
517                                int bgn = errpos - 10;
518
519                                const char * c = (const char *)(prog_text + bgn);
520                                for(int i = 0; i < 30; i++)
521                                {
522                                        if(bgn+i >= int(size-1))
523                                                break;
524                                        fprintf(stderr, "%c", *c++);
525                                }
526                                fprintf(stderr, "\n");
527                        }
528                }
529
530                void load(const char * prog_text)
531                { load((GLuint)strlen(prog_text), prog_text); }
532
533                void del()
534                { if(valid) glDeleteProgramsNV(1, &program); valid = false; }
535               
536                bool is_valid() const { return valid; }
537               
538                GLuint program;
539        private:
540               
541                void gen() { glGenProgramsNV(1, &program); valid=true; }
542               
543                bool valid;
544        bool manageObjects;
545        };
546
547
548#endif
549
550#ifdef GL_ARB_fragment_program
551
552        class arb_fragment_program
553        {
554        public:
555        // set managed to true if you want the class to cleanup objects in the destructor
556                arb_fragment_program(bool managed = false)
557                        : valid(false), manageObjects(managed) {}
558               
559                virtual ~arb_fragment_program()
560        {
561            if (manageObjects)
562                del();
563        }
564               
565                void bind()
566                { if(!valid) gen(); glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, program); }
567               
568                void load(GLuint size, const GLubyte * prog_text)
569                {
570                        if(!valid) gen();
571            glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, size, prog_text);
572                        //glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, program, size, prog_text);
573
574                        GLint errpos;
575                        glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errpos);
576                        if(errpos != -1)
577                        {
578                                fprintf(stderr, "program error:\n");
579                                int bgn = errpos - 10;
580                                bgn < 0 ? 0 : bgn;
581                                const char * c = (const char *)(prog_text + bgn);
582                                for(int i = 0; i < 30; i++)
583                                {
584                                        if(bgn+i >= int(size-1))
585                                                break;
586                                        fprintf(stderr, "%c", *c++);
587                                }
588                                fprintf(stderr, "\n");
589                        }
590                }
591
592                void load(GLuint size, const char * prog_text)
593                {
594                        if(!valid) gen();
595            glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, size, prog_text);
596                        //glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, program, size, (const GLubyte *) prog_text);
597                        GLint errpos;
598                        glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errpos);
599                        if(errpos != -1)
600                        {
601                                fprintf(stderr, "program error:\n");
602                                int bgn = errpos - 10;
603
604                                const char * c = (const char *)(prog_text + bgn);
605                                for(int i = 0; i < 30; i++)
606                                {
607                                        if(bgn+i >= int(size-1))
608                                                break;
609                                        fprintf(stderr, "%c", *c++);
610                                }
611                                fprintf(stderr, "\n");
612                        }
613                }
614
615                void load(const char * prog_text)
616                { load((GLuint)strlen(prog_text), prog_text); }
617
618                void del()
619                { if(valid) glDeleteProgramsARB(1, &program); valid = false; }
620               
621                bool is_valid() const { return valid; }
622               
623                GLuint program;
624        private:
625               
626                void gen() { glGenProgramsARB(1, &program); valid=true; }
627               
628                bool valid;
629        bool manageObjects;
630        };
631
632
633#endif
634
635}
636#endif
Note: See TracBrowser for help on using the repository browser.