From 08e578d96bbde6a302eb79720caf1af0e9233561 Mon Sep 17 00:00:00 2001 From: villares Date: Sun, 9 Jun 2019 19:05:56 -0300 Subject: [PATCH] 190606b_fix --- 2019/sketch_190606b/sketch_190606b.py | 11 +- .../target/org.transcrypt.__runtime__.js | 2 +- 2019/sketch_190606b/target/pytop5js.js | 1259 +++++++++++++++++ 2019/sketch_190606b/target/pytop5js.map | 8 + 2019/sketch_190606b/target/pytop5js.py | 1051 ++++++++++++++ 2019/sketch_190606b/target/sketch_190606b.js | 215 +++ 2019/sketch_190606b/target/sketch_190606b.map | 8 + .../target/sketch_190606b.options | Bin 635 -> 668 bytes 2019/sketch_190606b/target/sketch_190606b.py | 194 +++ 9 files changed, 2744 insertions(+), 4 deletions(-) create mode 100644 2019/sketch_190606b/target/pytop5js.js create mode 100644 2019/sketch_190606b/target/pytop5js.map create mode 100644 2019/sketch_190606b/target/pytop5js.py create mode 100644 2019/sketch_190606b/target/sketch_190606b.js create mode 100644 2019/sketch_190606b/target/sketch_190606b.map create mode 100644 2019/sketch_190606b/target/sketch_190606b.py diff --git a/2019/sketch_190606b/sketch_190606b.py b/2019/sketch_190606b/sketch_190606b.py index 26bc201e..e3cf402b 100644 --- a/2019/sketch_190606b/sketch_190606b.py +++ b/2019/sketch_190606b/sketch_190606b.py @@ -22,11 +22,16 @@ def draw(): ellipse(pt[0], pt[1], 10, 10) -def mouseWheel(event): +def keyPressed(): global r, d + delta = 0 + if key == "-": + delta = -1 + elif key == "=" or key == "+": + delta = 1 for i, pt in enumerate(pts): if dist(mouseX, mouseY, pt[0], pt[1]) < 10: - rds[i] += 5 * event.delta + rds[i] += 5 * delta return False def mousePressed(): @@ -185,5 +190,5 @@ def b_arc(cx, cy, w, h, start_angle, end_angle, mode): endShape() # ==== This is required by pyp5js to work -event_functions = {"mouseWheel": mouseWheel, "mousePressed": mousePressed, "mouseDragged": mouseDragged, "mouseReleased": mouseReleased, } +event_functions = { "mousePressed": mousePressed, "mouseDragged": mouseDragged, "mouseReleased": mouseReleased, "keyPressed":keyPressed } start_p5(setup, draw, event_functions) diff --git a/2019/sketch_190606b/target/org.transcrypt.__runtime__.js b/2019/sketch_190606b/target/org.transcrypt.__runtime__.js index c773e7fc..37535d80 100644 --- a/2019/sketch_190606b/target/org.transcrypt.__runtime__.js +++ b/2019/sketch_190606b/target/org.transcrypt.__runtime__.js @@ -1,4 +1,4 @@ -// Transcrypt'ed from Python, 2019-06-06 23:32:30 +// Transcrypt'ed from Python, 2019-06-09 19:05:09 var __name__ = 'org.transcrypt.__runtime__'; export var __envir__ = {}; __envir__.interpreter_name = 'python'; diff --git a/2019/sketch_190606b/target/pytop5js.js b/2019/sketch_190606b/target/pytop5js.js new file mode 100644 index 00000000..8fccbdb8 --- /dev/null +++ b/2019/sketch_190606b/target/pytop5js.js @@ -0,0 +1,1259 @@ +// Transcrypt'ed from Python, 2019-06-09 19:05:10 +import {AssertionError, AttributeError, BaseException, DeprecationWarning, Exception, IndexError, IterableError, KeyError, NotImplementedError, RuntimeWarning, StopIteration, UserWarning, ValueError, Warning, __JsIterator__, __PyIterator__, __Terminal__, __add__, __and__, __call__, __class__, __envir__, __eq__, __floordiv__, __ge__, __get__, __getcm__, __getitem__, __getslice__, __getsm__, __gt__, __i__, __iadd__, __iand__, __idiv__, __ijsmod__, __ilshift__, __imatmul__, __imod__, __imul__, __in__, __init__, __ior__, __ipow__, __irshift__, __isub__, __ixor__, __jsUsePyNext__, __jsmod__, __k__, __kwargtrans__, __le__, __lshift__, __lt__, __matmul__, __mergefields__, __mergekwargtrans__, __mod__, __mul__, __ne__, __neg__, __nest__, __or__, __pow__, __pragma__, __proxy__, __pyUseJsNext__, __rshift__, __setitem__, __setproperty__, __setslice__, __sort__, __specialattrib__, __sub__, __super__, __t__, __terminal__, __truediv__, __withblock__, __xor__, all, any, assert, bool, bytearray, bytes, callable, chr, deepcopy, delattr, dict, dir, divmod, enumerate, getattr, hasattr, input, isinstance, issubclass, len, list, object, ord, property, py_TypeError, py_iter, py_metatype, py_next, py_reversed, py_typeof, range, repr, setattr, sorted, sum, tuple, zip} from './org.transcrypt.__runtime__.js'; +var __name__ = 'pytop5js'; +export var _P5_INSTANCE = null; +export var _CTX_MIDDLE = null; +export var _DEFAULT_FILL = null; +export var _DEFAULT_LEADMULT = null; +export var _DEFAULT_STROKE = null; +export var _DEFAULT_TEXT_FILL = null; +export var ADD = null; +export var ALT = null; +export var ARROW = null; +export var AUTO = null; +export var AXES = null; +export var BACKSPACE = null; +export var BASELINE = null; +export var BEVEL = null; +export var BEZIER = null; +export var BLEND = null; +export var BLUR = null; +export var BOLD = null; +export var BOLDITALIC = null; +export var BOTTOM = null; +export var BURN = null; +export var CENTER = null; +export var CHORD = null; +export var CLAMP = null; +export var CLOSE = null; +export var CONTROL = null; +export var CORNER = null; +export var CORNERS = null; +export var CROSS = null; +export var CURVE = null; +export var DARKEST = null; +export var DEG_TO_RAD = null; +export var DEGREES = null; +export var DELETE = null; +export var DIFFERENCE = null; +export var DILATE = null; +export var DODGE = null; +export var DOWN_ARROW = null; +export var ENTER = null; +export var ERODE = null; +export var ESCAPE = null; +export var EXCLUSION = null; +export var FILL = null; +export var GRAY = null; +export var GRID = null; +export var HALF_PI = null; +export var HAND = null; +export var HARD_LIGHT = null; +export var HSB = null; +export var HSL = null; +export var IMAGE = null; +export var IMMEDIATE = null; +export var INVERT = null; +export var ITALIC = null; +export var LANDSCAPE = null; +export var LEFT = null; +export var LEFT_ARROW = null; +export var LIGHTEST = null; +export var LINE_LOOP = null; +export var LINE_STRIP = null; +export var LINEAR = null; +export var LINES = null; +export var MIRROR = null; +export var MITER = null; +export var MOVE = null; +export var MULTIPLY = null; +export var NEAREST = null; +export var NORMAL = null; +export var OPAQUE = null; +export var OPEN = null; +export var OPTION = null; +export var OVERLAY = null; +export var PI = null; +export var PIE = null; +export var POINTS = null; +export var PORTRAIT = null; +export var POSTERIZE = null; +export var PROJECT = null; +export var QUAD_STRIP = null; +export var QUADRATIC = null; +export var QUADS = null; +export var QUARTER_PI = null; +export var RAD_TO_DEG = null; +export var RADIANS = null; +export var RADIUS = null; +export var REPEAT = null; +export var REPLACE = null; +export var RETURN = null; +export var RGB = null; +export var RIGHT = null; +export var RIGHT_ARROW = null; +export var ROUND = null; +export var SCREEN = null; +export var SHIFT = null; +export var SOFT_LIGHT = null; +export var SQUARE = null; +export var STROKE = null; +export var SUBTRACT = null; +export var TAB = null; +export var TAU = null; +export var TEXT = null; +export var TEXTURE = null; +export var THRESHOLD = null; +export var TOP = null; +export var TRIANGLE_FAN = null; +export var TRIANGLE_STRIP = null; +export var TRIANGLES = null; +export var TWO_PI = null; +export var UP_ARROW = null; +export var WAIT = null; +export var WEBGL = null; +export var P2D = null; +var PI = null; +export var frameCount = null; +export var focused = null; +export var displayWidth = null; +export var displayHeight = null; +export var windowWidth = null; +export var windowHeight = null; +export var width = null; +export var height = null; +export var disableFriendlyErrors = null; +export var deviceOrientation = null; +export var accelerationX = null; +export var accelerationY = null; +export var accelerationZ = null; +export var pAccelerationX = null; +export var pAccelerationY = null; +export var pAccelerationZ = null; +export var rotationX = null; +export var rotationY = null; +export var rotationZ = null; +export var pRotationX = null; +export var pRotationY = null; +export var pRotationZ = null; +export var turnAxis = null; +export var keyIsPressed = null; +export var key = null; +export var keyCode = null; +export var mouseX = null; +export var mouseY = null; +export var pmouseX = null; +export var pmouseY = null; +export var winMouseX = null; +export var winMouseY = null; +export var pwinMouseX = null; +export var pwinMouseY = null; +export var mouseButton = null; +export var mouseIsPressed = null; +export var touches = null; +export var pixels = null; +export var alpha = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.alpha (...args); +}; +export var blue = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.blue (...args); +}; +export var brightness = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.brightness (...args); +}; +export var color = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.color (...args); +}; +export var green = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.green (...args); +}; +export var hue = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.hue (...args); +}; +export var lerpColor = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.lerpColor (...args); +}; +export var lightness = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.lightness (...args); +}; +export var red = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.red (...args); +}; +export var saturation = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.saturation (...args); +}; +export var background = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.background (...args); +}; +export var py_clear = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.py_clear (...args); +}; +export var colorMode = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.colorMode (...args); +}; +export var fill = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.fill (...args); +}; +export var noFill = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.noFill (...args); +}; +export var noStroke = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.noStroke (...args); +}; +export var stroke = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.stroke (...args); +}; +export var arc = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.arc (...args); +}; +export var ellipse = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.ellipse (...args); +}; +export var circle = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.circle (...args); +}; +export var line = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.line (...args); +}; +export var point = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.point (...args); +}; +export var quad = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.quad (...args); +}; +export var rect = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.rect (...args); +}; +export var square = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.square (...args); +}; +export var triangle = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.triangle (...args); +}; +export var plane = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.plane (...args); +}; +export var box = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.box (...args); +}; +export var sphere = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.sphere (...args); +}; +export var cylinder = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.cylinder (...args); +}; +export var cone = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.cone (...args); +}; +export var ellipsoid = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.ellipsoid (...args); +}; +export var torus = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.torus (...args); +}; +export var loadModel = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.loadModel (...args); +}; +export var model = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.model (...args); +}; +export var ellipseMode = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.ellipseMode (...args); +}; +export var noSmooth = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.noSmooth (...args); +}; +export var rectMode = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.rectMode (...args); +}; +export var smooth = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.smooth (...args); +}; +export var strokeCap = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.strokeCap (...args); +}; +export var strokeJoin = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.strokeJoin (...args); +}; +export var strokeWeight = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.strokeWeight (...args); +}; +export var bezier = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.bezier (...args); +}; +export var bezierDetail = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.bezierDetail (...args); +}; +export var bezierPoint = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.bezierPoint (...args); +}; +export var bezierTangent = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.bezierTangent (...args); +}; +export var curve = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.curve (...args); +}; +export var curveDetail = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.curveDetail (...args); +}; +export var curveTightness = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.curveTightness (...args); +}; +export var curvePoint = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.curvePoint (...args); +}; +export var curveTangent = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.curveTangent (...args); +}; +export var beginContour = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.beginContour (...args); +}; +export var beginShape = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.beginShape (...args); +}; +export var bezierVertex = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.bezierVertex (...args); +}; +export var curveVertex = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.curveVertex (...args); +}; +export var endContour = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.endContour (...args); +}; +export var endShape = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.endShape (...args); +}; +export var quadraticVertex = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.quadraticVertex (...args); +}; +export var vertex = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.vertex (...args); +}; +export var print = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.print (...args); +}; +export var cursor = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.cursor (...args); +}; +export var frameRate = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.frameRate (...args); +}; +export var noCursor = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.noCursor (...args); +}; +export var fullscreen = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.fullscreen (...args); +}; +export var pixelDensity = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.pixelDensity (...args); +}; +export var displayDensity = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.displayDensity (...args); +}; +export var getURL = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.getURL (...args); +}; +export var getURLPath = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.getURLPath (...args); +}; +export var getURLParams = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.getURLParams (...args); +}; +export var preload = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.preload (...args); +}; +export var setup = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.setup (...args); +}; +export var draw = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.draw (...args); +}; +export var remove = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.remove (...args); +}; +export var noLoop = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.noLoop (...args); +}; +export var loop = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.loop (...args); +}; +export var push = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.push (...args); +}; +export var redraw = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.redraw (...args); +}; +export var resizeCanvas = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.resizeCanvas (...args); +}; +export var noCanvas = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.noCanvas (...args); +}; +export var createGraphics = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.createGraphics (...args); +}; +export var blendMode = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.blendMode (...args); +}; +export var setAttributes = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.setAttributes (...args); +}; +export var applyMatrix = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.applyMatrix (...args); +}; +export var resetMatrix = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.resetMatrix (...args); +}; +export var rotate = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.rotate (...args); +}; +export var rotateX = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.rotateX (...args); +}; +export var rotateY = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.rotateY (...args); +}; +export var rotateZ = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.rotateZ (...args); +}; +export var scale = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.scale (...args); +}; +export var shearX = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.shearX (...args); +}; +export var shearY = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.shearY (...args); +}; +export var translate = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.translate (...args); +}; +export var createStringDict = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.createStringDict (...args); +}; +export var createNumberDict = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.createNumberDict (...args); +}; +export var append = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.append (...args); +}; +export var arrayCopy = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.arrayCopy (...args); +}; +export var concat = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.concat (...args); +}; +export var reverse = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.reverse (...args); +}; +export var shorten = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.shorten (...args); +}; +export var shuffle = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.shuffle (...args); +}; +export var py_sort = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.py_sort (...args); +}; +export var splice = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.splice (...args); +}; +export var subset = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.subset (...args); +}; +export var float = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.float (...args); +}; +export var int = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.int (...args); +}; +export var str = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.str (...args); +}; +export var boolean = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.boolean (...args); +}; +export var byte = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.byte (...args); +}; +export var char = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.char (...args); +}; +export var unchar = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.unchar (...args); +}; +export var hex = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.hex (...args); +}; +export var unhex = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.unhex (...args); +}; +export var join = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.join (...args); +}; +export var match = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.match (...args); +}; +export var matchAll = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.matchAll (...args); +}; +export var nf = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.nf (...args); +}; +export var nfc = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.nfc (...args); +}; +export var nfp = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.nfp (...args); +}; +export var nfs = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.nfs (...args); +}; +export var py_split = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.py_split (...args); +}; +export var splitTokens = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.splitTokens (...args); +}; +export var trim = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.trim (...args); +}; +export var setMoveThreshold = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.setMoveThreshold (...args); +}; +export var setShakeThreshold = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.setShakeThreshold (...args); +}; +export var keyIsDown = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.keyIsDown (...args); +}; +export var createImage = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.createImage (...args); +}; +export var saveCanvas = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.saveCanvas (...args); +}; +export var saveFrames = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.saveFrames (...args); +}; +export var loadImage = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.loadImage (...args); +}; +export var image = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.image (...args); +}; +export var tint = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.tint (...args); +}; +export var noTint = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.noTint (...args); +}; +export var imageMode = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.imageMode (...args); +}; +export var blend = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.blend (...args); +}; +export var copy = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.copy (...args); +}; +export var filter = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.filter (...args); +}; +export var py_get = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.py_get (...args); +}; +export var loadPixels = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.loadPixels (...args); +}; +export var set = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.set (...args); +}; +export var updatePixels = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.updatePixels (...args); +}; +export var loadJSON = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.loadJSON (...args); +}; +export var loadStrings = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.loadStrings (...args); +}; +export var loadTable = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.loadTable (...args); +}; +export var loadXML = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.loadXML (...args); +}; +export var loadBytes = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.loadBytes (...args); +}; +export var httpGet = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.httpGet (...args); +}; +export var httpPost = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.httpPost (...args); +}; +export var httpDo = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.httpDo (...args); +}; +export var createWriter = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.createWriter (...args); +}; +export var save = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.save (...args); +}; +export var saveJSON = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.saveJSON (...args); +}; +export var saveStrings = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.saveStrings (...args); +}; +export var saveTable = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.saveTable (...args); +}; +export var day = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.day (...args); +}; +export var hour = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.hour (...args); +}; +export var minute = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.minute (...args); +}; +export var millis = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.millis (...args); +}; +export var month = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.month (...args); +}; +export var second = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.second (...args); +}; +export var year = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.year (...args); +}; +export var createVector = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.createVector (...args); +}; +export var abs = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.abs (...args); +}; +export var ceil = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.ceil (...args); +}; +export var constrain = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.constrain (...args); +}; +export var dist = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.dist (...args); +}; +export var exp = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.exp (...args); +}; +export var floor = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.floor (...args); +}; +export var lerp = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.lerp (...args); +}; +export var log = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.log (...args); +}; +export var mag = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.mag (...args); +}; +export var map = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.map (...args); +}; +export var max = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.max (...args); +}; +export var min = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.min (...args); +}; +export var norm = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.norm (...args); +}; +export var pow = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.pow (...args); +}; +export var round = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.round (...args); +}; +export var sq = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.sq (...args); +}; +export var sqrt = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.sqrt (...args); +}; +export var noise = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.noise (...args); +}; +export var noiseDetail = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.noiseDetail (...args); +}; +export var noiseSeed = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.noiseSeed (...args); +}; +export var randomSeed = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.randomSeed (...args); +}; +export var random = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.random (...args); +}; +export var randomGaussian = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.randomGaussian (...args); +}; +export var acos = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.acos (...args); +}; +export var asin = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.asin (...args); +}; +export var atan = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.atan (...args); +}; +export var atan2 = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.atan2 (...args); +}; +export var cos = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.cos (...args); +}; +export var sin = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.sin (...args); +}; +export var tan = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.tan (...args); +}; +export var degrees = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.degrees (...args); +}; +export var radians = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.radians (...args); +}; +export var angleMode = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.angleMode (...args); +}; +export var textAlign = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.textAlign (...args); +}; +export var textLeading = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.textLeading (...args); +}; +export var textSize = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.textSize (...args); +}; +export var textStyle = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.textStyle (...args); +}; +export var textWidth = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.textWidth (...args); +}; +export var textAscent = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.textAscent (...args); +}; +export var textDescent = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.textDescent (...args); +}; +export var loadFont = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.loadFont (...args); +}; +export var text = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.text (...args); +}; +export var textFont = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.textFont (...args); +}; +export var orbitControl = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.orbitControl (...args); +}; +export var debugMode = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.debugMode (...args); +}; +export var noDebugMode = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.noDebugMode (...args); +}; +export var ambientLight = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.ambientLight (...args); +}; +export var directionalLight = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.directionalLight (...args); +}; +export var pointLight = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.pointLight (...args); +}; +export var lights = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.lights (...args); +}; +export var loadShader = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.loadShader (...args); +}; +export var createShader = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.createShader (...args); +}; +export var shader = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.shader (...args); +}; +export var resetShader = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.resetShader (...args); +}; +export var normalMaterial = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.normalMaterial (...args); +}; +export var texture = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.texture (...args); +}; +export var textureMode = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.textureMode (...args); +}; +export var textureWrap = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.textureWrap (...args); +}; +export var ambientMaterial = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.ambientMaterial (...args); +}; +export var specularMaterial = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.specularMaterial (...args); +}; +export var shininess = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.shininess (...args); +}; +export var camera = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.camera (...args); +}; +export var perspective = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.perspective (...args); +}; +export var ortho = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.ortho (...args); +}; +export var createCamera = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.createCamera (...args); +}; +export var setCamera = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + return _P5_INSTANCE.setCamera (...args); +}; +export var createCanvas = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + var result = _P5_INSTANCE.createCanvas (...args); + width = _P5_INSTANCE.width; + height = _P5_INSTANCE.height; +}; +export var py_pop = function () { + var args = tuple ([].slice.apply (arguments).slice (0)); + var p5_pop = _P5_INSTANCE.pop (...args); + return p5_pop; +}; +export var pre_draw = function (p5_instance, draw_func) { + _CTX_MIDDLE = p5_instance._CTX_MIDDLE; + _DEFAULT_FILL = p5_instance._DEFAULT_FILL; + _DEFAULT_LEADMULT = p5_instance._DEFAULT_LEADMULT; + _DEFAULT_STROKE = p5_instance._DEFAULT_STROKE; + _DEFAULT_TEXT_FILL = p5_instance._DEFAULT_TEXT_FILL; + ADD = p5_instance.ADD; + ALT = p5_instance.ALT; + ARROW = p5_instance.ARROW; + AUTO = p5_instance.AUTO; + AXES = p5_instance.AXES; + BACKSPACE = p5_instance.BACKSPACE; + BASELINE = p5_instance.BASELINE; + BEVEL = p5_instance.BEVEL; + BEZIER = p5_instance.BEZIER; + BLEND = p5_instance.BLEND; + BLUR = p5_instance.BLUR; + BOLD = p5_instance.BOLD; + BOLDITALIC = p5_instance.BOLDITALIC; + BOTTOM = p5_instance.BOTTOM; + BURN = p5_instance.BURN; + CENTER = p5_instance.CENTER; + CHORD = p5_instance.CHORD; + CLAMP = p5_instance.CLAMP; + CLOSE = p5_instance.CLOSE; + CONTROL = p5_instance.CONTROL; + CORNER = p5_instance.CORNER; + CORNERS = p5_instance.CORNERS; + CROSS = p5_instance.CROSS; + CURVE = p5_instance.CURVE; + DARKEST = p5_instance.DARKEST; + DEG_TO_RAD = p5_instance.DEG_TO_RAD; + DEGREES = p5_instance.DEGREES; + DELETE = p5_instance.DELETE; + DIFFERENCE = p5_instance.DIFFERENCE; + DILATE = p5_instance.DILATE; + DODGE = p5_instance.DODGE; + DOWN_ARROW = p5_instance.DOWN_ARROW; + ENTER = p5_instance.ENTER; + ERODE = p5_instance.ERODE; + ESCAPE = p5_instance.ESCAPE; + EXCLUSION = p5_instance.EXCLUSION; + FILL = p5_instance.FILL; + GRAY = p5_instance.GRAY; + GRID = p5_instance.GRID; + HALF_PI = p5_instance.HALF_PI; + HAND = p5_instance.HAND; + HARD_LIGHT = p5_instance.HARD_LIGHT; + HSB = p5_instance.HSB; + HSL = p5_instance.HSL; + IMAGE = p5_instance.IMAGE; + IMMEDIATE = p5_instance.IMMEDIATE; + INVERT = p5_instance.INVERT; + ITALIC = p5_instance.ITALIC; + LANDSCAPE = p5_instance.LANDSCAPE; + LEFT = p5_instance.LEFT; + LEFT_ARROW = p5_instance.LEFT_ARROW; + LIGHTEST = p5_instance.LIGHTEST; + LINE_LOOP = p5_instance.LINE_LOOP; + LINE_STRIP = p5_instance.LINE_STRIP; + LINEAR = p5_instance.LINEAR; + LINES = p5_instance.LINES; + MIRROR = p5_instance.MIRROR; + MITER = p5_instance.MITER; + MOVE = p5_instance.MOVE; + MULTIPLY = p5_instance.MULTIPLY; + NEAREST = p5_instance.NEAREST; + NORMAL = p5_instance.NORMAL; + OPAQUE = p5_instance.OPAQUE; + OPEN = p5_instance.OPEN; + OPTION = p5_instance.OPTION; + OVERLAY = p5_instance.OVERLAY; + PI = p5_instance.PI; + PIE = p5_instance.PIE; + POINTS = p5_instance.POINTS; + PORTRAIT = p5_instance.PORTRAIT; + POSTERIZE = p5_instance.POSTERIZE; + PROJECT = p5_instance.PROJECT; + QUAD_STRIP = p5_instance.QUAD_STRIP; + QUADRATIC = p5_instance.QUADRATIC; + QUADS = p5_instance.QUADS; + QUARTER_PI = p5_instance.QUARTER_PI; + RAD_TO_DEG = p5_instance.RAD_TO_DEG; + RADIANS = p5_instance.RADIANS; + RADIUS = p5_instance.RADIUS; + REPEAT = p5_instance.REPEAT; + REPLACE = p5_instance.REPLACE; + RETURN = p5_instance.RETURN; + RGB = p5_instance.RGB; + RIGHT = p5_instance.RIGHT; + RIGHT_ARROW = p5_instance.RIGHT_ARROW; + ROUND = p5_instance.ROUND; + SCREEN = p5_instance.SCREEN; + SHIFT = p5_instance.SHIFT; + SOFT_LIGHT = p5_instance.SOFT_LIGHT; + SQUARE = p5_instance.SQUARE; + STROKE = p5_instance.STROKE; + SUBTRACT = p5_instance.SUBTRACT; + TAB = p5_instance.TAB; + TAU = p5_instance.TAU; + TEXT = p5_instance.TEXT; + TEXTURE = p5_instance.TEXTURE; + THRESHOLD = p5_instance.THRESHOLD; + TOP = p5_instance.TOP; + TRIANGLE_FAN = p5_instance.TRIANGLE_FAN; + TRIANGLE_STRIP = p5_instance.TRIANGLE_STRIP; + TRIANGLES = p5_instance.TRIANGLES; + TWO_PI = p5_instance.TWO_PI; + UP_ARROW = p5_instance.UP_ARROW; + WAIT = p5_instance.WAIT; + WEBGL = p5_instance.WEBGL; + P2D = p5_instance.P2D; + PI = p5_instance.PI; + frameCount = p5_instance.frameCount; + focused = p5_instance.focused; + displayWidth = p5_instance.displayWidth; + displayHeight = p5_instance.displayHeight; + windowWidth = p5_instance.windowWidth; + windowHeight = p5_instance.windowHeight; + width = p5_instance.width; + height = p5_instance.height; + disableFriendlyErrors = p5_instance.disableFriendlyErrors; + deviceOrientation = p5_instance.deviceOrientation; + accelerationX = p5_instance.accelerationX; + accelerationY = p5_instance.accelerationY; + accelerationZ = p5_instance.accelerationZ; + pAccelerationX = p5_instance.pAccelerationX; + pAccelerationY = p5_instance.pAccelerationY; + pAccelerationZ = p5_instance.pAccelerationZ; + rotationX = p5_instance.rotationX; + rotationY = p5_instance.rotationY; + rotationZ = p5_instance.rotationZ; + pRotationX = p5_instance.pRotationX; + pRotationY = p5_instance.pRotationY; + pRotationZ = p5_instance.pRotationZ; + turnAxis = p5_instance.turnAxis; + keyIsPressed = p5_instance.keyIsPressed; + key = p5_instance.key; + keyCode = p5_instance.keyCode; + mouseX = p5_instance.mouseX; + mouseY = p5_instance.mouseY; + pmouseX = p5_instance.pmouseX; + pmouseY = p5_instance.pmouseY; + winMouseX = p5_instance.winMouseX; + winMouseY = p5_instance.winMouseY; + pwinMouseX = p5_instance.pwinMouseX; + pwinMouseY = p5_instance.pwinMouseY; + mouseButton = p5_instance.mouseButton; + mouseIsPressed = p5_instance.mouseIsPressed; + touches = p5_instance.touches; + pixels = p5_instance.pixels; + return draw_func (); +}; +export var global_p5_injection = function (p5_sketch) { + var decorator = function (f) { + var wrapper = function () { + _P5_INSTANCE = p5_sketch; + return pre_draw (_P5_INSTANCE, f); + }; + return wrapper; + }; + return decorator; +}; +export var start_p5 = function (setup_func, draw_func, event_functions) { + var sketch_setup = function (p5_sketch) { + p5_sketch.setup = global_p5_injection (p5_sketch) (setup_func); + p5_sketch.draw = global_p5_injection (p5_sketch) (draw_func); + }; + var instance = new p5 (sketch_setup, 'sketch-holder'); + var event_function_names = list (['deviceMoved', 'deviceTurned', 'deviceShaken', 'keyPressed', 'keyReleased', 'keyTyped', 'mouseMoved', 'mouseDragged', 'mousePressed', 'mouseReleased', 'mouseClicked', 'doubleClicked', 'mouseWheel', 'touchStarted', 'touchMoved', 'touchEnded', 'windowResized']); + for (var f_name of (function () { + var __accu0__ = []; + for (var f of event_function_names) { + if (__in__ (f, event_functions)) { + __accu0__.append (f); + } + } + return __accu0__; + }) ()) { + var func = event_functions [f_name]; + var event_func = global_p5_injection (instance) (func); + setattr (instance, f_name, event_func); + } +}; + +//# sourceMappingURL=pytop5js.map \ No newline at end of file diff --git a/2019/sketch_190606b/target/pytop5js.map b/2019/sketch_190606b/target/pytop5js.map new file mode 100644 index 00000000..8a1634e4 --- /dev/null +++ b/2019/sketch_190606b/target/pytop5js.map @@ -0,0 +1,8 @@ +{ + "version": 3, + "file": "pytop5js.js", + "sources": [ + "pytop5js.py" + ], + "mappings": "AAAA;AA0hCA;AA1hCA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAIA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAEA;AAAA;AACA;AAAA;AAGA;AAAA;AACA;AAGA;AACA;AAAA;AAGA;AAAA;AAEA;AAEA;AAAA;AAEA;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAAA;AAGA;AAKA;AAEA;AAEA;AACA;AAAA;AACA;AAAA;AAEA;AAAA;AAGA;AAYA;AACA;AACA;AAAA;AAEA;AAGA;AAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA;AACA;AACA;AAAA;AAAA;AAAA" +} \ No newline at end of file diff --git a/2019/sketch_190606b/target/pytop5js.py b/2019/sketch_190606b/target/pytop5js.py new file mode 100644 index 00000000..f8f21f3c --- /dev/null +++ b/2019/sketch_190606b/target/pytop5js.py @@ -0,0 +1,1051 @@ +_P5_INSTANCE = None +_CTX_MIDDLE = None +_DEFAULT_FILL = None +_DEFAULT_LEADMULT = None +_DEFAULT_STROKE = None +_DEFAULT_TEXT_FILL = None +ADD = None +ALT = None +ARROW = None +AUTO = None +AXES = None +BACKSPACE = None +BASELINE = None +BEVEL = None +BEZIER = None +BLEND = None +BLUR = None +BOLD = None +BOLDITALIC = None +BOTTOM = None +BURN = None +CENTER = None +CHORD = None +CLAMP = None +CLOSE = None +CONTROL = None +CORNER = None +CORNERS = None +CROSS = None +CURVE = None +DARKEST = None +DEG_TO_RAD = None +DEGREES = None +DELETE = None +DIFFERENCE = None +DILATE = None +DODGE = None +DOWN_ARROW = None +ENTER = None +ERODE = None +ESCAPE = None +EXCLUSION = None +FILL = None +GRAY = None +GRID = None +HALF_PI = None +HAND = None +HARD_LIGHT = None +HSB = None +HSL = None +IMAGE = None +IMMEDIATE = None +INVERT = None +ITALIC = None +LANDSCAPE = None +LEFT = None +LEFT_ARROW = None +LIGHTEST = None +LINE_LOOP = None +LINE_STRIP = None +LINEAR = None +LINES = None +MIRROR = None +MITER = None +MOVE = None +MULTIPLY = None +NEAREST = None +NORMAL = None +OPAQUE = None +OPEN = None +OPTION = None +OVERLAY = None +PI = None +PIE = None +POINTS = None +PORTRAIT = None +POSTERIZE = None +PROJECT = None +QUAD_STRIP = None +QUADRATIC = None +QUADS = None +QUARTER_PI = None +RAD_TO_DEG = None +RADIANS = None +RADIUS = None +REPEAT = None +REPLACE = None +RETURN = None +RGB = None +RIGHT = None +RIGHT_ARROW = None +ROUND = None +SCREEN = None +SHIFT = None +SOFT_LIGHT = None +SQUARE = None +STROKE = None +SUBTRACT = None +TAB = None +TAU = None +TEXT = None +TEXTURE = None +THRESHOLD = None +TOP = None +TRIANGLE_FAN = None +TRIANGLE_STRIP = None +TRIANGLES = None +TWO_PI = None +UP_ARROW = None +WAIT = None +WEBGL = None +P2D = None +PI = None +frameCount = None +focused = None +displayWidth = None +displayHeight = None +windowWidth = None +windowHeight = None +width = None +height = None +disableFriendlyErrors = None +deviceOrientation = None +accelerationX = None +accelerationY = None +accelerationZ = None +pAccelerationX = None +pAccelerationY = None +pAccelerationZ = None +rotationX = None +rotationY = None +rotationZ = None +pRotationX = None +pRotationY = None +pRotationZ = None +turnAxis = None +keyIsPressed = None +key = None +keyCode = None +mouseX = None +mouseY = None +pmouseX = None +pmouseY = None +winMouseX = None +winMouseY = None +pwinMouseX = None +pwinMouseY = None +mouseButton = None +mouseIsPressed = None +touches = None +pixels = None + + + +def alpha(*args): + return _P5_INSTANCE.alpha(*args) + +def blue(*args): + return _P5_INSTANCE.blue(*args) + +def brightness(*args): + return _P5_INSTANCE.brightness(*args) + +def color(*args): + return _P5_INSTANCE.color(*args) + +def green(*args): + return _P5_INSTANCE.green(*args) + +def hue(*args): + return _P5_INSTANCE.hue(*args) + +def lerpColor(*args): + return _P5_INSTANCE.lerpColor(*args) + +def lightness(*args): + return _P5_INSTANCE.lightness(*args) + +def red(*args): + return _P5_INSTANCE.red(*args) + +def saturation(*args): + return _P5_INSTANCE.saturation(*args) + +def background(*args): + return _P5_INSTANCE.background(*args) + +def clear(*args): + return _P5_INSTANCE.clear(*args) + +def colorMode(*args): + return _P5_INSTANCE.colorMode(*args) + +def fill(*args): + return _P5_INSTANCE.fill(*args) + +def noFill(*args): + return _P5_INSTANCE.noFill(*args) + +def noStroke(*args): + return _P5_INSTANCE.noStroke(*args) + +def stroke(*args): + return _P5_INSTANCE.stroke(*args) + +def arc(*args): + return _P5_INSTANCE.arc(*args) + +def ellipse(*args): + return _P5_INSTANCE.ellipse(*args) + +def circle(*args): + return _P5_INSTANCE.circle(*args) + +def line(*args): + return _P5_INSTANCE.line(*args) + +def point(*args): + return _P5_INSTANCE.point(*args) + +def quad(*args): + return _P5_INSTANCE.quad(*args) + +def rect(*args): + return _P5_INSTANCE.rect(*args) + +def square(*args): + return _P5_INSTANCE.square(*args) + +def triangle(*args): + return _P5_INSTANCE.triangle(*args) + +def plane(*args): + return _P5_INSTANCE.plane(*args) + +def box(*args): + return _P5_INSTANCE.box(*args) + +def sphere(*args): + return _P5_INSTANCE.sphere(*args) + +def cylinder(*args): + return _P5_INSTANCE.cylinder(*args) + +def cone(*args): + return _P5_INSTANCE.cone(*args) + +def ellipsoid(*args): + return _P5_INSTANCE.ellipsoid(*args) + +def torus(*args): + return _P5_INSTANCE.torus(*args) + +def loadModel(*args): + return _P5_INSTANCE.loadModel(*args) + +def model(*args): + return _P5_INSTANCE.model(*args) + +def ellipseMode(*args): + return _P5_INSTANCE.ellipseMode(*args) + +def noSmooth(*args): + return _P5_INSTANCE.noSmooth(*args) + +def rectMode(*args): + return _P5_INSTANCE.rectMode(*args) + +def smooth(*args): + return _P5_INSTANCE.smooth(*args) + +def strokeCap(*args): + return _P5_INSTANCE.strokeCap(*args) + +def strokeJoin(*args): + return _P5_INSTANCE.strokeJoin(*args) + +def strokeWeight(*args): + return _P5_INSTANCE.strokeWeight(*args) + +def bezier(*args): + return _P5_INSTANCE.bezier(*args) + +def bezierDetail(*args): + return _P5_INSTANCE.bezierDetail(*args) + +def bezierPoint(*args): + return _P5_INSTANCE.bezierPoint(*args) + +def bezierTangent(*args): + return _P5_INSTANCE.bezierTangent(*args) + +def curve(*args): + return _P5_INSTANCE.curve(*args) + +def curveDetail(*args): + return _P5_INSTANCE.curveDetail(*args) + +def curveTightness(*args): + return _P5_INSTANCE.curveTightness(*args) + +def curvePoint(*args): + return _P5_INSTANCE.curvePoint(*args) + +def curveTangent(*args): + return _P5_INSTANCE.curveTangent(*args) + +def beginContour(*args): + return _P5_INSTANCE.beginContour(*args) + +def beginShape(*args): + return _P5_INSTANCE.beginShape(*args) + +def bezierVertex(*args): + return _P5_INSTANCE.bezierVertex(*args) + +def curveVertex(*args): + return _P5_INSTANCE.curveVertex(*args) + +def endContour(*args): + return _P5_INSTANCE.endContour(*args) + +def endShape(*args): + return _P5_INSTANCE.endShape(*args) + +def quadraticVertex(*args): + return _P5_INSTANCE.quadraticVertex(*args) + +def vertex(*args): + return _P5_INSTANCE.vertex(*args) + +def print(*args): + return _P5_INSTANCE.print(*args) + +def cursor(*args): + return _P5_INSTANCE.cursor(*args) + +def frameRate(*args): + return _P5_INSTANCE.frameRate(*args) + +def noCursor(*args): + return _P5_INSTANCE.noCursor(*args) + +def fullscreen(*args): + return _P5_INSTANCE.fullscreen(*args) + +def pixelDensity(*args): + return _P5_INSTANCE.pixelDensity(*args) + +def displayDensity(*args): + return _P5_INSTANCE.displayDensity(*args) + +def getURL(*args): + return _P5_INSTANCE.getURL(*args) + +def getURLPath(*args): + return _P5_INSTANCE.getURLPath(*args) + +def getURLParams(*args): + return _P5_INSTANCE.getURLParams(*args) + +def preload(*args): + return _P5_INSTANCE.preload(*args) + +def setup(*args): + return _P5_INSTANCE.setup(*args) + +def draw(*args): + return _P5_INSTANCE.draw(*args) + +def remove(*args): + return _P5_INSTANCE.remove(*args) + +def noLoop(*args): + return _P5_INSTANCE.noLoop(*args) + +def loop(*args): + return _P5_INSTANCE.loop(*args) + +def push(*args): + return _P5_INSTANCE.push(*args) + +def redraw(*args): + return _P5_INSTANCE.redraw(*args) + +def resizeCanvas(*args): + return _P5_INSTANCE.resizeCanvas(*args) + +def noCanvas(*args): + return _P5_INSTANCE.noCanvas(*args) + +def createGraphics(*args): + return _P5_INSTANCE.createGraphics(*args) + +def blendMode(*args): + return _P5_INSTANCE.blendMode(*args) + +def setAttributes(*args): + return _P5_INSTANCE.setAttributes(*args) + +def applyMatrix(*args): + return _P5_INSTANCE.applyMatrix(*args) + +def resetMatrix(*args): + return _P5_INSTANCE.resetMatrix(*args) + +def rotate(*args): + return _P5_INSTANCE.rotate(*args) + +def rotateX(*args): + return _P5_INSTANCE.rotateX(*args) + +def rotateY(*args): + return _P5_INSTANCE.rotateY(*args) + +def rotateZ(*args): + return _P5_INSTANCE.rotateZ(*args) + +def scale(*args): + return _P5_INSTANCE.scale(*args) + +def shearX(*args): + return _P5_INSTANCE.shearX(*args) + +def shearY(*args): + return _P5_INSTANCE.shearY(*args) + +def translate(*args): + return _P5_INSTANCE.translate(*args) + +def createStringDict(*args): + return _P5_INSTANCE.createStringDict(*args) + +def createNumberDict(*args): + return _P5_INSTANCE.createNumberDict(*args) + +def append(*args): + return _P5_INSTANCE.append(*args) + +def arrayCopy(*args): + return _P5_INSTANCE.arrayCopy(*args) + +def concat(*args): + return _P5_INSTANCE.concat(*args) + +def reverse(*args): + return _P5_INSTANCE.reverse(*args) + +def shorten(*args): + return _P5_INSTANCE.shorten(*args) + +def shuffle(*args): + return _P5_INSTANCE.shuffle(*args) + +def sort(*args): + return _P5_INSTANCE.sort(*args) + +def splice(*args): + return _P5_INSTANCE.splice(*args) + +def subset(*args): + return _P5_INSTANCE.subset(*args) + +def float(*args): + return _P5_INSTANCE.float(*args) + +def int(*args): + return _P5_INSTANCE.int(*args) + +def str(*args): + return _P5_INSTANCE.str(*args) + +def boolean(*args): + return _P5_INSTANCE.boolean(*args) + +def byte(*args): + return _P5_INSTANCE.byte(*args) + +def char(*args): + return _P5_INSTANCE.char(*args) + +def unchar(*args): + return _P5_INSTANCE.unchar(*args) + +def hex(*args): + return _P5_INSTANCE.hex(*args) + +def unhex(*args): + return _P5_INSTANCE.unhex(*args) + +def join(*args): + return _P5_INSTANCE.join(*args) + +def match(*args): + return _P5_INSTANCE.match(*args) + +def matchAll(*args): + return _P5_INSTANCE.matchAll(*args) + +def nf(*args): + return _P5_INSTANCE.nf(*args) + +def nfc(*args): + return _P5_INSTANCE.nfc(*args) + +def nfp(*args): + return _P5_INSTANCE.nfp(*args) + +def nfs(*args): + return _P5_INSTANCE.nfs(*args) + +def split(*args): + return _P5_INSTANCE.split(*args) + +def splitTokens(*args): + return _P5_INSTANCE.splitTokens(*args) + +def trim(*args): + return _P5_INSTANCE.trim(*args) + +def setMoveThreshold(*args): + return _P5_INSTANCE.setMoveThreshold(*args) + +def setShakeThreshold(*args): + return _P5_INSTANCE.setShakeThreshold(*args) + +def keyIsDown(*args): + return _P5_INSTANCE.keyIsDown(*args) + +def createImage(*args): + return _P5_INSTANCE.createImage(*args) + +def saveCanvas(*args): + return _P5_INSTANCE.saveCanvas(*args) + +def saveFrames(*args): + return _P5_INSTANCE.saveFrames(*args) + +def loadImage(*args): + return _P5_INSTANCE.loadImage(*args) + +def image(*args): + return _P5_INSTANCE.image(*args) + +def tint(*args): + return _P5_INSTANCE.tint(*args) + +def noTint(*args): + return _P5_INSTANCE.noTint(*args) + +def imageMode(*args): + return _P5_INSTANCE.imageMode(*args) + +def blend(*args): + return _P5_INSTANCE.blend(*args) + +def copy(*args): + return _P5_INSTANCE.copy(*args) + +def filter(*args): + return _P5_INSTANCE.filter(*args) + +def get(*args): + return _P5_INSTANCE.get(*args) + +def loadPixels(*args): + return _P5_INSTANCE.loadPixels(*args) + +def set(*args): + return _P5_INSTANCE.set(*args) + +def updatePixels(*args): + return _P5_INSTANCE.updatePixels(*args) + +def loadJSON(*args): + return _P5_INSTANCE.loadJSON(*args) + +def loadStrings(*args): + return _P5_INSTANCE.loadStrings(*args) + +def loadTable(*args): + return _P5_INSTANCE.loadTable(*args) + +def loadXML(*args): + return _P5_INSTANCE.loadXML(*args) + +def loadBytes(*args): + return _P5_INSTANCE.loadBytes(*args) + +def httpGet(*args): + return _P5_INSTANCE.httpGet(*args) + +def httpPost(*args): + return _P5_INSTANCE.httpPost(*args) + +def httpDo(*args): + return _P5_INSTANCE.httpDo(*args) + +def createWriter(*args): + return _P5_INSTANCE.createWriter(*args) + +def save(*args): + return _P5_INSTANCE.save(*args) + +def saveJSON(*args): + return _P5_INSTANCE.saveJSON(*args) + +def saveStrings(*args): + return _P5_INSTANCE.saveStrings(*args) + +def saveTable(*args): + return _P5_INSTANCE.saveTable(*args) + +def day(*args): + return _P5_INSTANCE.day(*args) + +def hour(*args): + return _P5_INSTANCE.hour(*args) + +def minute(*args): + return _P5_INSTANCE.minute(*args) + +def millis(*args): + return _P5_INSTANCE.millis(*args) + +def month(*args): + return _P5_INSTANCE.month(*args) + +def second(*args): + return _P5_INSTANCE.second(*args) + +def year(*args): + return _P5_INSTANCE.year(*args) + +def createVector(*args): + return _P5_INSTANCE.createVector(*args) + +def abs(*args): + return _P5_INSTANCE.abs(*args) + +def ceil(*args): + return _P5_INSTANCE.ceil(*args) + +def constrain(*args): + return _P5_INSTANCE.constrain(*args) + +def dist(*args): + return _P5_INSTANCE.dist(*args) + +def exp(*args): + return _P5_INSTANCE.exp(*args) + +def floor(*args): + return _P5_INSTANCE.floor(*args) + +def lerp(*args): + return _P5_INSTANCE.lerp(*args) + +def log(*args): + return _P5_INSTANCE.log(*args) + +def mag(*args): + return _P5_INSTANCE.mag(*args) + +def map(*args): + return _P5_INSTANCE.map(*args) + +def max(*args): + return _P5_INSTANCE.max(*args) + +def min(*args): + return _P5_INSTANCE.min(*args) + +def norm(*args): + return _P5_INSTANCE.norm(*args) + +def pow(*args): + return _P5_INSTANCE.pow(*args) + +def round(*args): + return _P5_INSTANCE.round(*args) + +def sq(*args): + return _P5_INSTANCE.sq(*args) + +def sqrt(*args): + return _P5_INSTANCE.sqrt(*args) + +def noise(*args): + return _P5_INSTANCE.noise(*args) + +def noiseDetail(*args): + return _P5_INSTANCE.noiseDetail(*args) + +def noiseSeed(*args): + return _P5_INSTANCE.noiseSeed(*args) + +def randomSeed(*args): + return _P5_INSTANCE.randomSeed(*args) + +def random(*args): + return _P5_INSTANCE.random(*args) + +def randomGaussian(*args): + return _P5_INSTANCE.randomGaussian(*args) + +def acos(*args): + return _P5_INSTANCE.acos(*args) + +def asin(*args): + return _P5_INSTANCE.asin(*args) + +def atan(*args): + return _P5_INSTANCE.atan(*args) + +def atan2(*args): + return _P5_INSTANCE.atan2(*args) + +def cos(*args): + return _P5_INSTANCE.cos(*args) + +def sin(*args): + return _P5_INSTANCE.sin(*args) + +def tan(*args): + return _P5_INSTANCE.tan(*args) + +def degrees(*args): + return _P5_INSTANCE.degrees(*args) + +def radians(*args): + return _P5_INSTANCE.radians(*args) + +def angleMode(*args): + return _P5_INSTANCE.angleMode(*args) + +def textAlign(*args): + return _P5_INSTANCE.textAlign(*args) + +def textLeading(*args): + return _P5_INSTANCE.textLeading(*args) + +def textSize(*args): + return _P5_INSTANCE.textSize(*args) + +def textStyle(*args): + return _P5_INSTANCE.textStyle(*args) + +def textWidth(*args): + return _P5_INSTANCE.textWidth(*args) + +def textAscent(*args): + return _P5_INSTANCE.textAscent(*args) + +def textDescent(*args): + return _P5_INSTANCE.textDescent(*args) + +def loadFont(*args): + return _P5_INSTANCE.loadFont(*args) + +def text(*args): + return _P5_INSTANCE.text(*args) + +def textFont(*args): + return _P5_INSTANCE.textFont(*args) + +def orbitControl(*args): + return _P5_INSTANCE.orbitControl(*args) + +def debugMode(*args): + return _P5_INSTANCE.debugMode(*args) + +def noDebugMode(*args): + return _P5_INSTANCE.noDebugMode(*args) + +def ambientLight(*args): + return _P5_INSTANCE.ambientLight(*args) + +def directionalLight(*args): + return _P5_INSTANCE.directionalLight(*args) + +def pointLight(*args): + return _P5_INSTANCE.pointLight(*args) + +def lights(*args): + return _P5_INSTANCE.lights(*args) + +def loadShader(*args): + return _P5_INSTANCE.loadShader(*args) + +def createShader(*args): + return _P5_INSTANCE.createShader(*args) + +def shader(*args): + return _P5_INSTANCE.shader(*args) + +def resetShader(*args): + return _P5_INSTANCE.resetShader(*args) + +def normalMaterial(*args): + return _P5_INSTANCE.normalMaterial(*args) + +def texture(*args): + return _P5_INSTANCE.texture(*args) + +def textureMode(*args): + return _P5_INSTANCE.textureMode(*args) + +def textureWrap(*args): + return _P5_INSTANCE.textureWrap(*args) + +def ambientMaterial(*args): + return _P5_INSTANCE.ambientMaterial(*args) + +def specularMaterial(*args): + return _P5_INSTANCE.specularMaterial(*args) + +def shininess(*args): + return _P5_INSTANCE.shininess(*args) + +def camera(*args): + return _P5_INSTANCE.camera(*args) + +def perspective(*args): + return _P5_INSTANCE.perspective(*args) + +def ortho(*args): + return _P5_INSTANCE.ortho(*args) + +def createCamera(*args): + return _P5_INSTANCE.createCamera(*args) + +def setCamera(*args): + return _P5_INSTANCE.setCamera(*args) + + +def createCanvas(*args): + result = _P5_INSTANCE.createCanvas(*args) + + global width, height + width = _P5_INSTANCE.width + height = _P5_INSTANCE.height + + +def pop(*args): + __pragma__('noalias', 'pop') + p5_pop = _P5_INSTANCE.pop(*args) + __pragma__('alias', 'pop', 'py_pop') + return p5_pop + +def pre_draw(p5_instance, draw_func): + """ + We need to run this before the actual draw to insert and update p5 env variables + """ + global _CTX_MIDDLE, _DEFAULT_FILL, _DEFAULT_LEADMULT, _DEFAULT_STROKE, _DEFAULT_TEXT_FILL, ADD, ALT, ARROW, AUTO, AXES, BACKSPACE, BASELINE, BEVEL, BEZIER, BLEND, BLUR, BOLD, BOLDITALIC, BOTTOM, BURN, CENTER, CHORD, CLAMP, CLOSE, CONTROL, CORNER, CORNERS, CROSS, CURVE, DARKEST, DEG_TO_RAD, DEGREES, DELETE, DIFFERENCE, DILATE, DODGE, DOWN_ARROW, ENTER, ERODE, ESCAPE, EXCLUSION, FILL, GRAY, GRID, HALF_PI, HAND, HARD_LIGHT, HSB, HSL, IMAGE, IMMEDIATE, INVERT, ITALIC, LANDSCAPE, LEFT, LEFT_ARROW, LIGHTEST, LINE_LOOP, LINE_STRIP, LINEAR, LINES, MIRROR, MITER, MOVE, MULTIPLY, NEAREST, NORMAL, OPAQUE, OPEN, OPTION, OVERLAY, PI, PIE, POINTS, PORTRAIT, POSTERIZE, PROJECT, QUAD_STRIP, QUADRATIC, QUADS, QUARTER_PI, RAD_TO_DEG, RADIANS, RADIUS, REPEAT, REPLACE, RETURN, RGB, RIGHT, RIGHT_ARROW, ROUND, SCREEN, SHIFT, SOFT_LIGHT, SQUARE, STROKE, SUBTRACT, TAB, TAU, TEXT, TEXTURE, THRESHOLD, TOP, TRIANGLE_FAN, TRIANGLE_STRIP, TRIANGLES, TWO_PI, UP_ARROW, WAIT, WEBGL, P2D, PI, frameCount, focused, displayWidth, displayHeight, windowWidth, windowHeight, width, height, disableFriendlyErrors, deviceOrientation, accelerationX, accelerationY, accelerationZ, pAccelerationX, pAccelerationY, pAccelerationZ, rotationX, rotationY, rotationZ, pRotationX, pRotationY, pRotationZ, turnAxis, keyIsPressed, key, keyCode, mouseX, mouseY, pmouseX, pmouseY, winMouseX, winMouseY, pwinMouseX, pwinMouseY, mouseButton, mouseIsPressed, touches, pixels + + _CTX_MIDDLE = p5_instance._CTX_MIDDLE + _DEFAULT_FILL = p5_instance._DEFAULT_FILL + _DEFAULT_LEADMULT = p5_instance._DEFAULT_LEADMULT + _DEFAULT_STROKE = p5_instance._DEFAULT_STROKE + _DEFAULT_TEXT_FILL = p5_instance._DEFAULT_TEXT_FILL + ADD = p5_instance.ADD + ALT = p5_instance.ALT + ARROW = p5_instance.ARROW + AUTO = p5_instance.AUTO + AXES = p5_instance.AXES + BACKSPACE = p5_instance.BACKSPACE + BASELINE = p5_instance.BASELINE + BEVEL = p5_instance.BEVEL + BEZIER = p5_instance.BEZIER + BLEND = p5_instance.BLEND + BLUR = p5_instance.BLUR + BOLD = p5_instance.BOLD + BOLDITALIC = p5_instance.BOLDITALIC + BOTTOM = p5_instance.BOTTOM + BURN = p5_instance.BURN + CENTER = p5_instance.CENTER + CHORD = p5_instance.CHORD + CLAMP = p5_instance.CLAMP + CLOSE = p5_instance.CLOSE + CONTROL = p5_instance.CONTROL + CORNER = p5_instance.CORNER + CORNERS = p5_instance.CORNERS + CROSS = p5_instance.CROSS + CURVE = p5_instance.CURVE + DARKEST = p5_instance.DARKEST + DEG_TO_RAD = p5_instance.DEG_TO_RAD + DEGREES = p5_instance.DEGREES + DELETE = p5_instance.DELETE + DIFFERENCE = p5_instance.DIFFERENCE + DILATE = p5_instance.DILATE + DODGE = p5_instance.DODGE + DOWN_ARROW = p5_instance.DOWN_ARROW + ENTER = p5_instance.ENTER + ERODE = p5_instance.ERODE + ESCAPE = p5_instance.ESCAPE + EXCLUSION = p5_instance.EXCLUSION + FILL = p5_instance.FILL + GRAY = p5_instance.GRAY + GRID = p5_instance.GRID + HALF_PI = p5_instance.HALF_PI + HAND = p5_instance.HAND + HARD_LIGHT = p5_instance.HARD_LIGHT + HSB = p5_instance.HSB + HSL = p5_instance.HSL + IMAGE = p5_instance.IMAGE + IMMEDIATE = p5_instance.IMMEDIATE + INVERT = p5_instance.INVERT + ITALIC = p5_instance.ITALIC + LANDSCAPE = p5_instance.LANDSCAPE + LEFT = p5_instance.LEFT + LEFT_ARROW = p5_instance.LEFT_ARROW + LIGHTEST = p5_instance.LIGHTEST + LINE_LOOP = p5_instance.LINE_LOOP + LINE_STRIP = p5_instance.LINE_STRIP + LINEAR = p5_instance.LINEAR + LINES = p5_instance.LINES + MIRROR = p5_instance.MIRROR + MITER = p5_instance.MITER + MOVE = p5_instance.MOVE + MULTIPLY = p5_instance.MULTIPLY + NEAREST = p5_instance.NEAREST + NORMAL = p5_instance.NORMAL + OPAQUE = p5_instance.OPAQUE + OPEN = p5_instance.OPEN + OPTION = p5_instance.OPTION + OVERLAY = p5_instance.OVERLAY + PI = p5_instance.PI + PIE = p5_instance.PIE + POINTS = p5_instance.POINTS + PORTRAIT = p5_instance.PORTRAIT + POSTERIZE = p5_instance.POSTERIZE + PROJECT = p5_instance.PROJECT + QUAD_STRIP = p5_instance.QUAD_STRIP + QUADRATIC = p5_instance.QUADRATIC + QUADS = p5_instance.QUADS + QUARTER_PI = p5_instance.QUARTER_PI + RAD_TO_DEG = p5_instance.RAD_TO_DEG + RADIANS = p5_instance.RADIANS + RADIUS = p5_instance.RADIUS + REPEAT = p5_instance.REPEAT + REPLACE = p5_instance.REPLACE + RETURN = p5_instance.RETURN + RGB = p5_instance.RGB + RIGHT = p5_instance.RIGHT + RIGHT_ARROW = p5_instance.RIGHT_ARROW + ROUND = p5_instance.ROUND + SCREEN = p5_instance.SCREEN + SHIFT = p5_instance.SHIFT + SOFT_LIGHT = p5_instance.SOFT_LIGHT + SQUARE = p5_instance.SQUARE + STROKE = p5_instance.STROKE + SUBTRACT = p5_instance.SUBTRACT + TAB = p5_instance.TAB + TAU = p5_instance.TAU + TEXT = p5_instance.TEXT + TEXTURE = p5_instance.TEXTURE + THRESHOLD = p5_instance.THRESHOLD + TOP = p5_instance.TOP + TRIANGLE_FAN = p5_instance.TRIANGLE_FAN + TRIANGLE_STRIP = p5_instance.TRIANGLE_STRIP + TRIANGLES = p5_instance.TRIANGLES + TWO_PI = p5_instance.TWO_PI + UP_ARROW = p5_instance.UP_ARROW + WAIT = p5_instance.WAIT + WEBGL = p5_instance.WEBGL + P2D = p5_instance.P2D + PI = p5_instance.PI + frameCount = p5_instance.frameCount + focused = p5_instance.focused + displayWidth = p5_instance.displayWidth + displayHeight = p5_instance.displayHeight + windowWidth = p5_instance.windowWidth + windowHeight = p5_instance.windowHeight + width = p5_instance.width + height = p5_instance.height + disableFriendlyErrors = p5_instance.disableFriendlyErrors + deviceOrientation = p5_instance.deviceOrientation + accelerationX = p5_instance.accelerationX + accelerationY = p5_instance.accelerationY + accelerationZ = p5_instance.accelerationZ + pAccelerationX = p5_instance.pAccelerationX + pAccelerationY = p5_instance.pAccelerationY + pAccelerationZ = p5_instance.pAccelerationZ + rotationX = p5_instance.rotationX + rotationY = p5_instance.rotationY + rotationZ = p5_instance.rotationZ + pRotationX = p5_instance.pRotationX + pRotationY = p5_instance.pRotationY + pRotationZ = p5_instance.pRotationZ + turnAxis = p5_instance.turnAxis + keyIsPressed = p5_instance.keyIsPressed + key = p5_instance.key + keyCode = p5_instance.keyCode + mouseX = p5_instance.mouseX + mouseY = p5_instance.mouseY + pmouseX = p5_instance.pmouseX + pmouseY = p5_instance.pmouseY + winMouseX = p5_instance.winMouseX + winMouseY = p5_instance.winMouseY + pwinMouseX = p5_instance.pwinMouseX + pwinMouseY = p5_instance.pwinMouseY + mouseButton = p5_instance.mouseButton + mouseIsPressed = p5_instance.mouseIsPressed + touches = p5_instance.touches + pixels = p5_instance.pixels + + return draw_func() + + +def global_p5_injection(p5_sketch): + """ + Injects the p5js's skecth instance as a global variable to setup and draw functions + """ + + def decorator(f): + + def wrapper(): + global _P5_INSTANCE + _P5_INSTANCE = p5_sketch + return pre_draw(_P5_INSTANCE, f) + return wrapper + + return decorator + + +def start_p5(setup_func, draw_func, event_functions): + """ + This is the entrypoint function. It accepts 2 parameters: + + - setup_func: a Python setup callable + - draw_func: a Python draw callable + - event_functions: a config dict for the event functions in the format: + {"eventFunctionName": python_event_function} + + This method gets the p5js's sketch instance and injects them + """ + + def sketch_setup(p5_sketch): + p5_sketch.setup = global_p5_injection(p5_sketch)(setup_func) + p5_sketch.draw = global_p5_injection(p5_sketch)(draw_func) + + instance = __new__ (p5(sketch_setup, 'sketch-holder')) + + # inject event functions into p5 + event_function_names = ["deviceMoved", "deviceTurned", "deviceShaken", "keyPressed", "keyReleased", "keyTyped", "mouseMoved", "mouseDragged", "mousePressed", "mouseReleased", "mouseClicked", "doubleClicked", "mouseWheel", "touchStarted", "touchMoved", "touchEnded", "windowResized", ] + + for f_name in [f for f in event_function_names if f in event_functions]: + func = event_functions[f_name] + event_func = global_p5_injection(instance)(func) + setattr(instance, f_name, event_func) diff --git a/2019/sketch_190606b/target/sketch_190606b.js b/2019/sketch_190606b/target/sketch_190606b.js new file mode 100644 index 00000000..23510e1a --- /dev/null +++ b/2019/sketch_190606b/target/sketch_190606b.js @@ -0,0 +1,215 @@ +// Transcrypt'ed from Python, 2019-06-09 19:05:10 +import {AssertionError, AttributeError, BaseException, DeprecationWarning, Exception, IndexError, IterableError, KeyError, NotImplementedError, RuntimeWarning, StopIteration, UserWarning, ValueError, Warning, __JsIterator__, __PyIterator__, __Terminal__, __add__, __and__, __call__, __class__, __envir__, __eq__, __floordiv__, __ge__, __get__, __getcm__, __getitem__, __getslice__, __getsm__, __gt__, __i__, __iadd__, __iand__, __idiv__, __ijsmod__, __ilshift__, __imatmul__, __imod__, __imul__, __in__, __init__, __ior__, __ipow__, __irshift__, __isub__, __ixor__, __jsUsePyNext__, __jsmod__, __k__, __kwargtrans__, __le__, __lshift__, __lt__, __matmul__, __mergefields__, __mergekwargtrans__, __mod__, __mul__, __ne__, __neg__, __nest__, __or__, __pow__, __pragma__, __proxy__, __pyUseJsNext__, __rshift__, __setitem__, __setproperty__, __setslice__, __sort__, __specialattrib__, __sub__, __super__, __t__, __terminal__, __truediv__, __withblock__, __xor__, all, any, assert, bool, bytearray, bytes, callable, chr, deepcopy, delattr, dict, dir, divmod, enumerate, getattr, hasattr, input, isinstance, issubclass, len, list, object, ord, property, py_TypeError, py_iter, py_metatype, py_next, py_reversed, py_typeof, range, repr, setattr, sorted, sum, tuple, zip} from './org.transcrypt.__runtime__.js'; +import {ADD, ALT, ARROW, AUTO, AXES, BACKSPACE, BASELINE, BEVEL, BEZIER, BLEND, BLUR, BOLD, BOLDITALIC, BOTTOM, BURN, CENTER, CHORD, CLAMP, CLOSE, CONTROL, CORNER, CORNERS, CROSS, CURVE, DARKEST, DEGREES, DEG_TO_RAD, DELETE, DIFFERENCE, DILATE, DODGE, DOWN_ARROW, ENTER, ERODE, ESCAPE, EXCLUSION, FILL, GRAY, GRID, HALF_PI, HAND, HARD_LIGHT, HSB, HSL, IMAGE, IMMEDIATE, INVERT, ITALIC, LANDSCAPE, LEFT, LEFT_ARROW, LIGHTEST, LINEAR, LINES, LINE_LOOP, LINE_STRIP, MIRROR, MITER, MOVE, MULTIPLY, NEAREST, NORMAL, OPAQUE, OPEN, OPTION, OVERLAY, P2D, PI, PIE, POINTS, PORTRAIT, POSTERIZE, PROJECT, QUADRATIC, QUADS, QUAD_STRIP, QUARTER_PI, RADIANS, RADIUS, RAD_TO_DEG, REPEAT, REPLACE, RETURN, RGB, RIGHT, RIGHT_ARROW, ROUND, SCREEN, SHIFT, SOFT_LIGHT, SQUARE, STROKE, SUBTRACT, TAB, TAU, TEXT, TEXTURE, THRESHOLD, TOP, TRIANGLES, TRIANGLE_FAN, TRIANGLE_STRIP, TWO_PI, UP_ARROW, WAIT, WEBGL, _CTX_MIDDLE, _DEFAULT_FILL, _DEFAULT_LEADMULT, _DEFAULT_STROKE, _DEFAULT_TEXT_FILL, _P5_INSTANCE, abs, accelerationX, accelerationY, accelerationZ, acos, alpha, ambientLight, ambientMaterial, angleMode, append, applyMatrix, arc, arrayCopy, asin, atan, atan2, background, beginContour, beginShape, bezier, bezierDetail, bezierPoint, bezierTangent, bezierVertex, blend, blendMode, blue, boolean, box, brightness, byte, camera, ceil, char, circle, color, colorMode, concat, cone, constrain, copy, cos, createCamera, createCanvas, createGraphics, createImage, createNumberDict, createShader, createStringDict, createVector, createWriter, cursor, curve, curveDetail, curvePoint, curveTangent, curveTightness, curveVertex, cylinder, day, debugMode, degrees, deviceOrientation, directionalLight, disableFriendlyErrors, displayDensity, displayHeight, displayWidth, dist, ellipse, ellipseMode, ellipsoid, endContour, endShape, exp, fill, filter, float, floor, focused, frameCount, frameRate, fullscreen, getURL, getURLParams, getURLPath, global_p5_injection, green, height, hex, hour, httpDo, httpGet, httpPost, hue, image, imageMode, int, join, key, keyCode, keyIsDown, keyIsPressed, lerp, lerpColor, lightness, lights, line, loadBytes, loadFont, loadImage, loadJSON, loadModel, loadPixels, loadShader, loadStrings, loadTable, loadXML, log, loop, mag, map, match, matchAll, max, millis, min, minute, model, month, mouseButton, mouseIsPressed, mouseX, mouseY, nf, nfc, nfp, nfs, noCanvas, noCursor, noDebugMode, noFill, noLoop, noSmooth, noStroke, noTint, noise, noiseDetail, noiseSeed, norm, normalMaterial, orbitControl, ortho, pAccelerationX, pAccelerationY, pAccelerationZ, pRotationX, pRotationY, pRotationZ, perspective, pixelDensity, pixels, plane, pmouseX, pmouseY, point, pointLight, pow, pre_draw, preload, print, push, pwinMouseX, pwinMouseY, py_clear, py_get, py_pop, py_sort, py_split, quad, quadraticVertex, radians, random, randomGaussian, randomSeed, rect, rectMode, red, redraw, remove, resetMatrix, resetShader, resizeCanvas, reverse, rotate, rotateX, rotateY, rotateZ, rotationX, rotationY, rotationZ, round, saturation, save, saveCanvas, saveFrames, saveJSON, saveStrings, saveTable, scale, second, set, setAttributes, setCamera, setMoveThreshold, setShakeThreshold, shader, shearX, shearY, shininess, shorten, shuffle, sin, smooth, specularMaterial, sphere, splice, splitTokens, sq, sqrt, square, start_p5, str, stroke, strokeCap, strokeJoin, strokeWeight, subset, tan, text, textAlign, textAscent, textDescent, textFont, textLeading, textSize, textStyle, textWidth, texture, textureMode, textureWrap, tint, torus, touches, translate, triangle, trim, turnAxis, unchar, unhex, updatePixels, vertex, width, winMouseX, winMouseY, windowHeight, windowWidth, year} from './pytop5js.js'; +var __name__ = '__main__'; +export var pts = list ([]); +export var rds = list ([30, 70, 50]); +export var dragged_pt = -(1); +export var setup = function () { + createCanvas (500, 500); + pts.append (tuple ([250, 150])); + pts.append (tuple ([250 + 100 * cos (PI / 6.0), 250 + 100 * sin (PI / 6.0)])); + pts.append (tuple ([250 - 100 * cos (PI / 6.0), 250 + 100 * sin (PI / 6.0)])); +}; +export var draw = function () { + background (200); + fill (255, 100); + b_poly_arc_augmented (pts, rds); + fill (0, 0, 100); + for (var pt of pts) { + ellipse (pt [0], pt [1], 10, 10); + } +}; +export var keyPressed = function () { + var delta = 0; + if (key == '-') { + var delta = -(1); + } + else if (key == '=' || key == '+') { + var delta = 1; + } + for (var [i, pt] of enumerate (pts)) { + if (dist (mouseX, mouseY, pt [0], pt [1]) < 10) { + rds [i] += 5 * delta; + } + } + return false; +}; +export var mousePressed = function () { + for (var [i, pt] of enumerate (pts)) { + if (dist (mouseX, mouseY, pt [0], pt [1]) < 10) { + dragged_pt = i; + break; + } + } +}; +export var mouseDragged = function () { + if (dragged_pt >= 0) { + pts [dragged_pt] = tuple ([mouseX, mouseY]); + } +}; +export var mouseReleased = function () { + dragged_pt = -(1); +}; +export var b_poly_arc_augmented = function (op_list, or_list) { + var __left0__ = tuple ([list ([]), list ([]), or_list.__getslice__ (0, null, 1)]); + var p_list = __left0__ [0]; + var r_list = __left0__ [1]; + var r2_list = __left0__ [2]; + for (var [i1, p1] of enumerate (op_list)) { + var i2 = __mod__ (i1 + 1, len (op_list)); + var __left0__ = tuple ([op_list [i2], r2_list [i2], r2_list [i1]]); + var p2 = __left0__ [0]; + var r2 = __left0__ [1]; + var r1 = __left0__ [2]; + if (dist (p1 [0], p1 [1], p2 [0], p2 [1]) > 1) { + p_list.append (p1); + r_list.append (r1); + } + else { + r2_list [i2] = min (r1, r2); + } + } + for (var [i1, p1] of enumerate (p_list)) { + var i2 = __mod__ (i1 + 1, len (p_list)); + var __left0__ = tuple ([p_list [i2], r_list [i2], r_list [i1]]); + var p2 = __left0__ [0]; + var r2 = __left0__ [1]; + var r1 = __left0__ [2]; + var __left0__ = reduce_radius (p1, p2, r1, r2); + r_list [i1] = __left0__ [0]; + r_list [i2] = __left0__ [1]; + } + var a_list = list ([]); + for (var [i1, p1] of enumerate (p_list)) { + var i2 = __mod__ (i1 + 1, len (p_list)); + var __left0__ = tuple ([p_list [i2], r_list [i2], r_list [i1]]); + var p2 = __left0__ [0]; + var r2 = __left0__ [1]; + var r1 = __left0__ [2]; + var a = circ_circ_tangent (p1, p2, r1, r2); + a_list.append (a); + } + beginShape (); + for (var [i1, _] of enumerate (a_list)) { + var i2 = __mod__ (i1 + 1, len (a_list)); + var __left0__ = tuple ([p_list [i1], p_list [i2], r_list [i1], r_list [i2]]); + var p1 = __left0__ [0]; + var p2 = __left0__ [1]; + var r1 = __left0__ [2]; + var r2 = __left0__ [3]; + var __left0__ = a_list [i1]; + var a1 = __left0__ [0]; + var p11 = __left0__ [1]; + var p12 = __left0__ [2]; + var __left0__ = a_list [i2]; + var a2 = __left0__ [0]; + var p21 = __left0__ [1]; + var p22 = __left0__ [2]; + if (a1 && a2) { + var start = (a1 < a2 ? a1 : a1 - TWO_PI); + if (r2 < 0) { + var a2 = a2 - TWO_PI; + } + b_arc (p2 [0], p2 [1], r2 * 2, r2 * 2, start, a2, 2); + } + else { + if (a1) { + vertex (p12 [0], p12 [1]); + } + if (a2) { + vertex (p21 [0], p21 [1]); + } + } + } + endShape (CLOSE); +}; +export var reduce_radius = function (p1, p2, r1, r2) { + var d = dist (p1 [0], p1 [1], p2 [0], p2 [1]); + var ri = abs (r1 - r2); + if (d - ri < 0) { + if (r1 > r2) { + var r1 = map (d, ri + 1, 0, r1, r2); + } + else { + var r2 = map (d, ri + 1, 0, r2, r1); + } + } + return tuple ([r1, r2]); +}; +export var circ_circ_tangent = function (p1, p2, r1, r2) { + var d = dist (p1 [0], p1 [1], p2 [0], p2 [1]); + var ri = r1 - r2; + var line_angle = atan2 (p1 [0] - p2 [0], p2 [1] - p1 [1]); + if (d - abs (ri) > 0) { + var theta = asin (ri / float (d)); + var x1 = -(cos (line_angle + theta)) * r1; + var y1 = -(sin (line_angle + theta)) * r1; + var x2 = -(cos (line_angle + theta)) * r2; + var y2 = -(sin (line_angle + theta)) * r2; + return tuple ([line_angle + theta, tuple ([p1 [0] - x1, p1 [1] - y1]), tuple ([p2 [0] - x2, p2 [1] - y2])]); + } + else { + return tuple ([null, tuple ([p1 [0], p1 [1]]), tuple ([p2 [0], p2 [1]])]); + } +}; +export var b_arc = function (cx, cy, w, h, start_angle, end_angle, mode) { + var theta = end_angle - start_angle; + if (mode != 1 || abs (theta) < HALF_PI) { + var x0 = cos (theta / 2.0); + var y0 = sin (theta / 2.0); + var x3 = x0; + var y3 = 0 - y0; + var x1 = (4.0 - x0) / 3.0; + if (y0 != 0) { + var y1 = ((1.0 - x0) * (3.0 - x0)) / (3.0 * y0); + } + else { + var y1 = 0; + } + var x2 = x1; + var y2 = 0 - y1; + var bezAng = start_angle + theta / 2.0; + var cBezAng = cos (bezAng); + var sBezAng = sin (bezAng); + var rx0 = cBezAng * x0 - sBezAng * y0; + var ry0 = sBezAng * x0 + cBezAng * y0; + var rx1 = cBezAng * x1 - sBezAng * y1; + var ry1 = sBezAng * x1 + cBezAng * y1; + var rx2 = cBezAng * x2 - sBezAng * y2; + var ry2 = sBezAng * x2 + cBezAng * y2; + var rx3 = cBezAng * x3 - sBezAng * y3; + var ry3 = sBezAng * x3 + cBezAng * y3; + var __left0__ = tuple ([w / 2.0, h / 2.0]); + var rx = __left0__ [0]; + var ry = __left0__ [1]; + var px0 = cx + rx * rx0; + var py0 = cy + ry * ry0; + var px1 = cx + rx * rx1; + var py1 = cy + ry * ry1; + var px2 = cx + rx * rx2; + var py2 = cy + ry * ry2; + var px3 = cx + rx * rx3; + var py3 = cy + ry * ry3; + } + if (mode == 0) { + beginShape (); + } + if (mode != 1) { + vertex (px3, py3); + } + if (abs (theta) < HALF_PI) { + bezierVertex (px2, py2, px1, py1, px0, py0); + } + else { + b_arc (cx, cy, w, h, start_angle, end_angle - theta / 2.0, __kwargtrans__ ({mode: 1})); + b_arc (cx, cy, w, h, start_angle + theta / 2.0, end_angle, __kwargtrans__ ({mode: 1})); + } + if (mode == 0) { + endShape (); + } +}; +export var event_functions = dict ({'mousePressed': mousePressed, 'mouseDragged': mouseDragged, 'mouseReleased': mouseReleased, 'keyPressed': keyPressed}); +start_p5 (setup, draw, event_functions); + +//# sourceMappingURL=sketch_190606b.map \ No newline at end of file diff --git a/2019/sketch_190606b/target/sketch_190606b.map b/2019/sketch_190606b/target/sketch_190606b.map new file mode 100644 index 00000000..10c66374 --- /dev/null +++ b/2019/sketch_190606b/target/sketch_190606b.map @@ -0,0 +1,8 @@ +{ + "version": 3, + "file": "sketch_190606b.js", + "sources": [ + "sketch_190606b.py" + ], + "mappings": "AAAA;AAAA;AAAA;AAAA;AAEA;AACA;AACA;AAEA;AACA;AACA;AAGA;AAEA;AAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AAEA;AACA;AACA;AAAA;AACA;AACA;AAAA;AACA;AACA;AAAA;AAAA;AAAA;AAEA;AAAA;AAEA;AAEA;AACA;AACA;AAAA;AAAA;AAAA;AAAA;AAGA;AACA;AACA;AAAA;AAAA;AAEA;AAEA;AAAA;AAEA;AAIA;AAAA;AAAA;AAAA;AACA;AACA;AACA;AAAA;AAAA;AAAA;AACA;AACA;AACA;AAAA;AACA;AACA;AAAA;AAAA;AAEA;AACA;AACA;AAAA;AAAA;AAAA;AACA;AAAA;AAAA;AAAA;AAEA;AACA;AACA;AACA;AAAA;AAAA;AAAA;AACA;AACA;AAAA;AAEA;AACA;AACA;AACA;AAAA;AAAA;AAAA;AAAA;AACA;AAAA;AAAA;AAAA;AACA;AAAA;AAAA;AAAA;AACA;AACA;AACA;AACA;AAAA;AACA;AAAA;AACA;AAIA;AACA;AAAA;AACA;AACA;AAAA;AAAA;AAAA;AACA;AAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AAAA;AACA;AACA;AAAA;AAAA;AACA;AAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGA;AACA;AAAA;AAAA;AAIA;AASA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AACA;AACA;AAAA;AACA;AACA;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAAA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAMA;AACA;AAAA;AACA;AACA;AAAA;AACA;AACA;AAAA;AACA;AAEA;AACA;AAAA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AAjMA" +} \ No newline at end of file diff --git a/2019/sketch_190606b/target/sketch_190606b.options b/2019/sketch_190606b/target/sketch_190606b.options index 2e247eacbfe0a86a50538043b12e8f9bf8317c5c..2e7b351720cbeeb0ad1465d333a56532913ef62c 100644 GIT binary patch delta 97 zcmey(GKY17h=C6S1A~4>er~FMS!Pa7Vo_?besOkcNpeO~ettHTshg;ql31y4WMF8i tzfppVNl_Q1skFFAKPNvqF-JcqGfBUovLquv&sfh)KP9ucWU?QVE&u`b9{~UW delta 64 zcmbQk`kQ5f2#W#(1H(oaE+!odAVWVRKQ~psEHfu3u_(1zUoR&=IWb2+Co@UEpt2+* SKhIdtOusm@Bz1B=lP&;8j}w9b diff --git a/2019/sketch_190606b/target/sketch_190606b.py b/2019/sketch_190606b/target/sketch_190606b.py new file mode 100644 index 00000000..e3cf402b --- /dev/null +++ b/2019/sketch_190606b/target/sketch_190606b.py @@ -0,0 +1,194 @@ +from pytop5js import * + +pts = [] +rds = [30, 70, 50] +dragged_pt = -1 + +def setup(): + createCanvas(500, 500) + pts.append((250, 150)) + + pts.append((250 + 100 * cos(PI / 6.0), + 250 + 100 * sin(PI / 6.0))) + pts.append((250 - 100 * cos(PI / 6.0), + 250 + 100 * sin(PI / 6.0))) + +def draw(): + background(200) + fill(255, 100) + b_poly_arc_augmented(pts, rds) + fill(0, 0, 100) + for pt in pts: + ellipse(pt[0], pt[1], 10, 10) + + +def keyPressed(): + global r, d + delta = 0 + if key == "-": + delta = -1 + elif key == "=" or key == "+": + delta = 1 + for i, pt in enumerate(pts): + if dist(mouseX, mouseY, pt[0], pt[1]) < 10: + rds[i] += 5 * delta + return False + +def mousePressed(): + global dragged_pt + for i, pt in enumerate(pts): + if dist(mouseX, mouseY, pt[0], pt[1]) < 10: + dragged_pt = i + break + +def mouseDragged(): + if dragged_pt >= 0: + pts[dragged_pt] = mouseX, mouseY + +def mouseReleased(): + global dragged_pt + dragged_pt = -1 + +def b_poly_arc_augmented(op_list, or_list): + assert len(op_list) == len(or_list), \ + "Number of points and radii not the same" + # remove overlapping adjacent points + p_list, r_list, r2_list = [], [], or_list[:] + for i1, p1 in enumerate(op_list): + i2 = (i1 + 1) % len(op_list) + p2, r2, r1 = op_list[i2], r2_list[i2], r2_list[i1] + if dist(p1[0], p1[1], p2[0], p2[1]) > 1: # or p1 != p2: + p_list.append(p1) + r_list.append(r1) + else: + r2_list[i2] = min(r1, r2) + # reduce radius that won't fit + for i1, p1 in enumerate(p_list): + i2 = (i1 + 1) % len(p_list) + p2, r2, r1 = p_list[i2], r_list[i2], r_list[i1] + r_list[i1], r_list[i2] = reduce_radius(p1, p2, r1, r2) + # calculate the tangents + a_list = [] + for i1, p1 in enumerate(p_list): + i2 = (i1 + 1) % len(p_list) + p2, r2, r1 = p_list[i2], r_list[i2], r_list[i1] + a = circ_circ_tangent(p1, p2, r1, r2) + a_list.append(a) + # draw + beginShape() + for i1, _ in enumerate(a_list): + i2 = (i1 + 1) % len(a_list) + p1, p2, r1, r2 = p_list[i1], p_list[i2], r_list[i1], r_list[i2] + a1, p11, p12 = a_list[i1] + a2, p21, p22 = a_list[i2] + if a1 and a2: + start = a1 if a1 < a2 else a1 - TWO_PI + if r2 < 0: + a2 = a2 - TWO_PI + b_arc(p2[0], p2[1], r2 * 2, r2 * 2, start, a2, 2) + else: + # when the the segment is smaller than the diference between + # radius, circ_circ_tangent won't renturn the angle + # ellipse(p2[0], p2[1], r2 * 2, r2 * 2) # debug + if a1: + vertex(p12[0], p12[1]) + if a2: + vertex(p21[0], p21[1]) + endShape(CLOSE) + +def reduce_radius(p1, p2, r1, r2): + d = dist(p1[0], p1[1], p2[0], p2[1]) + ri = abs(r1 - r2) + if d - ri < 0: + if r1 > r2: + r1 = map(d, ri + 1, 0, r1, r2) + else: + r2 = map(d, ri + 1, 0, r2, r1) + return(r1, r2) + +def circ_circ_tangent(p1, p2, r1, r2): + d = dist(p1[0], p1[1], p2[0], p2[1]) + ri = r1 - r2 + line_angle = atan2(p1[0] - p2[0], p2[1] - p1[1]) + if d - abs(ri) > 0: + theta = asin(ri / float(d)) + x1 = -cos(line_angle + theta) * r1 + y1 = -sin(line_angle + theta) * r1 + x2 = -cos(line_angle + theta) * r2 + y2 = -sin(line_angle + theta) * r2 + return (line_angle + theta, + (p1[0] - x1, p1[1] - y1), + (p2[0] - x2, p2[1] - y2)) + else: + return (None, + (p1[0], p1[1]), + (p2[0], p2[1])) + +def b_arc(cx, cy, w, h, start_angle, end_angle, mode): + """ + A bezier approximation of an arc + using the same signature as the original Processing arc() + mode: 0 "normal" arc, using beginShape() and endShape() + 1 "middle" used in recursive call of smaller arcs + 2 "naked" like normal, but without beginShape() and endShape() + for use inside a larger PShape + """ + theta = end_angle - start_angle + # Compute raw Bezier coordinates. + if mode != 1 or abs(theta) < HALF_PI: + x0 = cos(theta / 2.0) + y0 = sin(theta / 2.0) + x3 = x0 + y3 = 0 - y0 + x1 = (4.0 - x0) / 3.0 + if y0 != 0: + y1 = ((1.0 - x0) * (3.0 - x0)) / (3.0 * y0) # y0 != 0... + else: + y1 = 0 + x2 = x1 + y2 = 0 - y1 + # Compute rotationally-offset Bezier coordinates, using: + # x' = cos(angle) * x - sin(angle) * y + # y' = sin(angle) * x + cos(angle) * y + bezAng = start_angle + theta / 2.0 + cBezAng = cos(bezAng) + sBezAng = sin(bezAng) + rx0 = cBezAng * x0 - sBezAng * y0 + ry0 = sBezAng * x0 + cBezAng * y0 + rx1 = cBezAng * x1 - sBezAng * y1 + ry1 = sBezAng * x1 + cBezAng * y1 + rx2 = cBezAng * x2 - sBezAng * y2 + ry2 = sBezAng * x2 + cBezAng * y2 + rx3 = cBezAng * x3 - sBezAng * y3 + ry3 = sBezAng * x3 + cBezAng * y3 + # Compute scaled and translated Bezier coordinates. + rx, ry = w / 2.0, h / 2.0 + px0 = cx + rx * rx0 + py0 = cy + ry * ry0 + px1 = cx + rx * rx1 + py1 = cy + ry * ry1 + px2 = cx + rx * rx2 + py2 = cy + ry * ry2 + px3 = cx + rx * rx3 + py3 = cy + ry * ry3 + # Debug points... comment this out! + # stroke(0) + # ellipse(px3, py3, 15, 15) + # ellipse(px0, py0, 5, 5) + # Drawing + if mode == 0: # 'normal' arc (not 'middle' nor 'naked') + beginShape() + if mode != 1: # if not 'middle' + vertex(px3, py3) + if abs(theta) < HALF_PI: + bezierVertex(px2, py2, px1, py1, px0, py0) + else: + # to avoid distortion, break into 2 smaller arcs + b_arc(cx, cy, w, h, start_angle, end_angle - theta / 2.0, mode=1) + b_arc(cx, cy, w, h, start_angle + theta / 2.0, end_angle, mode=1) + if mode == 0: # end of a 'normal' arc + endShape() + +# ==== This is required by pyp5js to work +event_functions = { "mousePressed": mousePressed, "mouseDragged": mouseDragged, "mouseReleased": mouseReleased, "keyPressed":keyPressed } +start_p5(setup, draw, event_functions)