├── Makefile.Linux
├── Makefile.Darwin
├── examples
    ├── gles
    │   ├── assets
    │   │   ├── basemap.png
    │   │   └── lightmap.png
    │   ├── shaders
    │   │   ├── ch8-simple-vertexshader.fs
    │   │   ├── m3d-vshader.sl
    │   │   ├── ch8-simple-vertexshader.vs
    │   │   ├── ch9-vshader.sl
    │   │   ├── ch9-fshader.sl
    │   │   ├── ch10-vshader.sl
    │   │   ├── ch9-texture2d-fshader.sl
    │   │   ├── ch9-texture2d-vshader.sl
    │   │   ├── ch10-fshader.sl
    │   │   └── m3d-fshader.sl
    │   ├── metatunnel-3d.js
    │   ├── shaderutil.js
    │   ├── lib
    │   │   ├── v3d.js
    │   │   ├── core.js
    │   │   └── matrix.js
    │   ├── ch8-simple-vertexshader.js
    │   ├── ch2-hello-triangle.js
    │   ├── ch9-simple-texture-cubemap.js
    │   ├── ch9-simple-texture2d.js
    │   ├── ch10-multitexture.js
    │   ├── metaballs
    │   │   └── metaballs.js
    │   └── common.js
    ├── example1.js
    └── example2.js
├── glutbindings
    ├── glutInit.template
    ├── glutbind.h
    ├── glutTimerFunc.template
    ├── glutbind.py
    └── glut.h
├── utils.h
├── glbindings
    ├── glbind.h
    ├── make_json.py
    └── glbind.py
├── glesbindings
    ├── glesbind.h
    ├── glew_desktop_shim.h
    ├── make_json.py
    ├── gles_desktop_shim.h
    └── glesbind.py
├── glubindings
    ├── glubind.h
    ├── glubind.py
    └── glu.h
├── v8-typed-array
    ├── wscript
    ├── package.json
    ├── README.md
    └── typed-array.cc
├── v8-gl.h
├── main.cpp
├── Makefile
├── imageloader.h
├── utils.cpp
├── README.mkd
├── imageloader.cpp
└── v8-gl.cpp


/Makefile.Linux:
--------------------------------------------------------------------------------
1 | LIBS =  v8/libv8.a -lpthread -lglut -lGLU -lGL
2 | 


--------------------------------------------------------------------------------
/Makefile.Darwin:
--------------------------------------------------------------------------------
1 | LIBS =  v8/libv8.a -lpthread -framework OpenGL -framework GLUT
2 | 


--------------------------------------------------------------------------------
/examples/gles/assets/basemap.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/philogb/v8-gl/HEAD/examples/gles/assets/basemap.png


--------------------------------------------------------------------------------
/examples/gles/assets/lightmap.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/philogb/v8-gl/HEAD/examples/gles/assets/lightmap.png


--------------------------------------------------------------------------------
/examples/gles/shaders/ch8-simple-vertexshader.fs:
--------------------------------------------------------------------------------
1 | void main() {
2 |   gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
3 | }


--------------------------------------------------------------------------------
/examples/gles/shaders/m3d-vshader.sl:
--------------------------------------------------------------------------------
1 | attribute vec4 pos; 
2 | 
3 | void main() { 
4 |   gl_Position = vec4(pos.x * float(370), pos.y * float(240), 0.0, 1.0);
5 | }


--------------------------------------------------------------------------------
/glutbindings/glutInit.template:
--------------------------------------------------------------------------------
1 | 
2 | Handle<Value> GLUTInitCallback(const Arguments& args) {
3 |   glutInit(( int* ) pargc_, ( char** ) argv_);
4 |   return v8::Undefined();
5 | }
6 | 


--------------------------------------------------------------------------------
/examples/gles/shaders/ch8-simple-vertexshader.vs:
--------------------------------------------------------------------------------
1 | uniform mat4 u_mvpMatrix;
2 | attribute vec4 a_position;
3 | void main() {
4 |   gl_Position = u_mvpMatrix * a_position;
5 |   //gl_PointSize = 1
6 | }


--------------------------------------------------------------------------------
/examples/gles/shaders/ch9-vshader.sl:
--------------------------------------------------------------------------------
1 | attribute vec4 a_position;
2 | attribute vec3 a_normal;
3 | varying vec3 v_normal;
4 | void main()
5 | {
6 |   gl_Position = a_position;
7 |   v_normal = a_normal;
8 | }
9 | 


--------------------------------------------------------------------------------
/examples/gles/shaders/ch9-fshader.sl:
--------------------------------------------------------------------------------
1 | /*precision mediump float;*/
2 | varying vec3 v_normal;
3 | uniform samplerCube s_texture;
4 | void main()
5 | {
6 |   gl_FragColor = textureCube(s_texture, v_normal);
7 | }
8 | 


--------------------------------------------------------------------------------
/examples/gles/shaders/ch10-vshader.sl:
--------------------------------------------------------------------------------
1 | attribute vec4 a_position;
2 | attribute vec2 a_texCoord;
3 | varying vec2 v_texCoord;
4 | void main()
5 | {
6 |   gl_Position = a_position;
7 |   v_texCoord = a_texCoord;
8 | }
9 | 


--------------------------------------------------------------------------------
/examples/gles/shaders/ch9-texture2d-fshader.sl:
--------------------------------------------------------------------------------
1 | /*precision mediump float;*/
2 | varying vec2 v_texCoord;
3 | uniform sampler2D s_texture;
4 | void main()
5 | {
6 |   gl_FragColor = texture2D(s_texture, v_texCoord);
7 | }


--------------------------------------------------------------------------------
/examples/gles/shaders/ch9-texture2d-vshader.sl:
--------------------------------------------------------------------------------
1 | attribute vec4 a_position;
2 | attribute vec2 a_texCoord;
3 | varying vec2 v_texCoord;
4 | void main()
5 | {
6 |   gl_Position = a_position;
7 |   v_texCoord = a_texCoord;
8 | }
9 | 


--------------------------------------------------------------------------------
/utils.h:
--------------------------------------------------------------------------------
 1 | #ifndef V8GLUTILS_H_
 2 | #define V8GLUTILS_H_
 3 | 
 4 | namespace V8GLUtils {
 5 | 		void setRootPath(char* program_path, char* jsfile_path);
 6 | 
 7 | 		char* getRootPath(void);
 8 | 		char* getRealPath(char* file_path);
 9 | 
10 | 		char *pushRootPath(char *new_path);
11 | 		void popRootPath(char *old_path);
12 | };
13 | 
14 | #endif
15 | 


--------------------------------------------------------------------------------
/glbindings/glbind.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * glbind.h
 3 |  *
 4 |  *  Created on: Jun 15, 2009
 5 |  *      Author: nicolas
 6 |  */
 7 | 
 8 | #ifndef GLBIND_H_
 9 | #define GLBIND_H_
10 | 
11 | #include <v8.h>
12 | 
13 | class GlFactory {
14 | public:
15 | 	static v8::Handle<v8::ObjectTemplate> createGl(void);
16 | 
17 | 	static v8::Persistent<v8::Object> self_;
18 | };
19 | 
20 | #endif /* GLBIND_H_ */
21 | 


--------------------------------------------------------------------------------
/examples/gles/shaders/ch10-fshader.sl:
--------------------------------------------------------------------------------
 1 | /*precision mediump float;*/
 2 | varying vec2 v_texCoord;
 3 | uniform sampler2D s_baseMap;
 4 | uniform sampler2D s_lightMap;
 5 | void main()
 6 | {
 7 |   vec4 baseColor;
 8 |   vec4 lightColor;
 9 | 
10 |   baseColor = texture2D(s_baseMap, v_texCoord);
11 |   lightColor = texture2D(s_lightMap, v_texCoord);
12 |   gl_FragColor = baseColor * (lightColor + 0.25);
13 | }
14 | 


--------------------------------------------------------------------------------
/glesbindings/glesbind.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * glesbind.h
 3 |  *
 4 |  */
 5 | 
 6 | #ifndef GLESBIND_H_
 7 | #define GLESBIND_H_
 8 | 
 9 | #include <v8.h>
10 | #include "../utils.h"
11 | #include "../imageloader.h"
12 | 
13 | class GlesFactory {
14 | public:
15 | 	static v8::Handle<v8::ObjectTemplate> createGles(void);
16 | 	static v8::Persistent<v8::Context> gles_persistent_context;
17 | 	static v8::Persistent<v8::Object> self_;
18 | };
19 | 
20 | #endif /* GLESBIND_H_ */
21 | 


--------------------------------------------------------------------------------
/glubindings/glubind.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * glubind.h
 3 |  *
 4 |  *  Created on: Jun 15, 2009
 5 |  *      Author: nicolas
 6 |  */
 7 | 
 8 | #ifndef GLUBIND_H_
 9 | #define GLUBIND_H_
10 | 
11 | 
12 | #include <v8-debug.h>
13 | 
14 | #ifdef __APPLE__
15 | #include <OpenGL/OpenGL.h>
16 | #include <GLUT/glut.h>
17 | #else
18 | #include <GL/glut.h>
19 | #endif
20 | 
21 | #include <stdio.h>
22 | 
23 | using namespace std;
24 | using namespace v8;
25 | 
26 | Handle<ObjectTemplate> createGlu(void);
27 | 
28 | #endif /* GLUBIND_H_ */
29 | 


--------------------------------------------------------------------------------
/v8-typed-array/wscript:
--------------------------------------------------------------------------------
 1 | from os import mkdir
 2 | from os import symlink
 3 | from os import remove
 4 | from os.path import lexists
 5 | 
 6 | srcdir = '.'
 7 | blddir = 'build'
 8 | VERSION = '0.0.2'
 9 | 
10 | def set_options(opt):
11 |   opt.tool_options('compiler_cxx')
12 | 
13 | def configure(conf):
14 |   conf.check_tool('compiler_cxx')
15 |   conf.check_tool('node_addon')
16 | 
17 | def build(bld):
18 |   obj = bld.new_task_gen('cxx', 'shlib', 'node_addon')
19 |   obj.target = 'typed-array'
20 |   obj.source = 'typed-array.cc'
21 | 


--------------------------------------------------------------------------------
/v8-typed-array/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "typed-array",
 3 |   "description": "Typed Array implementation for V8 and Node.js",
 4 |   "version": "0.0.2",
 5 |   "repository": {
 6 |     "type": "git",
 7 |     "url": "https://github.com/tlrobinson/v8-typed-array.git"
 8 |   },
 9 |   "keywords": ["buffer", "typed array", "webgl"],
10 |   "author": "Tom Robinson <tlrobinson@gmail.com> (http://tlrobinson.net/)",
11 |   "main": "build/default/typed-array.node",
12 |   "scripts": { "install": "node-waf configure build" },
13 |   "engines": {
14 |     "node": "*"
15 |   }
16 | }


--------------------------------------------------------------------------------
/v8-gl.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * v8-gl.h
 3 |  */
 4 | 
 5 | #ifndef V8GL_H_
 6 | #define V8GL_H_
 7 | 
 8 | #include <string>
 9 | #include <v8-debug.h>
10 | 
11 | #include "utils.h"
12 | #ifdef BUILD_GL_BINDINGS
13 | #include "glbindings/glbind.h"
14 | #endif
15 | #ifdef BUILD_GLES_BINDINGS
16 | #include "glesbindings/glesbind.h"
17 | #endif
18 | #ifdef BUILD_GLU_BINDINGS
19 | #include "glubindings/glubind.h"
20 | #endif
21 | #ifdef BUILD_GLUT_BINDINGS
22 | #include "glutbindings/glutbind.h"
23 | #endif
24 | 
25 | using namespace std;
26 | using namespace v8;
27 | 
28 | class V8GL {
29 | 
30 | public:
31 | 	bool initialize(int* pargc, char** argv, string scriptname);
32 | 	bool executeScript(string scriptname);
33 | 	static const char* ToCString(const v8::String::Utf8Value& value);
34 | 	static void ReportException(TryCatch* try_catch);
35 | 
36 | 	//keep a reference to the global context.
37 | 	static Persistent<Context> context;
38 | };
39 | 
40 | #endif /* V8GL_H_ */
41 | 


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <v8.h>
 2 | 
 3 | #include "v8-gl.h"
 4 | #include <string>
 5 | 
 6 | using namespace v8;
 7 | 
 8 | void ParseOptions(int argc,
 9 |                   char* argv[],
10 |                   string* file) {
11 |   for (int i = 1; i < argc; i++) {
12 |     std::string arg = argv[i];
13 |     size_t index = arg.find('=', 0);
14 |     if (index == std::string::npos) {
15 |       *file = arg;
16 |     } else {
17 |       std::string key = arg.substr(0, index);
18 |       std::string value = arg.substr(index+1);
19 |     }
20 |   }
21 | }
22 | 
23 | int main(int argc, char* argv[]) {
24 | 	  string file;
25 | 	  ParseOptions(argc, argv, &file);
26 | 	  if (file.empty()) {
27 | 	    fprintf(stderr, "No script was specified.\n");
28 | 	    return 1;
29 | 	  }
30 | 
31 | 	  V8GL v8gl;
32 | 	  if(!v8gl.initialize(&argc, argv, file)) {
33 | 		    fprintf(stderr, "Error initializing script.\n");
34 | 		    return 1;
35 | 	  }
36 | 
37 | 	  return 0;
38 | }
39 | 


--------------------------------------------------------------------------------
/glutbindings/glutbind.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * glutbind.h
 3 |  *
 4 |  *  Created on: Jun 15, 2009
 5 |  *      Author: nicolas
 6 |  */
 7 | 
 8 | #ifndef GLUTBIND_H_
 9 | #define GLUTBIND_H_
10 | 
11 | #include <v8-debug.h>
12 | 
13 | #ifdef __APPLE__
14 | #include <OpenGL/OpenGL.h>
15 | #include <GLUT/glut.h>
16 | #else
17 | #include <GL/glut.h>
18 | #endif
19 | 
20 | #ifndef GLUT_APIENTRY_DEFINED
21 | #define GLUT_APIENTRY_DEFINED 1
22 | #endif
23 | 
24 | #ifndef GLUT_WINGDIAPI_DEFINED
25 | #define GLUT_WINGDIAPI_DEFINED 1
26 | #endif
27 | 
28 | #ifndef GLUT_MACOSX_IMPLEMENTATION
29 | #define GLUT_MACOSX_IMPLEMENTATION 0
30 | #endif
31 | #ifndef GLUT_NO_RECOVERY
32 | #define GLUT_NO_RECOVERY 0
33 | #endif
34 | 
35 | #include <stdio.h>
36 | #include <map>
37 | using namespace std;
38 | using namespace v8;
39 | 
40 | class GlutFactory {
41 | public:
42 | 	static Handle<ObjectTemplate> createGlut(int* pargc, char** argv);
43 | 	static Persistent<Context> glut_persistent_context;
44 | };
45 | 
46 | #endif /* GLUTBIND_H_ */
47 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | # Pull in platform specific settings.
 2 | include Makefile.$(firstword $(subst _, ,$(shell uname -s)))
 3 | 
 4 | CC = g++
 5 | CFLAGS := $(CFLAGS) -m32 -Wall -Iv8/include 
 6 | PROG = v8-gl 
 7 | 
 8 | BUILD_GL_BINDINGS=1
 9 | BUILD_GLES_BINDINGS=1
10 | BUILD_GLU_BINDINGS=1
11 | BUILD_GLUT_BINDINGS=1
12 | 
13 | SRCS = main.cpp imageloader.cpp utils.cpp v8-gl.cpp \
14 | 	v8-typed-array/typed-array.cc
15 | 
16 | ifdef BUILD_GL_BINDINGS
17 | SRCS += glbindings/glbind.cpp
18 | CFLAGS += -DBUILD_GL_BINDINGS
19 | endif
20 | 
21 | ifdef BUILD_GLES_BINDINGS
22 | SRCS += glesbindings/glesbind.cpp
23 | CFLAGS += -DBUILD_GLES_BINDINGS
24 | endif
25 | 
26 | ifdef BUILD_GLU_BINDINGS
27 | SRCS += glubindings/glubind.cpp
28 | CFLAGS += -DBUILD_GLU_BINDINGS
29 | endif
30 | 
31 | ifdef BUILD_GLUT_BINDINGS
32 | SRCS += glutbindings/glutbind.cpp
33 | CFLAGS += -DBUILD_GLUT_BINDINGS
34 | endif
35 | 
36 | all: $(PROG)
37 | 
38 | $(PROG):	$(SRCS)
39 | 	$(CC) $(CFLAGS) $(SRCS) -o $(PROG) $(LIBS)
40 | 
41 | clean:
42 | 	rm -f $(PROG)
43 | 


--------------------------------------------------------------------------------
/examples/gles/shaders/m3d-fshader.sl:
--------------------------------------------------------------------------------
 1 | uniform vec4 in_color;
 2 | vec2 v=(gl_FragCoord.xy-vec2(400,300))/vec2(400,300);
 3 | float w=dot(in_color.xyz,vec3(1.0,256.0,65536.0))*.25;
 4 | const float s=0.4;
 5 | 
 6 | float obj(vec3 pos){
 7 |   float final=1.0;
 8 |   final *= distance(pos,vec3(cos(w)+sin(w*0.2),0.3,2.0+cos(w*0.5)*0.5));
 9 |   final *= distance(pos,vec3(-cos(w*0.7),0.3,2.0+sin(w*0.5)));
10 |   final *= distance(pos,vec3(-sin(w*0.2)*0.5,sin(w),2.0));
11 |   final *= cos(pos.y)*cos(pos.x)-0.1-cos(pos.z*7.+w*7.)*cos(pos.x*3.)*cos(pos.y*4.)*0.1;
12 |   return final;
13 | }
14 | 
15 | void main(){
16 |   vec3 o=vec3(v.x,v.y*1.25,0.0);
17 |   vec3 d=vec3(v.x+cos(w)*.3,v.y,1.0)/64.0;
18 |   vec4 color=vec4(0.0);
19 |   float t=0.0;
20 | 
21 |   for(int i=0;i<75;i++) {
22 |     if(obj(o+d*t)<s){
23 |       t-=5.0;
24 |       for(int j=0;j<5;j++){
25 |         if(obj(o+d*t)<s){
26 |           break;
27 |         }
28 |         t+=1.0;
29 |       }
30 |       vec3 e=vec3(0.01,.0,.0);
31 |       vec3 n=vec3(0.0);
32 |       n.x=obj(o+d*t)-obj(vec3(o+d*t+e.xyy));
33 |       n.y=obj(o+d*t)-obj(vec3(o+d*t+e.yxy));
34 |       n.z=obj(o+d*t)-obj(vec3(o+d*t+e.yyx));
35 |       n=normalize(n);
36 |       color+=max(dot(vec3(0.0,0.0,-0.5),n),0.0)+max(dot(vec3(0.0,-0.5,0.5),n),0.0)*0.5;break;
37 |     }
38 |     t+=5.0;
39 |   }
40 |   gl_FragColor=color+vec4(0.1,0.2,0.5,1.0)*(t*0.025);
41 | }
42 | 


--------------------------------------------------------------------------------
/examples/gles/metatunnel-3d.js:
--------------------------------------------------------------------------------
 1 | // This is a hacked up version of vlad's port of FRequency's metatunnel.
 2 | //   http://people.mozilla.com/~vladimir/misc/metatunnel-3d.html
 3 | load("shaderutil.js");
 4 | 
 5 | var w = 740, h = 480;
 6 | 
 7 | //Initialize Glut
 8 | Glut.init();
 9 | Glut.initDisplayMode(Glut.DOUBLE | Glut.RGB | Glut.DEPTH);
10 | Glut.initWindowSize(w, h);
11 | 
12 | //Create the window
13 | Glut.createWindow("OpenGL on V8 baby!");
14 | 
15 | //Make a program with the following shaders
16 | var p = getProgram("shaders/m3d-vshader.sl", 
17 |                   "shaders/m3d-fshader.sl");
18 | 
19 | if (p == 0)
20 |   return false;
21 | 
22 | Gles.useProgram(p);
23 | 
24 | // Store our attrib data in a VBO.
25 | var buffers = Gles.genBuffers(1);
26 | Gles.bindBuffer(Gles.ARRAY_BUFFER, buffers[0]);
27 | Gles.bufferData(Gles.ARRAY_BUFFER, [ -1, 1, 1, 1, -1, -1, 1, -1], Gles.FLOAT, Gles.STATIC_DRAW);
28 | 
29 | Gles.vertexAttribPointer(0, 2, Gles.FLOAT, false, 0, 0);
30 | Gles.enableVertexAttribArray(0);
31 | 
32 | function draw() {
33 |   Gles.viewport(0, 0, w, h);
34 |   var n = Date.now();
35 |   var r = n & 0xff;
36 |   var g = (n>>8) & 0xff;
37 |   var b = (n>>16) & 0xff;
38 |   Gles.uniform4fv(0, 1, [r/255.0, g/255.0, b/255.0, 1.0]);
39 |   Gles.drawArrays(Gles.TRIANGLE_STRIP, 0, 4);
40 | 
41 |   Glut.swapBuffers();
42 | }
43 | 
44 | Glut.displayFunc(draw);
45 | 
46 | //Set timeout callback
47 | Glut.timerFunc(25, function() {
48 |   Glut.postRedisplay();
49 |   Glut.timerFunc(25, arguments.callee, 0);
50 | }, 0);
51 | 
52 | Glut.mainLoop();
53 | 


--------------------------------------------------------------------------------
/examples/example1.js:
--------------------------------------------------------------------------------
 1 | //Initializes 3D rendering
 2 | function initRendering() {
 3 | 	Gl.enable(Gl.DEPTH_TEST)
 4 | 	  .enable(Gl.COLOR_MATERIAL);
 5 | }
 6 | 
 7 | //Called when the window is resized
 8 | function handleResize(w, h) {
 9 | 	Gl.viewport(0, 0, w, h)
10 | 	  .matrixMode(Gl.PROJECTION)
11 | 	  .loadIdentity();
12 | 
13 | 	Glu.perspective(45.0, w / h, 1.0, 200.0);
14 | }
15 | 
16 | //Draws the 3D scene
17 | function drawScene() {
18 | 	Gl.clear(Gl.COLOR_BUFFER_BIT | Gl.DEPTH_BUFFER_BIT)
19 | 	  .matrixMode(Gl.MODELVIEW)
20 | 	  .loadIdentity()
21 | 
22 | 	  .begin(Gl.QUADS)
23 | 	
24 | 	   //Trapezoid
25 | 	  .vertex3f(-0.7, -1.5, -5.0)
26 | 	  .vertex3f(0.7, -1.5, -5.0)
27 | 	  .vertex3f(0.4, -0.5, -5.0)
28 | 	  .vertex3f(-0.4, -0.5, -5.0)
29 | 	
30 | 	  .end() 
31 | 	
32 | 	  .begin(Gl.TRIANGLES)
33 | 	
34 | 	//Pentagon
35 | 	  .vertex3f(0.5, 0.5, -5.0)
36 | 	  .vertex3f(1.5, 0.5, -5.0)
37 | 	  .vertex3f(0.5, 1.0, -5.0)
38 | 	
39 | 	  .vertex3f(0.5, 1.0, -5.0)
40 | 	  .vertex3f(1.5, 0.5, -5.0)
41 | 	  .vertex3f(1.5, 1.0, -5.0)
42 | 	
43 | 	  .vertex3f(0.5, 1.0, -5.0)
44 | 	  .vertex3f(1.5, 1.0, -5.0)
45 | 	  .vertex3f(1.0, 1.5, -5.0)
46 | 	
47 | 	//Triangle
48 | 	  .vertex3f(-0.5, 0.5, -5.0)
49 | 	  .vertex3f(-1.0, 1.5, -5.0)
50 | 	  .vertex3f(-1.5, 0.5, -5.0)
51 | 	
52 | 	  .end();
53 | 
54 | 	Glut.swapBuffers();
55 | }
56 | 
57 | function main() {
58 | 	//Initialize Glut
59 | 	Glut.init();
60 | 	Glut.initDisplayMode(Glut.DOUBLE | Glut.RGB | Glut.DEPTH);
61 | 	Glut.initWindowSize(400, 400);
62 | 	
63 | 	//Create the window
64 | 	Glut.createWindow("OpenGL on V8 baby!");
65 | 	initRendering(); //Initialize rendering
66 | 	
67 | 	//Set handler functions for drawing, keypresses, and window resizes
68 | 	Glut.displayFunc(drawScene);
69 | 	Glut.reshapeFunc(handleResize);
70 | 	
71 | 	Glut.mainLoop(); //Start the main loop.
72 | }
73 | 
74 | main();
75 | 


--------------------------------------------------------------------------------
/imageloader.h:
--------------------------------------------------------------------------------
 1 | /* Permission is hereby granted, free of charge, to any person obtaining a copy
 2 |  * of this software and associated documentation files (the "Software"), to deal
 3 |  * in the Software without restriction, including without limitation the rights
 4 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 5 |  * copies of the Software, and to permit persons to whom the Software is
 6 |  * furnished to do so, subject to the following conditions:
 7 |  *
 8 |  * The above notice and this permission notice shall be included in all copies
 9 |  * or substantial portions of the Software.
10 |  *
11 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
12 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
14 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
15 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
16 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
17 |  * SOFTWARE.
18 |  */
19 | 
20 | 
21 | #ifndef IMAGE_LOADER_H_
22 | #define IMAGE_LOADER_H_
23 | 
24 | //Represents an image
25 | class Image {
26 | 	public:
27 | 		Image(char* ps, int w, int h);
28 | 		~Image();
29 | 
30 | 		/* An array of the form (R1, G1, B1, R2, G2, B2, ...) indicating the
31 | 		 * color of each pixel in image.  Color components range from 0 to 255.
32 | 		 * The array starts the bottom-left pixel, then moves right to the end
33 | 		 * of the row, then moves up to the next column, and so on.  This is the
34 | 		 * format in which OpenGL likes images.
35 | 		 */
36 | 		char* pixels;
37 | 		int width;
38 | 		int height;
39 | };
40 | 
41 | //Reads a bitmap image from file.
42 | Image* loadBMP(const char* filename);
43 | Image* loadPNG(const char* filename);
44 | 
45 | #endif
46 | 


--------------------------------------------------------------------------------
/examples/example2.js:
--------------------------------------------------------------------------------
 1 | //Add array iteration method
 2 | Array.prototype.each = function(f) {
 3 | 	var len = this.length;
 4 | 	for ( var i = 0; i < len; i++) f(this[i]);
 5 | };
 6 | 
 7 | //Initializes 3D rendering
 8 | function initRendering() {
 9 | 	"DEPTH_TEST COLOR_MATERIAL LIGHTING LIGHT0 NORMALIZE COLOR_MATERIAL"
10 | 		.split(" ").each(function(elem) {
11 | 		Gl.enable(Gl[elem]);
12 | 	});
13 | }
14 | 
15 | //angle variable
16 | var angle = 0;
17 | 
18 | //Draws the 3D scene
19 | function drawScene() {
20 | 	//Set global color and drawing properties
21 | 	Gl.clear(Gl.COLOR_BUFFER_BIT | Gl.DEPTH_BUFFER_BIT);
22 | 	Gl.matrixMode(Gl.MODELVIEW); 
23 | 	Gl.loadIdentity();
24 | 	Gl.translatef(0.0, 0.0, -5.0);
25 | 	//Set diffuse and positioned lights
26 | 	Gl.lightModelfv(Gl.LIGHT_MODEL_AMBIENT, [0.3, 0.3, 0.3, 1.0]);
27 | 	Gl.lightfv(Gl.LIGHT0, Gl.DIFFUSE, [0.4, 0.4, 0.4, 1.0]);
28 | 	Gl.lightfv(Gl.LIGHT0, Gl.POSITION, [5.0, 5.0, 5.0, 1.0]);
29 | 	//Rotate and plot Icosahedron
30 | 	Gl.rotatef(angle, 1.0, 1.0, 1.0);
31 | 	Gl.color3f(0.5, 0.0, 0.8);
32 | 	Glut.solidIcosahedron(2.5);
33 | 	//Render
34 | 	Glut.swapBuffers(); 
35 | }
36 | 
37 | (function() {
38 | 	//Initialize Glut
39 | 	Glut.init();
40 | 	Glut.initDisplayMode(Glut.DOUBLE | Glut.RGB | Glut.DEPTH);
41 | 	Glut.initWindowSize(400, 400); //Set the window size
42 | 	//Create the window
43 | 	Glut.createWindow("OpenGL on V8 baby!");
44 | 	initRendering();
45 | 	//Set drawing callback
46 | 	Glut.displayFunc(drawScene);
47 | 	//Set resize window callback
48 | 	Glut.reshapeFunc(function(w, h) {
49 | 		Gl.viewport(0, 0, w, h);
50 | 		Gl.matrixMode(Gl.PROJECTION);
51 | 		Gl.loadIdentity();
52 | 		Glu.perspective(45.0, w / h, 1.0, 200.0);
53 | 	});
54 | 	//Set timeout callback
55 | 	Glut.timerFunc(25, function() {
56 | 		angle += 2.0;
57 | 		if (angle > 360) angle -= 360;
58 | 		Glut.postRedisplay();
59 | 		Glut.timerFunc(25, arguments.callee, 0);
60 | 	}, 0);
61 | 	//Start the main loop.
62 | 	Glut.mainLoop();
63 | })();
64 | 


--------------------------------------------------------------------------------
/v8-typed-array/README.md:
--------------------------------------------------------------------------------
 1 | v8-typed-array
 2 | ==============
 3 | 
 4 | Typed Array implementation for V8 and Node.js. Works well enough to run jslinux but otherwise has not been tested. Many missing APIs.
 5 | 
 6 | * ArrayBuffer
 7 | * Int8Array
 8 | * Uint8Array
 9 | * Int16Array
10 | * Uint16Array
11 | * Int32Array
12 | * Uint32Array
13 | * Float32Array
14 | 
15 | Based Editor's Draft 28 April 2011: http://www.khronos.org/registry/typedarray/specs/latest/
16 | 
17 | Build
18 | -----
19 | 
20 |     node-waf configure build
21 | 
22 | Or install using NPM (npm install typed-array)
23 | 
24 | Credits
25 | -------
26 | 
27 | Inspired by:
28 | 
29 | * https://github.com/pufuwozu/node-webgl
30 | * http://v8.googlecode.com/svn/trunk/samples/shell.cc
31 | 
32 | TODO
33 | ----
34 | 
35 | * Implement the rest of the API
36 | * Bridge to Node's Buffers?
37 | 
38 | License
39 | -------
40 | 
41 | Copyright (C) 2011 by Thomas Robinson (http://tlrobinson.net/)
42 | 
43 | Permission is hereby granted, free of charge, to any person obtaining a copy
44 | of this software and associated documentation files (the "Software"), to deal
45 | in the Software without restriction, including without limitation the rights
46 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
47 | copies of the Software, and to permit persons to whom the Software is
48 | furnished to do so, subject to the following conditions:
49 | 
50 | The above copyright notice and this permission notice shall be included in
51 | all copies or substantial portions of the Software.
52 | 
53 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
54 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
55 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
56 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
57 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
58 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
59 | THE SOFTWARE.
60 | 


--------------------------------------------------------------------------------
/glutbindings/glutTimerFunc.template:
--------------------------------------------------------------------------------
 1 | 
 2 | typedef struct {
 3 |     int value;
 4 |     Persistent<Function> timerFunc;
 5 | } timerData;
 6 | 
 7 | timerData * persistentTimers[50] = { NULL };
 8 | 
 9 | void callbackTimerFunc(int value) {
10 |     timerData * elem = persistentTimers[value];
11 |     if(elem != NULL) {
12 |       //define handle scope
13 |       HandleScope scope;
14 |       Handle<Value> args[1];
15 |       args[0] = Integer::New(elem->value);
16 |       Persistent<Function> timer = elem->timerFunc;
17 |       timer->Call(GlutFactory::glut_persistent_context->Global(), 1, args);
18 | 
19 |       timer.Dispose();
20 |       delete elem;
21 |       persistentTimers[value] = NULL;
22 |     }
23 | }
24 | 
25 | Handle<Value> GLUTTimerFuncCallback(const Arguments& args) {
26 |   //if less that nbr of formal parameters then do nothing
27 |   if (args.Length() < 3) return v8::Undefined();
28 |   //get arguments
29 |   unsigned int millisec = args[0]->Uint32Value();
30 |   int timerId = args[2]->IntegerValue();
31 | 
32 |   //find an empty timer spot and place the function there.
33 |   int i = 0;
34 |   bool found = false;
35 |   for(; i < 50; i++) {
36 |       if(persistentTimers[i] == NULL) {
37 |           //get the function
38 |           Handle<Function> value = Handle<Function>::Cast(args[1]);
39 |           Persistent<Function> persistentValue = Persistent<Function>::New(value);
40 |           //assign callback and value values.
41 |           timerData * structElem = new timerData;
42 |           structElem->value = timerId;
43 |           structElem->timerFunc = persistentValue;
44 |           persistentTimers[i] = structElem;
45 |           found = true;
46 |           break;
47 |       }
48 |   }
49 | 
50 |   //TODO add dynamic resize for persistent Timers
51 |   if(!found) return v8::Undefined();
52 | 
53 |   //make call
54 |   //Don't pass the actual *value*, but an id to our persistent Function
55 |   glutTimerFunc(( unsigned int ) millisec, (  void (* )( int )) callbackTimerFunc, ( int ) i);
56 |   return v8::Undefined();
57 | }
58 | 


--------------------------------------------------------------------------------
/utils.cpp:
--------------------------------------------------------------------------------
 1 | #include "utils.h"
 2 | #include <string>
 3 | #include <string.h>
 4 | 
 5 | namespace V8GLUtils {
 6 | 	char separator = '/';
 7 | 	char* root_path;
 8 | 
 9 | 	void setRootPath(char* program_path, char* jsfile_path) {
10 | 	  //Set the root_path for opening shader files with
11 | 	  //relative paths
12 | 	  //take path from executable
13 | 	  char* pch = strrchr(program_path, V8GLUtils::separator);
14 | 	  int last_index = pch ? (pch - program_path +1) : 2;
15 | 	  char* tmp_exec_path = new char[last_index +1];
16 | 	  strncpy(tmp_exec_path, pch ? program_path : "./", last_index);
17 | 	  tmp_exec_path[last_index] = '\0';
18 | 
19 | 	  //take relative path from javascript file
20 | 	  char* p1ch = strrchr(jsfile_path, V8GLUtils::separator);
21 | 	  int last_index1 = p1ch ? (p1ch - jsfile_path +1) : 2;
22 | 	  char* tmp_js_path = new char[last_index1 +1];
23 | 	  strncpy(tmp_js_path, p1ch ? jsfile_path : "./", last_index1);
24 | 	  tmp_js_path[last_index1] = '\0';
25 | 
26 | 	  V8GLUtils::root_path = new char[last_index + last_index1 +1];
27 | 
28 | 	  strcpy(V8GLUtils::root_path, tmp_exec_path);
29 | 	  strcat(V8GLUtils::root_path, tmp_js_path);
30 | 
31 | 	  delete[] tmp_exec_path;
32 | 	  delete[] tmp_js_path;
33 | 	}
34 | 
35 |         char *pushRootPath(char *new_path) {
36 | 	    char *old_path = root_path;
37 | 	    char *pch = strrchr(new_path, V8GLUtils::separator);
38 | 	    int last_index = pch ? (pch - new_path + 1) : 2;
39 | 	    root_path = new char[last_index + 1];
40 | 	    strncpy(root_path, pch ? new_path : "./", last_index);
41 | 	    root_path[last_index] = '\0';
42 | 	    return old_path;
43 | 	}
44 |         void popRootPath(char *old_path) {
45 | 	    delete[] root_path;
46 | 	    root_path = old_path;
47 | 	}
48 | 
49 | 	char* getRootPath(void) {
50 | 		return V8GLUtils::root_path;
51 | 	}
52 | 
53 | 	char* getRealPath(char* filepath_str) {
54 | 		//read the file source
55 | 		char* filename = NULL;
56 | 		if(filepath_str[0] != V8GLUtils::separator) {
57 | 		  filename = new char[strlen(V8GLUtils::root_path) + strlen(filepath_str) +1];
58 | 		  strcpy(filename, V8GLUtils::root_path);
59 | 		  strcat(filename, filepath_str);
60 | 		} else {
61 | 		  filename = new char[strlen(filepath_str) +1];
62 | 		  strcpy(filename, filepath_str);
63 | 		}
64 | 		return filename;
65 | 	}
66 | };
67 | 


--------------------------------------------------------------------------------
/examples/gles/shaderutil.js:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2009, Nicolas Garcia Belmonte
 3 |  * 
 4 |  * Some Utility functions.
 5 |  */
 6 | 
 7 | (function() {
 8 | //convenience function to create a shader from a filepath
 9 |   function getShader(filepath, type)
10 |   {
11 |       var shaderScriptType = type;
12 |       var shaderPath = filepath;
13 |    
14 |       if (!shaderPath || shaderPath.length == 0)
15 |           return 0;
16 |    
17 |       var shader = Gles.createShader(type);
18 |       
19 |       if (shader == 0) return 0;
20 |    
21 |       //added method
22 |       Gles.shaderSourceFile(shader, filepath);
23 |       Gles.compileShader(shader);
24 |    
25 |       if (Gles.getShaderiv(shader, Gles.COMPILE_STATUS) != 1) {
26 |         var error = Gles.getShaderInfoLog(shader);
27 |         log("Error while compiling " + id + ":");
28 |         log(shader);
29 |    
30 |         Gles.deleteShader(shader);
31 |           return 0;
32 |       }
33 |    
34 |       return shader;
35 |   }
36 |    
37 |   // Convenience function to create a program from all the passed-in
38 |   // shader filepaths and types.
39 |   function getProgram() {
40 |       var shaders = [];
41 |    
42 |       // first load and compile all the passed-in shaders.
43 |       for (var i = 0; i < arguments.length; i+=2) {
44 |         var shader = getShader(arguments[i], arguments[i+1]);
45 |         if (shader == 0)
46 |           return 0;
47 |         shaders.push(shader);
48 |       }
49 |    
50 |       // then do the program object creation
51 |       var program = Gles.createProgram();
52 |       if (program == 0)
53 |         return 0;
54 |    
55 |       // attach all the shaders
56 |       for (var i = 0; i < shaders.length; i++) {
57 |         Gles.attachShader(program, shaders[i]);
58 |       }
59 |    
60 |       // link, and check for errors
61 |       Gles.linkProgram(program);
62 |    
63 |       var linked = Gles.getProgramiv(program, Gles.LINK_STATUS);
64 |       if (!linked) {
65 |         var error = Gles.getProgramInfoLog(program);
66 |         log("Error while linking: " + error);
67 |         return 0;
68 |       }
69 |    
70 |       return program;
71 |   }
72 |   
73 |   this.getProgram = function(vertexShader, fragmentShader) {
74 |     return getProgram(vertexShader, Gles.VERTEX_SHADER, 
75 |                       fragmentShader, Gles.FRAGMENT_SHADER);
76 |   };
77 | 
78 | })();
79 | 


--------------------------------------------------------------------------------
/glesbindings/glew_desktop_shim.h:
--------------------------------------------------------------------------------
 1 | #define GL_ES_VERSION_2_0                 1
 2 | #define GL_FIXED                          0x140C
 3 | #define GL_MAX_VERTEX_UNIFORM_VECTORS       0x8DFB
 4 | #define GL_MAX_VARYING_VECTORS              0x8DFC
 5 | #define GL_MAX_FRAGMENT_UNIFORM_VECTORS     0x8DFD
 6 | #define GL_SHADER_COMPILER                0x8DFA
 7 | #define GL_SHADER_BINARY_FORMATS          0x8DF8
 8 | #define GL_NUM_SHADER_BINARY_FORMATS      0x8DF9
 9 | #define GL_LOW_FLOAT                      0x8DF0
10 | #define GL_MEDIUM_FLOAT                   0x8DF1
11 | #define GL_HIGH_FLOAT                     0x8DF2
12 | #define GL_LOW_INT                        0x8DF3
13 | #define GL_MEDIUM_INT                     0x8DF4
14 | #define GL_HIGH_INT                       0x8DF5
15 | #define GL_FRAMEBUFFER                    0x8D40
16 | #define GL_RENDERBUFFER                   0x8D41
17 | #define GL_RGB565                         0x8D62
18 | #define GL_STENCIL_INDEX8                 0x8D48
19 | #define GL_RENDERBUFFER_WIDTH             0x8D42
20 | #define GL_RENDERBUFFER_HEIGHT            0x8D43
21 | #define GL_RENDERBUFFER_INTERNAL_FORMAT   0x8D44
22 | #define GL_RENDERBUFFER_RED_SIZE          0x8D50
23 | #define GL_RENDERBUFFER_GREEN_SIZE        0x8D51
24 | #define GL_RENDERBUFFER_BLUE_SIZE         0x8D52
25 | #define GL_RENDERBUFFER_ALPHA_SIZE        0x8D53
26 | #define GL_RENDERBUFFER_DEPTH_SIZE        0x8D54
27 | #define GL_RENDERBUFFER_STENCIL_SIZE      0x8D55
28 | #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE           0x8CD0
29 | #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME           0x8CD1
30 | #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL         0x8CD2
31 | #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3
32 | #define GL_COLOR_ATTACHMENT0              0x8CE0
33 | #define GL_DEPTH_ATTACHMENT               0x8D00
34 | #define GL_STENCIL_ATTACHMENT             0x8D20
35 | #define GL_FRAMEBUFFER_COMPLETE                      0x8CD5
36 | #define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT         0x8CD6
37 | #define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7
38 | #define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS         0x8CD9
39 | #define GL_FRAMEBUFFER_UNSUPPORTED                   0x8CDD
40 | #define GL_FRAMEBUFFER_BINDING            0x8CA6
41 | #define GL_RENDERBUFFER_BINDING           0x8CA7
42 | #define GL_MAX_RENDERBUFFER_SIZE          0x84E8
43 | 
44 | // Some of the OpenGL 2.0 spec is defined as doubles, so ES 2.0 adds float
45 | // versions.  Implement some simple shims here.
46 | #define glClearDepthf(depth) glClearDepth(depth)
47 | #define glDepthRangef(zNear, zFar) glDepthRange((zNear), (zFar))
48 | 
49 | // These don't exist in desktop OpenGL, just stub them out.
50 | #define glReleaseShaderCompiler ((void) 0)
51 | #define glGetShaderPrecisionFormat(a, b, c, d) ((void) 0)
52 | 
53 | 


--------------------------------------------------------------------------------
/examples/gles/lib/v3d.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |   File: v3d.js
  3 |   
  4 |   Description:
  5 |   
  6 |   3D Vector Class.
  7 |   
  8 |   Dependencies:
  9 |   
 10 |   core.js
 11 |   
 12 |   Author: 
 13 |   
 14 |   Nicolas Garcia Belmonte
 15 |   
 16 |   Copyright: 
 17 |   
 18 |   Copyright 2009 by Nicolas Garcia Belmonte.
 19 |   
 20 |   Homepage: 
 21 |   
 22 |   <http://blog.thejit.org>
 23 |   
 24 |   License: 
 25 |   
 26 |   MIT License
 27 |  */
 28 | var V3D = new Class({
 29 |   x: null, y: null, z: null,
 30 |   
 31 |   initialize: function(x, y, z){
 32 |     this.x = x || 0;
 33 |     this.y = y || 0;
 34 |     this.z = z || 0;
 35 |   },
 36 |   
 37 |   copy: function(v){
 38 |     this.x = v.x;
 39 |     this.y = v.y;
 40 |     this.z = v.z;
 41 |     return this;
 42 |   },
 43 |   
 44 |   add: function(v){
 45 |     this.x += v.x;
 46 |     this.y += v.y;
 47 |     this.z += v.z;
 48 |     return this;
 49 |   },
 50 |   
 51 |   sub: function(v){
 52 |     this.x -= v.x;
 53 |     this.y -= v.y;
 54 |     this.z -= v.z;
 55 |     return this;
 56 |   },
 57 |   
 58 |   cross: function(v){
 59 |     var tx = this.x,
 60 |         ty = this.y,
 61 |         tz = this.z;
 62 |     
 63 |     this.x = ty * v.z - tz * v.y;
 64 |     this.y = tz * v.x - tx * v.z;
 65 |     this.z = tx * v.y - ty * v.x;
 66 |     return this;
 67 |   },
 68 |   
 69 |   scale: function(s){
 70 |     this.x *= s;
 71 |     this.y *= s;
 72 |     this.z *= s;
 73 |     return this;
 74 |   },
 75 |   
 76 |   distanceTo: function(v){
 77 |     return Math.sqrt(this.distanceToSq(v));
 78 |   },
 79 |   
 80 |   distanceToSq: function(v){
 81 |     var dx = this.x - v.x,
 82 |         dy = this.y - v.y,
 83 |         dz = this.z - v.z;
 84 |     
 85 |     return dx * dx + dy * dy + dz * dz;
 86 |   },
 87 |   
 88 |   length: function(){
 89 |     return Math.sqrt(this.lengthSq());
 90 |   },
 91 |   
 92 |   lengthSq: function(){
 93 |     return this.distanceToSq(V3D.KER);
 94 |   },
 95 |   
 96 |   negate: function(){
 97 |     this.x = -this.x;
 98 |     this.y = -this.y;
 99 |     this.z = -this.z;
100 |     return this;
101 |   },
102 |   
103 |   normalize: function(){
104 |     var len = this.length(), ratio;
105 |     if (len > 0)
106 |       ratio = 1.0 / len;
107 |     else
108 |       ratio = 0;
109 |       
110 |     this.x *= ratio;
111 |     this.y *= ratio;
112 |     this.z *= ratio;
113 |     return this;
114 |   },
115 |   
116 |   dot: function(v){
117 |     return this.x * v.x + this.y * v.y + this.z * v.z;
118 |   },
119 |   
120 |   clone: function(){
121 |     return new V3D(this.x, this.y, this.z);
122 |   },
123 |   
124 |   toString: function(){
125 |     return '(' + this.x + ', ' + this.y + ', ' + this.z + ')';
126 |   }  
127 | });
128 | 
129 | V3D.KER = new V3D;
130 | 
131 | V3D.add = function(a, b) {
132 |   return new V3D( a.x + b.x, a.y + b.y, a.z + b.z );
133 | };
134 | 
135 | V3D.sub = function(a, b) {
136 |   return new V3D( a.x - b.x, a.y - b.y, a.z - b.z );
137 | };   
138 | 
139 | V3D.scale = function(a, s) {
140 |   return new V3D( a.x * s, a.y * s, a.z * s );
141 | };
142 | 
143 | V3D.cross = function(a, b) {
144 |   return new V3D( a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x );
145 | };
146 | 
147 | V3D.dot = function(a, b) {
148 |   return a.x * b.x + a.y * b.y + a.z * b.z;
149 | };
150 | 


--------------------------------------------------------------------------------
/glbindings/make_json.py:
--------------------------------------------------------------------------------
  1 | import re
  2 | import json
  3 | 
  4 | PATH_GL = 'gl.h'
  5 | FILE_JSON = 'glbind.json'
  6 | 
  7 | #constant and function patterns
  8 | constant_pattern = """
  9 |     .+define[\s]+       #define C/C++ keyword
 10 |     
 11 |     (?P<name>GL_[^\s]+) #Constant name
 12 |     
 13 |     [\s]+
 14 |     
 15 |     (?P<value>[^\s]+)   #Constant value
 16 |     
 17 |     [\s]*
 18 | """
 19 | 
 20 | function_pattern = """
 21 |     [\s]*extern[\s]+          #extern declaration
 22 |     
 23 |     (?P<return_type>[^\s]+)  #Function return type
 24 |     
 25 |     [\s]+ 
 26 |     
 27 |     (?P<name>gl[A-Za-z0-9]+) #Function name
 28 |     
 29 |     [\s]*
 30 |     
 31 |     \((?P<parameters>.*)\);  #Function parameters
 32 | """
 33 | #precompile regexps
 34 | constant = re.compile(constant_pattern, re.VERBOSE)
 35 | function = re.compile(function_pattern, re.VERBOSE)
 36 | 
 37 | def main():
 38 |     json_out = []
 39 |     constants = []
 40 |     #open input file
 41 |     with open(PATH_GL, 'r') as fin:
 42 |         #line accumulator. Function definitions 
 43 |         #can be spread into multiple lines
 44 |         l = ''
 45 |         #get function/constant prototype
 46 |         for cont in fin:
 47 |            l += cont.replace('\n', '')
 48 |            if not balanced(l):
 49 |               continue
 50 |            #is constant declaration
 51 |            mat = re.match(constant, l)
 52 |            if mat and not mat.group('name') in constants:
 53 |                constants.append(mat.group('name'))
 54 |                json_out.append(make_constant(mat))
 55 |            else:
 56 |                #is function declaration
 57 |                mat = re.match(function, l)
 58 |                if mat: 
 59 |                    json_out.append(make_function(mat))
 60 |                
 61 |            l = '' #empty line accumulator
 62 | 
 63 |     #dump as JSON
 64 |     with open(FILE_JSON, 'w') as fout:
 65 |         fout.write(json.dumps(json_out, indent=4))
 66 | 
 67 | def make_constant(match):
 68 |     """Returns a Constant JSON Object"""
 69 |     
 70 |     return {
 71 |         'type': 'c', #c for constant, f for function
 72 |         'name': match.group('name'),
 73 |         'value': match.group('value') #is this necessary?        
 74 |     }
 75 | 
 76 | def make_function(match):
 77 |     """Returns a Function JSON Object"""
 78 |     
 79 |     return {
 80 |         'type': 'f', #f for function
 81 |         'name': match.group('name'),
 82 |         'return_type': match.group('return_type'),
 83 |         'parameters': get_parameters(match.group('parameters'))
 84 |     }
 85 | 
 86 | def get_parameters(params):
 87 |     """Returns an ordered list of parameter types"""
 88 |     
 89 |     params_list = []
 90 |     params_aux = params.split(',')
 91 |     passed = False
 92 |     for par in params_aux:
 93 |         if passed and not balanced(params_list[-1]):
 94 |             params_list[-1] += ',' + par
 95 |         else:
 96 |             #magic
 97 |             param = ' '.join(par.strip().split(' ')[:-1]) + ('*' * (par.count('*') + par.count('[')))
 98 |             if param.strip() != '': params_list.append(param)
 99 |         passed = True
100 |     
101 |     return params_list
102 | 
103 | 
104 | def balanced(l):
105 |     return l.count('(') == l.count(')')
106 | 
107 | if __name__ == '__main__': main()


--------------------------------------------------------------------------------
/glesbindings/make_json.py:
--------------------------------------------------------------------------------
  1 | import re
  2 | import json
  3 | 
  4 | PATH_GL = 'gl2.h'
  5 | FILE_JSON = 'glesbind.json'
  6 | 
  7 | #constant and function patterns
  8 | constant_pattern = """
  9 |     .+define[\s]+       #define C/C++ keyword
 10 |     
 11 |     (?P<name>GL_[^\s]+) #Constant name
 12 |     
 13 |     [\s]+
 14 |     
 15 |     (?P<value>[^\s]+)   #Constant value
 16 |     
 17 |     [\s]*
 18 | """
 19 | 
 20 | function_pattern = """
 21 |     [\s]*GL_APICALL[\s]+          #GLAPICALL typedef
 22 |     
 23 |     (?P<return_type>[^\s]+)       #Function return type
 24 |     
 25 |     [\s]+GL_APIENTRY[\s]+         #GLAPIENTRY typedef
 26 |     
 27 |     (?P<name>gl[A-Za-z0-9]+)      #Function name
 28 |     
 29 |     [\s]*
 30 |     
 31 |     \((?P<parameters>.*)\);       #Function parameters
 32 | """
 33 | #precompile regexps
 34 | constant = re.compile(constant_pattern, re.VERBOSE)
 35 | function = re.compile(function_pattern, re.VERBOSE)
 36 | 
 37 | def main():
 38 |     json_out = []
 39 |     constants = []
 40 |     #open input file
 41 |     with open(PATH_GL, 'r') as fin:
 42 |         #line accumulator. Function definitions 
 43 |         #can be spread into multiple lines
 44 |         l = ''
 45 |         #get function/constant prototype
 46 |         for cont in fin:
 47 |            l += cont.replace('\n', '')
 48 |            if not balanced(l):
 49 |               continue
 50 |            #is constant declaration
 51 |            mat = re.match(constant, l)
 52 |            if mat and not mat.group('name') in constants:
 53 |                constants.append(mat.group('name'))
 54 |                json_out.append(make_constant(mat))
 55 |            else:
 56 |                #is function declaration
 57 |                mat = re.match(function, l)
 58 |                if mat: 
 59 |                    json_out.append(make_function(mat))
 60 |                
 61 |            l = '' #empty line accumulator
 62 | 
 63 |     #dump as JSON
 64 |     with open(FILE_JSON, 'w') as fout:
 65 |         fout.write(json.dumps(json_out, indent=4))
 66 | 
 67 | def make_constant(match):
 68 |     """Returns a Constant JSON Object"""
 69 |     
 70 |     return {
 71 |         'type': 'c', #c for constant, f for function
 72 |         'name': match.group('name'),
 73 |         'value': match.group('value') #is this necessary?        
 74 |     }
 75 | 
 76 | def make_function(match):
 77 |     """Returns a Function JSON Object"""
 78 |     
 79 |     return {
 80 |         'type': 'f', #f for function
 81 |         'name': match.group('name'),
 82 |         'return_type': match.group('return_type'),
 83 |         'parameters': get_parameters(match.group('parameters'))
 84 |     }
 85 | 
 86 | def get_parameters(params):
 87 |     """Returns an ordered list of parameter types"""
 88 |     
 89 |     params_list = []
 90 |     params_aux = params.split(',')
 91 |     passed = False
 92 |     for par in params_aux:
 93 |         if passed and not balanced(params_list[-1]):
 94 |             params_list[-1] += ',' + par
 95 |         else:
 96 |             #magic
 97 |             param = ' '.join(par.strip().replace('*', '').split(' ')[:-1]) + ('*' * (par.count('*') + par.count('[')))
 98 |             if param.strip() != '': params_list.append(param)
 99 |         passed = True
100 |     
101 |     return params_list
102 | 
103 | 
104 | def balanced(l):
105 |     return l.count('(') == l.count(')')
106 | 
107 | if __name__ == '__main__': main()


--------------------------------------------------------------------------------
/examples/gles/ch8-simple-vertexshader.js:
--------------------------------------------------------------------------------
  1 | //load common code.
  2 | load("common.js", "shaderutil.js");
  3 | 
  4 | //start custom code.
  5 | var angle = 0;
  6 | 
  7 | // an object we'll use to store shaders, textures, etc. on as we create them
  8 | var userData = {};
  9 | 
 10 | function init() {
 11 | 	userData.programObject = getProgram("shaders/ch8-simple-vertexshader.vs", 
 12 | 	                                    "shaders/ch8-simple-vertexshader.fs");
 13 | 	
 14 | 	if(userData.programObject == 0) return false;
 15 | 	
 16 | 	userData.positionLoc = Gles.getAttribLocation(userData.programObject, "a_position");
 17 | 	userData.mvpLoc = Gles.getUniformLocation(userData.programObject, "u_mvpMatrix");
 18 | 	userData.obj = esGenCube(1.0);
 19 | 	Gles.clearColor(0, 0, 0, 0);
 20 | 	return true;
 21 | }
 22 | 
 23 | function updateObjects() {
 24 | 	// compute the window aspect ratio
 25 |     var aspect = 800 / 600;
 26 | 
 27 |     // Generate a perspective matrix with a 60 degree FOV
 28 |     var persp = new Matrix4x4();
 29 |     persp.perspective(60, aspect, 1.0, 20.0);
 30 | 
 31 |     // Create our modelview matrix
 32 |     var modelview = new Matrix4x4();
 33 | 
 34 |     // translate away from the viewer
 35 |     modelview.translate(0, 0, -2);
 36 | 
 37 |     // then rotating the cube
 38 |     modelview.rotate(angle, 1, 1, 1);
 39 | 
 40 |     userData.mvpMatrix = modelview.multiply(persp);
 41 | }
 42 | 
 43 | 
 44 | // Update MVP matrix based on time; deltaTime is in seconds
 45 | function update() {
 46 | 	angle += 2.0;
 47 | 	if (angle > 360) angle -= 360;
 48 | 	updateObjects();
 49 |   Glut.postRedisplay();
 50 | 	Glut.timerFunc(25, update, 0);
 51 | }
 52 | 
 53 | // Actually draw the triangle, using the program created in init()
 54 | function draw() {
 55 |     // Set up the viewport
 56 |     Gles.viewport(0, 0, 800, 600);
 57 | 
 58 |     // Clear the color buffer
 59 |     Gles.clear(Gles.COLOR_BUFFER_BIT);
 60 | 
 61 |     // Use the program object we created in init()
 62 |     Gles.useProgram(userData.programObject);
 63 | 
 64 |     // Load the vertex data
 65 |     Gles.vertexAttribPointer(userData.positionLoc, 3, Gles.FLOAT, false, 0, userData.obj.vertices);
 66 |     Gles.enableVertexAttribArray(userData.positionLoc);
 67 | 
 68 |     // Load the MVP matrix
 69 |     Gles.uniformMatrix4fv(userData.mvpLoc, userData.mvpMatrix.elements.length, Gles.FALSE, userData.mvpMatrix.elements);
 70 | 
 71 |     // Draw the cube
 72 |     //Gles.drawArrays(Gles.TRIANGLE_FAN, 0, userData.obj.vertices.length);
 73 |     Gles.drawElements(Gles.TRIANGLES, userData.obj.indices.length, Gles.UNSIGNED_SHORT, userData.obj.indices);
 74 | 
 75 |     // Finally do the swap to display what we just drew
 76 |     Glut.swapBuffers();
 77 | }
 78 | 
 79 | function main() {
 80 | 	//Initialize Glut
 81 | 	Glut.init();
 82 | 	Glut.initDisplayMode(Glut.DOUBLE | Glut.RGB | Glut.DEPTH);
 83 | 	Glut.initWindowSize(800, 600);
 84 | 	//Create the window
 85 | 	Glut.createWindow("OpenGL ES on V8!  (^_^)/");
 86 | 	
 87 |     if (!init())
 88 |       return;
 89 |     
 90 |     updateObjects();
 91 | 	//Set drawing callback
 92 | 	Glut.displayFunc(draw);
 93 | 	//Set resize window callback
 94 | 	Glut.reshapeFunc(function(w, h) {
 95 | 		Gles.viewport(0, 0, w, h);
 96 | 		Gl.matrixMode(Gl.PROJECTION);
 97 | 		Gl.loadIdentity();
 98 | 		Glu.perspective(45.0, w / h, 1.0, 200.0);
 99 | 	});
100 | 
101 | 	Glut.timerFunc(25, update, 0);
102 | 	//Start the main loop.
103 | 	Glut.mainLoop();
104 | }
105 | 
106 | main();


--------------------------------------------------------------------------------
/glesbindings/gles_desktop_shim.h:
--------------------------------------------------------------------------------
 1 | #define GL_ES_VERSION_2_0                 1
 2 | #define GL_FIXED                          0x140C
 3 | #define GL_MAX_VERTEX_UNIFORM_VECTORS       0x8DFB
 4 | #define GL_MAX_VARYING_VECTORS              0x8DFC
 5 | #define GL_MAX_FRAGMENT_UNIFORM_VECTORS     0x8DFD
 6 | #define GL_SHADER_COMPILER                0x8DFA
 7 | #define GL_SHADER_BINARY_FORMATS          0x8DF8
 8 | #define GL_NUM_SHADER_BINARY_FORMATS      0x8DF9
 9 | #define GL_LOW_FLOAT                      0x8DF0
10 | #define GL_MEDIUM_FLOAT                   0x8DF1
11 | #define GL_HIGH_FLOAT                     0x8DF2
12 | #define GL_LOW_INT                        0x8DF3
13 | #define GL_MEDIUM_INT                     0x8DF4
14 | #define GL_HIGH_INT                       0x8DF5
15 | #define GL_FRAMEBUFFER                    0x8D40
16 | #define GL_RENDERBUFFER                   0x8D41
17 | #define GL_RGB565                         0x8D62
18 | #define GL_STENCIL_INDEX8                 0x8D48
19 | #define GL_RENDERBUFFER_WIDTH             0x8D42
20 | #define GL_RENDERBUFFER_HEIGHT            0x8D43
21 | #define GL_RENDERBUFFER_INTERNAL_FORMAT   0x8D44
22 | #define GL_RENDERBUFFER_RED_SIZE          0x8D50
23 | #define GL_RENDERBUFFER_GREEN_SIZE        0x8D51
24 | #define GL_RENDERBUFFER_BLUE_SIZE         0x8D52
25 | #define GL_RENDERBUFFER_ALPHA_SIZE        0x8D53
26 | #define GL_RENDERBUFFER_DEPTH_SIZE        0x8D54
27 | #define GL_RENDERBUFFER_STENCIL_SIZE      0x8D55
28 | #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE           0x8CD0
29 | #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME           0x8CD1
30 | #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL         0x8CD2
31 | #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3
32 | #define GL_COLOR_ATTACHMENT0              0x8CE0
33 | #define GL_DEPTH_ATTACHMENT               0x8D00
34 | #define GL_STENCIL_ATTACHMENT             0x8D20
35 | #define GL_FRAMEBUFFER_COMPLETE                      0x8CD5
36 | #define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT         0x8CD6
37 | #define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7
38 | #define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS         0x8CD9
39 | #define GL_FRAMEBUFFER_UNSUPPORTED                   0x8CDD
40 | #define GL_FRAMEBUFFER_BINDING            0x8CA6
41 | #define GL_RENDERBUFFER_BINDING           0x8CA7
42 | #define GL_MAX_RENDERBUFFER_SIZE          0x84E8
43 | #define glBindFramebuffer glBindFramebufferEXT
44 | #define glBindRenderbuffer glBindRenderbufferEXT
45 | #define glCheckFramebufferStatus glCheckFramebufferStatusEXT
46 | #define glDeleteFramebuffers glDeleteFramebuffersEXT
47 | #define glDeleteRenderbuffers glDeleteRenderbuffersEXT
48 | #define glFramebufferRenderbuffer glFramebufferRenderbufferEXT
49 | #define glFramebufferTexture2D glFramebufferTexture2DEXT
50 | #define glGenerateMipmap glGenerateMipmapEXT
51 | #define glGenFramebuffers glGenFramebuffersEXT
52 | #define glGenRenderbuffers glGenRenderbuffersEXT
53 | #define glGetFramebufferAttachmentParameteriv glGetFramebufferAttachmentParameterivEXT
54 | #define glGetRenderbufferParameteriv glGetRenderbufferParameterivEXT
55 | #define glIsFramebuffer glIsFramebufferEXT
56 | #define glIsRenderbuffer glIsRenderbufferEXT
57 | #define glRenderbufferStorage glRenderbufferStorageEXT
58 | 
59 | // Some of the OpenGL 2.0 spec is defined as doubles, so ES 2.0 adds float
60 | // versions.  Implement some simple shims here.
61 | #define glClearDepthf(depth) glClearDepth(depth)
62 | #define glDepthRangef(zNear, zFar) glDepthRange((zNear), (zFar))
63 | 
64 | // These don't exist in desktop OpenGL, just stub them out.
65 | #define glReleaseShaderCompiler ((void) 0)
66 | #define glGetShaderPrecisionFormat(a, b, c, d) ((void) 0)
67 | 
68 | 


--------------------------------------------------------------------------------
/examples/gles/ch2-hello-triangle.js:
--------------------------------------------------------------------------------
  1 | // an object we'll use to store shaders, textures, etc. on as we create them
  2 | var userData = { };
  3 | 
  4 | function loadShader(shaderType, shaderSource) {
  5 |     // Create the shader object
  6 |     var shader = Gles.createShader(shaderType);
  7 |     if (shader == 0) return 0;
  8 | 
  9 |     // Load the shader source
 10 |     Gles.shaderSource(shader, shaderSource);
 11 | 
 12 |     // Compile the shader
 13 |     Gles.compileShader(shader);
 14 | 
 15 |     // Check the compile status
 16 |     var compiled = Gles.getShaderiv(shader, Gles.COMPILE_STATUS);
 17 |     if (!compiled) {
 18 |   		// Something went wrong during compilation; get the error
 19 |   		var error = Gles.getShaderInfoLog(shader);
 20 |   		Gles.deleteShader(shader);
 21 |   		return 0;
 22 |     }
 23 | 
 24 |     return shader;
 25 | }
 26 | 
 27 | function init() {
 28 |     // put our shader source in variables
 29 |     var vertexShaderSource = 
 30 | 	"attribute vec4 vPosition;     \n" +
 31 | 	"void main()                   \n" +
 32 | 	"{                             \n" +
 33 | 	"  gl_Position = vPosition;    \n" +
 34 | 	"} ";
 35 |     var fragmentShaderSource =
 36 | 	"/*precision mediump float;*/  \n" +
 37 | 	"void main()                   \n" +
 38 | 	"{                             \n" +
 39 | 	"  gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); \n" +
 40 | 	"} ";
 41 |     
 42 |     // create our shaders
 43 |     var vertexShader = loadShader(Gles.VERTEX_SHADER, vertexShaderSource);
 44 |     var fragmentShader = loadShader(Gles.FRAGMENT_SHADER, fragmentShaderSource);
 45 |     
 46 |     if (!vertexShader || !fragmentShader)
 47 | 	return false;
 48 | 
 49 |     // Create the program object
 50 |     var programObject = Gles.createProgram();
 51 |     if (programObject == 0)
 52 |       return false;
 53 | 
 54 |     // Attach our two shaders to the program
 55 |     Gles.attachShader (programObject, vertexShader);
 56 |     Gles.attachShader (programObject, fragmentShader);
 57 | 
 58 |     // Bind "vPosition" to attribute 0
 59 |     Gles.bindAttribLocation (programObject, 0, "vPosition");
 60 |     
 61 |     // Link the program
 62 |     Gles.linkProgram (programObject);
 63 | 
 64 |     // Check the link status
 65 |     var linked = Gles.getProgramiv (programObject, Gles.LINK_STATUS);
 66 |     if (!linked) {
 67 | 		// something went wrong with the link
 68 | 		var error = Gles.getProgramInfoLog (programObject);
 69 | 	
 70 | 		Gles.deleteProgram(programObject);
 71 | 		Gles.deleteProgram(fragmentShader);
 72 | 		Gles.deleteProgram(vertexShader);
 73 | 	
 74 | 		return false;
 75 |     }
 76 | 
 77 |     userData.programObject = programObject;
 78 | 
 79 |     // set up the clear color to clear to transparent black
 80 |     Gles.clearColor (0, 0, 0, 0);
 81 | 
 82 | 	//Set drawing callback
 83 | 	Glut.displayFunc(draw);
 84 |     
 85 |     return true;
 86 | }
 87 | 
 88 | // Actually draw the triangle, using the program created in init()
 89 | function draw() {
 90 | 	var vertices = [  0.0,  0.5,  0.0,
 91 | 				     -0.5, -0.5,  0.0,
 92 | 				      0.5, -0.5,  0.0  ];
 93 | 
 94 |     // Set up the viewport
 95 |     Gles.viewport(0, 0, 800, 600);
 96 | 
 97 |     // Clear the color buffer
 98 |     Gles.clear(Gles.COLOR_BUFFER_BIT);
 99 | 
100 |     // Use the program object we created in init()
101 |     Gles.useProgram(userData.programObject);
102 | 
103 |     // Load the vertex data
104 |     Gles.vertexAttribPointer(0, 3, Gles.FLOAT, false, 0, vertices);
105 |     Gles.enableVertexAttribArray(0);
106 | 
107 |     // Do the draw, as triangles
108 |     Gles.drawArrays(Gles.TRIANGLES, 0, 3);
109 |     
110 |     // Finally do the swap to display what we just drew
111 |     Glut.swapBuffers();
112 | }
113 | 
114 | function main() {
115 | 	//Initialize Glut
116 | 	Glut.init();
117 | 	Glut.initDisplayMode(Glut.DOUBLE | Glut.RGB | Glut.DEPTH);
118 | 	Glut.initWindowSize(800, 600);
119 | 	//Create the window
120 | 	Glut.createWindow("OpenGL ES on V8!  \\(^_^)/");
121 | 	
122 |     if (!init())
123 | 	return;
124 |     
125 |     Glut.mainLoop();
126 | }
127 | 
128 | main();


--------------------------------------------------------------------------------
/examples/gles/ch9-simple-texture-cubemap.js:
--------------------------------------------------------------------------------
  1 | //load libraries
  2 | load("common.js", "shaderutil.js");
  3 | 
  4 | // an object we'll use to store shaders, textures, etc. on as we create them
  5 | var userData = { };
  6 | 
  7 | //
  8 | // Create a simple cubemap texture
  9 | //
 10 | function createSimpleTextureCube()
 11 | {
 12 |     // Generate a texture object.  genTextures always returns
 13 |     // an array, and we're only interested in the first element
 14 |     var textureId = Gles.genTextures(1)[0];
 15 | 
 16 |     // Bind the texture object
 17 |     Gles.bindTexture(Gles.TEXTURE_CUBE_MAP, textureId);
 18 | 
 19 |     // Load each cube face
 20 |     Gles.texImage2D(Gles.TEXTURE_CUBE_MAP_POSITIVE_X, 0, Gles.RGB, 1, 1, 0, Gles.RGB, Gles.UNSIGNED_BYTE, [ 255, 0, 0 ]);
 21 |     Gles.texImage2D(Gles.TEXTURE_CUBE_MAP_NEGATIVE_X, 0, Gles.RGB, 1, 1, 0, Gles.RGB, Gles.UNSIGNED_BYTE, [ 0, 255, 0 ]);
 22 |     Gles.texImage2D(Gles.TEXTURE_CUBE_MAP_POSITIVE_Y, 0, Gles.RGB, 1, 1, 0, Gles.RGB, Gles.UNSIGNED_BYTE, [ 0, 0, 255 ]);
 23 |     Gles.texImage2D(Gles.TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, Gles.RGB, 1, 1, 0, Gles.RGB, Gles.UNSIGNED_BYTE, [ 255, 255, 0 ]);
 24 |     Gles.texImage2D(Gles.TEXTURE_CUBE_MAP_POSITIVE_Z, 0, Gles.RGB, 1, 1, 0, Gles.RGB, Gles.UNSIGNED_BYTE, [ 255, 0, 255 ]);
 25 |     Gles.texImage2D(Gles.TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, Gles.RGB, 1, 1, 0, Gles.RGB, Gles.UNSIGNED_BYTE, [ 255, 255, 255 ]);
 26 | 
 27 |     // set up filtering modes
 28 |     Gles.texParameteri(Gles.TEXTURE_CUBE_MAP, Gles.TEXTURE_MIN_FILTER, Gles.NEAREST);
 29 |     Gles.texParameteri(Gles.TEXTURE_CUBE_MAP, Gles.TEXTURE_MAG_FILTER, Gles.NEAREST);
 30 | 
 31 |     return textureId;
 32 | }
 33 | 
 34 | function init()
 35 | {
 36 |     // Create the linked program object
 37 |     userData.programObject = getProgram("shaders/ch9-vshader.sl",
 38 |     		                                "shaders/ch9-fshader.sl");
 39 |     if (userData.programObject == 0)
 40 |       return false;
 41 | 
 42 |     // Get the attribute locations
 43 |     userData.positionLoc = Gles.getAttribLocation(userData.programObject, "a_position");
 44 |     userData.normalLoc = Gles.getAttribLocation(userData.programObject, "a_normal");
 45 | 
 46 |     // Get the sampler location
 47 |     userData.samplerLoc = Gles.getUniformLocation(userData.programObject, "s_texture");
 48 | 
 49 |     // Load the texture
 50 |     userData.textureId = createSimpleTextureCube();
 51 | 
 52 |     // Create a sphere object
 53 |     userData.obj = esGenSphere(20, 0.75);
 54 | 
 55 |     // set up the clear color to clear to transparent black
 56 |     Gles.clearColor (0, 0, 0, 0);
 57 | 
 58 |     Glut.displayFunc(draw);
 59 |     return true;
 60 | }
 61 | 
 62 | //
 63 | // Draw the sphere we created in init()
 64 | //
 65 | function draw()
 66 | {
 67 |     // set up the viewport
 68 |     Gles.viewport (0, 0, 800, 600);
 69 | 
 70 |     // clear
 71 |     Gles.clear (Gles.COLOR_BUFFER_BIT);
 72 |     
 73 |     Gles.cullFace(Gles.BACK);
 74 | 
 75 |     Gles.enable(Gles.CULL_FACE);
 76 |     // use the program
 77 |     Gles.useProgram (userData.programObject);
 78 | 
 79 |     // load the vertex positions
 80 |     Gles.vertexAttribPointer (userData.positionLoc, 3, Gles.FLOAT, false, 0, userData.obj.vertices);
 81 | 
 82 |     // load the texture coordinates
 83 |     Gles.vertexAttribPointer (userData.normalLoc, 3, Gles.FLOAT, false, 0, userData.obj.normals);
 84 | 
 85 |     Gles.enableVertexAttribArray (userData.positionLoc);
 86 |     Gles.enableVertexAttribArray (userData.normalLoc);
 87 | 
 88 |     // bind the texture
 89 |     Gles.activeTexture(Gles.TEXTURE0);
 90 |     Gles.bindTexture(Gles.TEXTURE_CUBE_MAP, userData.textureId);
 91 | 
 92 |     // and set the sampler to texture unit 0
 93 |     Gles.uniform1i(userData.samplerLoc, 0);
 94 | 
 95 |     // and finally do the draw
 96 |     Gles.drawElements(Gles.TRIANGLES, userData.obj.indices.length, Gles.UNSIGNED_SHORT, userData.obj.indices);
 97 | 
 98 |     // swap buffers to display
 99 |     Glut.swapBuffers();
100 | }
101 | 
102 | function main()
103 | {
104 | 	//Initialize Glut
105 | 	Glut.init();
106 | 	Glut.initDisplayMode(Glut.DOUBLE | Glut.RGB | Glut.DEPTH);
107 | 	Glut.initWindowSize(800, 600);
108 | 	//Create the window
109 | 	Glut.createWindow("v8-gl Textures");
110 | 
111 |     if (!init())
112 | 	return;
113 |     
114 |     Glut.mainLoop();
115 | 
116 | }
117 | 
118 | main();
119 | 


--------------------------------------------------------------------------------
/examples/gles/ch9-simple-texture2d.js:
--------------------------------------------------------------------------------
  1 | //load common code.
  2 | load("common.js", "shaderutil.js");
  3 | 
  4 | // an object we'll use to store shaders, textures, etc. on as we create them
  5 | var userData = { };
  6 | 
  7 | //
  8 | //Create a simple 2x2 texture image with four different colors
  9 | //
 10 | function createSimpleTexture2D()
 11 | {
 12 |  var textureId;
 13 | 
 14 |  // 2x2 Image, 3 bytes per pixel (RGB)
 15 |  var pixels = [
 16 | 	255, 0, 0,   // Red
 17 |   0, 255, 0,   // Green
 18 | 	0, 0, 255,   // Blue
 19 | 	255, 255, 0  // Yellow
 20 |  ];
 21 | 
 22 |  // Use tightly packed data
 23 |  Gles.pixelStorei(Gles.UNPACK_ALIGNMENT, 1);
 24 | 
 25 |  // Generate a texture object.  genTextures always returns
 26 |  // an array, and we're only interested in the first element
 27 |  textureId = Gles.genTextures(1)[0];
 28 | 
 29 |  // Bind the texture object
 30 |  Gles.bindTexture(Gles.TEXTURE_2D, textureId);
 31 | 
 32 |  // Load the pixels into the texture object
 33 |  Gles.texImage2D(Gles.TEXTURE_2D,  // target
 34 | 		  0,		  // level
 35 | 		  Gles.RGB,	  // interal format
 36 | 		  2, 2,		  // width, height
 37 | 		  0,		  // border
 38 | 		  Gles.RGB,	  // format
 39 | 		  Gles.UNSIGNED_BYTE, // type
 40 | 		  pixels);	  // pixels array
 41 | 
 42 |  // set up filtering modes
 43 |  Gles.texParameteri(Gles.TEXTURE_2D, Gles.TEXTURE_MIN_FILTER, Gles.NEAREST);
 44 |  Gles.texParameteri(Gles.TEXTURE_2D, Gles.TEXTURE_MAG_FILTER, Gles.NEAREST);
 45 | 
 46 |  return textureId;
 47 | }
 48 | 
 49 | 
 50 | function init()
 51 | {
 52 |     // Create the linked program object
 53 |     userData.programObject = getProgram("shaders/ch9-texture2d-vshader.sl", 
 54 |     		                                "shaders/ch9-texture2d-fshader.sl");
 55 |     if (userData.programObject == 0)
 56 |       return false;
 57 | 
 58 |     // Get the attribute locations
 59 |     userData.positionLoc = Gles.getAttribLocation(userData.programObject, "a_position");
 60 |     userData.texCoordLoc = Gles.getAttribLocation(userData.programObject, "a_texCoord");
 61 | 
 62 |     // Get the sampler location
 63 |     userData.samplerLoc = Gles.getUniformLocation(userData.programObject, "s_texture");
 64 | 
 65 |     // Load the texture
 66 |     userData.textureId = createSimpleTexture2D();
 67 | 
 68 |     // set up the clear color to clear to transparent black
 69 |     Gles.clearColor (0, 0, 0, 0);
 70 | 
 71 |     Glut.displayFunc(draw);
 72 |     
 73 |     return true;
 74 | }
 75 | 
 76 | function draw()
 77 | {
 78 |     var vVertices = [
 79 |          -0.5,  0.5, 0.0,  // Position 0
 80 |          -0.5, -0.5, 0.0,  // Position 1
 81 |           0.5, -0.5, 0.0,  // Position 2
 82 |           0.5,  0.5, 0.0   // Position 3
 83 |      ];
 84 | 
 85 |      var vTexCoords = [
 86 |          0.0,  0.0,        // TexCoord 0
 87 |          0.0,  1.0,        // TexCoord 1
 88 |          1.0,  1.0,        // TexCoord 2
 89 |          1.0,  0.0         // TexCoord 3
 90 |      ];
 91 | 
 92 |      var indices = [ 0, 1, 2, 0, 2, 3 ];
 93 | 
 94 |      // set up the viewport
 95 |      Gles.viewport (0, 0, 800, 600);
 96 | 
 97 |      // clear
 98 |      Gles.clear (Gles.COLOR_BUFFER_BIT);
 99 | 
100 |      // use the program
101 |      Gles.useProgram (userData.programObject);
102 | 
103 |      // load the vertex positions
104 |      Gles.vertexAttribPointer (userData.positionLoc, 3, Gles.FLOAT, false, 0, vVertices);
105 | 
106 |      // load the texture coordinates
107 |      Gles.vertexAttribPointer (userData.texCoordLoc, 2, Gles.FLOAT, false, 0, vTexCoords);
108 | 
109 |      Gles.enableVertexAttribArray (userData.positionLoc);
110 |      Gles.enableVertexAttribArray (userData.texCoordLoc);
111 | 
112 |      // bind the texture
113 |      Gles.activeTexture(Gles.TEXTURE0);
114 |      Gles.bindTexture(Gles.TEXTURE_2D, userData.textureId);
115 | 
116 |      // and set the sampler to texture unit 0
117 |      Gles.uniform1i(userData.samplerLoc, 0);
118 | 
119 |      // and finally do the draw
120 |      Gles.drawElements(Gles.TRIANGLES, indices.length, Gles.UNSIGNED_SHORT, indices);
121 | 
122 |     // swap buffers to display
123 |     Glut.swapBuffers();
124 | }
125 | 
126 | function main() {
127 | 	//Initialize Glut
128 | 	Glut.init();
129 | 	Glut.initDisplayMode(Glut.DOUBLE | Glut.RGB | Glut.DEPTH);
130 | 	Glut.initWindowSize(800, 600);
131 | 	//Create the window
132 | 	Glut.createWindow("v8-gl Texture2D");
133 | 
134 |   if (!init())
135 |     return;
136 |     
137 |   Glut.mainLoop();
138 | }
139 | 
140 | main();
141 | 


--------------------------------------------------------------------------------
/examples/gles/ch10-multitexture.js:
--------------------------------------------------------------------------------
  1 | //load common code
  2 | load("common.js", "shaderutil.js");
  3 | 
  4 | // an object we'll use to store shaders, textures, etc. on as we create them
  5 | var userData = { };
  6 | 
  7 | //
  8 | // Create a 2D texture from the given HTML image
  9 | //
 10 | function textureFromImage(img)
 11 | {
 12 |     var textureId = Gles.genTextures(1)[0];
 13 | 
 14 |     Gles.bindTexture(Gles.TEXTURE_2D, textureId);
 15 | 
 16 |     // Load it.  The dimensions, format, etc. are all read from the image.
 17 |     Gles.texImage2DFile(img);
 18 | 
 19 |     // Set up filtering and wrap modes
 20 |     Gles.texParameteri(Gles.TEXTURE_2D, Gles.TEXTURE_MIN_FILTER, Gles.NEAREST);
 21 |     Gles.texParameteri(Gles.TEXTURE_2D, Gles.TEXTURE_MAG_FILTER, Gles.NEAREST);
 22 | 
 23 |     Gles.texParameteri(Gles.TEXTURE_2D, Gles.TEXTURE_WRAP_S, Gles.CLAMP_TO_EDGE);
 24 |     Gles.texParameteri(Gles.TEXTURE_2D, Gles.TEXTURE_WRAP_T, Gles.CLAMP_TO_EDGE);
 25 | 
 26 |     return textureId;
 27 | }
 28 | 
 29 | 
 30 | function init()
 31 | {
 32 | 
 33 | 	// Create the linked program object
 34 |     userData.programObject = getProgram("shaders/ch10-vshader.sl", 
 35 |     		                                "shaders/ch10-fshader.sl");
 36 |     if (userData.programObject == 0)
 37 |       return false;
 38 | 
 39 |     // Get the attribute locations
 40 |     userData.positionLoc = Gles.getAttribLocation(userData.programObject, "a_position");
 41 |     userData.texCoordLoc = Gles.getAttribLocation(userData.programObject, "a_texCoord");
 42 | 
 43 |     // Get the sampler locations
 44 |     userData.baseMapLoc = Gles.getUniformLocation(userData.programObject, "s_baseMap");
 45 |     userData.lightMapLoc = Gles.getUniformLocation(userData.programObject, "s_lightMap");
 46 | 
 47 |     // Load the textures; the textures were loaded earlier in main()
 48 |     userData.baseMapTexId = textureFromImage("assets/basemap.png");
 49 |     userData.lightMapTexId = textureFromImage("assets/lightmap.png");
 50 | 
 51 |     // set up the clear color to clear to transparent black
 52 |     Gles.clearColor (0, 0, 0, 0);
 53 |     
 54 |     Glut.displayFunc(draw);
 55 |     
 56 |     return true;
 57 | }
 58 | 
 59 | //
 60 | // Draw a rectangle using a pair of triangles and the program
 61 | // created in init()
 62 | //
 63 | function draw()
 64 | {
 65 |     var vVertices = [
 66 |         -0.5,  0.5, 0.0,  // Position 0
 67 |         -0.5, -0.5, 0.0,  // Position 1
 68 |          0.5, -0.5, 0.0,  // Position 2
 69 |          0.5,  0.5, 0.0   // Position 3
 70 |     ];
 71 | 
 72 |     var vTexCoords = [
 73 |         0.0,  0.0,        // TexCoord 0
 74 |         0.0,  1.0,        // TexCoord 1
 75 |         1.0,  1.0,        // TexCoord 2
 76 |         1.0,  0.0         // TexCoord 3
 77 |     ];
 78 | 
 79 |     var indices = [ 0, 1, 2, 0, 2, 3 ];
 80 | 
 81 |     // set up the viewport
 82 |     Gles.viewport (0, 0, 800, 600);
 83 | 
 84 |     // clear
 85 |     Gles.clear (Gles.COLOR_BUFFER_BIT);
 86 | 
 87 |     // use the program
 88 |     Gles.useProgram (userData.programObject);
 89 | 
 90 |     // load the vertex positions
 91 |     Gles.vertexAttribPointer (userData.positionLoc, 3, Gles.FLOAT, false, 0, vVertices);
 92 | 
 93 |     // load the texture coordinates
 94 |     Gles.vertexAttribPointer (userData.texCoordLoc, 2, Gles.FLOAT, false, 0, vTexCoords);
 95 | 
 96 |     Gles.enableVertexAttribArray (userData.positionLoc);
 97 |     Gles.enableVertexAttribArray (userData.texCoordLoc);
 98 | 
 99 |     // bind the base map
100 |     Gles.activeTexture(Gles.TEXTURE0);
101 |     Gles.bindTexture(Gles.TEXTURE_2D, userData.baseMapTexId);
102 | 
103 |     // and set the base map sampler to texture unit 0
104 |     Gles.uniform1i(userData.baseMapLoc, 0);
105 | 
106 |     // bind the light map
107 |     Gles.activeTexture(Gles.TEXTURE1);
108 |     Gles.bindTexture(Gles.TEXTURE_2D, userData.lightMapTexId);
109 | 
110 |     // and set the light map sampler to texture unit 1
111 |     Gles.uniform1i(userData.lightMapLoc, 1);
112 | 
113 |     // and finally do the draw
114 |     Gles.drawElements(Gles.TRIANGLES, indices.length, Gles.UNSIGNED_SHORT, indices);
115 | 
116 |     // swap buffers to display
117 |     Glut.swapBuffers();
118 | }
119 | 
120 | function main()
121 | {
122 | 	//Initialize Glut
123 | 	Glut.init();
124 | 	Glut.initDisplayMode(Glut.DOUBLE | Glut.RGB | Glut.DEPTH);
125 | 	Glut.initWindowSize(800, 600);
126 | 	//Create the window
127 | 	Glut.createWindow("v8-gl Textures");
128 | 
129 | 	if (!init())
130 | 	    return;
131 |     
132 |     Glut.mainLoop();
133 | }
134 | 
135 | main();
136 | 


--------------------------------------------------------------------------------
/examples/gles/metaballs/metaballs.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |   File: metaballs.js
  3 |   
  4 |   Description:
  5 |   
  6 |   Creates a Metaballs class similar to what's defined in the sprite-o-mat example.
  7 |   
  8 |   <http://www.pouet.net/prod.php?which=30222>
  9 |   
 10 |   Dependencies:
 11 |   
 12 |   core.js
 13 |   
 14 |   Author: 
 15 |   
 16 |   Nicolas Garcia Belmonte
 17 |   
 18 |   Copyright: 
 19 |   
 20 |   Copyright 2009 by Nicolas Garcia Belmonte.
 21 |   
 22 |   Homepage: 
 23 |   
 24 |   <http://blog.thejit.org>
 25 |   
 26 |   License: 
 27 |   
 28 |   MIT License
 29 |  */
 30 | 
 31 | var Config = {
 32 |     gridDim: 64,
 33 |     shift1: 6,
 34 |     shift2: 12,
 35 |     ballCount: 128,
 36 |     
 37 |     GP_TYPE_META: 0x1,
 38 |     GP_TYPE_BORDER: 0x2,
 39 |     GP_TYPE_TEXT: 0x4
 40 | };
 41 | 
 42 | var MetaBalls = new Class({
 43 |   balls: null,
 44 |   grid: null,
 45 |   
 46 |   initialize: function(grid) {
 47 |     this.grid = grid;
 48 |     var count = Config.ballCount;
 49 |     var b = this.balls = new Array(count);
 50 |     for(var i=0; i < count; i++) {
 51 |       //add metaobject
 52 |       b.push({
 53 |         'pos': { 'x':0, 'y':0, 'z':0 },
 54 |         'a': 0,
 55 |         'b': 0
 56 |       });
 57 |     }
 58 |   },
 59 |   
 60 |   update: function(from, to) {
 61 |     var balls = this.balls;
 62 |     var dim = Config.gridDim;
 63 |     var points = this.grid.points;
 64 |     var shift1 = Config.shift1, shift2 = Config.shift2;
 65 |     var meta = Config.GP_TYPE_META;
 66 |     
 67 |     while (from < num) {
 68 |       var ballsFrom = balls[from];
 69 |       var influenceRange = 1 + (ballsFrom.b >> 0);
 70 |       var pos = ballsFrom.pos;
 71 |       var posx = (pos.x >> 0);
 72 |       var posy = (pos.y >> 0);
 73 |       var posz = (pos.z >> 0);   
 74 |       for (var z = posz-influenceRange; z < posz+influenceRange; ++z) {
 75 |         if (z < 0 || z >= dim)
 76 |           continue;
 77 | 
 78 |         for (var y = posy-influenceRange; y < posy+influenceRange; ++y) {
 79 |           if (y < 0 || y >= dim)
 80 |             continue;
 81 | 
 82 |           for (var x = posx-influenceRange; x < posx+influenceRange; ++x) {
 83 |             if (x < 0 || x >= dim)
 84 |               continue;
 85 | 
 86 |             var dist = {
 87 |                 'x': pos.x - x,
 88 |                 'y': pos.y - y,
 89 |                 'z': pos.z - z
 90 |             };
 91 |             var dist2 = dist.x * dist.x + dist.y * dist.y + dist.z * dist.z;
 92 |             var range2 = ballsFrom.b * ballsFrom.b;
 93 | 
 94 |             if (range2 > dist2) {
 95 |               var gp = points[(z<<shift2) + (y<<shift1) + x];
 96 |               gp.value += ballsFrom.a * 
 97 |                 (1.0f - 
 98 |                 0.4444444f * dist2 * dist2 * dist2 / (range2 * range2 * range2) + 
 99 |                 1.8888888f * dist2 * dist2 / (range2 * range2) - 
100 |                 2.4444444f * dist2 / range2);
101 |               
102 |               gp.flags |= meta;
103 |             }
104 |           }
105 |         }
106 |       }
107 |       ++from;
108 |     }
109 |   }
110 | });
111 | 
112 | var MetaGrid = new Class({
113 |   points: null, 
114 |   
115 |   dim: null,
116 |   dimSq: null,
117 |   dimCb: null,
118 |   
119 |   initialize: function() {
120 |     var count = Config.gridDim;
121 |     this.dim = count;
122 |     this.dimSq = count * count;
123 |     this.dimCb = count * count * count;
124 |     
125 |     var p = this.points = new Array(count);
126 |     for(var i=0; i < count; i++) {
127 |       //add gridpoint
128 |       p.push({
129 |         'value': 0,
130 |         'flags': 0
131 |       });
132 |     }
133 |   },
134 |   
135 |   move: function(fac) {
136 |     var movecount = this.dimCb;
137 |     var dimSq = this.dimSq;
138 |     var points = this.points;
139 |     
140 |     while (movecount--) {
141 |       if (((movecount >> 12) & 0x3f) > 0) {
142 |         var p = points[movecount];
143 |         var pdiff = points[movecount - dimSq];
144 |         
145 |         p.value = fac * pdiff.value;
146 |         p.flags = pdiff.flags;
147 |       } else {
148 |         points[movecount].value = 0;
149 |       }
150 |     } 
151 |   }
152 | 
153 | });
154 | 
155 | function rgba(redval, greenval, blueval, alphaval) {
156 |   return ((alphaval << 24) | (redval << 16) | (greenval << 8) | blueval); 
157 | }
158 | 
159 | function gridColor(gp) {
160 |   var maxval = 2.0 * gp.value - 1.0;
161 |   
162 |   if (maxval > 1.0)
163 |     maxval = 1.0;
164 |   
165 |   var metacolor = rgba(196, 64 + ((192.0 * (1.0 - maxval)) >> 0), 0, 0);
166 |   
167 |   if (gp.flags & Config.GP_TYPE_META) {
168 |     if (gp.flags & Config.GP_TYPE_BORDER)
169 |       return {
170 |         'color': ((metacolor & 0xfefefefe) >> 1) + rgba(0, 64, 92, 0),
171 |         'maxval': maxval
172 |       };
173 |     else
174 |       return {
175 |         'color': metacolor,
176 |         'maxval': maxval
177 |       };
178 |   } else {
179 |     if (gp.flags & Config.GP_TYPE_BORDER)
180 |       return {
181 |         'color': rgba(0, 128, 196, 0),
182 |         'maxval': maxval
183 |       };
184 |     else
185 |       return {
186 |         'color': rgba(128, 228, 128, 0),
187 |         'maxval': maxval
188 |       };
189 |   }
190 | }
191 | 


--------------------------------------------------------------------------------
/README.mkd:
--------------------------------------------------------------------------------
  1 | V8-GL
  2 | =========
  3 | 
  4 | A JavaScript Toolkit for creating Desktop Hardware Accelerated Graphics with JS.
  5 | 
  6 | ![A V8-GL example code](http://blog.thejit.org/assets/v8gl2.png)
  7 | 
  8 | Note
  9 | ------
 10 | 
 11 | If you're interested in this project you might also want to check out [Plask](http://www.plask.org/), a JavaScript multimedia programming environment by [Dean McNamee](https://github.com/deanm).
 12 | 
 13 | 
 14 | Description
 15 | ---------
 16 | 
 17 | V8-GL intends to provide bindings for creating 2D-3D hardware accelerated graphics on the Desktop with JavaScript.
 18 | 
 19 | Although OpenGL bindings are included in this library, this project main goal is to provide a more rich and easy-to-use toolkit 
 20 | for making 2D-3D graphics.
 21 | 
 22 | I set a few goals for this project, the first of those is to provide complete OpenGL bindings for V8.
 23 | Other goals will be explained at [my blog](http://blog.thejit.org) in due time.
 24 | 
 25 | 
 26 | Status
 27 | ---------
 28 | 
 29 | No releases yet. OpenGL 2.1 bindings are 75% complete. The repo already has some functional examples. See the *example* readme section for a complete working example.
 30 | 
 31 | Requirements
 32 | ---------
 33 | 
 34 | - I use Mac OS X, but you can try to build your examples with Linux or Windows if you want. I guess that the only differences between Mac and Linux might be a couple of lines in the Makefile.
 35 | - OpenGL 2.1+
 36 | - [V8](http://code.google.com/p/v8/) and its requirements
 37 | 
 38 | Download
 39 | ---------
 40 | 
 41 | Since there are no releases yet, you can clone the repo from github
 42 |  
 43 |     $ git clone git://github.com/philogb/v8-gl.git
 44 | 
 45 | Then [checkout](http://code.google.com/p/v8/source/checkout) V8 source
 46 | 
 47 |     $ cd v8-gl
 48 |     $ svn co http://v8.googlecode.com/svn/trunk/ v8
 49 | 
 50 | Build V8
 51 | 
 52 |     $ cd v8
 53 |     $ scons mode=release
 54 | 
 55 | Make the project
 56 | 
 57 |     $ cd ..
 58 |     $ make
 59 |     
 60 | You'll probably get some warnings (but no errors), so everything should be ok.
 61 | Finally, run some example JS code
 62 | 
 63 |     $ ./v8-gl examples/example2.js
 64 |     
 65 | 
 66 | 
 67 | Example
 68 | ---------
 69 | 
 70 | Here's an example of a rotating Icosahedron with some lighting and colors.
 71 | 
 72 |     //Add array iteration method
 73 |     Array.prototype.each = function(f) {
 74 |         var len = this.length;
 75 |         for ( var i = 0; i < len; i++) f(this[i]);
 76 |     };
 77 |     
 78 |     //Initializes 3D rendering
 79 |     function initRendering() {
 80 |         "DEPTH_TEST COLOR_MATERIAL LIGHTING LIGHT0 NORMALIZE COLOR_MATERIAL"
 81 |             .split(" ").each(function(elem) {
 82 |             Gl.Enable(Gl[elem]);
 83 |         });
 84 |     }
 85 |     
 86 |     //global angle variable
 87 |     var angle = 0;
 88 |     
 89 |     //Draws the 3D scene
 90 |     function drawScene() {
 91 |         //Set global color and drawing properties
 92 |         Gl.Clear(Gl.COLOR_BUFFER_BIT | Gl.DEPTH_BUFFER_BIT);
 93 |         Gl.MatrixMode(Gl.MODELVIEW); 
 94 |         Gl.LoadIdentity();
 95 |         Gl.Translatef(0.0, 0.0, -5.0);
 96 |         //Set diffuse and positioned lights
 97 |         Gl.LightModelfv(Gl.LIGHT_MODEL_AMBIENT, [0.3, 0.3, 0.3, 1.0]);
 98 |         Gl.Lightfv(Gl.LIGHT0, Gl.DIFFUSE, [0.4, 0.4, 0.4, 1.0]);
 99 |         Gl.Lightfv(Gl.LIGHT0, Gl.POSITION, [5.0, 5.0, 5.0, 1.0]);
100 |         //Rotate and plot Icosahedron
101 |         Gl.Rotatef(angle, 1.0, 1.0, 1.0);
102 |         Gl.Color3f(0.5, 0.0, 0.8);
103 |         Glut.SolidIcosahedron(2.5);
104 |         //Render
105 |         Glut.SwapBuffers(); 
106 |     }
107 |     
108 |     (function() {
109 |         //Initialize Glut
110 |         Glut.Init();
111 |         Glut.InitDisplayMode(Glut.DOUBLE | Glut.RGB | Glut.DEPTH);
112 |         Glut.InitWindowSize(400, 400); //Set the window size
113 |         //Create the window
114 |         Glut.CreateWindow("OpenGL on V8 baby!");
115 |         initRendering();
116 |         //Set drawing callback
117 |         Glut.DisplayFunc(drawScene);
118 |         //Set resize window callback
119 |         Glut.ReshapeFunc(function(w, h) {
120 |             var gl = { 'Viewport': [0, 0, w, h], 'MatrixMode': [Gl.PROJECTION], 'LoadIdentity': [] };
121 |             for (var i in gl) Gl[i].apply(this, gl[i]);
122 |             Glu.Perspective(45.0, w / h, 1.0, 200.0);
123 |         });
124 |         //Set timeout callback
125 |         Glut.TimerFunc(25, function() {
126 |             angle += 2.0;
127 |             if (angle > 360) angle -= 360;
128 |             Glut.PostRedisplay();
129 |             Glut.TimerFunc(25, arguments.callee, 0);
130 |         }, 0);
131 |         //Start the main loop.
132 |         Glut.MainLoop();
133 |     })();
134 |     
135 | 
136 | 
137 | License
138 | ---------
139 | 
140 | BSD License.
141 | 
142 |     Redistribution and use in source and binary forms, with or without
143 |     modification, are permitted provided that the following conditions are met:
144 |          * Redistributions of source code must retain the above copyright
145 |            notice, this list of conditions and the following disclaimer.
146 |          * Redistributions in binary form must reproduce the above copyright
147 |            notice, this list of conditions and the following disclaimer in the
148 |            documentation and/or other materials provided with the distribution.
149 |          * Neither the name of the organization nor the
150 |            names of its contributors may be used to endorse or promote products
151 |            derived from this software without specific prior written permission.
152 |     
153 |      THIS SOFTWARE IS PROVIDED BY Nicolas Garcia Belmonte ``AS IS'' AND ANY
154 |      EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
155 |      WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
156 |      DISCLAIMED. IN NO EVENT SHALL Nicolas Garcia Belmonte BE LIABLE FOR ANY
157 |      DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
158 |      (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
159 |      LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
160 |      ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
161 |      (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
162 |      SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
163 | 


--------------------------------------------------------------------------------
/examples/gles/lib/core.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |   File: core.js
  3 |   
  4 |   Description:
  5 |   
  6 |   Provides common utility functions and the Class object.
  7 |   
  8 |   Dependencies:
  9 |   
 10 |   [None]
 11 |   
 12 |   Author: 
 13 |   
 14 |   Nicolas Garcia Belmonte
 15 |   
 16 |   Copyright: 
 17 |   
 18 |   Copyright 2009 by Nicolas Garcia Belmonte.
 19 |   
 20 |   Homepage: 
 21 |   
 22 |   <http://blog.thejit.org>
 23 |   
 24 |   License: 
 25 |   
 26 |   MIT License
 27 |  */
 28 | 
 29 | var $ = {};
 30 | 
 31 | $.empty = function() {};
 32 | 
 33 | $.extend = function(original, extended){
 34 |     for (var key in (extended || {})) original[key] = extended[key];
 35 |     return original;
 36 | };
 37 | 
 38 | $.lambda = function(value){
 39 |     return (typeof value == 'function') ? value : function(){
 40 |         return value;
 41 |     };
 42 | };
 43 | 
 44 | $.time = Date.now || function(){
 45 |     return +new Date;
 46 | };
 47 | 
 48 | $.splat = function(obj){
 49 |     var type = $.type(obj);
 50 |     return (type) ? ((type != 'array') ? [obj] : obj) : [];
 51 | };
 52 | 
 53 | $.type = function(elem) {
 54 |   return $type.s.call(elem).match(/^\[object\s(.*)\]$/)[1].toLowerCase();
 55 | };
 56 | $.type.s = Object.prototype.toString;
 57 | 
 58 | $.each = function(iterable, fn){
 59 |   var type = $.type(iterable);
 60 |   if(type == 'object') {
 61 |     for (var key in iterable) fn(iterable[key], key);
 62 |   } else {
 63 |     for(var i=0; i < iterable.length; i++) fn(iterable[i], i);
 64 |   }
 65 | };
 66 | 
 67 | $.merge = function(){
 68 |     var mix = {};
 69 |     for (var i = 0, l = arguments.length; i < l; i++){
 70 |         var object = arguments[i];
 71 |         if ($.type(object) != 'object') continue;
 72 |         for (var key in object){
 73 |             var op = object[key], mp = mix[key];
 74 |             mix[key] = (mp && $.type(op) == 'object' && $.type(mp) == 'object') ? $.merge(mp, op) : $.unlink(op);
 75 |         }
 76 |     }
 77 |     return mix;
 78 | };
 79 | 
 80 | $.unlink = function(object){
 81 |     var unlinked;
 82 |     switch ($.type(object)){
 83 |         case 'object':
 84 |             unlinked = {};
 85 |             for (var p in object) unlinked[p] = $.unlink(object[p]);
 86 |         break;
 87 |         case 'array':
 88 |             unlinked = [];
 89 |             for (var i = 0, l = object.length; i < l; i++) unlinked[i] = $.unlink(object[i]);
 90 |         break;
 91 |         default: return object;
 92 |     }
 93 |     return unlinked;
 94 | };
 95 | 
 96 | $.rgbToHex = function(srcArray, array){
 97 |     if (srcArray.length < 3) return null;
 98 |     if (srcArray.length == 4 && srcArray[3] == 0 && !array) return 'transparent';
 99 |     var hex = [];
100 |     for (var i = 0; i < 3; i++){
101 |         var bit = (srcArray[i] - 0).toString(16);
102 |         hex.push((bit.length == 1) ? '0' + bit : bit);
103 |     }
104 |     return (array) ? hex : '#' + hex.join('');
105 | };
106 | 
107 | $.hexToRgb = function(hex) {
108 |   var hex = hex.match(/^#?(\w{1,2})(\w{1,2})(\w{1,2})$/);
109 |   var array = hex.slice(1); 
110 |   if (array.length != 3) return null;
111 |   var rgb = [];
112 |   $.each(array, function(value){
113 |     if (value.length == 1) value += value;
114 |     rgb.push(parseInt(value, 16));
115 |   });
116 |   return rgb;
117 | };
118 | 
119 | var Class = function(properties){
120 |   properties = properties || {};
121 |   var klass = function(){
122 |       for (var key in this){
123 |           if (typeof this[key] != 'function') this[key] = $.unlink(this[key]);
124 |       }
125 |       this.constructor = klass;
126 |       if (Class.prototyping) return this;
127 |       var instance = (this.initialize) ? this.initialize.apply(this, arguments) : this;
128 |       return instance;
129 |   };
130 |   
131 |   for (var mutator in Class.Mutators){
132 |       if (!properties[mutator]) continue;
133 |       properties = Class.Mutators[mutator](properties, properties[mutator]);
134 |       delete properties[mutator];
135 |   }
136 |   
137 |   $.extend(klass, this);
138 |   klass.constructor = Class;
139 |   klass.prototype = properties;
140 |   return klass;
141 | };
142 | 
143 | Class.Mutators = {
144 | 
145 |     Extends: function(self, klass){
146 |         Class.prototyping = klass.prototype;
147 |         var subclass = new klass;
148 |         delete subclass.parent;
149 |         subclass = Class.inherit(subclass, self);
150 |         delete Class.prototyping;
151 |         return subclass;
152 |     },
153 | 
154 |     Implements: function(self, klasses){
155 |         $.each($.splat(klasses), function(klass){
156 |             Class.prototying = klass;
157 |             $.extend(self, ($.type(klass) == 'function') ? new klass : klass);
158 |             delete Class.prototyping;
159 |         });
160 |         return self;
161 |     }
162 | 
163 | };
164 | 
165 | $extend(Class, {
166 | 
167 |     inherit: function(object, properties){
168 |         var caller = arguments.callee.caller;
169 |         for (var key in properties){
170 |             var override = properties[key];
171 |             var previous = object[key];
172 |             var type = $.type(override);
173 |             if (previous && type == 'function'){
174 |                 if (override != previous){
175 |                     if (caller){
176 |                         override.__parent = previous;
177 |                         object[key] = override;
178 |                     } else {
179 |                         Class.override(object, key, override);
180 |                     }
181 |                 }
182 |             } else if(type == 'object'){
183 |                 object[key] = $.merge(previous, override);
184 |             } else {
185 |                 object[key] = override;
186 |             }
187 |         }
188 | 
189 |         if (caller) object.parent = function(){
190 |             return arguments.callee.caller.__parent.apply(this, arguments);
191 |         };
192 | 
193 |         return object;
194 |     },
195 | 
196 |     override: function(object, name, method){
197 |         var parent = Class.prototyping;
198 |         if (parent && object[name] != parent[name]) parent = null;
199 |         var override = function(){
200 |             var previous = this.parent;
201 |             this.parent = parent ? parent[name] : object[name];
202 |             var value = method.apply(this, arguments);
203 |             this.parent = previous;
204 |             return value;
205 |         };
206 |         object[name] = override;
207 |     }
208 | 
209 | });
210 | 
211 | 
212 | Class.prototype.implement = function(){
213 |     var proto = this.prototype;
214 |     $.each(Array.prototype.slice.call(arguments || []), function(properties){
215 |         Class.inherit(proto, properties);
216 |     });
217 |     return this;
218 | };
219 | 


--------------------------------------------------------------------------------
/examples/gles/common.js:
--------------------------------------------------------------------------------
  1 | load("lib/matrix.js");
  2 | 
  3 | /*
  4 |  * Copyright (c) 2009, Mozilla Corp
  5 |  * All rights reserved.
  6 |  *
  7 |  * Redistribution and use in source and binary forms, with or without
  8 |  * modification, are permitted provided that the following conditions are met:
  9 |  *     * Redistributions of source code must retain the above copyright
 10 |  *       notice, this list of conditions and the following disclaimer.
 11 |  *     * Redistributions in binary form must reproduce the above copyright
 12 |  *       notice, this list of conditions and the following disclaimer in the
 13 |  *       documentation and/or other materials provided with the distribution.
 14 |  *     * Neither the name of the <organization> nor the
 15 |  *       names of its contributors may be used to endorse or promote products
 16 |  *       derived from this software without specific prior written permission.
 17 |  *
 18 |  * THIS SOFTWARE IS PROVIDED BY <copyright holder> ''AS IS'' AND ANY
 19 |  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 20 |  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 21 |  * DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
 22 |  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 23 |  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 24 |  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 25 |  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 26 |  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 27 |  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 28 |  */
 29 | 
 30 | /*
 31 |  * Based on sample code from the OpenGL(R) ES 2.0 Programming Guide, which carriers
 32 |  * the following header:
 33 |  *
 34 |  * Book:      OpenGL(R) ES 2.0 Programming Guide
 35 |  * Authors:   Aaftab Munshi, Dan Ginsburg, Dave Shreiner
 36 |  * ISBN-10:   0321502795
 37 |  * ISBN-13:   9780321502797
 38 |  * Publisher: Addison-Wesley Professional
 39 |  * URLs:      http://safari.informit.com/9780321563835
 40 |  *            http://www.opengles-book.com
 41 |  */
 42 | 
 43 | //
 44 | // port of esShapes.c
 45 | //
 46 | 
 47 | function shallowCloneArray(ar) {
 48 |   var o = Array(ar.length);
 49 |   for (var i = 0; i < ar.length; i++) {
 50 |     o[i] = ar[i];
 51 |   }
 52 |   return o;
 53 | }
 54 | 
 55 | function shallowCloneArrayScaled(ar, scale) {
 56 |   var o = Array(ar.length);
 57 |   for (var i = 0; i < ar.length; i++) {
 58 |     o[i] = ar[i] * scale;
 59 |   }
 60 |   return o;
 61 | }
 62 | 
 63 | // make these accessible directly in the glboal scope,
 64 | // in case someone wants to use them without copying
 65 | var esCubeVertices = [
 66 |   -0.5, -0.5, -0.5,
 67 |   -0.5, -0.5,  0.5,
 68 |    0.5, -0.5,  0.5,
 69 |    0.5, -0.5, -0.5,
 70 |   -0.5,  0.5, -0.5,
 71 |   -0.5,  0.5,  0.5,
 72 |    0.5,  0.5,  0.5,
 73 |    0.5,  0.5, -0.5,
 74 |   -0.5, -0.5, -0.5,
 75 |   -0.5,  0.5, -0.5,
 76 |    0.5,  0.5, -0.5,
 77 |    0.5, -0.5, -0.5,
 78 |   -0.5, -0.5, 0.5,
 79 |   -0.5,  0.5, 0.5,
 80 |    0.5,  0.5, 0.5,
 81 |    0.5, -0.5, 0.5,
 82 |   -0.5, -0.5, -0.5,
 83 |   -0.5, -0.5,  0.5,
 84 |   -0.5,  0.5,  0.5,
 85 |   -0.5,  0.5, -0.5,
 86 |    0.5, -0.5, -0.5,
 87 |    0.5, -0.5,  0.5,
 88 |    0.5,  0.5,  0.5,
 89 |    0.5,  0.5, -0.5
 90 | ];
 91 | 
 92 | var esCubeNormals = [
 93 |    0.0, -1.0, 0.0,
 94 |    0.0, -1.0, 0.0,
 95 |    0.0, -1.0, 0.0,
 96 |    0.0, -1.0, 0.0,
 97 |    0.0, 1.0, 0.0,
 98 |    0.0, 1.0, 0.0,
 99 |    0.0, 1.0, 0.0,
100 |    0.0, 1.0, 0.0,
101 |    0.0, 0.0, -1.0,
102 |    0.0, 0.0, -1.0,
103 |    0.0, 0.0, -1.0,
104 |    0.0, 0.0, -1.0,
105 |    0.0, 0.0, 1.0,
106 |    0.0, 0.0, 1.0,
107 |    0.0, 0.0, 1.0,
108 |    0.0, 0.0, 1.0,
109 |   -1.0, 0.0, 0.0,
110 |   -1.0, 0.0, 0.0,
111 |   -1.0, 0.0, 0.0,
112 |   -1.0, 0.0, 0.0,
113 |    1.0, 0.0, 0.0,
114 |    1.0, 0.0, 0.0,
115 |    1.0, 0.0, 0.0,
116 |    1.0, 0.0, 0.0
117 | ];
118 | 
119 | var esCubeTexCoords = [
120 |   0.0, 0.0,
121 |   0.0, 1.0,
122 |   1.0, 1.0,
123 |   1.0, 0.0,
124 |   1.0, 0.0,
125 |   1.0, 1.0,
126 |   0.0, 1.0,
127 |   0.0, 0.0,
128 |   0.0, 0.0,
129 |   0.0, 1.0,
130 |   1.0, 1.0,
131 |   1.0, 0.0,
132 |   0.0, 0.0,
133 |   0.0, 1.0,
134 |   1.0, 1.0,
135 |   1.0, 0.0,
136 |   0.0, 0.0,
137 |   0.0, 1.0,
138 |   1.0, 1.0,
139 |   1.0, 0.0,
140 |   0.0, 0.0,
141 |   0.0, 1.0,
142 |   1.0, 1.0,
143 |   1.0, 0.0
144 | ];
145 | 
146 | var esCubeIndices = [
147 |   0, 2, 1,
148 |   0, 3, 2,
149 |   4, 5, 6,
150 |   4, 6, 7,
151 |   8, 9, 10,
152 |   8, 10, 11,
153 |   12, 15, 14,
154 |   12, 14, 13,
155 |   16, 17, 18,
156 |   16, 18, 19,
157 |   20, 23, 22,
158 |   20, 22, 21
159 | ];
160 | 
161 | // will return an object that has vertices, normals, texCoords, and indices members
162 | function esGenCube (scale) {
163 |   return {
164 |     vertices: shallowCloneArrayScaled(esCubeVertices, scale),
165 |     texCoords: shallowCloneArray(esCubeTexCoords),
166 |     indices: shallowCloneArray(esCubeIndices),
167 |     normals: shallowCloneArray(esCubeNormals)
168 |   };
169 | }
170 | 
171 | //
172 | // generates coordinate information for a sphere
173 | //
174 | 
175 | function esGenSphere (numSlices, radius) {
176 |   var i, j;
177 |   var numParallels = numSlices;
178 |   var numVertices = (numParallels + 1) * (numSlices + 1);
179 |   var numIndices = numParallels * numSlices * 6;
180 |   var angleStep = (2 * Math.PI) / numSlices;
181 | 
182 |   var vertices = Array(3*numVertices);
183 |   var normals = Array(3*numVertices);
184 |   var texCoords = Array(2*numVertices);
185 |   var indices = Array(numIndices);
186 | 
187 |   for (i = 0; i < numParallels+1; i++) {
188 |     for (j = 0; j < numSlices+1; j++) {
189 |       var vertex = (i * (numSlices+1) + j) * 3;
190 | 
191 |       vertices[vertex+0] = radius * Math.sin(angleStep * i) * Math.sin(angleStep * j);
192 |       vertices[vertex+1] = radius * Math.cos(angleStep * i);
193 |       vertices[vertex+2] = radius * Math.sin(angleStep * i) * Math.cos(angleStep * j);
194 | 
195 |       normals[vertex+0] = vertices[vertex+0] / radius;
196 |       normals[vertex+1] = vertices[vertex+1] / radius;
197 |       normals[vertex+2] = vertices[vertex+2] / radius;
198 | 
199 |       var texIndex = (i * (numSlices+1) + j) * 2;
200 | 
201 |       texCoords[texIndex+0] = j / numSlices;
202 |       texCoords[texIndex+1] = (1 - i) / (numParallels - 1);
203 |     }
204 |   }
205 | 
206 |   var k = 0;
207 |   for (i = 0; i < numParallels; i++) {
208 |     for (j = 0; j < numSlices; j++) {
209 |       indices[k++] = i * (numSlices + 1) + j;
210 |       indices[k++] = (i + 1) * (numSlices + 1) + j;
211 |       indices[k++] = (i + 1) * (numSlices + 1) + (j + 1);
212 | 
213 |       indices[k++] = i * (numSlices + 1) + j;
214 |       indices[k++] = (i + 1) * (numSlices + 1) + (j + 1);
215 |       indices[k++] = i * (numSlices + 1) + (j + 1);
216 |     }
217 |   }
218 | 
219 |   return {
220 |     vertices: vertices,
221 |     normals: normals,
222 |     texCoords: texCoords,
223 |     indices: indices
224 |   };
225 | }
226 | 


--------------------------------------------------------------------------------
/glbindings/glbind.py:
--------------------------------------------------------------------------------
  1 | from __future__ import with_statement
  2 | 
  3 | import json
  4 | import re
  5 | 
  6 | #input output files
  7 | IN_FILE = 'glbind.json'
  8 | OUT_FILE = 'glbind.cpp'
  9 | 
 10 | #exclude functions by name
 11 | EXCLUDE = re.compile('ATI|MESA')
 12 | 
 13 | def main():
 14 |     """Generates Gl bindings"""
 15 |     
 16 |     with open(IN_FILE, 'r') as f:
 17 |         text_out = []
 18 |         data = f.read()
 19 |         try:
 20 |             # Try the python 2.6 json module first.
 21 |             json_in = json.loads(data)
 22 |         except AttributeError:
 23 |             # Fall back to json-py.
 24 |             reader = json.JsonReader()
 25 |             json_in = reader.read(data)
 26 |         constants, functions = [], []
 27 |         
 28 |         for obj in json_in:
 29 |             if not re.search(EXCLUDE, obj['name']):
 30 |                 try:
 31 |                     if obj['type'] == 'c':
 32 |                         constants.append(obj['name'])
 33 |                     else:
 34 |                         text_out.append(generate_function(obj))
 35 |                         functions.append(obj['name'])
 36 |                 except Exception, e: #probably an unhandled type
 37 |                     print e
 38 |                     pass
 39 | 
 40 |     with open(OUT_FILE, 'w') as fout:
 41 |         fout.write("""
 42 | #include "glbind.h"
 43 | 
 44 | #if defined(V8_GL_USE_GLEW)
 45 | #include "GL/glew.h"
 46 | #elif defined(__APPLE__)
 47 | #include <OpenGL/OpenGL.h>
 48 | #else
 49 | #define GL_GLEXT_PROTOTYPES
 50 | #include <GL/gl.h>
 51 | #endif
 52 | 
 53 | using namespace v8;
 54 | 
 55 | Persistent<Object> GlFactory::self_;
 56 | """ + '\n'.join(text_out) + '\n' + generate_main_function(constants, functions))
 57 | 
 58 | 
 59 | def generate_main_function(constants, functions):
 60 |     """Generates the main createGl function definition"""
 61 |     
 62 |     text_out_begin = """
 63 | 
 64 | Handle<ObjectTemplate> GlFactory::createGl(void) {
 65 |       HandleScope handle_scope;
 66 | 
 67 |       Handle<ObjectTemplate> Gl = ObjectTemplate::New();
 68 |       
 69 |       Gl->SetInternalFieldCount(1);
 70 | 
 71 | """
 72 | 
 73 |     text_out_end = """
 74 | 
 75 |       // Again, return the result through the current handle scope.
 76 |       return handle_scope.Close(Gl);
 77 | }    
 78 | """
 79 |     bind_accessor = lambda n: "     Gl->Set(String::NewSymbol(\"" + '_'.join(n.split('_')[1:]) \
 80 |         + "\"), Uint32::New(" + n + "), ReadOnly);\n"
 81 |     bind_function = lambda n: "     Gl->Set(String::NewSymbol(\"" + n[2].lower() + n[3:] + \
 82 |         "\"), FunctionTemplate::New(GL" + n + "Callback));\n"
 83 |     
 84 |     cts = [bind_accessor(name) for name in constants]
 85 |     fts = [bind_function(name) for name in functions]
 86 |     
 87 |     return text_out_begin + '\n'.join(cts) + '\n' + '\n'.join(fts) + text_out_end
 88 | 
 89 | def generate_function(obj):
 90 |     """Generates code for declaring a Function"""
 91 | 
 92 |     text_out = """
 93 | 
 94 | Handle<<ret>> GL<name>Callback(const Arguments& args) {
 95 |   //if less that nbr of formal parameters then do nothing
 96 |   if (args.Length() < <len_params>) return v8::Undefined();
 97 |   //get arguments
 98 | <args>
 99 |   //make call
100 |   <call>
101 | }
102 | 
103 | """
104 |     return multiple_replace({
105 |         '<name>': obj['name'],
106 |         '<len_params>': str(len(obj['parameters'])),
107 |         '<args>': generate_arguments(obj['parameters']),
108 |         '<call>': generate_call(obj),
109 |         '<ret>': 'Value'      
110 |     }, text_out)
111 | 
112 | 
113 | #map some OpenGL types to V8 types
114 | unsigned = re.compile('unsigned|ubyte|ushort|uint|bitfield|boolean')
115 | integer = re.compile('int|enum|sizei|short|byte')
116 | double = re.compile('double|float|clampf|clampd')
117 | 
118 | def generate_arguments(params):
119 |     """generates the formal parameter definition"""
120 |     
121 |     text_out = []
122 |     #assignment template
123 |     assign = lambda type, method, i: '  ' + type + ' arg' + i + \
124 |         ' = args[' + i + ']->' + method + '();\n'
125 |     
126 |     for i, type in enumerate(params):
127 |         si = str(i)
128 |         #TODO Find a way to map void* to a V8 type
129 |         if type.find('void*') != -1:
130 |             raise Exception("unhandled type " + type)
131 |         #is array
132 |         elif type.find('*') != -1 or type.find('[') != -1:
133 |             text_out.append(generate_array_expression(type, i))
134 |         #is unsigned integer
135 |         elif re.search(unsigned, type):
136 |             text_out.append(assign('unsigned int', 'Uint32Value', si))
137 |         #is integer
138 |         elif re.search(integer, type):
139 |             text_out.append(assign('int', 'IntegerValue', si))
140 |         #is double, float
141 |         elif re.search(double, type):
142 |             text_out.append(assign('double', 'NumberValue', si))
143 |         else:
144 |             raise Exception("unhandled type " + type)
145 | 
146 |     return ''.join(text_out)
147 | 
148 | def generate_array_expression(type, i):
149 |     """generates an Array assignment expression"""
150 |     type = multiple_replace({ '(':'', ')':'', 'const':'' }, type)
151 |     acc = get_accessor(type)
152 |     clean_type = type.replace('*', '')
153 |     
154 |     text_out = """
155 |     
156 |   Handle<Array> arrHandle##1 = Handle<Array>::Cast(args[##1]);
157 |   ##2 arg##1 = new ##3[arrHandle##1->Length()];
158 |   for (unsigned j = 0; j < arrHandle##1->Length(); j++) {
159 |       Handle<Value> arg(arrHandle##1->Get(Integer::New(j)));
160 |       ##3 aux = (##3)arg->##4;
161 |       arg##1[j] = aux; 
162 |   }
163 |     
164 |     """
165 |     return multiple_replace({
166 |         '##1': str(i),
167 |         '##2': type,
168 |         '##3': clean_type,
169 |         '##4': acc + 'Value()'
170 |     }, text_out)
171 | 
172 | def get_accessor(type):
173 |     """Returns the V8 type accesor method to be called"""
174 |     
175 |     if re.search(unsigned, type): return 'Uint32'
176 |     if re.search(integer, type): return 'Integer'
177 |     if re.search(double, type): return 'Number'
178 |     
179 |     return None
180 | 
181 | def generate_call(obj):
182 |     """generates the native function call syntax"""
183 | 
184 |     acc = get_accessor(obj['return_type'])
185 |     function_call = obj['name'] + "(" + ", ".join(['(' + param + ') ' + "arg" + str(i) \
186 |                         for i, param in enumerate(obj['parameters'])]) + ")"
187 |     
188 |     #dot-this-dot-that feature
189 |     if acc is None: 
190 |         return function_call + ';\n  Handle<Object> res(GlFactory::self_);\n  return res;'
191 |     else:
192 |         return 'return ' + acc + '::New(' + function_call + ');'
193 |     
194 | 
195 | def multiple_replace(dict, text): 
196 |   """ Replace in 'text' all occurences of any key in the given
197 |   dictionary by its corresponding value.  Returns the new string.""" 
198 | 
199 |   # Create a regular expression  from the dictionary keys
200 |   regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))
201 | 
202 |   # For each match, look-up corresponding value in dictionary
203 |   return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text) 
204 | 
205 | if __name__ == '__main__': main()
206 | 


--------------------------------------------------------------------------------
/imageloader.cpp:
--------------------------------------------------------------------------------
  1 | /* Permission is hereby granted, free of charge, to any person obtaining a copy
  2 |  * of this software and associated documentation files (the "Software"), to deal
  3 |  * in the Software without restriction, including without limitation the rights
  4 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  5 |  * copies of the Software, and to permit persons to whom the Software is
  6 |  * furnished to do so, subject to the following conditions:
  7 |  *
  8 |  * The above notice and this permission notice shall be included in all copies
  9 |  * or substantial portions of the Software.
 10 |  *
 11 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 12 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 13 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 14 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 15 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 16 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 17 |  * SOFTWARE.
 18 |  */
 19 | /* File for "Putting It All Together" lesson of the OpenGL tutorial on
 20 |  * www.videotutorialsrock.com
 21 |  */
 22 | 
 23 | 
 24 | 
 25 | #include <assert.h>
 26 | #include <fstream>
 27 | 
 28 | #include "imageloader.h"
 29 | 
 30 | using namespace std;
 31 | 
 32 | Image::Image(char* ps, int w, int h) : pixels(ps), width(w), height(h) {
 33 | 
 34 | }
 35 | 
 36 | Image::~Image() {
 37 | 	delete[] pixels;
 38 | }
 39 | 
 40 | namespace {
 41 | 	//Converts a four-character array to an integer, using big-endian form
 42 | 	int toInt(const char* bytes) {
 43 | 		return (int)(((unsigned char)bytes[0] << 24) |
 44 | 					 ((unsigned char)bytes[1] << 16) |
 45 | 					 ((unsigned char)bytes[2] << 8) |
 46 | 					 (unsigned char)bytes[3]);
 47 | 	}
 48 | 
 49 | 	//Converts a two-character array to a short, using little-endian form
 50 | 	short toShort(const char* bytes) {
 51 | 		return (short)(((unsigned char)bytes[1] << 8) |
 52 | 					   (unsigned char)bytes[0]);
 53 | 	}
 54 | 
 55 | 	//Reads the next four bytes as an integer, using big-endian form
 56 | 	int readInt(ifstream &input) {
 57 | 		char buffer[4];
 58 | 		input.read(buffer, 4);
 59 | 		return toInt(buffer);
 60 | 	}
 61 | 
 62 | 	//Reads the next two bytes as a short, using little-endian form
 63 | 	short readShort(ifstream &input) {
 64 | 		char buffer[2];
 65 | 		input.read(buffer, 2);
 66 | 		return toShort(buffer);
 67 | 	}
 68 | 
 69 | 	//Just like auto_ptr, but for arrays
 70 | 	template<class T>
 71 | 	class auto_array {
 72 | 		private:
 73 | 			T* array;
 74 | 			mutable bool isReleased;
 75 | 		public:
 76 | 			explicit auto_array(T* array_ = NULL) :
 77 | 				array(array_), isReleased(false) {
 78 | 			}
 79 | 
 80 | 			auto_array(const auto_array<T> &aarray) {
 81 | 				array = aarray.array;
 82 | 				isReleased = aarray.isReleased;
 83 | 				aarray.isReleased = true;
 84 | 			}
 85 | 
 86 | 			~auto_array() {
 87 | 				if (!isReleased && array != NULL) {
 88 | 					delete[] array;
 89 | 				}
 90 | 			}
 91 | 
 92 | 			T* get() const {
 93 | 				return array;
 94 | 			}
 95 | 
 96 | 			T &operator*() const {
 97 | 				return *array;
 98 | 			}
 99 | 
100 | 			void operator=(const auto_array<T> &aarray) {
101 | 				if (!isReleased && array != NULL) {
102 | 					delete[] array;
103 | 				}
104 | 				array = aarray.array;
105 | 				isReleased = aarray.isReleased;
106 | 				aarray.isReleased = true;
107 | 			}
108 | 
109 | 			T* operator->() const {
110 | 				return array;
111 | 			}
112 | 
113 | 			T* release() {
114 | 				isReleased = true;
115 | 				return array;
116 | 			}
117 | 
118 | 			void reset(T* array_ = NULL) {
119 | 				if (!isReleased && array != NULL) {
120 | 					delete[] array;
121 | 				}
122 | 				array = array_;
123 | 			}
124 | 
125 | 			T* operator+(int i) {
126 | 				return array + i;
127 | 			}
128 | 
129 | 			T &operator[](int i) {
130 | 				return array[i];
131 | 			}
132 | 	};
133 | 
134 | 
135 | }
136 | 
137 | Image* loadBMP(const char* filename) {
138 | 	ifstream input;
139 | 	input.open(filename, ifstream::binary);
140 | 	assert(!input.fail() || !"Could not find file");
141 | 	char buffer[2];
142 | 	input.read(buffer, 2);
143 | 	assert((buffer[0] == 'B' && buffer[1] == 'M') || !"Not a bitmap file");
144 | 	input.ignore(8);
145 | 	int dataOffset = readInt(input);
146 | 
147 | 	//Read the header
148 | 	int headerSize = readInt(input);
149 | 	int width;
150 | 	int height;
151 | 	switch(headerSize) {
152 | 		case 40:
153 | 			//V3
154 | 			width = readInt(input);
155 | 			height = readInt(input);
156 | 			input.ignore(2);
157 | 			assert(readShort(input) == 24 || !"Image is not 24 bits per pixel");
158 | 			assert(readShort(input) == 0 || !"Image is compressed");
159 | 			break;
160 | 		case 12:
161 | 			//OS/2 V1
162 | 			width = readShort(input);
163 | 			height = readShort(input);
164 | 			input.ignore(2);
165 | 			assert(readShort(input) == 24 || !"Image is not 24 bits per pixel");
166 | 			break;
167 | 		case 64:
168 | 			//OS/2 V2
169 | 			assert(!"Can't load OS/2 V2 bitmaps");
170 | 			break;
171 | 		case 108:
172 | 			//Windows V4
173 | 			assert(!"Can't load Windows V4 bitmaps");
174 | 			break;
175 | 		case 124:
176 | 			//Windows V5
177 | 			assert(!"Can't load Windows V5 bitmaps");
178 | 			break;
179 | 		default:
180 | 			assert(!"Unknown bitmap format");
181 | 	}
182 | 
183 | 	//Read the data
184 | 	int bytesPerRow = ((width * 3 + 3) / 4) * 4 - (width * 3 % 4);
185 | 	int size = bytesPerRow * height;
186 | 	auto_array<char> pixels(new char[size]);
187 | 	input.seekg(dataOffset, ios_base::beg);
188 | 	input.read(pixels.get(), size);
189 | 
190 | 	//Get the data into the right format
191 | 	auto_array<char> pixels2(new char[width * height * 3]);
192 | 	for(int y = 0; y < height; y++) {
193 | 		for(int x = 0; x < width; x++) {
194 | 			for(int c = 0; c < 3; c++) {
195 | 				pixels2[3 * (width * y + x) + c] =
196 | 					pixels[bytesPerRow * y + 3 * x + (2 - c)];
197 | 			}
198 | 		}
199 | 	}
200 | 
201 | 	input.close();
202 | 	return new Image(pixels2.release(), width, height);
203 | }
204 | 
205 | Image* loadPNG(const char* filename) {
206 | 	ifstream input;
207 | 	input.open(filename, ifstream::binary);
208 | 	assert(!input.fail() || !"Could not find file");
209 | 	//check if png file
210 | 	char buffer[8];
211 | 	input.read(buffer, 8);
212 | 	assert((buffer[1] == 'P' && buffer[2] == 'N' && buffer[3] == 'G')
213 | 			|| !"Not a png file");
214 | 
215 | 	char* data;
216 | 	int width, height;
217 | 
218 | 	//read header
219 | 	char type_buffer[4];
220 | 	//read header length
221 | 	int len = readInt(input);
222 | 	printf("%d - len\n", len);
223 | 	input.read(type_buffer, 4);
224 | 	if(type_buffer[0] == 'I' && type_buffer[1] == 'H'
225 | 			&& type_buffer[2] == 'D' && type_buffer[3] == 'R') {
226 | 		//grab width and height
227 | 		width = readInt(input);
228 | 		height = readInt(input);
229 | 
230 | 		printf("\n\nheader - width: %d, height: %d\n\n", width, height);
231 | 		//read other header options like color type, bit depths
232 | 		char buff[5];
233 | 		input.read(buff, 5);
234 | 		//check for RGB pixel data
235 | 		if((buff[0] == 8 || buff[0] == 16)
236 | 				&& buff[1] == 2) {
237 | 			input.ignore(4); //CRC
238 | 			//store data.
239 | 			data = new char[width * height * 3];
240 | 			int len_accum = 0;
241 | 			int len = 0;
242 | 			//read all data chunks
243 | 			len = readInt(input);
244 | 			input.read(type_buffer, 4);
245 | 			while(!(type_buffer[0] == 'I' && type_buffer[1] == 'E'
246 | 					&& type_buffer[2] == 'N' && type_buffer[3] == 'D')) {
247 | 				printf("%c-%c-%c-%c ", type_buffer[0], type_buffer[1], type_buffer[2], type_buffer[3]);
248 | 				if(type_buffer[0] == 'I' && type_buffer[1] == 'D'
249 | 						&& type_buffer[2] == 'A' && type_buffer[3] == 'T') {
250 | 					printf("data\n\n");
251 | //					char* d = new char[len];
252 | //					input.read(d, len);
253 | //					for(int i=0; i < len; i++) {
254 | //						data[len_accum + (len - i - 1)] = d[i];
255 | //					}
256 | //					delete[] d;
257 | 					input.read(data + len_accum, len);
258 | 					len_accum += len;
259 | 				} else {
260 | 					printf("not data\n\n");
261 | 					input.ignore(len);
262 | 				}
263 | 
264 | 				input.ignore(4); //CRC
265 | 				len = readInt(input);
266 | 				input.read(type_buffer, 4);
267 | 			}
268 | 		} else {
269 | 			//TODO(nico) take care of other png formats also
270 | 			return NULL;
271 | 		}
272 | 	} else {
273 | 		return NULL;
274 | 	}
275 | 
276 | 	input.close();
277 | 	return new Image(data, width, height);
278 | }
279 | 
280 | 
281 | 
282 | 
283 | 
284 | 
285 | 
286 | 


--------------------------------------------------------------------------------
/v8-gl.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * v8-gl.cpp
  3 |  *
  4 |  */
  5 | 
  6 | #include "v8-gl.h"
  7 | #include <assert.h>
  8 | #include <stdio.h>
  9 | #include <string>
 10 | #include <string.h>
 11 | 
 12 | extern "C" void
 13 | v8_typed_array_init (Handle<Object> target);
 14 | 
 15 | Persistent<Context> V8GL::context;
 16 | 
 17 | //UTILITY FUNCTIONS
 18 | // Reads a file into a v8 string.
 19 | Handle<String> ReadFile(const string& name) {
 20 |   FILE* file = fopen(name.c_str(), "rb");
 21 |   if (file == NULL) return Handle<String>();
 22 | 
 23 |   fseek(file, 0, SEEK_END);
 24 |   int size = ftell(file);
 25 |   rewind(file);
 26 | 
 27 |   char* chars = new char[size + 1];
 28 |   chars[size] = '\0';
 29 |   for (int i = 0; i < size;) {
 30 |     int read = fread(&chars[i], 1, size - i, file);
 31 |     i += read;
 32 |   }
 33 |   fclose(file);
 34 |   Handle<String> result = String::New(chars, size);
 35 |   delete[] chars;
 36 |   return result;
 37 | }
 38 | 
 39 | bool exec(string file) {
 40 |   HandleScope handle_scope;
 41 |   Handle<String> source = ReadFile(file);
 42 | 
 43 |   if (source.IsEmpty()) {
 44 | 	fprintf(stderr, "Error reading '%s'.\n", file.c_str());
 45 | 	return false;
 46 |   }
 47 | 
 48 |   // We're just about to compile the script; set up an error handler to
 49 |   // catch any exceptions the script might throw.
 50 |   TryCatch try_catch;
 51 | 
 52 |   // Compile the script and check for errors.
 53 |   Handle<Script> compiled_script = Script::Compile(source,
 54 | 						   String::New(file.c_str()));
 55 |   if (compiled_script.IsEmpty()) {
 56 | 	V8GL::ReportException(&try_catch);
 57 | 	// The script failed to compile; bail out.
 58 | 	return false;
 59 |   }
 60 | 
 61 |   // Run the script!
 62 |   Handle<Value> result = compiled_script->Run();
 63 |   if (result.IsEmpty()) {
 64 | 	// The TryCatch above is still in effect and will have caught the error.
 65 | 	assert(try_catch.HasCaught());
 66 | 	V8GL::ReportException(&try_catch);
 67 | 	// Running the script failed; bail out.
 68 | 	return false;
 69 |   }
 70 |   return true;
 71 | }
 72 | 
 73 | // nicer exception handling (borrowed from d8)
 74 | const char* V8GL::ToCString(const v8::String::Utf8Value& value) {
 75 |   return *value ? *value : "<string conversion failed>";
 76 | }
 77 | void V8GL::ReportException(v8::TryCatch* try_catch) {
 78 |   HandleScope handle_scope;
 79 |   v8::String::Utf8Value exception(try_catch->Exception());
 80 |   const char* exception_string = ToCString(exception);
 81 |   Handle<Message> message = try_catch->Message();
 82 |   if (message.IsEmpty()) {
 83 |     // V8 didn't provide any extra information about this error; just
 84 |     // print the exception.
 85 |     printf("%s\n", exception_string);
 86 |   } else {
 87 |     // Print (filename):(line number): (message).
 88 |     v8::String::Utf8Value filename(message->GetScriptResourceName());
 89 |     const char* filename_string = ToCString(filename);
 90 |     int linenum = message->GetLineNumber();
 91 |     printf("%s:%i: %s\n", filename_string, linenum, exception_string);
 92 |     // Print line of source code.
 93 |     v8::String::Utf8Value sourceline(message->GetSourceLine());
 94 |     const char* sourceline_string = ToCString(sourceline);
 95 |     printf("%s\n", sourceline_string);
 96 |     // Print wavy underline (GetUnderline is deprecated).
 97 |     int start = message->GetStartColumn();
 98 |     for (int i = 0; i < start; i++) {
 99 |       printf(" ");
100 |     }
101 |     int end = message->GetEndColumn();
102 |     for (int i = start; i < end; i++) {
103 |       printf("^");
104 |     }
105 |     printf("\n");
106 |     v8::String::Utf8Value stack_trace(try_catch->StackTrace());
107 |     if (stack_trace.length() > 0) {
108 |       const char* stack_trace_string = ToCString(stack_trace);
109 |       printf("%s\n", stack_trace_string);
110 |     }
111 |   }
112 | }
113 | 
114 | //FUNCTIONS IN GLOBAL SCOPE
115 | 
116 | //prints a string to stdout
117 | Handle<Value> log(const Arguments& args) {
118 |   //if less that nbr of formal parameters then do nothing
119 |   if (args.Length() < 1) return v8::Undefined();
120 |   //define handle scope
121 |   HandleScope scope;
122 |   //get arguments
123 |   String::Utf8Value value0(args[0]);
124 |   char* arg0 = *value0;
125 | 
126 |   //make call
127 |   fprintf(stdout, "%s", arg0);
128 |   return v8::Undefined();
129 | }
130 | 
131 | //loads a text file
132 | Handle<Value> read(const Arguments& args) {
133 |   if (args.Length() < 1) return v8::Undefined();
134 |   //define handle scope
135 |   HandleScope scope;
136 |   //get arguments
137 |   String::Utf8Value value0(args[0]);
138 |   char* arg0 = *value0;
139 |   string str(V8GLUtils::getRealPath(arg0));
140 |   Handle<String> result = ReadFile(str);
141 |   if (result.IsEmpty()) {
142 |       fprintf(stderr, "Error reading '%s'.\n", str.c_str());
143 |       return ThrowException(String::New("Could not open file."));
144 |   }
145 |   return scope.Close(result);
146 | }
147 | 
148 | //loads a js file
149 | Handle<Value> load(const Arguments& args) {
150 |   //if less that nbr of formal parameters then do nothing
151 |   int len = args.Length();
152 |   int i;
153 | 
154 |   if (len < 1) return v8::Undefined();
155 |   //define handle scope
156 |   HandleScope scope;
157 | 
158 |   // Enter the new context so all the following operations take place
159 |   // within it.
160 |   Context::Scope context_scope(V8GL::context);
161 | 
162 |   for (i = 0; i < len; ++i) {
163 | 	  //get argument
164 | 	  String::Utf8Value value0(args[i]);
165 | 	  char* arg0 = *value0;
166 | 	  char* filepath = V8GLUtils::getRealPath(arg0);
167 | 
168 | 	  char *old_path = V8GLUtils::pushRootPath(filepath);
169 | 	  bool success = exec(string(filepath));
170 | 	  V8GLUtils::popRootPath(old_path);
171 | 
172 | 	  if(!success) {
173 | 		  fprintf(stderr, "Error reading '%s'.\n", arg0);
174 | 		  return ThrowException(String::New("Failed to load script"));
175 | 	  }
176 |   }
177 | 
178 |   return v8::Undefined();
179 | }
180 | 
181 | bool V8GL::executeScript(string file) {
182 | 	return exec(file);
183 | }
184 | 
185 | bool V8GL::initialize(int* pargc, char** argv, string scriptname) {
186 | 	  // Create a handle scope to hold the temporary references.
187 | 	  HandleScope handle_scope;
188 | 
189 | 	  // Create a template for the global object where we set the
190 | 	  // built-in global functions.
191 | 	  Handle<ObjectTemplate> global = ObjectTemplate::New();
192 | 
193 | 	  // Each processor gets its own context so different processors
194 | 	  // don't affect each other.
195 | #ifdef BUILD_GL_BINDINGS
196 | 	  Handle<ObjectTemplate> Gl = GlFactory::createGl();
197 | #endif
198 | #ifdef BUILD_GLES_BINDINGS
199 | 	  Handle<ObjectTemplate> Gles = GlesFactory::createGles();
200 | #endif
201 | 
202 | 	  //Set global objects and functions.
203 | #ifdef BUILD_GL_BINDINGS
204 | 	  global->Set(String::New("Gl"), Gl);
205 | #endif
206 | #ifdef BUILD_GLES_BINDINGS
207 | 	  global->Set(String::New("Gles"), Gles);
208 | #endif
209 | #ifdef BUILD_GLU_BINDINGS
210 | 	  global->Set(String::New("Glu"), createGlu());
211 | #endif
212 | #ifdef BUILD_GLUT_BINDINGS
213 | 	  global->Set(String::New("Glut"), GlutFactory::createGlut(pargc, argv));
214 | #endif
215 | 	  global->Set(String::New("log"), FunctionTemplate::New(log));
216 | 	  global->Set(String::New("load"), FunctionTemplate::New(load));
217 | 	  global->Set(String::New("read"), FunctionTemplate::New(read));
218 | 
219 | 	  Handle<Context> context = Context::New(NULL, global);
220 | 
221 | 	  //TODO(nico): should find another way to set the right context when calling a func.
222 | 	  V8GL::context = Persistent<Context>::New(context);
223 | #ifdef BUILD_GLUT_BINDINGS
224 | 	  GlutFactory::glut_persistent_context = V8GL::context;
225 | #endif
226 | #ifdef BUILD_GLES_BINDINGS
227 | 	  GlesFactory::gles_persistent_context = V8GL::context;
228 | #endif
229 | 
230 | 	  // Enter the new context so all the following operations take place
231 | 	  // within it.
232 | 	  Context::Scope context_scope(context);
233 | 	  // hook up typed array support
234 | 	  v8_typed_array_init(context->Global());
235 | 
236 | 	  //Append *this* as Gl static variable so we can do dot-this-dot-that stuff
237 | #ifdef BUILD_GL_BINDINGS
238 | 	  GlFactory::self_ = Persistent<Object>::New(Gl->NewInstance());
239 | #endif
240 | #ifdef BUILD_GLES_BINDINGS
241 | 	  GlesFactory::self_ = Persistent<Object>::New(Gles->NewInstance());
242 | #endif
243 | 
244 | 	  //Set (only once) the absolute path for the .js file being executed.
245 | 	  V8GLUtils::setRootPath(argv[0], argv[1]);
246 | 
247 | 	  // Compile and run the script
248 | 	  if (!executeScript(scriptname))
249 | 		return false;
250 | 
251 | 	  return true;
252 | }
253 | 


--------------------------------------------------------------------------------
/examples/gles/lib/matrix.js:
--------------------------------------------------------------------------------
  1 | //adding matrix 4x4 library
  2 | /*
  3 |  * Copyright (c) 2009, Mozilla Corp
  4 |  * All rights reserved.
  5 |  *
  6 |  * Redistribution and use in source and binary forms, with or without
  7 |  * modification, are permitted provided that the following conditions are met:
  8 |  *     * Redistributions of source code must retain the above copyright
  9 |  *       notice, this list of conditions and the following disclaimer.
 10 |  *     * Redistributions in binary form must reproduce the above copyright
 11 |  *       notice, this list of conditions and the following disclaimer in the
 12 |  *       documentation and/or other materials provided with the distribution.
 13 |  *     * Neither the name of the <organization> nor the
 14 |  *       names of its contributors may be used to endorse or promote products
 15 |  *       derived from this software without specific prior written permission.
 16 |  *
 17 |  * THIS SOFTWARE IS PROVIDED BY <copyright holder> ''AS IS'' AND ANY
 18 |  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 19 |  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 20 |  * DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
 21 |  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 22 |  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 23 |  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 24 |  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 25 |  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 26 |  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 27 |  */
 28 | 
 29 | /*
 30 |  * Based on sample code from the OpenGL(R) ES 2.0 Programming Guide, which carriers
 31 |  * the following header:
 32 |  *
 33 |  * Book:      OpenGL(R) ES 2.0 Programming Guide
 34 |  * Authors:   Aaftab Munshi, Dan Ginsburg, Dave Shreiner
 35 |  * ISBN-10:   0321502795
 36 |  * ISBN-13:   9780321502797
 37 |  * Publisher: Addison-Wesley Professional
 38 |  * URLs:      http://safari.informit.com/9780321563835
 39 |  *            http://www.opengles-book.com
 40 |  */
 41 | 
 42 | //
 43 | // A simple 4x4 Matrix utility class
 44 | //
 45 | 
 46 | function Matrix4x4() {
 47 |   this.elements = Array(16);
 48 |   this.loadIdentity();
 49 | }
 50 | 
 51 | Matrix4x4.prototype = {
 52 |   scale: function (sx, sy, sz) {
 53 |     this.elements[0*4+0] *= sx;
 54 |     this.elements[0*4+1] *= sx;
 55 |     this.elements[0*4+2] *= sx;
 56 |     this.elements[0*4+3] *= sx;
 57 | 
 58 |     this.elements[1*4+0] *= sy;
 59 |     this.elements[1*4+1] *= sy;
 60 |     this.elements[1*4+2] *= sy;
 61 |     this.elements[1*4+3] *= sy;
 62 | 
 63 |     this.elements[2*4+0] *= sz;
 64 |     this.elements[2*4+1] *= sz;
 65 |     this.elements[2*4+2] *= sz;
 66 |     this.elements[2*4+3] *= sz;
 67 | 
 68 |     return this;
 69 |   },
 70 | 
 71 |   translate: function (tx, ty, tz) {
 72 |     this.elements[3*4+0] += this.elements[0*4+0] * tx + this.elements[1*4+0] * ty + this.elements[2*4+0] * tz;
 73 |     this.elements[3*4+1] += this.elements[0*4+1] * tx + this.elements[1*4+1] * ty + this.elements[2*4+1] * tz;
 74 |     this.elements[3*4+2] += this.elements[0*4+2] * tx + this.elements[1*4+2] * ty + this.elements[2*4+2] * tz;
 75 |     this.elements[3*4+3] += this.elements[0*4+3] * tx + this.elements[1*4+3] * ty + this.elements[2*4+3] * tz;
 76 | 
 77 |     return this;
 78 |   },
 79 | 
 80 |   rotate: function (angle, x, y, z) {
 81 |     var mag = Math.sqrt(x*x + y*y + z*z);
 82 |     var sinAngle = Math.sin(angle * Math.PI / 180.0);
 83 |     var cosAngle = Math.cos(angle * Math.PI / 180.0);
 84 | 
 85 |     if (mag > 0) {
 86 |       var xx, yy, zz, xy, yz, zx, xs, ys, zs;
 87 |       var oneMinusCos;
 88 |       var rotMat;
 89 | 
 90 |       x /= mag;
 91 |       y /= mag;
 92 |       z /= mag;
 93 | 
 94 |       xx = x * x;
 95 |       yy = y * y;
 96 |       zz = z * z;
 97 |       xy = x * y;
 98 |       yz = y * z;
 99 |       zx = z * x;
100 |       xs = x * sinAngle;
101 |       ys = y * sinAngle;
102 |       zs = z * sinAngle;
103 |       oneMinusCos = 1.0 - cosAngle;
104 | 
105 |       rotMat = new Matrix4x4();
106 | 
107 |       rotMat.elements[0*4+0] = (oneMinusCos * xx) + cosAngle;
108 |       rotMat.elements[0*4+1] = (oneMinusCos * xy) - zs;
109 |       rotMat.elements[0*4+2] = (oneMinusCos * zx) + ys;
110 |       rotMat.elements[0*4+3] = 0.0;
111 | 
112 |       rotMat.elements[1*4+0] = (oneMinusCos * xy) + zs;
113 |       rotMat.elements[1*4+1] = (oneMinusCos * yy) + cosAngle;
114 |       rotMat.elements[1*4+2] = (oneMinusCos * yz) - xs;
115 |       rotMat.elements[1*4+3] = 0.0;
116 | 
117 |       rotMat.elements[2*4+0] = (oneMinusCos * zx) - ys;
118 |       rotMat.elements[2*4+1] = (oneMinusCos * yz) + xs;
119 |       rotMat.elements[2*4+2] = (oneMinusCos * zz) + cosAngle;
120 |       rotMat.elements[2*4+3] = 0.0;
121 | 
122 |       rotMat.elements[3*4+0] = 0.0;
123 |       rotMat.elements[3*4+1] = 0.0;
124 |       rotMat.elements[3*4+2] = 0.0;
125 |       rotMat.elements[3*4+3] = 1.0;
126 | 
127 |       rotMat = rotMat.multiply(this);
128 |       this.elements = rotMat.elements;
129 |     }
130 | 
131 |     return this;
132 |   },
133 | 
134 |   frustum: function (left, right, bottom, top, nearZ, farZ) {
135 |     var deltaX = right - left;
136 |     var deltaY = top - bottom;
137 |     var deltaZ = farZ - nearZ;
138 |     var frust;
139 | 
140 |     if ( (nearZ <= 0.0) || (farZ <= 0.0) ||
141 |          (deltaX <= 0.0) || (deltaY <= 0.0) || (deltaZ <= 0.0) )
142 |          return this;
143 | 
144 |     frust = new Matrix4x4();
145 | 
146 |     frust.elements[0*4+0] = 2.0 * nearZ / deltaX;
147 |     frust.elements[0*4+1] = frust.elements[0*4+2] = frust.elements[0*4+3] = 0.0;
148 | 
149 |     frust.elements[1*4+1] = 2.0 * nearZ / deltaY;
150 |     frust.elements[1*4+0] = frust.elements[1*4+2] = frust.elements[1*4+3] = 0.0;
151 | 
152 |     frust.elements[2*4+0] = (right + left) / deltaX;
153 |     frust.elements[2*4+1] = (top + bottom) / deltaY;
154 |     frust.elements[2*4+2] = -(nearZ + farZ) / deltaZ;
155 |     frust.elements[2*4+3] = -1.0;
156 | 
157 |     frust.elements[3*4+2] = -2.0 * nearZ * farZ / deltaZ;
158 |     frust.elements[3*4+0] = frust.elements[3*4+1] = frust.elements[3*4+3] = 0.0;
159 | 
160 |     frust = frust.multiply(this);
161 |     this.elements = frust.elements;
162 | 
163 |     return this;
164 |   },
165 | 
166 |   perspective: function (fovy, aspect, nearZ, farZ) {
167 |     var frustumH = Math.tan(fovy / 360.0 * Math.PI) * nearZ;
168 |     var frustumW = frustumH * aspect;
169 | 
170 |     return this.frustum(-frustumW, frustumW, -frustumH, frustumH, nearZ, farZ);
171 |   },
172 | 
173 |   ortho: function (left, right, bottom, top, nearZ, farZ) {
174 |     var deltaX = right - left;
175 |     var deltaY = top - bottom;
176 |     var deltaZ = farZ - nearZ;
177 | 
178 |     var ortho = new Matrix4x4();
179 | 
180 |     if ( (deltaX == 0.0) || (deltaY == 0.0) || (deltaZ == 0.0) )
181 |         return this;
182 | 
183 |     ortho.elements[0*4+0] = 2.0 / deltaX;
184 |     ortho.elements[3*4+0] = -(right + left) / deltaX;
185 |     ortho.elements[1*4+1] = 2.0 / deltaY;
186 |     ortho.elements[3*4+1] = -(top + bottom) / deltaY;
187 |     ortho.elements[2*4+2] = -2.0 / deltaZ;
188 |     ortho.elements[3*4+2] = -(nearZ + farZ) / deltaZ;
189 | 
190 |     ortho = ortho.multiply(this);
191 |     this.elements = ortho.elements;
192 | 
193 |     return this;
194 |   },
195 | 
196 |   multiply: function (right) {
197 |     var tmp = new Matrix4x4();
198 | 
199 |     for (var i = 0; i < 4; i++) {
200 |       tmp.elements[i*4+0] =
201 |   (this.elements[i*4+0] * right.elements[0*4+0]) +
202 |   (this.elements[i*4+1] * right.elements[1*4+0]) +
203 |   (this.elements[i*4+2] * right.elements[2*4+0]) +
204 |   (this.elements[i*4+3] * right.elements[3*4+0]) ;
205 | 
206 |       tmp.elements[i*4+1] =
207 |   (this.elements[i*4+0] * right.elements[0*4+1]) +
208 |   (this.elements[i*4+1] * right.elements[1*4+1]) +
209 |   (this.elements[i*4+2] * right.elements[2*4+1]) +
210 |   (this.elements[i*4+3] * right.elements[3*4+1]) ;
211 | 
212 |       tmp.elements[i*4+2] =
213 |   (this.elements[i*4+0] * right.elements[0*4+2]) +
214 |   (this.elements[i*4+1] * right.elements[1*4+2]) +
215 |   (this.elements[i*4+2] * right.elements[2*4+2]) +
216 |   (this.elements[i*4+3] * right.elements[3*4+2]) ;
217 | 
218 |       tmp.elements[i*4+3] =
219 |   (this.elements[i*4+0] * right.elements[0*4+3]) +
220 |   (this.elements[i*4+1] * right.elements[1*4+3]) +
221 |   (this.elements[i*4+2] * right.elements[2*4+3]) +
222 |   (this.elements[i*4+3] * right.elements[3*4+3]) ;
223 |     }
224 | 
225 |     this.elements = tmp.elements;
226 |     return this;
227 |   },
228 | 
229 |   loadIdentity: function () {
230 |     for (var i = 0; i < 16; i++)
231 |       this.elements[i] = 0;
232 |     this.elements[0*4+0] = 1.0;
233 |     this.elements[1*4+1] = 1.0;
234 |     this.elements[2*4+2] = 1.0;
235 |     this.elements[3*4+3] = 1.0;
236 |     return this;
237 |   }
238 | };
239 | 


--------------------------------------------------------------------------------
/glubindings/glubind.py:
--------------------------------------------------------------------------------
  1 | import sys
  2 | import re
  3 | 
  4 | PATH_GL = 'glu.h'
  5 | FILE_GL = 'glubind.cpp'
  6 | 
  7 | def main():
  8 |     make_gl()
  9 | 
 10 | def make_gl():
 11 |     constants = []
 12 |     functions = []
 13 |     void_stars = []
 14 |     
 15 |     constant = re.compile(".+define[\s]+GLU_([^\s]+).*")
 16 |     function = re.compile("[\s]*extern[\s]+([^\s]+)[\s]+glu([A-Za-z0-9]+)[\s]*\((.*)\);")
 17 |     
 18 |     text_out = []
 19 |     
 20 |     fin = open(PATH_GL, 'r')
 21 |     for l in fin:
 22 |        try:
 23 |            mat = re.match(constant, l)
 24 |            if mat and not mat.group(1) in constants:
 25 |                name = mat.group(1)
 26 |                text_out.append(make_constant("GLU", name))
 27 |                constants.append(name)
 28 |                
 29 |                #print "GL_" + mat.group(1) + "\n"
 30 |                
 31 |            else:
 32 |                
 33 |                mat = re.match(function, l)
 34 |           
 35 |                if mat:
 36 |                    print l
 37 |                    prefix = "glu"
 38 |                    return_val = mat.group(1)
 39 |                    name = mat.group(2)
 40 |                    params = mat.group(3)
 41 |                    text_out.append(make_function(prefix, name, params, return_val))
 42 |                    functions.append(name)
 43 |                     
 44 |                    #print return_val + " " + name + " " + params
 45 |        except Exception, e:
 46 |             print e
 47 |             pass
 48 |     
 49 |     fin.close()
 50 | 
 51 |     fout = open(FILE_GL, 'w')
 52 |     fout.write("""
 53 | 
 54 | #include "glubind.h"
 55 |     
 56 |     """ + '\n'.join(text_out) + make_main_gl_function(constants, functions, void_stars))
 57 |     
 58 |     fout.close()
 59 | 
 60 | def make_main_gl_function(constants, functions, void_stars):
 61 |     text_out_begin = """
 62 | 
 63 | Handle<ObjectTemplate> createGlu(void) {
 64 |       HandleScope handle_scope;
 65 | 
 66 |       Handle<ObjectTemplate> Glu = ObjectTemplate::New();
 67 |       Glu->SetInternalFieldCount(1);
 68 | 
 69 | """
 70 | 
 71 |     text_out_end = """
 72 | 
 73 |       // Again, return the result through the current handle scope.
 74 |       return handle_scope.Close(Glu);
 75 | }    
 76 | """
 77 |     fnt = [bind_font(name) for name in void_stars]    
 78 |     cts = [bind_accessor("Glu", name) for name in constants]
 79 |     fts = [bind_function("Glu", name) for name in functions]
 80 |     
 81 |     return text_out_begin + '\n'.join(fnt) + '\n'.join(cts) + '\n'.join(fts) + text_out_end
 82 |     
 83 | 
 84 | def make_constant(prefix, name):
 85 |     return_val = "return Uint32::New(GLU_"+ name +");"
 86 |     text_out = """
 87 | 
 88 | Handle<Value> GetGLU_%%(Local<String> property,
 89 |                       const AccessorInfo &info) {
 90 |     ##
 91 | }
 92 | 
 93 | """
 94 |     return multiple_replace({
 95 |         '%%': name,
 96 |         '##': return_val
 97 |     }, text_out)
 98 | 
 99 | 
100 | 
101 | def make_function(prefix, name, params, return_val):
102 |     text_out = """
103 | 
104 | Handle<Value> GLU<name>Callback(const Arguments& args) {
105 |   //if less that nbr of formal parameters then do nothing
106 |   if (args.Length() < <len_params>) return v8::Undefined();
107 |   //get arguments
108 | <args>
109 |   //make call
110 |   <call>
111 |   return v8::Undefined();
112 | }
113 | 
114 | """
115 |     count, params_list = get_param_list(params)
116 |     return multiple_replace({
117 |         '<name>': name,
118 |         '<len_params>': str(count),
119 |         '<args>': make_args(params_list, count),
120 |         '<call>': make_call(prefix + name, params_list, count)      
121 |     }, text_out)
122 | 
123 | 
124 | def get_param_list(params):
125 |     params_list = []
126 |     params_aux = params.split(',')
127 |     passed = False
128 |     for par in params_aux:
129 |         if passed and params_list[-1].count('(') != params_list[-1].count(')'):
130 |             params_list[-1] += ',' + par
131 |         else:
132 |             params_list.append(par)
133 |         passed = True
134 |     
135 |     aux = len(params_list)
136 |     if aux == 1 and params_list[0].find('callback') == -1 and len(params_list[0].strip().split(' ')) == 1: 
137 |         nb = 0
138 |     else:
139 |         nb = aux
140 |     return nb, params_list
141 |     
142 | 
143 | def make_args(params_list, count):
144 |     ans = []
145 |     for i in range(count):
146 |         el = params_list[i]
147 |         type = get_type(el)
148 |         
149 |         #is function
150 |         if type.find('(*') != -1:
151 |             ans.append("  Handle<Function> value" + str(i) + " = Handle<Function>::Cast(args[" + str(i) + "]);\n  void* arg" + str(i) + " = *value" + str(i) + ";\n")
152 |             print "function " + type
153 |         #is string
154 |         elif type.find('char*') != -1:
155 |             ans.append("  String::Utf8Value value"+ str(i) +"(args["+ str(i) +"]);\n  char* arg" + str(i) + " = *value"+ str(i) +";\n")
156 |             print "string " + type
157 |         #is void*
158 |         elif type.find('void*') != -1 or type.find('**') != -1:
159 |             raise Exception("unhandled type " + type)
160 |         #is array
161 |         elif type.find('*') != -1 or el.find('[') != -1:
162 |             ans.append(make_array_expression(type, i))
163 |         #is unsigned integer
164 |         elif type.find('unsigned') != -1 or type.find('ubyte') != -1 or type.find('ushort') != -1 or type.find('uint') != -1 or type.find('bitfield') != -1 or type.find('boolean') != -1:
165 |             ans.append("  unsigned int arg" + str(i) + " = args["+ str(i) +"]->Uint32Value();\n")
166 |             print "unsigned " + type
167 |         #is integer
168 |         elif type.find('int') != -1 or type.find('enum') != -1 or type.find('sizei') != -1 or type.find('short') != -1 or type.find('byte') != -1:
169 |             ans.append("  int arg" + str(i) + " = args["+ str(i) +"]->IntegerValue();\n")
170 |             print "integer " + type
171 |         #is double, float
172 |         elif type.find('double') != -1 or type.find('float') != -1 or type.find('clampf') != -1 or type.find('clampd') != -1:
173 |             ans.append("  double arg" + str(i) + " = args["+ str(i) +"]->NumberValue();\n")
174 |             print "double " + type
175 |         else:
176 |             raise Exception("unhandled type " + type)
177 |     
178 |     return ''.join(ans)
179 | 
180 | 
181 | 
182 | 
183 | def make_call(name, params_list, nb):
184 |     return name + "(" + ", ".join([get_type(params_list[i]) + "arg" + str(i) for i in range(nb)]) + ");"
185 |             
186 | def bind_accessor(prefix, name):
187 |     return "     " + prefix + "->SetAccessor(String::NewSymbol(\"" + name + "\"), GetGLU_" + name + ");\n"
188 | 
189 | def bind_function(prefix, name):
190 |     return "     " + prefix + "->Set(String::NewSymbol(\"" + name[0].lower() + name[1:] + "\"), FunctionTemplate::New(GLU" + name + "Callback));\n"
191 | 
192 | def bind_font(name):
193 |     return "     font_[\""+ name +"\"] = GLUT_" + name + ";\n"
194 | 
195 | def get_accessor(type):
196 |     #is unsigned integer
197 |     if type.find('unsigned') != -1 or type.find('ubyte') != -1 or type.find('ushort') != -1 or type.find('uint') != -1 or type.find('bitfield') != -1 or type.find('boolean') != -1:
198 |         return "Uint32Value()"
199 |     #is integer
200 |     elif type.find('int') != -1 or type.find('enum') != -1 or type.find('sizei') != -1 or type.find('short') != -1 or type.find('byte') != -1:
201 |         return "IntegerValue()"
202 |     #is double, float
203 |     elif type.find('double') != -1 or type.find('float') != -1 or type.find('clampf') != -1 or type.find('clampd') != -1:
204 |         return "NumberValue()"
205 |     else:
206 |         raise Exception("unhandled type " + type)
207 |     
208 | 
209 | def make_array_expression(type, i):
210 |     type = multiple_replace({'(':'', ')':'', 'const':''}, type)
211 |     acc = get_accessor(type)
212 |     clean_type = type.replace('*', '', 1)
213 |     
214 |     text_out = """
215 |   Handle<Array> arrHandle##1 = Handle<Array>::Cast(args[##1]);
216 |   ##2 arg##1 = new ##3[arrHandle##1->Length()];
217 |   for (unsigned j = 0; j < arrHandle##1->Length(); j++) {
218 |       Handle<Value> arg(arrHandle##1->Get(Integer::New(j)));
219 |       ##3 aux = (##3)arg->##4;
220 |       arg##1[j] = aux; 
221 |   }
222 |     
223 |     """
224 |     return multiple_replace({
225 |         '##1': str(i),
226 |         '##2': type,
227 |         '##3': clean_type,
228 |         '##4': acc
229 |     }, text_out)
230 | 
231 | def get_type(t):
232 |     if t.find('callback') != -1: 
233 |         return '( ' + t.replace('callback', '') + ') '
234 |     return '( ' + ' '.join(t.strip().split(' ')[:-1]) + ('*' * (t.count('*') + t.count('['))) + ' ) '
235 | 
236 | def multiple_replace(dict, text): 
237 |   """ Replace in 'text' all occurences of any key in the given
238 |   dictionary by its corresponding value.  Returns the new tring.""" 
239 | 
240 |   # Create a regular expression  from the dictionary keys
241 |   regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))
242 | 
243 |   # For each match, look-up corresponding value in dictionary
244 |   return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text) 
245 | 
246 | main()  


--------------------------------------------------------------------------------
/v8-typed-array/typed-array.cc:
--------------------------------------------------------------------------------
  1 | #include <v8.h>
  2 | 
  3 | #include <stdlib.h>
  4 | #include <string.h>
  5 | 
  6 | using namespace v8;
  7 | 
  8 | #define DEFINE_ARRAY_BUFFER_VIEW(name, type, element_size) \
  9 |     Handle<Value> name(const Arguments& args) {\
 10 |         return CreateArrayBufferView(args, type, element_size);\
 11 |     }
 12 | 
 13 | #define INIT_ARRAY_BUFFER_VIEW(name, type, element_size) {\
 14 |     Local<FunctionTemplate> t = FunctionTemplate::New(name); \
 15 |     t->InstanceTemplate()->SetInternalFieldCount(1); \
 16 |     Local<Function> f = t->GetFunction();\
 17 |     f->Set(String::New("BYTES_PER_ELEMENT"), Int32::New(element_size), ReadOnly);\
 18 |     target->Set(String::New(#name), f);}
 19 | 
 20 | void ExternalArrayWeakCallback(Persistent<Value> object, void* data) {
 21 |     free(data);
 22 |     object.Dispose();
 23 | }
 24 | 
 25 | Persistent<FunctionTemplate> array_buffer_constructor_template;
 26 | 
 27 | Handle<Value> ArrayBuffer(const Arguments& args) {
 28 |     if (args.Length() != 1 || !args[0]->IsNumber()) {
 29 |         return ThrowException(String::New("Invalid ArrayBuffer arguments."));
 30 |     }
 31 | 
 32 |     unsigned long length = args[0]->Uint32Value();
 33 |     void* data = malloc(length);
 34 |     memset(data, 0, length);
 35 | 
 36 |     Persistent<Object> persistentHandle = Persistent<Object>::New(args.This());
 37 |     persistentHandle.MakeWeak(data, ExternalArrayWeakCallback);
 38 | 
 39 |     args.This()->SetPointerInInternalField(0, data);
 40 |     args.This()->SetPointerInInternalField(1, (void*)length);
 41 |     args.This()->Set(String::New("byteLength"), Int32::New(length), ReadOnly);
 42 | 
 43 |     return args.This();
 44 | }
 45 | 
 46 | Handle<Value> ArrayBufferViewSet(const Arguments& args) {
 47 |     Local<Object> arrayBuffer = args.This()->Get(String::New("buffer"))->ToObject();
 48 | 
 49 |     if (args.Length() >= 1 && args[0]->IsArray()) {
 50 |         Local<Array> source = Local<Array>::Cast(args[0]);
 51 |         unsigned int offset = 0;
 52 | 
 53 |         if (args.Length() >= 2 && args[1]->IsUint32()) {
 54 |             offset = args[1]->Uint32Value();
 55 |         }
 56 | 
 57 |         unsigned int dataLength = args.This()->GetIndexedPropertiesExternalArrayDataLength();
 58 |         if (offset + source->Length() > dataLength) {
 59 |             return ThrowException(String::New("INDEX_SIZE_ERR: array too large"));
 60 |         }
 61 | 
 62 |         for (unsigned int index = 0; index < source->Length(); index++) {
 63 |             args.This()->Set(offset + index, source->Get(index));
 64 |         }
 65 |     } else {
 66 |         return ThrowException(String::New("Invalid ArrayBufferView::set arguments."));
 67 |     }
 68 | 
 69 |     return Undefined();
 70 | }
 71 | 
 72 | Handle<Value> ArrayBufferViewSubarray(const Arguments& args) {
 73 |     return ThrowException(String::New("ArrayBufferView::subarray not yet implemented."));
 74 | }
 75 | 
 76 | Handle<Value> CreateArrayBufferView(const Arguments& args, ExternalArrayType type, int element_size) {
 77 |     Local<Object> arrayBuffer = Local<Object>();
 78 |     Local<Object> initData = Local<Object>();
 79 |     unsigned long elements = 0;
 80 |     unsigned long byteOffset = 0;
 81 |     unsigned long arrayBufferLength = 0;
 82 | 
 83 |     if (!args.IsConstructCall())
 84 | 	return ThrowException(String::New("Typed Array constructor cannot be called as a function."));
 85 | 
 86 |     if (args.Length() == 1 && args[0]->IsUint32()) {
 87 |         // TypedArray(unsigned long length)
 88 |         elements = args[0]->Uint32Value();
 89 |     } else if (args.Length() >= 1 && args[0]->IsObject() &&
 90 | 	       !((Handle<Object>::Cast(args[0]))->FindInstanceInPrototypeChain
 91 | 		 (array_buffer_constructor_template).IsEmpty())) {
 92 |         // TypedArray(ArrayBuffer buffer, optional unsigned long byteOffset, optional unsigned long length)
 93 |         arrayBuffer = args[0]->ToObject();
 94 | 	arrayBufferLength = (unsigned long)
 95 | 	    arrayBuffer->GetPointerFromInternalField(1);
 96 | 
 97 |         if (args.Length() > 1) {
 98 |             byteOffset = args[1]->Uint32Value();
 99 |         }
100 |         if (args.Length() > 2) {
101 |             elements = args[2]->Uint32Value();
102 |         } else {
103 | 	    if ((arrayBufferLength - byteOffset) % element_size != 0) {
104 | 		return ThrowException(String::New("Length of the ArrayBuffer minus the byteOffset must be a multiple of the element size."));
105 | 	    }
106 | 	    elements = (arrayBufferLength - byteOffset) / element_size;
107 | 	}
108 | 
109 |     } else if (args.Length() == 1 && args[0]->IsArray()) {
110 |         // TypedArray(type[] array)
111 | 	initData = Local<Object>::Cast(args[0]);
112 | 	elements = Handle<Array>::Cast(initData)->Length();
113 |     } else if (args.Length() == 1 && args[0]->IsObject() &&
114 | 	       Handle<Object>::Cast(args[0])->HasIndexedPropertiesInExternalArrayData()) {
115 |         // TypedArray(TypedArray array)
116 | 	initData = Local<Object>::Cast(args[0]);
117 | 	elements = initData->GetIndexedPropertiesExternalArrayDataLength();
118 |     } else {
119 |         return ThrowException(String::New("Invalid ArrayBufferView arguments."));
120 |     }
121 | 
122 |     if (arrayBuffer.IsEmpty()) {
123 |         Local<Value> arg = Int32::New(elements * element_size);
124 |         arrayBuffer = array_buffer_constructor_template->GetFunction()->NewInstance(1, &arg);
125 | 	arrayBufferLength = (unsigned long)
126 | 	    arrayBuffer->GetPointerFromInternalField(1);
127 |     }
128 | 
129 |     void* arrayBufferData = arrayBuffer->GetPointerFromInternalField(0);
130 | 
131 |     if (byteOffset + elements * element_size > arrayBufferLength) {
132 |         return ThrowException(String::New("Given byteOffset and length references an area beyond the end of the ArrayBuffer."));
133 |     }
134 | 
135 |     args.This()->SetIndexedPropertiesToExternalArrayData(((int8_t*)arrayBufferData) + byteOffset, type, elements);
136 | 
137 |     // Initialize
138 |     if (!initData.IsEmpty()) {
139 | 	if (initData->HasIndexedPropertiesInExternalArrayData() &&
140 | 	    initData->GetIndexedPropertiesExternalArrayDataType() == type) {
141 | 	    // fast path
142 | 	    void *source = initData->GetIndexedPropertiesExternalArrayData();
143 | 	    memcpy(((int8_t*)arrayBufferData) + byteOffset, source,
144 | 		   elements * element_size);
145 | 	} else {
146 | 	    // slow path
147 | 	    for (unsigned int index = 0; index < elements; index++) {
148 | 		args.This()->Set(index, initData->Get(index));
149 | 	    }
150 | 	}
151 |     }
152 | 
153 |     // ArrayBufferView properties
154 |     args.This()->Set(String::New("buffer"), arrayBuffer, ReadOnly);
155 |     args.This()->Set(String::New("byteLength"), Int32::New(elements * element_size), ReadOnly);
156 |     args.This()->Set(String::New("byteOffset"), Int32::New(byteOffset), ReadOnly);
157 | 
158 |     // TypedArray properties
159 |     args.This()->Set(String::New("BYTES_PER_ELEMENT"), Int32::New(element_size), ReadOnly);
160 |     args.This()->Set(String::New("length"), Int32::New(elements), ReadOnly);
161 | 
162 |     // TypedArray methods (TODO: move to prototype)
163 |     args.This()->Set(String::New("set"), FunctionTemplate::New(ArrayBufferViewSet)->GetFunction());
164 |     args.This()->Set(String::New("subarray"), FunctionTemplate::New(ArrayBufferViewSubarray)->GetFunction());
165 | 
166 |     return args.This();
167 | }
168 | 
169 | DEFINE_ARRAY_BUFFER_VIEW(Int8Array, kExternalByteArray, sizeof(int8_t));
170 | DEFINE_ARRAY_BUFFER_VIEW(Uint8Array, kExternalUnsignedByteArray, sizeof(uint8_t));
171 | DEFINE_ARRAY_BUFFER_VIEW(Int16Array, kExternalShortArray, sizeof(int16_t));
172 | DEFINE_ARRAY_BUFFER_VIEW(Uint16Array, kExternalUnsignedShortArray, sizeof(uint16_t));
173 | DEFINE_ARRAY_BUFFER_VIEW(Int32Array, kExternalIntArray, sizeof(int32_t));
174 | DEFINE_ARRAY_BUFFER_VIEW(Uint32Array, kExternalUnsignedIntArray, sizeof(uint32_t));
175 | DEFINE_ARRAY_BUFFER_VIEW(Float32Array, kExternalFloatArray, sizeof(float));
176 | // DEFINE_ARRAY_BUFFER_VIEW(Float64Array, kExternalDoubleArray, sizeof(double));
177 | // DEFINE_ARRAY_BUFFER_VIEW(PixelArray, kExternalPixelArray, sizeof(uint8_t));
178 | 
179 | extern "C" void
180 | v8_typed_array_init (Handle<Object> target) {
181 |     HandleScope scope;
182 | 
183 |     {
184 |         array_buffer_constructor_template = Persistent<FunctionTemplate>::New(FunctionTemplate::New(ArrayBuffer));
185 |         array_buffer_constructor_template->InstanceTemplate()->SetInternalFieldCount(2);
186 |         Local<Function> f = array_buffer_constructor_template->GetFunction();
187 |         target->Set(String::New("ArrayBuffer"), f);
188 |     }
189 | 
190 |     INIT_ARRAY_BUFFER_VIEW(Int8Array, kExternalByteArray, sizeof(int8_t));
191 |     INIT_ARRAY_BUFFER_VIEW(Uint8Array, kExternalUnsignedByteArray, sizeof(uint8_t));
192 |     INIT_ARRAY_BUFFER_VIEW(Int16Array, kExternalShortArray, sizeof(int16_t));
193 |     INIT_ARRAY_BUFFER_VIEW(Uint16Array, kExternalUnsignedShortArray, sizeof(uint16_t));
194 |     INIT_ARRAY_BUFFER_VIEW(Int32Array, kExternalIntArray, sizeof(int32_t));
195 |     INIT_ARRAY_BUFFER_VIEW(Uint32Array, kExternalUnsignedIntArray, sizeof(uint32_t));
196 |     INIT_ARRAY_BUFFER_VIEW(Float32Array, kExternalFloatArray, sizeof(float));
197 |     // INIT_ARRAY_BUFFER_VIEW(Float64Array, kExternalDoubleArray, sizeof(double));
198 |     // INIT_ARRAY_BUFFER_VIEW(PixelArray, kExternalPixelArray, sizeof(uint8_t));
199 | }
200 | 


--------------------------------------------------------------------------------
/glesbindings/glesbind.py:
--------------------------------------------------------------------------------
  1 | from __future__ import with_statement
  2 | 
  3 | import json
  4 | import re
  5 | from os import path
  6 | 
  7 | #input output files
  8 | IN_FILE = 'glesbind.json'
  9 | OUT_FILE = 'glesbind.cpp'
 10 | CUSTOM_CODE_FILE = 'glescustom.cpp'
 11 | 
 12 | #functions found in custom code file
 13 | #there won't be an automatic code generation
 14 | #for these functions. However there will be a corresponding
 15 | #accessor in the Gles object, if found.
 16 | template = """
 17 |     glGenBuffers               #custom code functions
 18 |     |glGenRenderbuffers
 19 |     |glGenFramebuffers
 20 |     |glGenTextures
 21 |     |glGetProgramiv
 22 |     |glGetShaderiv
 23 |     |glShaderSource
 24 |     |glVertexAttribPointer
 25 |     |glDrawElements
 26 |     |glBufferData                
 27 |     |glBufferSubData             
 28 |     |glReadPixels
 29 |     |glGetActiveAttrib
 30 |     |glGetActiveUniform
 31 |     |glGetBufferParameteriv
 32 |     |glGetProgramInfoLog
 33 |     |glGetShaderInfoLog
 34 |     |glTexImage2D              
 35 |     |glTexSubImage2D
 36 |     |glGetShaderSource
 37 |     |glGetAttachedShaders
 38 |            
 39 | """
 40 | 
 41 | #excluded functions
 42 | #there won't be an accessor for these functions
 43 | #in the Gles object.
 44 | exclude = """
 45 |     _ATI
 46 |     |ATI$
 47 |     |MESA     
 48 |     |IMPLEMENTATION
 49 |     |GL_INVALID_FRAMEBUFFER_OPERATION
 50 |     
 51 |     |glGetVertexAttribPointerv #functions to be considered for custom implementation
 52 |                                #might be missing some
 53 |                                
 54 |     |glCompressedTexImage2D    
 55 |     |glCompressedTexSubImage2D 
 56 |     |glShaderBinary            
 57 |         
 58 |     |glReleaseShaderCompiler    #commented functions
 59 |     |glGetShaderPrecisionFormat
 60 |     
 61 |     
 62 |     
 63 |     |glGetBooleaniv             #are replaced by glGetParameter
 64 |     |glGetIntegeriv
 65 |     |glGetFloativ
 66 |     |glGetDoubleiv
 67 |     
 68 |     |glGetTexParameterfv        #are replaced by glGetTexParameter
 69 |     |glGetTexParameteriv
 70 |     
 71 |     |glGetUniformfv                 #should be implemented but I find quite difficult
 72 |                                     #to guess the type of a queried uniform, so I'm not
 73 |                                     #sure how to allocate the resulting data.
 74 |                                 
 75 |     |glGetVertexAttribiv            #are replaced by glGetVertexAttrib
 76 |     |glGetVertexAttribfv
 77 |     
 78 |     |glGetRenderbufferParameteriv    #is replaced by glGetRenderbufferParameter
 79 |     
 80 | """
 81 | 
 82 | accessor_extras = ['glGetParameter', 
 83 |                    'glGetTexParameter', 
 84 |                    'glGetVertexAttrib', 
 85 |                    'glGetRenderbufferParameter',
 86 |                    'glShaderSourceFile',
 87 |                    'glTexImage2DFile']
 88 | 
 89 | EXCLUDE = re.compile(exclude, re.VERBOSE)
 90 | TEMPLATE = re.compile(template, re.VERBOSE)
 91 | 
 92 | def main():
 93 |     """Generates GLES bindings"""
 94 |     
 95 |     #read custom code
 96 |     with open(CUSTOM_CODE_FILE, 'r') as f:
 97 |         custom_code = f.read()
 98 |         
 99 |     with open(IN_FILE, 'r') as f:
100 |         text_out = []
101 |         data = f.read()
102 |         try:
103 |             # Try the python 2.6 json module first.
104 |             json_in = json.loads(data)
105 |         except AttributeError:
106 |             # Fall back to json-py.
107 |             reader = json.JsonReader()
108 |             json_in = reader.read(data)
109 |         constants, functions = [], []
110 |         
111 |         for obj in json_in:
112 |             if not re.search(EXCLUDE, obj['name']):
113 |                 try:
114 |                     if obj['type'] == 'c':
115 |                         constants.append(obj['name'])
116 |                     else:
117 |                       if not re.search(TEMPLATE, obj['name']):
118 |                         text_out.append(generate_function(obj))
119 |                       functions.append(obj['name'])
120 |                 except Exception, e: #probably an unhandled type
121 |                     print e
122 |                     pass
123 |             else:
124 |                 print obj['name']
125 | 
126 |         functions.extend(accessor_extras)
127 | 
128 |     with open(OUT_FILE, 'w') as fout:
129 |         fout.write("""
130 | #include "glesbind.h"
131 | 
132 | #if defined(V8_GL_USE_GLEW)
133 | #include "GL/glew.h"
134 | #include "glew_desktop_shim.h"
135 | #elif defined(__APPLE__)
136 | #include <OpenGL/OpenGL.h>
137 | #include "gles_desktop_shim.h"
138 | #else
139 | #define GL_GLEXT_PROTOTYPES
140 | #include <GL/gl.h>
141 | // If we're running on desktop OpenGL, some ES 2.0 constants don't exist, or
142 | // are under a name with EXT in them, etc.
143 | #include "gles_desktop_shim.h"
144 | #endif
145 | 
146 | #include <fstream>
147 | #include <string>
148 | using namespace v8;
149 | 
150 | 
151 | Persistent<Object> GlesFactory::self_;
152 | Persistent<Context> GlesFactory::gles_persistent_context;
153 | """ + custom_code  + '\n'.join(text_out) + '\n' + generate_main_function(constants, functions))
154 | 
155 | 
156 | def generate_main_function(constants, functions):
157 |     """Generates the main createGles function definition"""
158 |     
159 |     text_out_begin = """
160 | 
161 | Handle<ObjectTemplate> GlesFactory::createGles(void) {
162 |       HandleScope handle_scope;
163 | 
164 |       Handle<ObjectTemplate> Gles = ObjectTemplate::New();
165 |       
166 |       Gles->SetInternalFieldCount(1);
167 | 
168 | """
169 | 
170 |     text_out_end = """
171 | 
172 |       // Again, return the result through the current handle scope.
173 |       return handle_scope.Close(Gles);
174 | }    
175 | """
176 |     bind_accessor = lambda n: "     Gles->Set(String::NewSymbol(\"" + '_'.join(n.split('_')[1:]) \
177 |         + "\"), Uint32::New(" + n + "), ReadOnly);\n"
178 |     bind_function = lambda n: "     Gles->Set(String::NewSymbol(\"" + n[2].lower() + n[3:] + \
179 |         "\"), FunctionTemplate::New(GLES" + n + "Callback));\n"
180 |     
181 |     cts = [bind_accessor(name) for name in constants]
182 |     fts = [bind_function(name) for name in functions]
183 |     
184 |     return text_out_begin + '\n'.join(cts) + '\n' + '\n'.join(fts) + text_out_end
185 | 
186 | def generate_function(obj):
187 |     """Generates code for declaring a Function"""
188 | 
189 |     text_out = """
190 | 
191 | Handle<<ret>> GLES<name>Callback(const Arguments& args) {
192 |   //if less that nbr of formal parameters then do nothing
193 |   if (args.Length() < <len_params>) return v8::Undefined();
194 |   //get arguments
195 | <args>
196 |   //make call
197 |   <call>
198 | }
199 | 
200 | """
201 |     return multiple_replace({
202 |         '<name>': obj['name'],
203 |         '<len_params>': str(len(obj['parameters'])),
204 |         '<args>': generate_arguments(obj['parameters']),
205 |         '<call>': generate_call(obj),
206 |         '<ret>': 'Value'      
207 |     }, text_out)
208 | 
209 | 
210 | #map some OpenGL types to V8 types
211 | unsigned = re.compile('unsigned|ubyte|ushort|uint|bitfield|boolean|enum')
212 | integer = re.compile('int|sizei|short|byte')
213 | double = re.compile('double|float|clampf|clampd')
214 | 
215 | def generate_arguments(params):
216 |     """generates the formal parameter definition"""
217 |     
218 |     text_out = []
219 |     #assignment template
220 |     assign = lambda type, method, i: '  ' + type + ' arg' + i + \
221 |         ' = args[' + i + ']->' + method + '();\n'
222 |     
223 |     for i, type in enumerate(params):
224 |         si = str(i)
225 |         #TODO Find a way to map void* to a V8 type
226 |         if type.find('void*') != -1:
227 |             raise Exception("unhandled type " + type)
228 |         #is a name (char*)
229 |         if type.endswith('char*'):
230 |             text_out.append("  String::Utf8Value value"+ si +"(args["+ si +"]);\n  " + \
231 |                             "char* arg" + si + " = *value"+ si +";\n")
232 |         #is array
233 |         elif type.find('*') != -1 or type.find('[') != -1:
234 |             text_out.append(generate_array_expression(type, i))
235 |         #is unsigned integer
236 |         elif re.search(unsigned, type):
237 |             text_out.append(assign('unsigned int', 'Uint32Value', si))
238 |         #is integer
239 |         elif re.search(integer, type):
240 |             text_out.append(assign('int', 'IntegerValue', si))
241 |         #is double, float
242 |         elif re.search(double, type):
243 |             text_out.append(assign('double', 'NumberValue', si))
244 |         else:
245 |             raise Exception("unhandled type " + type)
246 | 
247 |     return ''.join(text_out)
248 | 
249 | def generate_array_expression(type, i):
250 |     """generates an Array assignment expression"""
251 |     type = multiple_replace({ '(':'', ')':'', 'const':'' }, type)
252 |     acc = get_accessor(type)
253 |     clean_type = type.replace('*', '')
254 |     
255 |     text_out = """
256 | 
257 |   Handle<Array> arrHandle##1 = Handle<Array>::Cast(args[##1]);
258 |   ##2 arg##1 = new ##3[arrHandle##1->Length()];
259 |   for (unsigned j = 0; j < arrHandle##1->Length(); j++) {
260 |       Handle<Value> arg(arrHandle##1->Get(Integer::New(j)));
261 |       ##3 aux = (##3)arg->##4;
262 |       arg##1[j] = aux;
263 |   }
264 | 
265 | """
266 |     return multiple_replace({
267 |         '##1': str(i),
268 |         '##2': type,
269 |         '##3': clean_type,
270 |         '##4': acc + 'Value()'
271 |     }, text_out)
272 | 
273 | def get_accessor(type):
274 |     """Returns the V8 type accesor method to be called"""
275 | 
276 |     if re.search(unsigned, type): return 'Uint32'
277 |     if re.search(integer, type): return 'Integer'
278 |     if re.search(double, type): return 'Number'
279 |     
280 |     return None
281 | 
282 | def generate_call(obj):
283 |     """generates the native function call syntax"""
284 | 
285 |     acc = get_accessor(obj['return_type'])
286 |     function_call = obj['name'] + "(" + ", ".join(['(' + param + ') ' + "arg" + str(i) \
287 |                         for i, param in enumerate(obj['parameters'])]) + ")"
288 |     
289 |     #dot-this-dot-that feature
290 |     if acc is None: 
291 |         return function_call + ';\n  Handle<Object> res(GlesFactory::self_);\n  return res;'
292 |     else:
293 |         return 'return ' + acc + '::New(' + function_call + ');'
294 |     
295 | 
296 | def multiple_replace(dict, text): 
297 |   """ Replace in 'text' all occurences of any key in the given
298 |   dictionary by its corresponding value.  Returns the new string.""" 
299 | 
300 |   # Create a regular expression  from the dictionary keys
301 |   regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))
302 | 
303 |   # For each match, look-up corresponding value in dictionary
304 |   return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text) 
305 | 
306 | if __name__ == '__main__': main()
307 | 


--------------------------------------------------------------------------------
/glutbindings/glutbind.py:
--------------------------------------------------------------------------------
  1 | import sys
  2 | import re
  3 | 
  4 | PATH_GLUT = 'glut.h'
  5 | FILE_GLUT = 'glutbind.cpp'
  6 | 
  7 | TEMPLATES = ['glutInit', 'glutTimerFunc']
  8 | 
  9 | def main():
 10 |     """ 
 11 |     Still some things have to be hand-made, like
 12 |     changing argv pargc values in the glutInit method definition
 13 |     Also change the TimerFunc method with some magic.
 14 |     """
 15 |     make_glut()
 16 | 
 17 | def make_glut():
 18 |     constants = []
 19 |     functions = []
 20 |     void_stars = []
 21 |     
 22 |     constant = re.compile(".+define[\s]+GLUT_([^\s]+).*")
 23 |     function = re.compile("[\s]*extern[\s]+([^\s]+)[\s]+APIENTRY[\s]+glut([A-Za-z0-9]+)\((.*)\);")
 24 |     
 25 |     text_out = []
 26 |     
 27 |     fin = open(PATH_GLUT, 'r')
 28 |     for l in fin:
 29 |        mat = re.match(constant, l)
 30 |        if mat and not mat.group(1) in constants:
 31 |            name = mat.group(1)
 32 |            constants.append(name)
 33 |            text_out.append(make_constant("GLUT", name))
 34 |            
 35 |            if name.find("STROKE") != -1 or name.find("BITMAP") != -1:
 36 |                void_stars.append(name)
 37 |            #print "GLUT_" + mat.group(1) + "\n"
 38 |            
 39 |        else:
 40 |            mat = re.match(function, l)
 41 |            if mat:
 42 |                prefix = "glut"
 43 |                return_val = mat.group(1)
 44 |                name = mat.group(2)
 45 |                params = mat.group(3)
 46 |                functions.append(name)
 47 |                #if has template then take the template code
 48 |                if (prefix + name) in TEMPLATES:
 49 |                    t = open(prefix + name + '.template', 'r')
 50 |                    text_out.append(t.read())
 51 |                    t.close()
 52 |                else:
 53 |                    has_lambda, count, params_list = get_param_list(params)
 54 |                    if has_lambda is True and count == 1:
 55 |                        text_out.append(make_function_with_callback(prefix, name, params_list, return_val))
 56 |                    else:
 57 |                        text_out.append(make_function(prefix, name, params_list, count, return_val))
 58 |                    #print return_val + " " + name + " " + params
 59 |                    
 60 |     fin.close()
 61 |     fout = open(FILE_GLUT, 'w')
 62 |     fout.write("""
 63 | 
 64 | #include "glutbind.h"
 65 | 
 66 | int* pargc_;
 67 | char** argv_;
 68 | map<const char*, void*> font_;
 69 | Persistent<Context> GlutFactory::glut_persistent_context;
 70 |     
 71 |     """ + '\n'.join(text_out) + make_main_glut_function(constants, functions, void_stars))
 72 |     
 73 |     fout.close()
 74 | 
 75 | def make_main_glut_function(constants, functions, void_stars):
 76 |     text_out_begin = """
 77 | 
 78 | Handle<ObjectTemplate> GlutFactory::createGlut(int* pargc, char** argv) {
 79 |       pargc_ = pargc;
 80 |       argv_  = argv;
 81 |       
 82 |       HandleScope handle_scope;
 83 | 
 84 |       Handle<ObjectTemplate> Glut = ObjectTemplate::New();
 85 |       Glut->SetInternalFieldCount(1);
 86 | 
 87 | """
 88 | 
 89 |     text_out_end = """
 90 | 
 91 |       // Again, return the result through the current handle scope.
 92 |       return handle_scope.Close(Glut);
 93 | }    
 94 | """
 95 |     fnt = [bind_font(name) for name in void_stars]    
 96 |     cts = [bind_accessor("Glut", name) for name in constants]
 97 |     fts = [bind_function("Glut", name) for name in functions]
 98 |     
 99 |     return text_out_begin + '\n'.join(fnt) + '\n'.join(cts) + '\n'.join(fts) + text_out_end
100 |     
101 | 
102 | def make_constant(prefix, name):
103 |     if name.find("BITMAP") != -1 or name.find("STROKE") != -1:
104 |         return_val = "return String::New(\""+ name +"\");\n"
105 |     else:
106 |         return_val = "return Uint32::New(GLUT_"+ name +");"
107 |     
108 |     text_out = """
109 | 
110 | Handle<Value> GetGLUT_%%(Local<String> property,
111 |                       const AccessorInfo &info) {
112 |     ##
113 | }
114 | 
115 | """
116 |     return multiple_replace({
117 |         '%%': name,
118 |         '##': return_val
119 |     }, text_out)
120 | 
121 | 
122 | 
123 | def make_function(prefix, name, params_list, count, return_val):
124 |     text_out = """
125 | 
126 | Handle<Value> GLUT<name>Callback(const Arguments& args) {
127 |   //if less that nbr of formal parameters then do nothing
128 |   if (args.Length() < <len_params>) return v8::Undefined();
129 |   //get arguments
130 | <args>
131 |   //make call
132 |   <call>
133 |   return v8::Undefined();
134 | }
135 | 
136 | """
137 |     return multiple_replace({
138 |         '<name>': name,
139 |         '<len_params>': str(count),
140 |         '<args>': make_args(params_list, count),
141 |         '<call>': make_call(prefix + name, params_list, count)      
142 |     }, text_out)
143 | 
144 | 
145 | def make_function_with_callback(prefix, name, params_list, return_val):    
146 |     
147 |     text_out = """
148 | 
149 | Persistent<Function> persistent<name>;
150 | 
151 | <prototype> {
152 |   //define handle scope
153 |   HandleScope scope;
154 | 
155 |   Handle<Value> valueArr[<nformalparams>];
156 | <formalparamassignment>
157 |   
158 |   TryCatch try_catch;
159 |   Handle<Value> result = persistent<name>->Call(GlutFactory::glut_persistent_context->Global(), <nformalparams>, valueArr);
160 |   if (result.IsEmpty()) {
161 |     String::Utf8Value error(try_catch.Exception());
162 |     fprintf(stderr, "Exception in <name>: %s\\n", *error);
163 |   }
164 | }
165 | 
166 | Handle<Value> GLUT<name>Callback(const Arguments& args) {
167 |   //if less that nbr of formal parameters then do nothing
168 |   if (args.Length() < 1 || !args[0]->IsFunction()) return v8::Undefined();
169 |   //get arguments
170 |   //delete previous assigned function
171 |   persistent<name>.Dispose();
172 |   Handle<Function> value0 = Handle<Function>::Cast(args[0]);
173 |   persistent<name> = Persistent<Function>::New(value0);
174 | 
175 |   //make call
176 |   glut<name>((<signature>) func<name>);
177 |   return v8::Undefined();
178 | }
179 | 
180 | """
181 |     nformalparams, prototype = make_prototype(name, params_list[0])
182 |     signature = params_list[0].replace('func', '')
183 |     formalparamassignment = formal_param_assignment(signature)
184 |      
185 |     return multiple_replace({
186 |         '<name>': name,
187 |         '<nformalparams>': str(nformalparams),
188 |         '<prototype>': prototype,
189 |         '<formalparamassignment>': formalparamassignment,
190 |         '<signature>': signature      
191 |     }, text_out)
192 | 
193 | def make_prototype(name, signature):
194 |     print 'prev ' + signature
195 |     signature = signature.replace('(*func)', 'func' + name)
196 |     ht = signature.split('(')
197 |     hd, tail = ht[0], ht[1].replace(')', '')
198 |     ans = [get_type(''.join(val), False) + ' arg' + str(i) for i, val in enumerate(tail.split(',')) if val.find('void') == -1]
199 |     #.strip().split(' ')[:-1]
200 |     print 'end ' + hd + ' ( ' + ','.join(ans) + ')'
201 |     return len(ans), hd + ' ( ' + ','.join(ans) + ')'
202 | 
203 | def formal_param_assignment(signature):
204 |     print "signature"
205 |     print signature
206 |     pat = re.compile('[\s]*[a-zA-Z0-9\*]+[\s]*\(\*[\s]*\)\((.*)\)')
207 |     pars = re.match(pat, signature)
208 |     if pars:
209 |         pars = pars.group(1).split(',')
210 |         ans = []
211 |         for i, val in enumerate(pars):
212 |             if val.find('int') != -1 or val.find('unsigned char') != -1:
213 |                 ans.append("  valueArr[" + str(i) + "] = Integer::New(arg" + str(i) + ");")
214 |             elif val.find('float') != -1 or val.find('double') != -1:
215 |                 ans.append("  valueArr[" + str(i) + "] = Number::New(arg" + str(i) + ");")
216 |             elif val.find('char*') != -1:
217 |                 ans.append("  valueArr[" + str(i) + "] = String::New(arg" + str(i) + ");")
218 |         return '\n'.join(ans)
219 |     else:
220 |         return ''    
221 | 
222 | def get_param_list(params):
223 |     params_list = []
224 |     params_aux = params.split(',')
225 |     passed = False
226 |     for par in params_aux:
227 |         if passed and params_list[-1].count('(') != params_list[-1].count(')'):
228 |             params_list[-1] += ',' + par
229 |         else:
230 |             params_list.append(par)
231 |         passed = True
232 |     
233 |     aux = len(params_list)
234 |     if aux == 1 and params_list[0].find('func') == -1 and len(params_list[0].strip().split(' ')) == 1: 
235 |         nb = 0
236 |     else:
237 |         nb = aux
238 |     return ' '.join(params_list).find('func') != -1, nb, params_list
239 |     
240 | 
241 | def make_args(params_list, count):
242 |     ans = []
243 |     for i in range(count):
244 |         el = params_list[i]
245 |         type = get_type(el)
246 |         
247 |         #is function
248 |         if type.find('(*') != -1:
249 |             ans.append("  Handle<Function> value" + str(i) + " = Handle<Function>::Cast(args[" + str(i) + "]);\n  void* arg" + str(i) + " = *value" + str(i) + ";\n")
250 |             #print "function " + type
251 |         #is string
252 |         elif type.find('char*') != -1:
253 |             ans.append("  String::Utf8Value value"+ str(i) +"(args["+ str(i) +"]);\n  char* arg" + str(i) + " = *value"+ str(i) +";\n")
254 |             #print "string " + type
255 |         #is void*
256 |         elif type.find('void*') != -1:
257 |             ans.append("  String::Utf8Value value"+ str(i) +"(args["+ str(i) +"]);\n  char* key" + str(i) + " = *value"+ str(i) +";\n  void* arg" + str(i) + " = font_[key"+ str(i) +"];\n")
258 |             #print "void " + type
259 |         #is array
260 |         elif type.find('*') != -1:
261 |             ans.append("  Handle<Array> arg" + str(i) + " = Array::Cast(args[" + str(i) + "]);\n")
262 |             #print "array " + type
263 |         #is unsigned integer
264 |         elif type.find('unsigned int') != -1:
265 |             ans.append("  unsigned int arg" + str(i) + " = args["+ str(i) +"]->Uint32Value();\n")
266 |             #print "unsigned int " + type
267 |         #is integer
268 |         elif type.find('int') != -1 or type.find('enum') != -1:
269 |             ans.append("  int arg" + str(i) + " = args["+ str(i) +"]->IntegerValue();\n")
270 |             #print "integer " + type
271 |         #is double, float
272 |         elif type.find('double') != -1 or type.find('float') != -1:
273 |             ans.append("  double arg" + str(i) + " = args["+ str(i) +"]->NumberValue();\n")
274 |             #print "double " + type
275 |         else:
276 |             print "don't know what this is "
277 |             print type
278 |     
279 |     return ''.join(ans)
280 | 
281 | def make_call(name, params_list, nb):
282 |     return name + "(" + ", ".join([get_type(params_list[i]) + "arg" + str(i) for i in range(nb)]) + ");"
283 |             
284 | def bind_accessor(prefix, name):
285 |     return "     " + prefix + "->SetAccessor(String::NewSymbol(\"" + name + "\"), GetGLUT_" + name + ");\n"
286 | 
287 | def bind_function(prefix, name):
288 |     return "     " + prefix + "->Set(String::NewSymbol(\"" + name[0].lower() + name[1:] + "\"), FunctionTemplate::New(GLUT" + name + "Callback));\n"
289 | 
290 | def bind_font(name):
291 |     return "     font_[\""+ name +"\"] = GLUT_" + name + ";\n"
292 | 
293 | 
294 | def get_type(t, parens=True):
295 |     if t.find('(*') != -1 or t.find('func') != -1: 
296 |         ans = t.replace('func', '')
297 |     else:
298 |         ans = ' '.join(t.strip().split(' ')[:-1]) + '*' * (t.strip().split(' ')[-1].count('*'))
299 |     return '(' + ans + ')' if parens else ans
300 | 
301 | def multiple_replace(dict, text): 
302 |   """ Replace in 'text' all occurences of any key in the given
303 |   dictionary by its corresponding value.  Returns the new tring.""" 
304 | 
305 |   # Create a regular expression  from the dictionary keys
306 |   regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))
307 | 
308 |   # For each match, look-up corresponding value in dictionary
309 |   return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text) 
310 | 
311 | main()  
312 | 


--------------------------------------------------------------------------------
/glubindings/glu.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |     Copyright:  (c) 1999 by Apple Computer, Inc., all rights reserved.
  3 | */
  4 | 
  5 | #ifndef __glu_h__
  6 | #define __glu_h__
  7 | 
  8 | #include <OpenGL/gl.h>
  9 | 
 10 | #ifdef __cplusplus
 11 | extern "C" {
 12 | #endif
 13 | 
 14 | 
 15 | /*************************************************************/
 16 | 
 17 | /* Extensions */
 18 | #define GLU_EXT_object_space_tess            1
 19 | #define GLU_EXT_nurbs_tessellator            1
 20 | 
 21 | /* Boolean */
 22 | #define GLU_FALSE                            0
 23 | #define GLU_TRUE                             1
 24 | 
 25 | /* Version */
 26 | #define GLU_VERSION_1_1                      1
 27 | #define GLU_VERSION_1_2                      1
 28 | #define GLU_VERSION_1_3                      1
 29 | 
 30 | /* StringName */
 31 | #define GLU_VERSION                          100800
 32 | #define GLU_EXTENSIONS                       100801
 33 | 
 34 | /* ErrorCode */
 35 | #define GLU_INVALID_ENUM                     100900
 36 | #define GLU_INVALID_VALUE                    100901
 37 | #define GLU_OUT_OF_MEMORY                    100902
 38 | #define GLU_INCOMPATIBLE_GL_VERSION          100903
 39 | #define GLU_INVALID_OPERATION                100904
 40 | 
 41 | 
 42 | /* NurbsDisplay */
 43 | /*      GLU_FILL */
 44 | #define GLU_OUTLINE_POLYGON                  100240
 45 | #define GLU_OUTLINE_PATCH                    100241
 46 | 
 47 | /* NurbsCallback */
 48 | #define GLU_NURBS_ERROR                      100103
 49 | #define GLU_ERROR                            100103
 50 | #define GLU_NURBS_BEGIN                      100164
 51 | #define GLU_NURBS_BEGIN_EXT                  100164
 52 | #define GLU_NURBS_VERTEX                     100165
 53 | #define GLU_NURBS_VERTEX_EXT                 100165
 54 | #define GLU_NURBS_NORMAL                     100166
 55 | #define GLU_NURBS_NORMAL_EXT                 100166
 56 | #define GLU_NURBS_COLOR                      100167
 57 | #define GLU_NURBS_COLOR_EXT                  100167
 58 | #define GLU_NURBS_TEXTURE_COORD              100168
 59 | #define GLU_NURBS_TEX_COORD_EXT              100168
 60 | #define GLU_NURBS_END                        100169
 61 | #define GLU_NURBS_END_EXT                    100169
 62 | #define GLU_NURBS_BEGIN_DATA                 100170
 63 | #define GLU_NURBS_BEGIN_DATA_EXT             100170
 64 | #define GLU_NURBS_VERTEX_DATA                100171
 65 | #define GLU_NURBS_VERTEX_DATA_EXT            100171
 66 | #define GLU_NURBS_NORMAL_DATA                100172
 67 | #define GLU_NURBS_NORMAL_DATA_EXT            100172
 68 | #define GLU_NURBS_COLOR_DATA                 100173
 69 | #define GLU_NURBS_COLOR_DATA_EXT             100173
 70 | #define GLU_NURBS_TEXTURE_COORD_DATA         100174
 71 | #define GLU_NURBS_TEX_COORD_DATA_EXT         100174
 72 | #define GLU_NURBS_END_DATA                   100175
 73 | #define GLU_NURBS_END_DATA_EXT               100175
 74 | 
 75 | /* NurbsError */
 76 | #define GLU_NURBS_ERROR1                     100251   /* spline order un-supported */
 77 | #define GLU_NURBS_ERROR2                     100252   /* too few knots */
 78 | #define GLU_NURBS_ERROR3                     100253   /* valid knot range is empty */
 79 | #define GLU_NURBS_ERROR4                     100254   /* decreasing knot sequence */
 80 | #define GLU_NURBS_ERROR5                     100255   /* knot multiplicity > spline order */
 81 | #define GLU_NURBS_ERROR6                     100256   /* endcurve() must follow bgncurve() */
 82 | #define GLU_NURBS_ERROR7                     100257   /* bgncurve() must precede endcurve() */
 83 | #define GLU_NURBS_ERROR8                     100258   /* ctrlarray or knot vector is NULL */
 84 | #define GLU_NURBS_ERROR9                     100259   /* can't draw pwlcurves */
 85 | #define GLU_NURBS_ERROR10                    100260   /* missing gluNurbsCurve() */
 86 | #define GLU_NURBS_ERROR11                    100261   /* missing gluNurbsSurface() */
 87 | #define GLU_NURBS_ERROR12                    100262   /* endtrim() must precede endsurface() */
 88 | #define GLU_NURBS_ERROR13                    100263   /* bgnsurface() must precede endsurface() */
 89 | #define GLU_NURBS_ERROR14                    100264   /* curve of improper type passed as trim curve */
 90 | #define GLU_NURBS_ERROR15                    100265   /* bgnsurface() must precede bgntrim() */
 91 | #define GLU_NURBS_ERROR16                    100266   /* endtrim() must follow bgntrim() */
 92 | #define GLU_NURBS_ERROR17                    100267   /* bgntrim() must precede endtrim()*/
 93 | #define GLU_NURBS_ERROR18                    100268   /* invalid or missing trim curve*/
 94 | #define GLU_NURBS_ERROR19                    100269   /* bgntrim() must precede pwlcurve() */
 95 | #define GLU_NURBS_ERROR20                    100270   /* pwlcurve referenced twice*/
 96 | #define GLU_NURBS_ERROR21                    100271   /* pwlcurve and nurbscurve mixed */
 97 | #define GLU_NURBS_ERROR22                    100272   /* improper usage of trim data type */
 98 | #define GLU_NURBS_ERROR23                    100273   /* nurbscurve referenced twice */
 99 | #define GLU_NURBS_ERROR24                    100274   /* nurbscurve and pwlcurve mixed */
100 | #define GLU_NURBS_ERROR25                    100275   /* nurbssurface referenced twice */
101 | #define GLU_NURBS_ERROR26                    100276   /* invalid property */
102 | #define GLU_NURBS_ERROR27                    100277   /* endsurface() must follow bgnsurface() */
103 | #define GLU_NURBS_ERROR28                    100278   /* intersecting or misoriented trim curves */
104 | #define GLU_NURBS_ERROR29                    100279   /* intersecting trim curves */
105 | #define GLU_NURBS_ERROR30                    100280   /* UNUSED */
106 | #define GLU_NURBS_ERROR31                    100281   /* unconnected trim curves */
107 | #define GLU_NURBS_ERROR32                    100282   /* unknown knot error */
108 | #define GLU_NURBS_ERROR33                    100283   /* negative vertex count encountered */
109 | #define GLU_NURBS_ERROR34                    100284   /* negative byte-stride */
110 | #define GLU_NURBS_ERROR35                    100285   /* unknown type descriptor */
111 | #define GLU_NURBS_ERROR36                    100286   /* null control point reference */
112 | #define GLU_NURBS_ERROR37                    100287   /* duplicate point on pwlcurve */
113 | 
114 | /* NurbsProperty */
115 | #define GLU_AUTO_LOAD_MATRIX                 100200
116 | #define GLU_CULLING                          100201
117 | #define GLU_SAMPLING_TOLERANCE               100203
118 | #define GLU_DISPLAY_MODE                     100204
119 | #define GLU_PARAMETRIC_TOLERANCE             100202
120 | #define GLU_SAMPLING_METHOD                  100205
121 | #define GLU_U_STEP                           100206
122 | #define GLU_V_STEP                           100207
123 | #define GLU_NURBS_MODE                       100160
124 | #define GLU_NURBS_MODE_EXT                   100160
125 | #define GLU_NURBS_TESSELLATOR                100161
126 | #define GLU_NURBS_TESSELLATOR_EXT            100161
127 | #define GLU_NURBS_RENDERER                   100162
128 | #define GLU_NURBS_RENDERER_EXT               100162
129 | 
130 | /* NurbsSampling */
131 | #define GLU_OBJECT_PARAMETRIC_ERROR          100208
132 | #define GLU_OBJECT_PARAMETRIC_ERROR_EXT      100208
133 | #define GLU_OBJECT_PATH_LENGTH               100209
134 | #define GLU_OBJECT_PATH_LENGTH_EXT           100209
135 | #define GLU_PATH_LENGTH                      100215
136 | #define GLU_PARAMETRIC_ERROR                 100216
137 | #define GLU_DOMAIN_DISTANCE                  100217
138 | 
139 | /* NurbsTrim */
140 | #define GLU_MAP1_TRIM_2                      100210
141 | #define GLU_MAP1_TRIM_3                      100211
142 | 
143 | /* QuadricDrawStyle */ 
144 | #define GLU_POINT                            100010
145 | #define GLU_LINE                             100011
146 | #define GLU_FILL                             100012
147 | #define GLU_SILHOUETTE                       100013
148 |   
149 | /* QuadricCallback */
150 | /*      GLU_ERROR */
151 | 
152 | /* QuadricNormal */
153 | #define GLU_SMOOTH                           100000
154 | #define GLU_FLAT                             100001
155 | #define GLU_NONE                             100002
156 |  
157 | /* QuadricOrientation */
158 | #define GLU_OUTSIDE                          100020
159 | #define GLU_INSIDE                           100021
160 | 
161 | /* TessCallback */
162 | #define GLU_TESS_BEGIN                       100100
163 | #define GLU_BEGIN                            100100
164 | #define GLU_TESS_VERTEX                      100101
165 | #define GLU_VERTEX                           100101
166 | #define GLU_TESS_END                         100102
167 | #define GLU_END                              100102
168 | #define GLU_TESS_ERROR                       100103
169 | #define GLU_TESS_EDGE_FLAG                   100104
170 | #define GLU_EDGE_FLAG                        100104
171 | #define GLU_TESS_COMBINE                     100105
172 | #define GLU_TESS_BEGIN_DATA                  100106
173 | #define GLU_TESS_VERTEX_DATA                 100107
174 | #define GLU_TESS_END_DATA                    100108
175 | #define GLU_TESS_ERROR_DATA                  100109
176 | #define GLU_TESS_EDGE_FLAG_DATA              100110
177 | #define GLU_TESS_COMBINE_DATA                100111
178 | 
179 | /* TessContour */
180 | #define GLU_CW                               100120
181 | #define GLU_CCW                              100121
182 | #define GLU_INTERIOR                         100122
183 | #define GLU_EXTERIOR                         100123
184 | #define GLU_UNKNOWN                          100124
185 | 
186 | /* TessProperty */
187 | #define GLU_TESS_WINDING_RULE                100140
188 | #define GLU_TESS_BOUNDARY_ONLY               100141
189 | #define GLU_TESS_TOLERANCE                   100142
190 | 
191 | /* TessError */
192 | #define GLU_TESS_ERROR1                      100151
193 | #define GLU_TESS_ERROR2                      100152
194 | #define GLU_TESS_ERROR3                      100153
195 | #define GLU_TESS_ERROR4                      100154
196 | #define GLU_TESS_ERROR5                      100155
197 | #define GLU_TESS_ERROR6                      100156
198 | #define GLU_TESS_ERROR7                      100157
199 | #define GLU_TESS_ERROR8                      100158
200 | #define GLU_TESS_MISSING_BEGIN_POLYGON       100151
201 | #define GLU_TESS_MISSING_BEGIN_CONTOUR       100152
202 | #define GLU_TESS_MISSING_END_POLYGON         100153
203 | #define GLU_TESS_MISSING_END_CONTOUR         100154
204 | #define GLU_TESS_COORD_TOO_LARGE             100155
205 | #define GLU_TESS_NEED_COMBINE_CALLBACK       100156
206 | 
207 | /* TessWinding */
208 | #define GLU_TESS_WINDING_ODD                 100130
209 | #define GLU_TESS_WINDING_NONZERO             100131
210 | #define GLU_TESS_WINDING_POSITIVE            100132
211 | #define GLU_TESS_WINDING_NEGATIVE            100133
212 | #define GLU_TESS_WINDING_ABS_GEQ_TWO         100134
213 | 
214 | /*************************************************************/
215 | 
216 | 
217 | #ifdef __cplusplus
218 | class GLUnurbs;
219 | class GLUquadric;
220 | class GLUtesselator;
221 | 
222 | typedef class GLUnurbs GLUnurbsObj;
223 | typedef class GLUquadric GLUquadricObj;
224 | typedef class GLUtesselator GLUtesselatorObj;
225 | typedef class GLUtesselator GLUtriangulatorObj;
226 | #else
227 | typedef struct GLUnurbs GLUnurbs;
228 | typedef struct GLUquadric GLUquadric;
229 | typedef struct GLUtesselator GLUtesselator;
230 | 
231 | typedef struct GLUnurbs GLUnurbsObj;
232 | typedef struct GLUquadric GLUquadricObj;
233 | typedef struct GLUtesselator GLUtesselatorObj;
234 | typedef struct GLUtesselator GLUtriangulatorObj;
235 | #endif
236 | 
237 | #define GLU_TESS_MAX_COORD 1.0e150
238 | 
239 | extern void gluBeginCurve (GLUnurbs* nurb);
240 | extern void gluBeginPolygon (GLUtesselator* tess);
241 | extern void gluBeginSurface (GLUnurbs* nurb);
242 | extern void gluBeginTrim (GLUnurbs* nurb);
243 | extern GLint gluBuild1DMipmapLevels (GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void *data);
244 | extern GLint gluBuild1DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void *data);
245 | extern GLint gluBuild2DMipmapLevels (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void *data);
246 | extern GLint gluBuild2DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *data);
247 | extern GLint gluBuild3DMipmapLevels (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void *data);
248 | extern GLint gluBuild3DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data);
249 | extern GLboolean gluCheckExtension (const GLubyte *extName, const GLubyte *extString);
250 | extern void gluCylinder (GLUquadric* quad, GLdouble base, GLdouble top, GLdouble height, GLint slices, GLint stacks);
251 | extern void gluDeleteNurbsRenderer (GLUnurbs* nurb);
252 | extern void gluDeleteQuadric (GLUquadric* quad);
253 | extern void gluDeleteTess (GLUtesselator* tess);
254 | extern void gluDisk (GLUquadric* quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops);
255 | extern void gluEndCurve (GLUnurbs* nurb);
256 | extern void gluEndPolygon (GLUtesselator* tess);
257 | extern void gluEndSurface (GLUnurbs* nurb);
258 | extern void gluEndTrim (GLUnurbs* nurb);
259 | extern const GLubyte * gluErrorString (GLenum error);
260 | extern void gluGetNurbsProperty (GLUnurbs* nurb, GLenum property, GLfloat* data);
261 | extern const GLubyte * gluGetString (GLenum name);
262 | extern void gluGetTessProperty (GLUtesselator* tess, GLenum which, GLdouble* data);
263 | extern void gluLoadSamplingMatrices (GLUnurbs* nurb, const GLfloat *model, const GLfloat *perspective, const GLint *view);
264 | extern void gluLookAt (GLdouble eyeX, GLdouble eyeY, GLdouble eyeZ, GLdouble centerX, GLdouble centerY, GLdouble centerZ, GLdouble upX, GLdouble upY, GLdouble upZ);
265 | extern GLUnurbs* gluNewNurbsRenderer (void);
266 | extern GLUquadric* gluNewQuadric (void);
267 | extern GLUtesselator* gluNewTess (void);
268 | extern void gluNextContour (GLUtesselator* tess, GLenum type);
269 | extern void gluNurbsCallback (GLUnurbs* nurb, GLenum which, GLvoid (*CallBackFunc)());
270 | extern void gluNurbsCallbackData (GLUnurbs* nurb, GLvoid* userData);
271 | extern void gluNurbsCallbackDataEXT (GLUnurbs* nurb, GLvoid* userData);
272 | extern void gluNurbsCurve (GLUnurbs* nurb, GLint knotCount, GLfloat *knots, GLint stride, GLfloat *control, GLint order, GLenum type);
273 | extern void gluNurbsProperty (GLUnurbs* nurb, GLenum property, GLfloat value);
274 | extern void gluNurbsSurface (GLUnurbs* nurb, GLint sKnotCount, GLfloat* sKnots, GLint tKnotCount, GLfloat* tKnots, GLint sStride, GLint tStride, GLfloat* control, GLint sOrder, GLint tOrder, GLenum type);
275 | extern void gluOrtho2D (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top);
276 | extern void gluPartialDisk (GLUquadric* quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops, GLdouble start, GLdouble sweep);
277 | extern void gluPerspective (GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar);
278 | extern void gluPickMatrix (GLdouble x, GLdouble y, GLdouble delX, GLdouble delY, GLint *viewport);
279 | extern GLint gluProject (GLdouble objX, GLdouble objY, GLdouble objZ, const GLdouble *model, const GLdouble *proj, const GLint *view, GLdouble* winX, GLdouble* winY, GLdouble* winZ);
280 | extern void gluPwlCurve (GLUnurbs* nurb, GLint count, GLfloat* data, GLint stride, GLenum type);
281 | extern void gluQuadricCallback (GLUquadric* quad, GLenum which, GLvoid (*CallBackFunc)());
282 | extern void gluQuadricDrawStyle (GLUquadric* quad, GLenum draw);
283 | extern void gluQuadricNormals (GLUquadric* quad, GLenum normal);
284 | extern void gluQuadricOrientation (GLUquadric* quad, GLenum orientation);
285 | extern void gluQuadricTexture (GLUquadric* quad, GLboolean texture);
286 | extern GLint gluScaleImage (GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void *dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid* dataOut);
287 | extern void gluSphere (GLUquadric* quad, GLdouble radius, GLint slices, GLint stacks);
288 | extern void gluTessBeginContour (GLUtesselator* tess);
289 | extern void gluTessBeginPolygon (GLUtesselator* tess, GLvoid* data);
290 | extern void gluTessCallback (GLUtesselator* tess, GLenum which, GLvoid (*CallBackFunc)());
291 | extern void gluTessEndContour (GLUtesselator* tess);
292 | extern void gluTessEndPolygon (GLUtesselator* tess);
293 | extern void gluTessNormal (GLUtesselator* tess, GLdouble valueX, GLdouble valueY, GLdouble valueZ);
294 | extern void gluTessProperty (GLUtesselator* tess, GLenum which, GLdouble data);
295 | extern void gluTessVertex (GLUtesselator* tess, GLdouble *location, GLvoid* data);
296 | extern GLint gluUnProject (GLdouble winX, GLdouble winY, GLdouble winZ, const GLdouble *model, const GLdouble *proj, const GLint *view, GLdouble* objX, GLdouble* objY, GLdouble* objZ);
297 | extern GLint gluUnProject4 (GLdouble winX, GLdouble winY, GLdouble winZ, GLdouble clipW, const GLdouble *model, const GLdouble *proj, const GLint *view, GLdouble nearPlane, GLdouble farPlane, GLdouble* objX, GLdouble* objY, GLdouble* objZ, GLdouble* objW);
298 | 
299 | #ifdef __cplusplus
300 | }
301 | #endif
302 | 
303 | #endif /* __glu_h__ */
304 | 


--------------------------------------------------------------------------------
/glutbindings/glut.h:
--------------------------------------------------------------------------------
  1 | #ifndef __glut_h__
  2 | #define __glut_h__
  3 | 
  4 | /* Copyright (c) Mark J. Kilgard, 1994, 1995, 1996, 1998. */
  5 | 
  6 | /* This program is freely distributable without licensing fees  and is
  7 |    provided without guarantee or warrantee expressed or  implied. This
  8 |    program is -not- in the public domain. */
  9 | 
 10 | #if defined(_WIN32)
 11 | 
 12 | /* GLUT 3.7 now tries to avoid including <windows.h>
 13 |    to avoid name space pollution, but Win32's <GL/gl.h> 
 14 |    needs APIENTRY and WINGDIAPI defined properly. */
 15 | # if 0
 16 | #  define  WIN32_LEAN_AND_MEAN
 17 | #  include <windows.h>
 18 | # else
 19 |    /* XXX This is from Win32's <windef.h> */
 20 | #  ifndef APIENTRY
 21 | #   define GLUT_APIENTRY_DEFINED
 22 | #   if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED)
 23 | #    define APIENTRY    __stdcall
 24 | #   else
 25 | #    define APIENTRY
 26 | #   endif
 27 | #  endif
 28 |    /* XXX This is from Win32's <winnt.h> */
 29 | #  ifndef CALLBACK
 30 | #   if (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS)
 31 | #    define CALLBACK __stdcall
 32 | #   else
 33 | #    define CALLBACK
 34 | #   endif
 35 | #  endif
 36 |    /* XXX This is from Win32's <wingdi.h> and <winnt.h> */
 37 | #  ifndef WINGDIAPI
 38 | #   define GLUT_WINGDIAPI_DEFINED
 39 | #   define WINGDIAPI __declspec(dllimport)
 40 | #  endif
 41 |    /* XXX This is from Win32's <ctype.h> */
 42 | #  ifndef _WCHAR_T_DEFINED
 43 | typedef unsigned short wchar_t;
 44 | #   define _WCHAR_T_DEFINED
 45 | #  endif
 46 | # endif
 47 | 
 48 | #pragma comment (lib, "winmm.lib")     /* link with Windows MultiMedia lib */
 49 | #pragma comment (lib, "opengl32.lib")  /* link with Microsoft OpenGL lib */
 50 | #pragma comment (lib, "glu32.lib")     /* link with OpenGL Utility lib */
 51 | #pragma comment (lib, "glut32.lib")    /* link with Win32 GLUT lib */
 52 | 
 53 | #pragma warning (disable:4244)	/* Disable bogus conversion warnings. */
 54 | #pragma warning (disable:4305)  /* VC++ 5.0 version of above warning. */
 55 | 
 56 | #endif
 57 | 
 58 | #if defined(__APPLE__) || defined(MACOSX)
 59 | #include <OpenGL/gl.h>
 60 | #include <OpenGL/glu.h>
 61 | #else
 62 | #include <GL/gl.h>
 63 | #include <GL/glu.h>
 64 | #endif
 65 | 
 66 | /* define APIENTRY and CALLBACK to null string if we aren't on Win32 */
 67 | #if !defined(_WIN32)
 68 | #define APIENTRY
 69 | #define GLUT_APIENTRY_DEFINED
 70 | #define CALLBACK
 71 | #endif
 72 | 
 73 | #ifdef __cplusplus
 74 | extern "C" {
 75 | #endif
 76 | 
 77 | /**
 78 |  GLUT API revision history:
 79 |  
 80 |  GLUT_API_VERSION is updated to reflect incompatible GLUT
 81 |  API changes (interface changes, semantic changes, deletions,
 82 |  or additions).
 83 |  
 84 |  GLUT_API_VERSION=1  First public release of GLUT.  11/29/94
 85 | 
 86 |  GLUT_API_VERSION=2  Added support for OpenGL/GLX multisampling,
 87 |  extension.  Supports new input devices like tablet, dial and button
 88 |  box, and Spaceball.  Easy to query OpenGL extensions.
 89 | 
 90 |  GLUT_API_VERSION=3  glutMenuStatus added.
 91 | 
 92 |  GLUT_API_VERSION=4  glutInitDisplayString, glutWarpPointer,
 93 |  glutBitmapLength, glutStrokeLength, glutWindowStatusFunc, dynamic
 94 |  video resize subAPI, glutPostWindowRedisplay, glutKeyboardUpFunc,
 95 |  glutSpecialUpFunc, glutIgnoreKeyRepeat, glutSetKeyRepeat,
 96 |  glutJoystickFunc, glutForceJoystickFunc (NOT FINALIZED!).
 97 | 
 98 |  GLUT_API_VERSION=5  glutGetProcAddress (added by BrianP)
 99 | **/
100 | #ifndef GLUT_API_VERSION  /* allow this to be overriden */
101 | #define GLUT_API_VERSION		5
102 | #endif
103 | 
104 | /**
105 |  GLUT implementation revision history:
106 |  
107 |  GLUT_XLIB_IMPLEMENTATION is updated to reflect both GLUT
108 |  API revisions and implementation revisions (ie, bug fixes).
109 | 
110 |  GLUT_XLIB_IMPLEMENTATION=1  mjk's first public release of
111 |  GLUT Xlib-based implementation.  11/29/94
112 | 
113 |  GLUT_XLIB_IMPLEMENTATION=2  mjk's second public release of
114 |  GLUT Xlib-based implementation providing GLUT version 2 
115 |  interfaces.
116 | 
117 |  GLUT_XLIB_IMPLEMENTATION=3  mjk's GLUT 2.2 images. 4/17/95
118 | 
119 |  GLUT_XLIB_IMPLEMENTATION=4  mjk's GLUT 2.3 images. 6/?/95
120 | 
121 |  GLUT_XLIB_IMPLEMENTATION=5  mjk's GLUT 3.0 images. 10/?/95
122 | 
123 |  GLUT_XLIB_IMPLEMENTATION=7  mjk's GLUT 3.1+ with glutWarpPoitner.  7/24/96
124 | 
125 |  GLUT_XLIB_IMPLEMENTATION=8  mjk's GLUT 3.1+ with glutWarpPoitner
126 |  and video resize.  1/3/97
127 | 
128 |  GLUT_XLIB_IMPLEMENTATION=9 mjk's GLUT 3.4 release with early GLUT 4 routines.
129 | 
130 |  GLUT_XLIB_IMPLEMENTATION=11 Mesa 2.5's GLUT 3.6 release.
131 | 
132 |  GLUT_XLIB_IMPLEMENTATION=12 mjk's GLUT 3.6 release with early GLUT 4 routines + signal handling.
133 | 
134 |  GLUT_XLIB_IMPLEMENTATION=13 mjk's GLUT 3.7 beta with GameGLUT support.
135 | 
136 |  GLUT_XLIB_IMPLEMENTATION=14 mjk's GLUT 3.7 beta with f90gl friend interface.
137 | 
138 |  GLUT_XLIB_IMPLEMENTATION=15 mjk's GLUT 3.7 beta sync'ed with Mesa <GL/glut.h>
139 | **/
140 | #ifndef GLUT_XLIB_IMPLEMENTATION  /* Allow this to be overriden. */
141 | #define GLUT_XLIB_IMPLEMENTATION	15
142 | #endif
143 | 
144 | /**
145 |  MacOS X GLUT implementation revision history:
146 |  
147 |  GLUT_MACOSX_IMPLEMENTATION is updated to reflect MacOS X
148 |  specific GLUT API revisions and implementation revisions
149 |  (ie, bug fixes).
150 | 
151 |  GLUT_MACOSX_IMPLEMENTATION=1  glutSurfaceTexture.
152 | 
153 |  GLUT_MACOSX_IMPLEMENTATION=2  glutWMCloseFunc, glutCheckLoop.
154 | **/
155 | #ifndef GLUT_MACOSX_IMPLEMENTATION  /* Allow this to be overriden. */
156 | #define GLUT_MACOSX_IMPLEMENTATION	2
157 | #endif
158 | 
159 | /* Display mode bit masks. */
160 | #define GLUT_RGB			0
161 | #define GLUT_RGBA			GLUT_RGB
162 | #define GLUT_INDEX			1
163 | #define GLUT_SINGLE			0
164 | #define GLUT_DOUBLE			2
165 | #define GLUT_ACCUM			4
166 | #define GLUT_ALPHA			8
167 | #define GLUT_DEPTH			16
168 | #define GLUT_STENCIL			32
169 | #if (GLUT_API_VERSION >= 2)
170 | #define GLUT_MULTISAMPLE		128
171 | #define GLUT_STEREO			256
172 | #endif
173 | #if (GLUT_API_VERSION >= 3)
174 | #define GLUT_LUMINANCE			512
175 | #endif
176 | #define GLUT_NO_RECOVERY    1024
177 | 
178 | /* Mouse buttons. */
179 | #define GLUT_LEFT_BUTTON		0
180 | #define GLUT_MIDDLE_BUTTON		1
181 | #define GLUT_RIGHT_BUTTON		2
182 | 
183 | /* Mouse button  state. */
184 | #define GLUT_DOWN			0
185 | #define GLUT_UP				1
186 | 
187 | #if (GLUT_API_VERSION >= 2)
188 | /* function keys */
189 | #define GLUT_KEY_F1			1
190 | #define GLUT_KEY_F2			2
191 | #define GLUT_KEY_F3			3
192 | #define GLUT_KEY_F4			4
193 | #define GLUT_KEY_F5			5
194 | #define GLUT_KEY_F6			6
195 | #define GLUT_KEY_F7			7
196 | #define GLUT_KEY_F8			8
197 | #define GLUT_KEY_F9			9
198 | #define GLUT_KEY_F10			10
199 | #define GLUT_KEY_F11			11
200 | #define GLUT_KEY_F12			12
201 | /* directional keys */
202 | #define GLUT_KEY_LEFT			100
203 | #define GLUT_KEY_UP			101
204 | #define GLUT_KEY_RIGHT			102
205 | #define GLUT_KEY_DOWN			103
206 | #define GLUT_KEY_PAGE_UP		104
207 | #define GLUT_KEY_PAGE_DOWN		105
208 | #define GLUT_KEY_HOME			106
209 | #define GLUT_KEY_END			107
210 | #define GLUT_KEY_INSERT			108
211 | #endif
212 | 
213 | /* Entry/exit  state. */
214 | #define GLUT_LEFT			0
215 | #define GLUT_ENTERED			1
216 | 
217 | /* Menu usage  state. */
218 | #define GLUT_MENU_NOT_IN_USE		0
219 | #define GLUT_MENU_IN_USE		1
220 | 
221 | /* Visibility  state. */
222 | #define GLUT_NOT_VISIBLE		0
223 | #define GLUT_VISIBLE			1
224 | 
225 | /* Window status  state. */
226 | #define GLUT_HIDDEN			0
227 | #define GLUT_FULLY_RETAINED		1
228 | #define GLUT_PARTIALLY_RETAINED		2
229 | #define GLUT_FULLY_COVERED		3
230 | 
231 | /* Color index component selection values. */
232 | #define GLUT_RED			0
233 | #define GLUT_GREEN			1
234 | #define GLUT_BLUE			2
235 | 
236 | /* Layers for use. */
237 | #define GLUT_NORMAL			0
238 | #define GLUT_OVERLAY			1
239 | 
240 | #if defined(_WIN32)
241 | /* Stroke font constants (use these in GLUT program). */
242 | #define GLUT_STROKE_ROMAN		((void*)0)
243 | #define GLUT_STROKE_MONO_ROMAN		((void*)1)
244 | 
245 | /* Bitmap font constants (use these in GLUT program). */
246 | #define GLUT_BITMAP_9_BY_15		((void*)2)
247 | #define GLUT_BITMAP_8_BY_13		((void*)3)
248 | #define GLUT_BITMAP_TIMES_ROMAN_10	((void*)4)
249 | #define GLUT_BITMAP_TIMES_ROMAN_24	((void*)5)
250 | #if (GLUT_API_VERSION >= 3)
251 | #define GLUT_BITMAP_HELVETICA_10	((void*)6)
252 | #define GLUT_BITMAP_HELVETICA_12	((void*)7)
253 | #define GLUT_BITMAP_HELVETICA_18	((void*)8)
254 | #endif
255 | #else
256 | /* Stroke font opaque addresses (use constants instead in source code). */
257 | extern void *glutStrokeRoman;
258 | extern void *glutStrokeMonoRoman;
259 | 
260 | /* Stroke font constants (use these in GLUT program). */
261 | #define GLUT_STROKE_ROMAN		(&glutStrokeRoman)
262 | #define GLUT_STROKE_MONO_ROMAN		(&glutStrokeMonoRoman)
263 | 
264 | /* Bitmap font opaque addresses (use constants instead in source code). */
265 | extern void *glutBitmap9By15;
266 | extern void *glutBitmap8By13;
267 | extern void *glutBitmapTimesRoman10;
268 | extern void *glutBitmapTimesRoman24;
269 | extern void *glutBitmapHelvetica10;
270 | extern void *glutBitmapHelvetica12;
271 | extern void *glutBitmapHelvetica18;
272 | 
273 | /* Bitmap font constants (use these in GLUT program). */
274 | #define GLUT_BITMAP_9_BY_15		(&glutBitmap9By15)
275 | #define GLUT_BITMAP_8_BY_13		(&glutBitmap8By13)
276 | #define GLUT_BITMAP_TIMES_ROMAN_10	(&glutBitmapTimesRoman10)
277 | #define GLUT_BITMAP_TIMES_ROMAN_24	(&glutBitmapTimesRoman24)
278 | #if (GLUT_API_VERSION >= 3)
279 | #define GLUT_BITMAP_HELVETICA_10	(&glutBitmapHelvetica10)
280 | #define GLUT_BITMAP_HELVETICA_12	(&glutBitmapHelvetica12)
281 | #define GLUT_BITMAP_HELVETICA_18	(&glutBitmapHelvetica18)
282 | #endif
283 | #endif
284 | 
285 | /* glutGet parameters. */
286 | #define GLUT_WINDOW_X			100
287 | #define GLUT_WINDOW_Y			101
288 | #define GLUT_WINDOW_WIDTH		102
289 | #define GLUT_WINDOW_HEIGHT		103
290 | #define GLUT_WINDOW_BUFFER_SIZE		104
291 | #define GLUT_WINDOW_STENCIL_SIZE	105
292 | #define GLUT_WINDOW_DEPTH_SIZE		106
293 | #define GLUT_WINDOW_RED_SIZE		107
294 | #define GLUT_WINDOW_GREEN_SIZE		108
295 | #define GLUT_WINDOW_BLUE_SIZE		109
296 | #define GLUT_WINDOW_ALPHA_SIZE		110
297 | #define GLUT_WINDOW_ACCUM_RED_SIZE	111
298 | #define GLUT_WINDOW_ACCUM_GREEN_SIZE	112
299 | #define GLUT_WINDOW_ACCUM_BLUE_SIZE	113
300 | #define GLUT_WINDOW_ACCUM_ALPHA_SIZE	114
301 | #define GLUT_WINDOW_DOUBLEBUFFER	115
302 | #define GLUT_WINDOW_RGBA		116
303 | #define GLUT_WINDOW_PARENT		117
304 | #define GLUT_WINDOW_NUM_CHILDREN	118
305 | #define GLUT_WINDOW_COLORMAP_SIZE	119
306 | #if (GLUT_API_VERSION >= 2)
307 | #define GLUT_WINDOW_NUM_SAMPLES		120
308 | #define GLUT_WINDOW_STEREO		121
309 | #endif
310 | #if (GLUT_API_VERSION >= 3)
311 | #define GLUT_WINDOW_CURSOR		122
312 | #endif
313 | #define GLUT_SCREEN_WIDTH		200
314 | #define GLUT_SCREEN_HEIGHT		201
315 | #define GLUT_SCREEN_WIDTH_MM		202
316 | #define GLUT_SCREEN_HEIGHT_MM		203
317 | #define GLUT_MENU_NUM_ITEMS		300
318 | #define GLUT_DISPLAY_MODE_POSSIBLE	400
319 | #define GLUT_INIT_WINDOW_X		500
320 | #define GLUT_INIT_WINDOW_Y		501
321 | #define GLUT_INIT_WINDOW_WIDTH		502
322 | #define GLUT_INIT_WINDOW_HEIGHT		503
323 | #define GLUT_INIT_DISPLAY_MODE		504
324 | #if (GLUT_API_VERSION >= 2)
325 | #define GLUT_ELAPSED_TIME		700
326 | #endif
327 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13)
328 | #define GLUT_WINDOW_FORMAT_ID		123
329 | #endif
330 | 
331 | #if (GLUT_API_VERSION >= 2)
332 | /* glutDeviceGet parameters. */
333 | #define GLUT_HAS_KEYBOARD		600
334 | #define GLUT_HAS_MOUSE			601
335 | #define GLUT_HAS_SPACEBALL		602
336 | #define GLUT_HAS_DIAL_AND_BUTTON_BOX	603
337 | #define GLUT_HAS_TABLET			604
338 | #define GLUT_NUM_MOUSE_BUTTONS		605
339 | #define GLUT_NUM_SPACEBALL_BUTTONS	606
340 | #define GLUT_NUM_BUTTON_BOX_BUTTONS	607
341 | #define GLUT_NUM_DIALS			608
342 | #define GLUT_NUM_TABLET_BUTTONS		609
343 | #endif
344 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13)
345 | #define GLUT_DEVICE_IGNORE_KEY_REPEAT   610
346 | #define GLUT_DEVICE_KEY_REPEAT          611
347 | #define GLUT_HAS_JOYSTICK		612
348 | #define GLUT_OWNS_JOYSTICK		613
349 | #define GLUT_JOYSTICK_BUTTONS		614
350 | #define GLUT_JOYSTICK_AXES		615
351 | #define GLUT_JOYSTICK_POLL_RATE		616
352 | #endif
353 | 
354 | #if (GLUT_API_VERSION >= 3)
355 | /* glutLayerGet parameters. */
356 | #define GLUT_OVERLAY_POSSIBLE           800
357 | #define GLUT_LAYER_IN_USE		801
358 | #define GLUT_HAS_OVERLAY		802
359 | #define GLUT_TRANSPARENT_INDEX		803
360 | #define GLUT_NORMAL_DAMAGED		804
361 | #define GLUT_OVERLAY_DAMAGED		805
362 | 
363 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
364 | /* glutVideoResizeGet parameters. */
365 | #define GLUT_VIDEO_RESIZE_POSSIBLE	900
366 | #define GLUT_VIDEO_RESIZE_IN_USE	901
367 | #define GLUT_VIDEO_RESIZE_X_DELTA	902
368 | #define GLUT_VIDEO_RESIZE_Y_DELTA	903
369 | #define GLUT_VIDEO_RESIZE_WIDTH_DELTA	904
370 | #define GLUT_VIDEO_RESIZE_HEIGHT_DELTA	905
371 | #define GLUT_VIDEO_RESIZE_X		906
372 | #define GLUT_VIDEO_RESIZE_Y		907
373 | #define GLUT_VIDEO_RESIZE_WIDTH		908
374 | #define GLUT_VIDEO_RESIZE_HEIGHT	909
375 | #endif
376 | 
377 | /* glutUseLayer parameters. */
378 | #define GLUT_NORMAL			0
379 | #define GLUT_OVERLAY			1
380 | 
381 | /* glutGetModifiers return mask. */
382 | #define GLUT_ACTIVE_SHIFT               1
383 | #define GLUT_ACTIVE_CTRL                2
384 | #define GLUT_ACTIVE_ALT                 4
385 | 
386 | /* glutSetCursor parameters. */
387 | /* Basic arrows. */
388 | #define GLUT_CURSOR_RIGHT_ARROW		0
389 | #define GLUT_CURSOR_LEFT_ARROW		1
390 | /* Symbolic cursor shapes. */
391 | #define GLUT_CURSOR_INFO		2
392 | #define GLUT_CURSOR_DESTROY		3
393 | #define GLUT_CURSOR_HELP		4
394 | #define GLUT_CURSOR_CYCLE		5
395 | #define GLUT_CURSOR_SPRAY		6
396 | #define GLUT_CURSOR_WAIT		7
397 | #define GLUT_CURSOR_TEXT		8
398 | #define GLUT_CURSOR_CROSSHAIR		9
399 | /* Directional cursors. */
400 | #define GLUT_CURSOR_UP_DOWN		10
401 | #define GLUT_CURSOR_LEFT_RIGHT		11
402 | /* Sizing cursors. */
403 | #define GLUT_CURSOR_TOP_SIDE		12
404 | #define GLUT_CURSOR_BOTTOM_SIDE		13
405 | #define GLUT_CURSOR_LEFT_SIDE		14
406 | #define GLUT_CURSOR_RIGHT_SIDE		15
407 | #define GLUT_CURSOR_TOP_LEFT_CORNER	16
408 | #define GLUT_CURSOR_TOP_RIGHT_CORNER	17
409 | #define GLUT_CURSOR_BOTTOM_RIGHT_CORNER	18
410 | #define GLUT_CURSOR_BOTTOM_LEFT_CORNER	19
411 | /* Inherit from parent window. */
412 | #define GLUT_CURSOR_INHERIT		100
413 | /* Blank cursor. */
414 | #define GLUT_CURSOR_NONE		101
415 | /* Fullscreen crosshair (if available). */
416 | #define GLUT_CURSOR_FULL_CROSSHAIR	102
417 | #endif
418 | 
419 | /* GLUT initialization sub-API. */
420 | extern void APIENTRY glutInit(int *argcp, char **argv);
421 | extern void APIENTRY glutInitDisplayMode(unsigned int mode);
422 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
423 | extern void APIENTRY glutInitDisplayString(const char *string);
424 | #endif
425 | extern void APIENTRY glutInitWindowPosition(int x, int y);
426 | extern void APIENTRY glutInitWindowSize(int width, int height);
427 | extern void APIENTRY glutMainLoop(void);
428 | 
429 | /* GLUT window sub-API. */
430 | extern int APIENTRY glutCreateWindow(const char *title);
431 | extern int APIENTRY glutCreateSubWindow(int win, int x, int y, int width, int height);
432 | extern void APIENTRY glutDestroyWindow(int win);
433 | extern void APIENTRY glutPostRedisplay(void);
434 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 11)
435 | extern void APIENTRY glutPostWindowRedisplay(int win);
436 | #endif
437 | extern void APIENTRY glutSwapBuffers(void);
438 | extern int APIENTRY glutGetWindow(void);
439 | extern void APIENTRY glutSetWindow(int win);
440 | extern void APIENTRY glutSetWindowTitle(const char *title);
441 | extern void APIENTRY glutSetIconTitle(const char *title);
442 | extern void APIENTRY glutPositionWindow(int x, int y);
443 | extern void APIENTRY glutReshapeWindow(int width, int height);
444 | extern void APIENTRY glutPopWindow(void);
445 | extern void APIENTRY glutPushWindow(void);
446 | extern void APIENTRY glutIconifyWindow(void);
447 | extern void APIENTRY glutShowWindow(void);
448 | extern void APIENTRY glutHideWindow(void);
449 | #if (GLUT_API_VERSION >= 3)
450 | extern void APIENTRY glutFullScreen(void);
451 | extern void APIENTRY glutSetCursor(int cursor);
452 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
453 | extern void APIENTRY glutWarpPointer(int x, int y);
454 | #if (GLUT_MACOSX_IMPLEMENTATION >= 1)
455 | /* surface texturing API Mac OS X specific */
456 | extern void APIENTRY glutSurfaceTexture (GLenum target, GLenum internalformat, int surfacewin);
457 | #endif
458 | #if (GLUT_MACOSX_IMPLEMENTATION >= 2)
459 | /* Mac OS X specific API */
460 | extern void APIENTRY glutWMCloseFunc(void (*func)(void));
461 | extern void APIENTRY glutCheckLoop(void);
462 | #endif
463 | #endif
464 | 
465 | /* GLUT overlay sub-API. */
466 | extern void APIENTRY glutEstablishOverlay(void);
467 | extern void APIENTRY glutRemoveOverlay(void);
468 | extern void APIENTRY glutUseLayer(GLenum layer);
469 | extern void APIENTRY glutPostOverlayRedisplay(void);
470 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 11)
471 | extern void APIENTRY glutPostWindowOverlayRedisplay(int win);
472 | #endif
473 | extern void APIENTRY glutShowOverlay(void);
474 | extern void APIENTRY glutHideOverlay(void);
475 | #endif
476 | 
477 | /* GLUT menu sub-API. */
478 | extern int APIENTRY glutCreateMenu(void (*)(int));
479 | extern void APIENTRY glutDestroyMenu(int menu);
480 | extern int APIENTRY glutGetMenu(void);
481 | extern void APIENTRY glutSetMenu(int menu);
482 | extern void APIENTRY glutAddMenuEntry(const char *label, int value);
483 | extern void APIENTRY glutAddSubMenu(const char *label, int submenu);
484 | extern void APIENTRY glutChangeToMenuEntry(int item, const char *label, int value);
485 | extern void APIENTRY glutChangeToSubMenu(int item, const char *label, int submenu);
486 | extern void APIENTRY glutRemoveMenuItem(int item);
487 | extern void APIENTRY glutAttachMenu(int button);
488 | extern void APIENTRY glutDetachMenu(int button);
489 | 
490 | /* GLUT window callback sub-API. */
491 | extern void APIENTRY glutDisplayFunc(void (*func)(void));
492 | extern void APIENTRY glutReshapeFunc(void (*func)(int width, int height));
493 | extern void APIENTRY glutKeyboardFunc(void (*func)(unsigned char key, int x, int y));
494 | extern void APIENTRY glutMouseFunc(void (*func)(int button, int state, int x, int y));
495 | extern void APIENTRY glutMotionFunc(void (*func)(int x, int y));
496 | extern void APIENTRY glutPassiveMotionFunc(void (*func)(int x, int y));
497 | extern void APIENTRY glutEntryFunc(void (*func)(int state));
498 | extern void APIENTRY glutVisibilityFunc(void (*func)(int state));
499 | extern void APIENTRY glutIdleFunc(void (*func)(void));
500 | extern void APIENTRY glutTimerFunc(unsigned int millis, void (*func)(int value), int value);
501 | extern void APIENTRY glutMenuStateFunc(void (*func)(int state));
502 | #if (GLUT_API_VERSION >= 2)
503 | extern void APIENTRY glutSpecialFunc(void (*func)(int key, int x, int y));
504 | extern void APIENTRY glutSpaceballMotionFunc(void (*func)(int x, int y, int z));
505 | extern void APIENTRY glutSpaceballRotateFunc(void (*func)(int x, int y, int z));
506 | extern void APIENTRY glutSpaceballButtonFunc(void (*func)(int button, int state));
507 | extern void APIENTRY glutButtonBoxFunc(void (*func)(int button, int state));
508 | extern void APIENTRY glutDialsFunc(void (*func)(int dial, int value));
509 | extern void APIENTRY glutTabletMotionFunc(void (*func)(int x, int y));
510 | extern void APIENTRY glutTabletButtonFunc(void (*func)(int button, int state, int x, int y));
511 | #if (GLUT_API_VERSION >= 3)
512 | extern void APIENTRY glutMenuStatusFunc(void (*func)(int status, int x, int y));
513 | extern void APIENTRY glutOverlayDisplayFunc(void (*func)(void));
514 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
515 | extern void APIENTRY glutWindowStatusFunc(void (*func)(int state));
516 | #endif
517 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13)
518 | extern void APIENTRY glutKeyboardUpFunc(void (*func)(unsigned char key, int x, int y));
519 | extern void APIENTRY glutSpecialUpFunc(void (*func)(int key, int x, int y));
520 | extern void APIENTRY glutJoystickFunc(void (*func)(unsigned int buttonMask, int x, int y, int z), int pollInterval);
521 | #endif
522 | #endif
523 | #endif
524 | 
525 | /* GLUT color index sub-API. */
526 | extern void APIENTRY glutSetColor(int, GLfloat red, GLfloat green, GLfloat blue);
527 | extern GLfloat APIENTRY glutGetColor(int ndx, int component);
528 | extern void APIENTRY glutCopyColormap(int win);
529 | 
530 | /* GLUT state retrieval sub-API. */
531 | extern int APIENTRY glutGet(GLenum type);
532 | extern int APIENTRY glutDeviceGet(GLenum type);
533 | #if (GLUT_API_VERSION >= 2)
534 | /* GLUT extension support sub-API */
535 | extern int APIENTRY glutExtensionSupported(const char *name);
536 | #endif
537 | #if (GLUT_API_VERSION >= 3)
538 | extern int APIENTRY glutGetModifiers(void);
539 | extern int APIENTRY glutLayerGet(GLenum type);
540 | #endif
541 | #if (GLUT_API_VERSION >= 5)
542 | extern void * APIENTRY glutGetProcAddress(const char *procName);
543 | #endif
544 | 
545 | /* GLUT font sub-API */
546 | extern void APIENTRY glutBitmapCharacter(void *font, int character);
547 | extern int APIENTRY glutBitmapWidth(void *font, int character);
548 | extern void APIENTRY glutStrokeCharacter(void *font, int character);
549 | extern int APIENTRY glutStrokeWidth(void *font, int character);
550 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
551 | extern int APIENTRY glutBitmapLength(void *font, const unsigned char *string);
552 | extern int APIENTRY glutStrokeLength(void *font, const unsigned char *string);
553 | #endif
554 | 
555 | /* GLUT pre-built models sub-API */
556 | extern void APIENTRY glutWireSphere(GLdouble radius, GLint slices, GLint stacks);
557 | extern void APIENTRY glutSolidSphere(GLdouble radius, GLint slices, GLint stacks);
558 | extern void APIENTRY glutWireCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);
559 | extern void APIENTRY glutSolidCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);
560 | extern void APIENTRY glutWireCube(GLdouble size);
561 | extern void APIENTRY glutSolidCube(GLdouble size);
562 | extern void APIENTRY glutWireTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings);
563 | extern void APIENTRY glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings);
564 | extern void APIENTRY glutWireDodecahedron(void);
565 | extern void APIENTRY glutSolidDodecahedron(void);
566 | extern void APIENTRY glutWireTeapot(GLdouble size);
567 | extern void APIENTRY glutSolidTeapot(GLdouble size);
568 | extern void APIENTRY glutWireOctahedron(void);
569 | extern void APIENTRY glutSolidOctahedron(void);
570 | extern void APIENTRY glutWireTetrahedron(void);
571 | extern void APIENTRY glutSolidTetrahedron(void);
572 | extern void APIENTRY glutWireIcosahedron(void);
573 | extern void APIENTRY glutSolidIcosahedron(void);
574 | 
575 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
576 | /* GLUT video resize sub-API. */
577 | extern int APIENTRY glutVideoResizeGet(GLenum param);
578 | extern void APIENTRY glutSetupVideoResizing(void);
579 | extern void APIENTRY glutStopVideoResizing(void);
580 | extern void APIENTRY glutVideoResize(int x, int y, int width, int height);
581 | extern void APIENTRY glutVideoPan(int x, int y, int width, int height);
582 | 
583 | /* GLUT debugging sub-API. */
584 | extern void APIENTRY glutReportErrors(void);
585 | #endif
586 | 
587 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13)
588 | /* GLUT device control sub-API. */
589 | /* glutSetKeyRepeat modes. */
590 | #define GLUT_KEY_REPEAT_OFF		0
591 | #define GLUT_KEY_REPEAT_ON		1
592 | #define GLUT_KEY_REPEAT_DEFAULT		2
593 | 
594 | /* Joystick button masks. */
595 | #define GLUT_JOYSTICK_BUTTON_A		1
596 | #define GLUT_JOYSTICK_BUTTON_B		2
597 | #define GLUT_JOYSTICK_BUTTON_C		4
598 | #define GLUT_JOYSTICK_BUTTON_D		8
599 | 
600 | extern void APIENTRY glutIgnoreKeyRepeat(int ignore);
601 | extern void APIENTRY glutSetKeyRepeat(int repeatMode);
602 | extern void APIENTRY glutForceJoystickFunc(void);
603 | 
604 | /* GLUT game mode sub-API. */
605 | /* glutGameModeGet. */
606 | #define GLUT_GAME_MODE_ACTIVE           0
607 | #define GLUT_GAME_MODE_POSSIBLE         1
608 | #define GLUT_GAME_MODE_WIDTH            2
609 | #define GLUT_GAME_MODE_HEIGHT           3
610 | #define GLUT_GAME_MODE_PIXEL_DEPTH      4
611 | #define GLUT_GAME_MODE_REFRESH_RATE     5
612 | #define GLUT_GAME_MODE_DISPLAY_CHANGED  6
613 | 
614 | extern void APIENTRY glutGameModeString(const char *string);
615 | extern int APIENTRY glutEnterGameMode(void);
616 | extern void APIENTRY glutLeaveGameMode(void);
617 | extern int APIENTRY glutGameModeGet(GLenum mode);
618 | #endif
619 | 
620 | #ifdef __cplusplus
621 | }
622 | 
623 | #endif
624 | 
625 | #ifdef GLUT_APIENTRY_DEFINED
626 | # undef GLUT_APIENTRY_DEFINED
627 | # undef APIENTRY
628 | #endif
629 | 
630 | #ifdef GLUT_WINGDIAPI_DEFINED
631 | # undef GLUT_WINGDIAPI_DEFINED
632 | # undef WINGDIAPI
633 | #endif
634 | 
635 | #endif                  /* __glut_h__ */
636 | 


--------------------------------------------------------------------------------