__NULL_OBJECT__ = Object.create(null);

__WEBWORKER__ = false;

__NODEJS__ = false;

__BROWSER__ = false;

if (( typeof(process) ) != "undefined") {

__NODEJS__ = true;

}

if (( typeof(window) ) != "undefined") {

__BROWSER__ = true;

}

if (( typeof(importScripts) ) == "function") {

__WEBWORKER__ = true;

}

__create_array__ = function() {

"Used to fix a bug/feature of Javascript where new Array(number)\n created a array with number of undefined elements which is not\n what we want";

var i,array;

array = [];

i = 0;

while (( i ) < arguments.length) {

array.push(arguments[i]);

i += 1;

}

return array;

}

__get__ = function(object, attribute, error_message) {

"Retrieve an attribute, method, property, or wrapper function.\n\n method are actually functions which are converted to methods by\n prepending their arguments with the current object. Properties are\n not functions!\n\n DOM support:\n http://stackoverflow.com/questions/14202699/document-createelement-not-working\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof\n\n Direct JavaScript Calls:\n if an external javascript function is found, and it was not a wrapper that was generated here,\n check the function for a 'cached_wrapper' attribute, if none is found then generate a new\n wrapper, cache it on the function, and return the wrapper.\n ";

if (( object ) === null) {

if (error_message) {

throw new AttributeError(("(`null` has no attributes) " + error_message));

} else {

throw new AttributeError(("null object (None) has no attribute: " + attribute));

}

} else {

if (( object ) === undefined) {

if (error_message) {

throw new AttributeError(("(`undefined` has no attributes) " + error_message));

} else {

throw new AttributeError(("undefined has no attribute: " + attribute));

}

}

}

if (( attribute ) == "__call__") {

if (object.pythonscript_function || object.is_wrapper) {

return object;

} else {

if (object.cached_wrapper) {

return object.cached_wrapper;

} else {

if ({}.toString.call(object) === '[object Function]') {

var wrapper = function(args, kwargs) {

var i,arg,keys;

if (( args ) != null) {

i = 0;

while (( i ) < args.length) {

arg = args[i];

if (arg && ( typeof(arg) ) == "object") {

if (arg.jsify) {

args[i] = arg.jsify();

}

}

i += 1;

}

}

if (( kwargs ) != null) {

keys = __object_keys__(kwargs);

if (( keys.length ) != 0) {

args.push(kwargs);

i = 0;

while (( i ) < keys.length) {

arg = kwargs[keys[i]];

if (arg && ( typeof(arg) ) == "object") {

if (arg.jsify) {

kwargs[keys[i]] = arg.jsify();

}

}

i += 1;

}

}

}

return object.apply(null, args);

}

wrapper.is_wrapper = true;

object.cached_wrapper = wrapper;

return wrapper;

}

}

}

}

if (Object.hasOwnProperty.call(object, "__getattribute__")) {

return object.__getattribute__(attribute);

}

var attr;

attr = object[attribute];

if (( __NODEJS__ ) === false && ( __WEBWORKER__ ) === false) {

if (object instanceof HTMLDocument) {

if (typeof(attr) === 'function') {

var wrapper = function(args, kwargs) {

return attr.apply(object, args);

}

wrapper.is_wrapper = true;

return wrapper;

} else {

return attr;

}

} else {

if (object instanceof HTMLElement) {

if (typeof(attr) === 'function') {

var wrapper = function(args, kwargs) {

return attr.apply(object, args);

}

wrapper.is_wrapper = true;

return wrapper;

} else {

return attr;

}

}

}

}

if (( attr ) !== undefined) {

if (( typeof(attr) ) == "function") {

if (attr.pythonscript_function === undefined && attr.is_wrapper === undefined) {

if (attr.prototype instanceof Object && ( Object.keys(attr.prototype).length ) > 0) {

return attr;

}

var wrapper = function(args, kwargs) {

var i,arg,keys;

if (( args ) != null) {

i = 0;

while (( i ) < args.length) {

arg = args[i];

if (arg && ( typeof(arg) ) == "object") {

if (arg.jsify) {

args[i] = arg.jsify();

}

}

i += 1;

}

}

if (( kwargs ) != null) {

keys = __object_keys__(kwargs);

if (( keys.length ) != 0) {

args.push(kwargs);

i = 0;

while (( i ) < keys.length) {

arg = kwargs[keys[i]];

if (arg && ( typeof(arg) ) == "object") {

if (arg.jsify) {

kwargs[keys[i]] = arg.jsify();

}

}

i += 1;

}

}

}

return attr.apply(object, args);

}

wrapper.is_wrapper = true;

wrapper.wrapped = attr;

return wrapper;

} else {

if (attr.is_classmethod) {

var method = function() {

var args;

args = Array.prototype.slice.call(arguments);

if (args[0] instanceof Array && {}.toString.call(args[1]) === '[object Object]' && ( args.length ) == 2) {

/*pass*/

} else {

args = [args, {}];

}

if (object.__class__) {

args[0].splice(0, 0, object.__class__);

} else {

args[0].splice(0, 0, object);

}

return attr.apply(this, args);

}

method.is_wrapper = true;

object[attribute] = method;

return method;

} else {

return attr;

}

}

} else {

return attr;

}

}

var __class__,bases;

__class__ = object.__class__;

if (__class__) {

if (( attribute ) in __class__.__properties__) {

return __class__.__properties__[attribute]["get"]([object], {});

}

if (( attribute ) in __class__.__unbound_methods__) {

attr = __class__.__unbound_methods__[attribute];

if (attr.fastdef) {

var method = function(args, kwargs) {

if (arguments && arguments[0]) {

arguments[0].splice(0, 0, object);

return attr.apply(this, arguments);

} else {

return attr([object], { });

}

}

} else {

var method = function(args, kwargs) {

if (( arguments.length ) == 0) {

return attr([object], __NULL_OBJECT__);

} else {

if (args instanceof Array && ( typeof(kwargs) ) === "object" && ( arguments.length ) == 2) {

args.splice(0, 0, object);

if (( kwargs ) === undefined) {

return attr(args, __NULL_OBJECT__);

} else {

return attr(args, kwargs);

}

} else {

args = Array.prototype.slice.call(arguments);

args.splice(0, 0, object);

args = [args, __NULL_OBJECT__];

return attr.apply(this, args);

}

}

}

}

method.is_wrapper = true;

object[attribute] = method;

return method;

}

attr = __class__[attribute];

if (( attribute ) in __class__) {

if ({}.toString.call(attr) === '[object Function]') {

if (attr.is_wrapper) {

return attr;

} else {

if (attr.fastdef) {

var method = function(args, kwargs) {

if (arguments && arguments[0]) {

arguments[0].splice(0, 0, object);

return attr.apply(this, arguments);

} else {

return attr([object], { });

}

}

} else {

var method = function(args, kwargs) {

if (( arguments.length ) == 0) {

return attr([object], __NULL_OBJECT__);

} else {

if (args instanceof Array && ( typeof(kwargs) ) === "object" && ( arguments.length ) == 2) {

args.splice(0, 0, object);

if (( kwargs ) === undefined) {

return attr(args, __NULL_OBJECT__);

} else {

return attr(args, kwargs);

}

} else {

args = Array.prototype.slice.call(arguments);

args.splice(0, 0, object);

args = [args, __NULL_OBJECT__];

return attr.apply(this, args);

}

}

}

}

}

method.is_wrapper = true;

object[attribute] = method;

return method;

} else {

return attr;

}

}

bases = __class__.__bases__;

var __iter1 = bases;

if (! (__iter1 instanceof Array || typeof __iter1 == "string" || __is_typed_array(__iter1) || __is_some_array(__iter1) )) { __iter1 = __object_keys__(__iter1) }

for (var __idx1=0; __idx1 < __iter1.length; __idx1++) {

var base = __iter1[ __idx1 ];

attr = _get_upstream_attribute(base, attribute);

if (( attr ) !== undefined) {

if ({}.toString.call(attr) === '[object Function]') {

if (attr.fastdef) {

var method = function(args, kwargs) {

if (arguments && arguments[0]) {

arguments[0].splice(0, 0, object);

return attr.apply(this, arguments);

} else {

return attr([object], { });

}

}

} else {

var method = function(args, kwargs) {

if (( arguments.length ) == 0) {

return attr([object], __NULL_OBJECT__);

} else {

if (args instanceof Array && ( typeof(kwargs) ) === "object" && ( arguments.length ) == 2) {

args.splice(0, 0, object);

if (( kwargs ) === undefined) {

return attr(args, __NULL_OBJECT__);

} else {

return attr(args, kwargs);

}

} else {

args = Array.prototype.slice.call(arguments);

args.splice(0, 0, object);

args = [args, __NULL_OBJECT__];

return attr.apply(this, args);

}

}

}

}

method.is_wrapper = true;

object[attribute] = method;

return method;

} else {

return attr;

}

}

}

var __iter2 = bases;

if (! (__iter2 instanceof Array || typeof __iter2 == "string" || __is_typed_array(__iter2) || __is_some_array(__iter2) )) { __iter2 = __object_keys__(__iter2) }

for (var __idx2=0; __idx2 < __iter2.length; __idx2++) {

var base = __iter2[ __idx2 ];

var prop;

prop = _get_upstream_property(base, attribute);

if (( prop ) !== undefined) {

return prop["get"]([object], {});

}

}

if (( "__getattr__" ) in __class__) {

return __class__["__getattr__"]([object, attribute], {});

}

var __iter3 = bases;

if (! (__iter3 instanceof Array || typeof __iter3 == "string" || __is_typed_array(__iter3) || __is_some_array(__iter3) )) { __iter3 = __object_keys__(__iter3) }

for (var __idx3=0; __idx3 < __iter3.length; __idx3++) {

var base = __iter3[ __idx3 ];

var f;

f = _get_upstream_attribute(base, "__getattr__");

if (( f ) !== undefined) {

return f([object, attribute], {});

}

}

}

if (( attribute ) == "__getitem__") {

var wrapper = function(args, kwargs) {

return object[args[0]];

}

wrapper.is_wrapper = true;

return wrapper;

} else {

if (( attribute ) == "__setitem__") {

var wrapper = function(args, kwargs) {

object[args[0]] = args[1];

}

wrapper.is_wrapper = true;

return wrapper;

}

}

if (typeof(object, "function") && object.is_wrapper) {

return object.wrapped[attribute];

}

if (( attribute ) == "__iter__" && object instanceof Object) {

var wrapper = function(args, kwargs) {

return new __ArrayIterator(Object.keys(object), 0);

}

wrapper.is_wrapper = true;

return wrapper;

}

if (( attribute ) == "__contains__" && object instanceof Object) {

var wrapper = function(args, kwargs) {

return ( Object.keys(object).indexOf(args[0]) ) != -1;

}

wrapper.is_wrapper = true;

return wrapper;

}

if (( attr ) === undefined) {

if (error_message) {

throw new AttributeError(error_message);

} else {

throw new AttributeError(attribute);

}

} else {

return attr;

}

}

_get_upstream_attribute = function(base, attr) {

if (( attr ) in base) {

return base[attr];

}

var __iter4 = base.__bases__;

if (! (__iter4 instanceof Array || typeof __iter4 == "string" || __is_typed_array(__iter4) || __is_some_array(__iter4) )) { __iter4 = __object_keys__(__iter4) }

for (var __idx4=0; __idx4 < __iter4.length; __idx4++) {

var parent = __iter4[ __idx4 ];

return _get_upstream_attribute(parent, attr);

}

}

_get_upstream_property = function(base, attr) {

if (( attr ) in base.__properties__) {

return base.__properties__[attr];

}

var __iter5 = base.__bases__;

if (! (__iter5 instanceof Array || typeof __iter5 == "string" || __is_typed_array(__iter5) || __is_some_array(__iter5) )) { __iter5 = __object_keys__(__iter5) }

for (var __idx5=0; __idx5 < __iter5.length; __idx5++) {

var parent = __iter5[ __idx5 ];

return _get_upstream_property(parent, attr);

}

}

__set__ = function(object, attribute, value) {

"\n __setattr__ is always called when an attribute is set,\n unlike __getattr__ that only triggers when an attribute is not found,\n this asymmetry is in fact part of the Python spec.\n note there is no __setattribute__\n\n In normal Python a property setter is not called before __setattr__,\n this is bad language design because the user has been more explicit\n in having the property setter.\n\n In PythonJS, property setters are called instead of __setattr__.\n ";

if (( "__class__" ) in object && ( object.__class__.__setters__.indexOf(attribute) ) != -1) {

object[attribute] = value;

} else {

if (( "__setattr__" ) in object) {

object.__setattr__(attribute, value);

} else {

object[attribute] = value;

}

}

}

__getargs__ = function(func_name, signature, args, kwargs) {

"Based on ``signature`` and ``args``, ``kwargs`` parameters retrieve\n the actual parameters.\n\n This will set default keyword arguments and retrieve positional arguments\n in kwargs if their called as such";

if (( args ) === null) {

args = [];

}

if (( kwargs ) === null) {

kwargs = { };

}

out = { };

if (( args.length ) > signature.args.length) {

if (signature.vararg) {

/*pass*/

} else {

console.log(("Error in function->" + func_name));

console.log("args:", args, "kwargs:", kwargs, "sig:", signature);

throw new TypeError("Supplemental positional arguments provided but signature doesn't accept them");

}

}

j = 0;

while (( j ) < signature.args.length) {

name = signature.args[j];

if (( name ) in kwargs) {

out[name] = kwargs[name];

} else {

if (( j ) < args.length) {

out[name] = args[j];

} else {

if (( name ) in signature.kwargs) {

out[name] = signature.kwargs[name];

}

}

}

j += 1;

}

args = args.slice(j);

if (signature.vararg) {

out[signature.vararg] = args;

}

if (signature.varkwarg) {

out[signature.varkwarg] = kwargs;

}

return out;

}

try {

/*pass*/

} catch(__exception__) {

console.trace();

console.error(__exception__, __exception__.message);

console.error("line 4: pythonjs.configure( runtime_exceptions=False )");

throw new RuntimeError("line 4: pythonjs.configure( runtime_exceptions=False )");

}

_PythonJS_UID = 0;

IndexError = function(msg) {this.message = msg || "";}; IndexError.prototype = Object.create(Error.prototype); IndexError.prototype.name = "IndexError";

KeyError = function(msg) {this.message = msg || "";}; KeyError.prototype = Object.create(Error.prototype); KeyError.prototype.name = "KeyError";

ValueError = function(msg) {this.message = msg || "";}; ValueError.prototype = Object.create(Error.prototype); ValueError.prototype.name = "ValueError";

AttributeError = function(msg) {this.message = msg || "";}; AttributeError.prototype = Object.create(Error.prototype);AttributeError.prototype.name = "AttributeError";

RuntimeError = function(msg) {this.message = msg || "";}; RuntimeError.prototype = Object.create(Error.prototype);RuntimeError.prototype.name = "RuntimeError";

__gpu_object = function(cls, struct_name, data_name) {

cls.prototype.__struct_name__ = struct_name;

cls.prototype.__struct_data__ = data_name;

}

gpu = { "object":__gpu_object };

glsljit_runtime = function(header) {

return new GLSLJITRuntime(header);

}

GLSLJITRuntime = function(header) {

GLSLJITRuntime.__init__(this, header);

this.__class__ = GLSLJITRuntime;

this.__uid__ = ("" + _PythonJS_UID);

_PythonJS_UID += 1;

}

GLSLJITRuntime.__uid__ = ("" + _PythonJS_UID);

_PythonJS_UID += 1;

GLSLJITRuntime.prototype.__init__ = function(header) {

this.header = header;

this.shader = [];

this.object_packagers = [];

this.struct_types = __jsdict([]);

this.glsltypes = ["vec2", "vec3", "vec4", "mat4"];

this.matrices = [];

}

GLSLJITRuntime.__init__ = function () { return GLSLJITRuntime.prototype.__init__.apply(arguments[0], Array.prototype.slice.call(arguments,1)) };

GLSLJITRuntime.prototype.compile_header = function() {

var a,b;

a = [];

var __iter1 = this.struct_types;

if (! (__iter1 instanceof Array || typeof __iter1 == "string" || __is_typed_array(__iter1) || __is_some_array(__iter1) )) { __iter1 = __object_keys__(__iter1) }

for (var __idx1=0; __idx1 < __iter1.length; __idx1++) {

var sname = __iter1[ __idx1 ];

if (__contains__(this.glsltypes, sname)) {

/*pass*/

} else {

a.push(this.struct_types[sname]["code"]);

}

}

a.push(__sprintf("int matrix_index() { return int(get_global_id().y*%s.0); }", this.matrices.length));

a.push("int matrix_row() { return int(get_global_id().x*4.0); }");

a = "\n".join(a);

b = "\n".join(this.header);

return "\n".join([a, b]);

}

GLSLJITRuntime.compile_header = function () { return GLSLJITRuntime.prototype.compile_header.apply(arguments[0], Array.prototype.slice.call(arguments,1)) };

GLSLJITRuntime.prototype.compile_main = function() {

return "\n".join(this.shader);

}

GLSLJITRuntime.compile_main = function () { return GLSLJITRuntime.prototype.compile_main.apply(arguments[0], Array.prototype.slice.call(arguments,1)) };

GLSLJITRuntime.prototype.push = function(s) {

this.shader.push(s);

}

GLSLJITRuntime.push = function () { return GLSLJITRuntime.prototype.push.apply(arguments[0], Array.prototype.slice.call(arguments,1)) };

GLSLJITRuntime.prototype.define_structure = function(ob) {

var integers,arr,code,struct_name,struct_type,member_list,subtype,t,members,arrays,structs,floats;

struct_name = null;

if (__test_if_true__(ob.__struct_name__)) {

struct_name = ob.__struct_name__;

if (__contains__(this.struct_types, struct_name)) {

return struct_name;

}

}

arrays = [];

floats = [];

integers = [];

structs = [];

struct_type = [];

if (__test_if_true__(struct_name && __contains__(this.glsltypes, struct_name))) {

return struct_name;

}

var __iter2 = dir(ob);

if (! (__iter2 instanceof Array || typeof __iter2 == "string" || __is_typed_array(__iter2) || __is_some_array(__iter2) )) { __iter2 = __object_keys__(__iter2) }

for (var __idx2=0; __idx2 < __iter2.length; __idx2++) {

var key = __iter2[ __idx2 ];

if (__test_if_true__(( key.length ) == 1 && __contains__("0123456789", key))) {

throw new RuntimeError(key);

}

t = typeof(ob[key]);

if (__test_if_true__(( t ) == "object" && ob[key] instanceof Array && ob[key].length && ( typeof(ob[key][0]) ) == "number")) {

struct_type.push(("ARY_" + key));

arrays.push(key);

} else {

if (( t ) == "number") {

struct_type.push(("NUM_" + key));

floats.push(key);

} else {

if (__test_if_true__(ob[key] instanceof Int16Array)) {

struct_type.push(("INT_" + key));

if (( ob[key].length ) == 1) {

integers.push(key);

} else {

/*pass*/

}

} else {

if (__test_if_true__(( t ) == "object" && ob[key].__struct_name__)) {

struct_type.push(("S_" + key));

structs.push(key);

if (! (__contains__(this.struct_types, ob[key].__struct_name__))) {

if (__contains__(this.glsltypes, ob[key].__struct_name__)) {

/*pass*/

} else {

this.define_structure(ob[key]);

}

}

}

}

}

}

}

if (( struct_name ) === null) {

struct_name = "".join(struct_type);

ob.__struct_name__ = struct_name;

}

if (! (__contains__(this.struct_types, struct_name))) {

member_list = [];

var __iter3 = integers;

if (! (__iter3 instanceof Array || typeof __iter3 == "string" || __is_typed_array(__iter3) || __is_some_array(__iter3) )) { __iter3 = __object_keys__(__iter3) }

for (var __idx3=0; __idx3 < __iter3.length; __idx3++) {

var key = __iter3[ __idx3 ];

member_list.append((("int " + key) + ";"));

}

var __iter4 = floats;

if (! (__iter4 instanceof Array || typeof __iter4 == "string" || __is_typed_array(__iter4) || __is_some_array(__iter4) )) { __iter4 = __object_keys__(__iter4) }

for (var __idx4=0; __idx4 < __iter4.length; __idx4++) {

var key = __iter4[ __idx4 ];

member_list.append((("float " + key) + ";"));

}

var __iter5 = arrays;

if (! (__iter5 instanceof Array || typeof __iter5 == "string" || __is_typed_array(__iter5) || __is_some_array(__iter5) )) { __iter5 = __object_keys__(__iter5) }

for (var __idx5=0; __idx5 < __iter5.length; __idx5++) {

var key = __iter5[ __idx5 ];

arr = ob[key];

member_list.append((((("float " + key) + "[") + arr.length) + "];"));

}

var __iter6 = structs;

if (! (__iter6 instanceof Array || typeof __iter6 == "string" || __is_typed_array(__iter6) || __is_some_array(__iter6) )) { __iter6 = __object_keys__(__iter6) }

for (var __idx6=0; __idx6 < __iter6.length; __idx6++) {

var key = __iter6[ __idx6 ];

subtype = ob[key].__struct_name__;

member_list.append((((subtype + " ") + key) + ";"));

}

if (( len(member_list) ) == 0) {

throw new RuntimeError(struct_name);

}

members = "".join(member_list);

code = (((("struct " + struct_name) + " {") + members) + "};");

this.struct_types[struct_name] = __jsdict([["arrays", arrays], ["floats", floats], ["integers", integers], ["structs", structs], ["code", code]]);

}

return struct_name;

}

GLSLJITRuntime.define_structure = function () { return GLSLJITRuntime.prototype.define_structure.apply(arguments[0], Array.prototype.slice.call(arguments,1)) };

GLSLJITRuntime.prototype.structure = function(ob, name) {

var sname,args,o,wrapper,value,aname,stype;

wrapper = null;

if (__test_if_true__(ob instanceof Object)) {

/*pass*/

} else {

if (( ob.__class__ ) === dict) {

wrapper = ob;

ob = ob["$wrapped"];

}

}

sname = this.define_structure(ob);

if (__test_if_true__(wrapper)) {

wrapper.__struct_name__ = sname;

}

args = [];

stype = this.struct_types[sname];

if (! (__contains__(this.struct_types, sname))) {

if (__contains__(this.glsltypes, sname)) {

if (( sname ) == "mat4") {

if (__test_if_true__(ob.__struct_data__)) {

o = ob[ob.__struct_data__];

} else {

o = ob;

}

var i,i__end__;

i = 0;

i__end__ = o.length;

while (( i ) < i__end__) {

value = (o[i] + "");

if (! (__contains__(value, "."))) {

value += ".0";

}

args.push(value);

i += 1;

}

}

} else {

throw new RuntimeError(("no method to pack structure: " + sname));

}

}

if (__test_if_true__(stype)) {

var __iter7 = stype["integers"];

if (! (__iter7 instanceof Array || typeof __iter7 == "string" || __is_typed_array(__iter7) || __is_some_array(__iter7) )) { __iter7 = __object_keys__(__iter7) }

for (var __idx7=0; __idx7 < __iter7.length; __idx7++) {

var key = __iter7[ __idx7 ];

args.push((ob[key][0] + ""));

}

var __iter8 = stype["floats"];

if (! (__iter8 instanceof Array || typeof __iter8 == "string" || __is_typed_array(__iter8) || __is_some_array(__iter8) )) { __iter8 = __object_keys__(__iter8) }

for (var __idx8=0; __idx8 < __iter8.length; __idx8++) {

var key = __iter8[ __idx8 ];

value = (ob[key] + "");

if (! (__contains__(value, "."))) {

value += ".0";

}

args.push(value);

}

var __iter9 = stype["arrays"];

if (! (__iter9 instanceof Array || typeof __iter9 == "string" || __is_typed_array(__iter9) || __is_some_array(__iter9) )) { __iter9 = __object_keys__(__iter9) }

for (var __idx9=0; __idx9 < __iter9.length; __idx9++) {

var key = __iter9[ __idx9 ];

aname = (("_" + key) + name);

this.array(ob[key], aname);

args.push(aname);

}

var __iter10 = stype["structs"];

if (! (__iter10 instanceof Array || typeof __iter10 == "string" || __is_typed_array(__iter10) || __is_some_array(__iter10) )) { __iter10 = __object_keys__(__iter10) }

for (var __idx10=0; __idx10 < __iter10.length; __idx10++) {

var key = __iter10[ __idx10 ];

aname = (("_" + key) + name);

this.structure(ob[key], aname);

args.push(aname);

}

}

args = ",".join(args);

this.shader.push((((((((sname + " ") + name) + "=") + sname) + "(") + args) + ");"));

}

GLSLJITRuntime.structure = function () { return GLSLJITRuntime.prototype.structure.apply(arguments[0], Array.prototype.slice.call(arguments,1)) };

GLSLJITRuntime.prototype.int16array = function(ob, name) {

var a,i;

a = [(((("int " + name) + "[") + ob.length) + "]")];

i = 0;

while (( i ) < ob.length) {

a.push((((((";" + name) + "[") + i) + "]=") + ob[i]));

i += 1;

}

this.shader.push("".join(a));

}

GLSLJITRuntime.int16array = function () { return GLSLJITRuntime.prototype.int16array.apply(arguments[0], Array.prototype.slice.call(arguments,1)) };

GLSLJITRuntime.prototype.array = function(ob, name) {

var a,i,j,subname,subarr,v;

if (__test_if_true__(ob[0] instanceof Array)) {

a = [];

i = 0;

while (( i ) < ob.length) {

subarr = ob[i];

subname = __sprintf("%s_%s", [name, i]);

if (( a.length ) == 0) {

a.append((((("float " + subname) + "[") + subarr.length) + "]"));

} else {

a.append(((((";float " + subname) + "[") + subarr.length) + "]"));

}

j = 0;

while (( j ) < subarr.length) {

v = (subarr[j] + "");

if (! (__contains__(v, "."))) {

v += ".0";

}

a.push((((((";" + subname) + "[") + j) + "]=") + v));

j += 1;

}

i += 1;

}

this.shader.push("".join(a));

} else {

if (__test_if_true__(ob[0] instanceof Object || ( ob[0].__class__ ) === dict)) {

i = 0;

while (( i ) < ob.length) {

this.structure(ob[i], ((name + "_") + i));

i += 1;

}

} else {

a = [(((("float " + name) + "[") + ob.length) + "];")];

i = 0;

while (( i ) < ob.length) {

a.push((((((name + "[") + i) + "]=") + ob[i]) + ";"));

i += 1;

}

this.shader.push("".join(a));

}

}

}

GLSLJITRuntime.array = function () { return GLSLJITRuntime.prototype.array.apply(arguments[0], Array.prototype.slice.call(arguments,1)) };

GLSLJITRuntime.prototype.object = function(ob, name) {

var func,cls;

var __iter11 = this.object_packagers;

if (! (__iter11 instanceof Array || typeof __iter11 == "string" || __is_typed_array(__iter11) || __is_some_array(__iter11) )) { __iter11 = __object_keys__(__iter11) }

for (var __idx11=0; __idx11 < __iter11.length; __idx11++) {

var p = __iter11[ __idx11 ];

var __r_0;

__r_0 = p;

cls = __r_0[0];

func = __r_0[1];

if (__test_if_true__(ob instanceof cls)) {

return func(ob);

}

}

}

GLSLJITRuntime.object = function () { return GLSLJITRuntime.prototype.object.apply(arguments[0], Array.prototype.slice.call(arguments,1)) };

GLSLJITRuntime.prototype.unpack_array2d = function(arr, dims) {

var h,rows,w,row;

if (( typeof(dims) ) == "number") {

return arr;

}

var __r_1;

__r_1 = dims;

w = __r_1[0];

h = __r_1[1];

row = [];

rows = [row];

var __iter12 = arr;

if (! (__iter12 instanceof Array || typeof __iter12 == "string" || __is_typed_array(__iter12) || __is_some_array(__iter12) )) { __iter12 = __object_keys__(__iter12) }

for (var __idx12=0; __idx12 < __iter12.length; __idx12++) {

var value = __iter12[ __idx12 ];

row.append(value);

if (( row.length ) >= w) {

row = [];

rows.append(row);

}

}

__jsdict_pop(rows);

if (( rows.length ) != h) {

console.log("ERROR: __unpack_array2d, invalid height.");

}

return rows;

}

GLSLJITRuntime.unpack_array2d = function () { return GLSLJITRuntime.prototype.unpack_array2d.apply(arguments[0], Array.prototype.slice.call(arguments,1)) };

GLSLJITRuntime.prototype.unpack_vec4 = function(arr, dims) {

var rows,i,h,vec,w,row;

if (( typeof(dims) ) == "number") {

w = dims;

h = 1;

} else {

var __r_2;

__r_2 = dims;

w = __r_2[0];

h = __r_2[1];

}

rows = [];

i = 0;

var y,y__end__;

y = 0;

y__end__ = h;

while (( y ) < y__end__) {

row = [];

rows.append(row);

var x,x__end__;

x = 0;

x__end__ = w;

while (( x ) < x__end__) {

vec = [];

var j,j__end__;

j = 0;

j__end__ = 4;

while (( j ) < j__end__) {

vec.append(arr[i]);

i += 1;

j += 1;

}

row.append(vec);

x += 1;

}

y += 1;

}

if (( rows.length ) != h) {

console.log("ERROR: __unpack_vec4, invalid height.");

}

return rows;

}

GLSLJITRuntime.unpack_vec4 = function () { return GLSLJITRuntime.prototype.unpack_vec4.apply(arguments[0], Array.prototype.slice.call(arguments,1)) };

GLSLJITRuntime.prototype.unpack_mat4 = function(arr) {

var i;

i = 0;

var __iter13 = this.matrices;

if (! (__iter13 instanceof Array || typeof __iter13 == "string" || __is_typed_array(__iter13) || __is_some_array(__iter13) )) { __iter13 = __object_keys__(__iter13) }

for (var __idx13=0; __idx13 < __iter13.length; __idx13++) {

var mat = __iter13[ __idx13 ];

var j,j__end__;

j = 0;

j__end__ = 16;

while (( j ) < j__end__) {

mat[j] = arr[i];

i += 1;

j += 1;

}

}

return this.matrices;

}

GLSLJITRuntime.unpack_mat4 = function () { return GLSLJITRuntime.prototype.unpack_mat4.apply(arguments[0], Array.prototype.slice.call(arguments,1)) };

GLSLJITRuntime.prototype.__properties__ = { };

GLSLJITRuntime.prototype.__unbound_methods__ = { };

__getattr__ = function(ob, a) {

if (ob.__getattr__) {

return ob.__getattr__(a);

}

}

;__getattr__.is_wrapper = true;

__test_if_true__ = function(ob) {

if (( ob ) === true) {

return true;

} else {

if (( ob ) === false) {

return false;

} else {

if (( typeof(ob) ) == "string") {

return ( ob.length ) != 0;

} else {

if (! (ob)) {

return false;

} else {

if (ob instanceof Array) {

return ( ob.length ) != 0;

} else {

if (( typeof(ob) ) == "function") {

return true;

} else {

if (ob.__class__ && ( ob.__class__ ) === dict) {

return ( Object.keys(ob["$wrapped"]).length ) != 0;

} else {

if (ob instanceof Object) {

return ( Object.keys(ob).length ) != 0;

} else {

return true;

}

}

}

}

}

}

}

}

}

;__test_if_true__.is_wrapper = true;

__replace_method = function(ob, a, b) {

if (( typeof(ob) ) == "string") {

return ob.split(a).join(b);

} else {

return ob.replace(a, b);

}

}

;__replace_method.is_wrapper = true;

__split_method = function(ob, delim) {

if (( typeof(ob) ) == "string") {

if (( delim ) === undefined) {

return ob.split(" ");

} else {

return ob.split(delim);

}

} else {

if (( delim ) === undefined) {

return ob.split();

} else {

return ob.split(delim);

}

}

}

;__split_method.is_wrapper = true;

__is_some_array = function(ob) {

var dom_array_types;

if (( typeof(NodeList) ) == "function") {

dom_array_types = [NodeList, FileList, ClientRectList, DOMStringList, HTMLCollection, HTMLAllCollection, SVGElementInstanceList, SVGNumberList, SVGTransformList];

if (( typeof(DataTransferItemList) ) == "function") {

dom_array_types.append(DataTransferItemList);

}

var __iter14 = dom_array_types;

if (! (__iter14 instanceof Array || typeof __iter14 == "string" || __is_typed_array(__iter14) || __is_some_array(__iter14) )) { __iter14 = __object_keys__(__iter14) }

for (var __idx14=0; __idx14 < __iter14.length; __idx14++) {

var t = __iter14[ __idx14 ];

if (__test_if_true__(ob instanceof t)) {

return true;

}

}

}

return false;

}