superCoderDOM
diff --git a/‎doc/gpu.md‎
Lines changed: 85 additions & 3 deletions b/‎doc/gpu.md‎
Lines changed: 85 additions & 3 deletions
diff --git a/‎pythonjs/ast_utils.py‎
Lines changed: 6 additions & 2 deletions b/‎pythonjs/ast_utils.py‎
Lines changed: 6 additions & 2 deletions
@@ -10,6 +10,7 @@ micro language:
 	. basic math ops and logic: if, elif, else, for i in range(n)
 	. list of lists iteration with dynamic size
 	. iterate over list of structs (dicts)
+	. simple classes
 
 	. define GPU `main` function with input arguments and subroutines
 		. `gpu.main` can take arguments typed as: int, float, and float*
@@ -235,15 +236,17 @@ list of dicts
 Use the for-iter loop to iterate over a list of dicts `for s in iter(A):`
 Regular JavaScript objects and Python dicts are uploaded to the shader as GLSL structs.
 The struct type name and GLSL code are generated at runtime based on the contents of
-each dict.  A struct may contain: floats and array of floats attributes.
+each dict.  A struct may contain: ints, floats and array of floats attributes.
+To use an integer value wrap it in a Int16Array with a single item,
+or call `int16(n)` which takes care of that for you.
 
 ```
 class myclass:
 
 	def new_struct(self, g):
 		return {
 			'attr1' : 0.6 + g,
-			'attr2' : 0.4 + g
+			'attr2' : int16(g)
 		}
 
 
@@ -256,7 +259,7 @@ class myclass:
 			struct* A = self.array
 			float b = 0.0
 			for s in iter(A):
-				b += s.attr1 + s.attr2
+				b += s.attr1 + float(s.attr2)
 			return b
 
 		return gpufunc()
@@ -266,6 +269,7 @@ class myclass:
 external method calls
 ---------------------
 Methods on external objects can be called within the shader function.
+This is useful for getting runtime data that is loop invariant.
 
 ```
 class myclass:
@@ -291,4 +295,82 @@ def main():
 	m = myclass(10)
 	r = m.run(64)
 
+```
+
+user defined classes
+-------
+A class decorated with `@gpu.object` will have its methods marked with `@gpu.method` translated into shader code.  GPU methods must be defined in use order, a method is defined before it is used by another method.  Recursive calls are not allowed.
+
+
+```
+@gpu.object
+class MyObject:
+	@gpu.method
+	float def subroutine(self, x,y):
+		float x
+		float y
+		return x + y * self.attr2
+
+	@gpu.method
+	float def mymethod(self, x,y):
+		float x
+		float y
+		if self.index == 0:
+			return -20.5
+		elif self.index == 0:
+			return 0.6
+		else:
+			return self.subroutine(x,y) * self.attr1
+
+	def __init__(self, a, b, i):
+		self.attr1 = a
+		self.attr2 = b
+		self.index = int16(i)
+
+
+class myclass:
+	def run(self, w):
+		self.array = [ MyObject( 1.1, 1.2, x ) for x in range(w) ]
+
+		@returns( array=64 )
+		@gpu.main
+		def gpufunc():
+			struct* A = self.array
+			float b = 0.0
+
+			for s in iter(A):
+				b += s.mymethod(1.1, 2.2)
+
+			return b
+
+		return gpufunc()
+
+```
+
+external type conversion
+------------------------
+@gpu.object classes can also contain sub-structures and GLSL types: `vec3`.
+To define a sub structure call the `gpu.object(class, name)` function.
+The example below types THREE.js Vector3 as a GLSL `vec` type.
+
+```
+import three
+gpu.object( three.Vector3, 'vec3' )
+
+```
+
+Then when a `three.Vector3` is assigned to an attribute in the __init__ function of the @gpu.object
+class it will be inlined into the shader as a `vec3`.
+
+```
+@gpu.object
+class MyObject:
+	def __init__(self, x,y,z, a,b,c):
+		self.vec1 = new( three.Vector3(x,y,z) )
+		self.vec2 = new( three.Vector3(a,b,c) )
+
+	@gpu.method
+	float def mymethod(self):
+		return self.vec1.x + self.vec2.y
+
 ```
@@ -64,9 +64,13 @@ def retrieve_vars(body):
 					pass  ## skips assignment to an attribute `a.x = y`
 
 			if user_typedef:  ## `int x`
-				if not isinstance(n.value, ast.Name):
+				if  isinstance(n.value, ast.Name):
+					local_vars.add( '%s=%s' %(user_typedef, n.value.id))
+				elif isinstance(n.value, ast.Num):
+					local_vars.add( '%s=%s' %(user_typedef, n.value.n))
+				else:
 					raise SyntaxError(n.value)
-				local_vars.add( '%s=%s' %(user_typedef, n.value.id))
+
 
 		elif isinstance(n, ast.Global):
 			global_vars.update( n.names )