diff options
Diffstat (limited to 'assets/viz/1/quil/core.cljc')
| -rw-r--r-- | assets/viz/1/quil/core.cljc | 4993 |
1 files changed, 4993 insertions, 0 deletions
diff --git a/assets/viz/1/quil/core.cljc b/assets/viz/1/quil/core.cljc new file mode 100644 index 0000000..dcdaa94 --- /dev/null +++ b/assets/viz/1/quil/core.cljc @@ -0,0 +1,4993 @@ +(ns ^{:doc "Wrappers and extensions around the core Processing.org API."} + quil.core + #?(:clj + (:import [processing.core PApplet PImage PGraphics PFont PConstants PShape] + [processing.opengl PShader] + [java.awt.event KeyEvent])) + #?(:clj + (:require quil.sketch + [clojure.set] + [quil.helpers.docs :as docs] + [quil.util :as u] + [quil.applet :as ap]) + + :cljs + (:require clojure.string + org.processingjs.Processing + [quil.sketch :as ap :include-macros true] + [quil.util :as u :include-macros true]))) + +(def ^{:dynamic true + :private true} + *graphics* nil) + +(def ^{:private true} no-fill-prop "no-fill-quil") + +(defn + ^{:requires-bindings true + :category "Environment" + :subcategory nil + :added "2.0" + :tag PGraphics} + current-graphics + "Graphics currently used for drawing. By default it is sketch graphics, + but if called inside with-graphics macro - graphics passed to the macro + is returned. This method should be used if you need to call some methods + that are not implemented by quil. Example: + (.beginDraw (current-graphics))." + [] + (or *graphics* + #?(:clj (.-g (ap/current-applet)) + :cljs (ap/current-applet)))) + +;; -------------------- PConstants section ----------------------- + +(u/generate-quil-constants #?(:clj :clj :cljs :cljs) + arc-modes (:open :chord :pie) + shape-modes (:points :lines :triangles :triangle-fan :triangle-strip :quads :quad-strip) + blend-modes (:blend :add :subtract :darkest :lightest :difference :exclusion :multiply + :screen :overlay :replace :hard-light :soft-light :dodge :burn) + color-modes (:rgb :hsb) + image-formats (:rgb :argb :alpha) + ellipse-modes (:center :radius :corner :corners) + hint-options (:enable-depth-test :disable-depth-test + :enable-depth-sort :disable-depth-sort + :enable-depth-mask :disable-depth-mask + :enable-opengl-errors :disable-opengl-errors + :enable-optimized-stroke :disable-optimized-stroke + :enable-stroke-perspective :disable-stroke-perspective + :enable-stroke-pure :disable-stroke-pure + :enable-texture-mipmaps :disable-texture-mipmaps) + image-modes (:corner :corners :center) + rect-modes (:corner :corners :center :radius) + p-shape-modes (:corner :corners :center) + stroke-cap-modes (:square :round :project :model) + stroke-join-modes (:miter :bevel :round) + horizontal-alignment-modes (:left :center :right) + vertical-alignment-modes (:top :bottom :center :baseline) + text-modes (:model :shape) + texture-modes (:image :normal) + texture-wrap-modes (:clamp :repeat) + filter-modes (:threshold :gray :invert :posterize :blur :opaque :erode :dilate) + cursor-modes (:arrow :cross :hand :move :text :wait)) + +;;; Useful trig constants +#?(:clj (def PI (float Math/PI)) + :cljs (def PI (.-PI js/Math))) +(def HALF-PI (/ PI (float 2.0))) +(def THIRD-PI (/ PI (float 3.0))) +(def QUARTER-PI (/ PI (float 4.0))) +(def TWO-PI (* PI (float 2.0))) + +(def DEG-TO-RAD (/ PI (float 180.0))) +(def RAD-TO-DEG (/ (float 180.0) PI)) + +#?(:clj + (def ^{:private true} + KEY-CODES {KeyEvent/VK_UP :up + KeyEvent/VK_DOWN :down + KeyEvent/VK_LEFT :left + KeyEvent/VK_RIGHT :right + KeyEvent/VK_ALT :alt + KeyEvent/VK_CONTROL :control + KeyEvent/VK_SHIFT :shift + KeyEvent/VK_WINDOWS :command + KeyEvent/VK_META :command + KeyEvent/VK_F1 :f1 + KeyEvent/VK_F2 :f2 + KeyEvent/VK_F3 :f3 + KeyEvent/VK_F4 :f4 + KeyEvent/VK_F5 :f5 + KeyEvent/VK_F6 :f6 + KeyEvent/VK_F7 :f7 + KeyEvent/VK_F8 :f8 + KeyEvent/VK_F9 :f9 + KeyEvent/VK_F10 :f10 + KeyEvent/VK_F11 :f11 + KeyEvent/VK_F12 :f12 + KeyEvent/VK_F13 :f13 + KeyEvent/VK_F14 :f14 + KeyEvent/VK_F15 :f15 + KeyEvent/VK_F16 :f16 + KeyEvent/VK_F17 :f17 + KeyEvent/VK_F18 :f18 + KeyEvent/VK_F19 :f19 + KeyEvent/VK_F20 :f20 + KeyEvent/VK_F21 :f21 + KeyEvent/VK_F22 :f22 + KeyEvent/VK_F23 :f23 + KeyEvent/VK_F24 :f24}) + + :cljs + (def ^{:private true} + KEY-CODES {38 :up + 40 :down + 37 :left + 39 :right + 18 :alt + 17 :control + 16 :shift + 157 :command + 112 :f1 + 113 :f2 + 114 :f3 + 115 :f4 + 116 :f5 + 117 :f6 + 118 :f7 + 119 :f8 + 120 :f9 + 121 :f10 + 122 :f11 + 123 :f12})) + +;; ------------------ end PConstants section --------------------- + +#?(:cljs + (defn + ^{:require-bindings true + :category "Output" + :subcategory "Text area" + :added "1.0"} + prc-println + "Writes to the text area of the Processing environment's console. + This is often helpful for looking at the data a program is producing. + Each call to this function creates a new line of output. + Individual elements can be separated with quotes (\"\") and joined with the string concatenation operator (+). + Also writes the content of an array to the text area of the Processing environment. + This is often helpful for looking at the data a program is producing. + A new line is put between each element of the array. This function can only print 1D arrays, + but can test to see if the content are null or not null for 2+ dimensional arrays." + [msg] + (.println (ap/current-applet) msg))) + +#?(:cljs + (defn + ^{:require-bindings true + :category "Output" + :subcategory "Text area" + :added "1.0"} + prc-print + "Writes to the console area of the Processing environment. + This is often helpful for looking at the data a program is producing. + The companion function println() works like print(), but creates a new line of text for each call to the function. + Individual elements can be separated with quotes (\"\") and joined with the addition operator (+). " + [msg] + (.print (ap/current-applet) msg))) + +#?(:cljs + (defn + ^{:requires-bindings true + :processing-name "getSketchById()" + :category nil + :subcategory nil + :added "1.0"} + get-sketch-by-id + "Returns sketch object by id of canvas element of sketch." + [id] + (.getInstanceById js/Processing id))) + +(defmacro with-sketch [applet & body] + (when-not (u/clj-compilation?) + `(quil.sketch/with-sketch ~applet ~@body))) + +(defn + ^{:requires-bindings true + :category "State" + :subcategory nil + :added "1.0"} + state-atom + "Retrieve sketch-specific state-atom. All changes to the + atom will be reflected in the state. + + (set-state! :foo 1) + (state :foo) ;=> 1 + (swap! (state-atom) update-in [:foo] inc) + (state :foo) ;=> 2" + #?(:clj ([] (-> (ap/current-applet) meta :state)) + :cljs ([] (. (ap/current-applet) -quil)))) + +(defn + ^{:requires-bindings true + :category "State" + :subcategory nil + :added "1.0"} + state + "Retrieve sketch-specific state by key. Must initially call + set-state! to store state. If no parameter passed whole + state map is returned. + + (set-state! :foo 1) + (state :foo) ;=> 1 + (state) ;=> {:foo 1}" + ([] @(state-atom)) + + ([key] (let [state (state)] + (when-not (contains? state key) + (throw #?(:clj (Exception. (str "Unable to find state with key: " key)) + :cljs (js/Error (str "Unable to find state with key: " key))))) + (get state key)))) + +(defn + ^{:requires-bindings true + :category "State" + :subcategory nil + :added "1.0"} + set-state! + "Set sketch-specific state. May only be called once (ideally in the + setup fn). Subsequent calls have no effect. + + Example: + (set-state! :foo 1 :bar (atom true) :baz (/ (width) 2))" + [& state-vals] + (let [state* (state-atom)] + (when-not @state* + (let [state-map (apply hash-map state-vals)] + (reset! state* state-map))))) + +#?(:clj + (defn + ^{:requires-bindings false + :processing-name "abs()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + abs-int + "Calculates the absolute value (magnitude) of a number. The absolute + value of a number is always positive. Takes and returns an int." + [n] + (PApplet/abs (int n)))) + +#?(:clj + (defn + ^{:requires-bindings false + :processing-name "abs()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + abs-float + "Calculates the absolute value (magnitude) of a number. The absolute + value of a number is always positive. Takes and returns a float." + [n] + (PApplet/abs (float n)))) + + +(defn + ^{:requires-bindings false + :processing-name "abs()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + abs + "Calculates the absolute value (magnitude) of a number. The + absolute value of a number is always positive. Dynamically casts to + an int or float appropriately" + [n] + #?(:clj + (if (u/int-like? n) + (abs-int n) + (abs-float n)) + :cljs + (.abs (ap/current-applet) n))) + +(defn + ^{:requires-bindings false + :processing-name "acos()" + :category "Math" + :subcategory "Trigonometry" + :added "1.0"} + acos + "The inverse of cos, returns the arc cosine of a value. This + function expects the values in the range of -1 to 1 and values are + returned in the range 0 to Math/PI (3.1415927)." + [n] + #?(:clj (PApplet/acos (float n)) + :cljs (.acos (ap/current-applet) n))) + +(defn + ^{:requires-bindings true + :processing-name "alpha()" + :category "Color" + :subcategory "Creating & Reading" + :added "1.0"} + alpha + "Extracts the alpha value from a color." + [color] + (.alpha (current-graphics) (unchecked-int color))) + +(defn + ^{:requires-bindings true + :processing-name "ambient()" + :category "Lights, Camera" + :subcategory "Material Properties" + :added "1.0"} + ambient-float + "Sets the ambient reflectance for shapes drawn to the screen. This + is combined with the ambient light component of environment. The + color components set through the parameters define the + reflectance. For example in the default color mode, setting x=255, + y=126, z=0, would cause all the red light to reflect and half of the + green light to reflect. Used in combination with emissive, specular, + and shininess in setting the material properties of shapes." + ([gray] (.ambient (current-graphics) (float gray))) + ([x y z] (.ambient (current-graphics) (float x) (float y) (float z)))) + +(defn + ^{:requires-bindings true + :processing-name "ambient()" + :category "Lights, Camera" + :subcategory "Material Properties" + :added "1.0"} + ambient-int + "Sets the ambient reflectance for shapes drawn to the screen. This + is combined with the ambient light component of environment. The rgb + color components set define the reflectance. Used in combination + with emissive, specular, and shininess in setting the material + properties of shapes." + [rgb] + (.ambient (current-graphics) (int rgb))) + +(defn + ^{:requires-bindings true + :processing-name "ambient()" + :category "Lights, Camera" + :subcategory "Material Properties" + :added "1.0"} + ambient + "Sets the ambient reflectance for shapes drawn to the screen. This + is combined with the ambient light component of environment. The + color components set through the parameters define the + reflectance. For example in the default color mode, setting x=255, + y=126, z=0, would cause all the red light to reflect and half of the + green light to reflect. Used in combination with emissive, specular, + and shininess in setting the material properties of shapes." + ([rgb] + #?(:clj (if (u/int-like? rgb) (ambient-int rgb) (ambient-float rgb)) + :cljs (ambient-float rgb))) + ([x y z] (ambient-float x y z))) + +(defn + ^{:requires-bindings true + :processing-name "ambientLight()" + :category "Lights, Camera" + :subcategory "Lights" + :added "1.0"} + ambient-light + "Adds an ambient light. Ambient light doesn't come from a specific direction, + the rays have light have bounced around so much that objects are + evenly lit from all sides. Ambient lights are almost always used in + combination with other types of lights. Lights need to be included + in the draw to remain persistent in a looping program. Placing them + in the setup of a looping program will cause them to only have an + effect the first time through the loop. The effect of the + parameters is determined by the current color mode." + ([red green blue] + (.ambientLight (current-graphics) (float red) (float green) (float blue))) + ([red green blue x y z] + (.ambientLight (current-graphics) (float red) (float green) (float blue) + (float x) (float y) (float z)))) + +(defn + ^{:requires-bindings true + :processing-name "applyMatrix()" + :category "Transform" + :subcategory nil + :added "1.0"} + apply-matrix + "Multiplies the current matrix by the one specified through the + parameters. This is very slow because it will try to calculate the + inverse of the transform, so avoid it whenever possible. The + equivalent function in OpenGL is glMultMatrix()." + #?(:clj + ([n00 n01 n02 n10 n11 n12] + (.applyMatrix (current-graphics) + (float n00) (float n01) (float n02) + (float n10) (float n11) (float n12)))) + ([n00 n01 n02 n03 + n10 n11 n12 n13 + n20 n21 n22 n23 + n30 n31 n32 n33] + (.applyMatrix (current-graphics) + (float n00) (float n01) (float n02) (float n03) + (float n10) (float n11) (float n12) (float n13) + (float n20) (float n21) (float n22) (float n23) + (float n30) (float n31) (float n32) (float n33)))) + +(defn + ^{:requires-bindings true + :processing-name "arc()" + :category "Shape" + :subcategory "2D Primitives" + :added "1.0"} + arc + "Draws an arc in the display window. Arcs are drawn along the outer + edge of an ellipse defined by the x, y, width and height + parameters. The origin or the arc's ellipse may be changed with the + ellipse-mode function. The start and stop parameters specify the + angles at which to draw the arc. The mode is either :open, :chord or :pie." + ([x y width height start stop] + (.arc (current-graphics) (float x) (float y) (float width) (float height) + (float start) (float stop))) + + #?(:clj + ([x y width height start stop mode] + (let [arc-mode (u/resolve-constant-key mode arc-modes)] + (.arc (current-graphics) (float x) (float y) (float width) (float height) + (float start) (float stop) (int arc-mode)))))) + +(defn + ^{:requires-bindings false + :processing-name "asin()" + :category "Math" + :subcategory "Trigonometry" + :added "1.0"} + asin + "The inverse of sin, returns the arc sine of a value. This function + expects the values in the range of -1 to 1 and values are returned + in the range -PI/2 to PI/2." + [n] + #?(:clj (PApplet/asin (float n)) + :cljs (.asin (ap/current-applet) n))) + +(defn + ^{:requires-bindings false + :processing-name "atan()" + :category "Math" + :subcategory "Trigonometry" + :added "1.0"} + atan + "The inverse of tan, returns the arc tangent of a value. This + function expects the values in the range of -Infinity to + Infinity (exclusive) and values are returned in the range -PI/2 to + PI/2 ." + [n] + #?(:clj (PApplet/atan (float n)) + :cljs (.atan (ap/current-applet) n))) + +(defn + ^{:requires-bindings false + :processing-name "atan2()" + :category "Math" + :subcategory "Trigonometry" + :added "1.0"} + atan2 + "Calculates the angle (in radians) from a specified point to the + coordinate origin as measured from the positive x-axis. Values are + returned as a float in the range from PI to -PI. The atan2 function + is most often used for orienting geometry to the position of the + cursor. Note: The y-coordinate of the point is the first parameter + and the x-coordinate is the second due to the structure of + calculating the tangent." + [y x] + #?(:clj (PApplet/atan2 (float y) (float x)) + :cljs (.atan2 (ap/current-applet) y x))) + +(defn + ^{:requires-bindings false + :processing-name "PFont.list()" + :category "Typography" + :subcategory "Loading & Displaying" + :added "1.0"} + available-fonts + "A sequence of strings representing the fonts on this system + available for use. + + Because of limitations in Java, not all fonts can be used and some + might work with one operating system and not others. When sharing a + sketch with other people or posting it on the web, you may need to + include a .ttf or .otf version of your font in the data directory of + the sketch because other people might not have the font installed on + their computer. Only fonts that can legally be distributed should be + included with a sketch." + [] + #?(:clj (seq (PFont/list)) + :cljs (seq (.list js/PFont)))) + +(defn + ^{:requires-bindings true + :processing-name "background()" + :category "Color" + :subcategory "Setting" + :added "1.0"} + background-float + "Sets the color used for the background of the Processing + window. The default background is light gray. In the draw function, + the background color is used to clear the display window at the + beginning of each frame. + + It is not possible to use transparency (alpha) in background colors + with the main drawing surface, however they will work properly with + create-graphics. Converts args to floats." + ([gray] (.background (current-graphics) (float gray))) + ([gray alpha] (.background (current-graphics) (float gray) (float alpha))) + ([r g b] (.background (current-graphics) (float r) (float g) (float b))) + ([r g b a] (.background (current-graphics) (float r) (float g) (float b) (float a)))) + +(defn + ^{:requires-bindings true + :processing-name "background()" + :category "Color" + :subcategory "Setting" + :added "1.0"} + background-int + "Sets the color used for the background of the Processing + window. The default background is light gray. In the draw function, + the background color is used to clear the display window at the + beginning of each frame. + + It is not possible to use transparency (alpha) in background colors + with the main drawing surface, however they will work properly with + create-graphics. Converts rgb to an int and alpha to a float." + ([rgb] (.background (current-graphics) (unchecked-int rgb))) + ([rgb alpha] (.background (current-graphics) (unchecked-int rgb) (float alpha)))) + +(defn + ^{:requires-bindings true + :processing-name "background()" + :category "Color" + :subcategory "Setting" + :added "1.0"} + background + "Sets the color used for the background of the Processing + window. The default background is light gray. In the draw function, + the background color is used to clear the display window at the + beginning of each frame. + + It is not possible to use transparency (alpha) in background colors + with the main drawing surface, however they will work properly with + create-graphics. Converts args to floats." + #?(:clj ([rgb] (if (u/int-like? rgb) (background-int rgb) (background-float rgb))) + :cljs ([rgb] (.background (current-graphics) rgb))) + #?(:clj ([rgb alpha] (if (u/int-like? rgb) (background-int rgb alpha) (background-float rgb alpha))) + :cljs ([rgb alpha] (.background (current-graphics) rgb alpha))) + ([r g b] (background-float r g b)) + ([r g b a] (background-float r g b a))) + +(defn + ^{:requires-bindings true + :processing-name "background()" + :category "Color" + :subcategory "Setting" + :added "1.0"} + background-image + "Specify an image to be used as the background for a sketch. Its + width and height must be the same size as the sketch window. Images + used as background will ignore the current tint setting." + [^PImage img] + (.background (current-graphics) img)) + +(defn + ^{:requires-bindings true + :processing-name "beginCamera()" + :category "Lights, Camera" + :subcategory "Camera" + :added "1.0"} + begin-camera + "Sets the matrix mode to the camera matrix so calls such as + translate, rotate, apply-matrix and reset-matrix affect the + camera. begin-camera should always be used with a following + end-camera and pairs of begin-camera and end-camera cannot be + nested. + + For most situations the camera function will be sufficient." + [] + (.beginCamera (current-graphics))) + +(defn + ^{:requires-bindings true + :processing-name "beginContour()" + :category "Shape" + :subcategory "Vertex" + :added "2.0"} + begin-contour + "Use the begin-contour and end-contour function to create negative + shapes within shapes. These functions can only be within a + begin-shape/end-shape pair and they only work with the :p2d and :p3d + renderers." + [] + (.beginContour (current-graphics))) + +#?(:clj + (defn + ^{:requires-bindings true + :processing-name "beginRaw()" + :category "Output" + :subcategory "Files" + :added "1.0"} + begin-raw + "Enables the creation of vectors from 3D data. Requires + corresponding end-raw command. These commands will grab the shape + data just before it is rendered to the screen. At this stage, your + entire scene is nothing but a long list of individual lines and + triangles. This means that a shape created with sphere method will + be made up of hundreds of triangles, rather than a single object. Or + that a multi-segment line shape (such as a curve) will be rendered + as individual segments." + ([renderer filename] + (.beginRaw (ap/current-applet) (ap/resolve-renderer renderer) (u/absolute-path filename))))) + +(defn + ^{:requires-bindings true + :processing-name "beginShape()" + :category "Shape" + :subcategory "Vertex" + :added "1.0"} + begin-shape + "Enables the creation of complex forms. begin-shape begins recording + vertices for a shape and end-shape stops recording. Use the mode + keyword to specify which shape create from the provided + vertices. With no mode specified, the shape can be any irregular + polygon. + + The available mode keywords are :points, :lines, :triangles, + :triangle-fan, :triangle-strip, + :quads, :quad-strip. + + After calling the begin-shape function, a series of vertex commands + must follow. To stop drawing the shape, call end-shape. The vertex + function with two parameters specifies a position in 2D and the + vertex function with three parameters specifies a position in + 3D. Each shape will be outlined with the current stroke color and + filled with the fill color. + + Transformations such as translate, rotate, and scale do not work + within begin-shape. It is also not possible to use other shapes, + such as ellipse or rect within begin-shape." + ([] (.beginShape (current-graphics))) + ([mode] + (let [mode (u/resolve-constant-key mode shape-modes)] + (.beginShape (current-graphics) (int mode))))) + +(defn + ^{:requires-bindings true + :processing-name "bezier()" + :category "Shape" + :subcategory "Curves" + :added "1.0"} + bezier + "Draws a Bezier curve on the screen. These curves are defined by a + series of anchor and control points. The first two parameters + specify the first anchor point and the last two parameters specify + the other anchor point. The middle parameters specify the control + points which define the shape of the curve." + ([x1 y1 cx1 cy1 cx2 cy2 x2 y2] + (.bezier (current-graphics) + (float x1) (float y1) + (float cx1) (float cy1) + (float cx2) (float cy2) + (float x2) (float y2))) + ([x1 y1 z1 cx1 cy1 cz1 cx2 cy2 cz2 x2 y2 z2] + (.bezier (current-graphics) + (float x1) (float y1) (float z1) + (float cx1) (float cy1) (float cz1) + (float cx2) (float cy2) (float cz2) + (float x2) (float y2) (float z2)))) + +(defn + ^{:requires-bindings true + :processing-name "bezierDetail()" + :category "Shape" + :subcategory "Curves" + :added "1.0"} + bezier-detail + "Sets the resolution at which Beziers display. The default value is + 20. This function is only useful when using the :p3d or :opengl + renderer as the default (:java2d) renderer does not use this + information." + [detail] + (.bezierDetail (current-graphics) (int detail))) + +(defn + ^{:requires-bindings true + :processing-name "bezierPoint()" + :category "Shape" + :subcategory "Curves" + :added "1.0"} + bezier-point + "Evaluates the Bezier at point t for points a, b, c, d. The + parameter t varies between 0 and 1, a and d are points on the curve, + and b and c are the control points. This can be done once with the x + coordinates and a second time with the y coordinates to get the + location of a bezier curve at t." + [a b c d t] + (.bezierPoint (current-graphics) (float a) (float b) (float c) + (float d) (float t))) + +(defn + ^{:requires-bindings true + :processing-name "bezierTangent()" + :category "Shape" + :subcategory "Curves" + :added "1.0"} + bezier-tangent + "Calculates the tangent of a point on a Bezier curve. + (See http://en.wikipedia.org/wiki/Tangent)" + [a b c d t] + (.bezierTangent (current-graphics) (float a) (float b) (float c) + (float d) (float t))) + +(defn + ^{:requires-bindings true + :processing-name "bezierVertex()" + :category "Shape" + :subcategory "Vertex" + :added "1.0"} + bezier-vertex + "Specifies vertex coordinates for Bezier curves. Each call to + bezier-vertex defines the position of two control points and one + anchor point of a Bezier curve, adding a new segment to a line or + shape. The first time bezier-vertex is used within a begin-shape + call, it must be prefaced with a call to vertex to set the first + anchor point. This function must be used between begin-shape and + end-shape and only when there is no parameter specified to + begin-shape." + ([cx1 cy1 cx2 cy2 x y] + (.bezierVertex (current-graphics) + (float cx1) (float cy1) + (float cx2) (float cy2) + (float x) (float y))) + ([cx1 cy1 cz1 cx2 cy2 cz2 x y z] + (.bezierVertex (current-graphics) + (float cx1) (float cy1) (float cz1) + (float cx2) (float cy2) (float cz2) + (float x) (float y) (float z)))) + +(defn + ^{:require-binding false + :processing-name "binary()" + :category "Data" + :subcategory "Conversion" + :added "1.0"} + binary + "Returns a string representing the binary value of an int, char or + byte. When converting an int to a string, it is possible to specify + the number of digits used." + ([val] + #?(:clj (PApplet/binary (int val)) + :cljs (.binary (ap/current-applet) val))) + ([val num-digits] + #?(:clj (PApplet/binary (int val) (int num-digits)) + :cljs (.binary (ap/current-applet) val num-digits)))) + +(defn + ^{:requires-bindings true + :processing-name "blend()" + :category "Image" + :subcategory "Pixels" + :added "1.0"} + blend + "Blends a region of pixels from one image into another with full alpha + channel support. If src is not specified it defaults to current-graphics. + If dest is not specified it defaults to current-graphics. + + Note: blend-mode function is recommended to use instead of this one. + + Available blend modes are: + + :blend - linear interpolation of colours: C = A*factor + B + :add - additive blending with white clip: + C = min(A*factor + B, 255) + :subtract - subtractive blending with black clip: + C = max(B - A*factor, 0) + :darkest - only the darkest colour succeeds: + C = min(A*factor, B) + :lightest - only the lightest colour succeeds: + C = max(A*factor, B) + :difference - subtract colors from underlying image. + :exclusion - similar to :difference, but less extreme. + :multiply - Multiply the colors, result will always be darker. + :screen - Opposite multiply, uses inverse values of the colors. + :overlay - A mix of :multiply and :screen. Multiplies dark values + and screens light values. + :hard-light - :screen when greater than 50% gray, :multiply when + lower. + :soft-light - Mix of :darkest and :lightest. Works like :overlay, + but not as harsh. + :dodge - Lightens light tones and increases contrast, ignores + darks. + Called \"Color Dodge\" in Illustrator and Photoshop. + :burn - Darker areas are applied, increasing contrast, ignores + lights. Called \"Color Burn\" in Illustrator and + Photoshop." + ([x y width height dx dy dwidth dheight mode] + (blend (current-graphics) (current-graphics) x y width height dx dy dwidth dheight mode)) + ([^PImage src-img x y width height dx dy dwidth dheight mode] + (blend src-img (current-graphics) x y width height dx dy dwidth dheight mode)) + ([^PImage src-img ^PImage dest-img x y width height dx dy dwidth dheight mode] + (let [mode (u/resolve-constant-key mode blend-modes)] + (.blend dest-img src-img (int x) (int y) (int width) (int height) + (int dx) (int dy) (int dwidth) (int dheight) (int mode))))) + +(defn + ^{:requires-bindings false + :processing-name "blendColor()" + :processing-link nil + :category "Color" + :subcategory "Creating & Reading" + :added "1.0"} + blend-color + "Blends two color values together based on the blending mode given specified + with the mode keyword. + + Available blend modes are: + + :blend - linear interpolation of colours: C = A*factor + B + :add - additive blending with white clip: + C = min(A*factor + B, 255) + :subtract - subtractive blending with black clip: + C = max(B - A*factor, 0) + :darkest - only the darkest colour succeeds: + C = min(A*factor, B) + :lightest - only the lightest colour succeeds: + C = max(A*factor, B) + :difference - subtract colors from underlying image. + :exclusion - similar to :difference, but less extreme. + :multiply - Multiply the colors, result will always be darker. + :screen - Opposite multiply, uses inverse values of the colors. + :overlay - A mix of :multiply and :screen. Multiplies dark values + and screens light values. + :hard-light - :screen when greater than 50% gray, :multiply when + lower. + :soft-light - Mix of :darkest and :lightest. Works like :overlay, + but not as harsh. + :dodge - Lightens light tones and increases contrast, ignores + darks. + Called \"Color Dodge\" in Illustrator and Photoshop. + :burn - Darker areas are applied, increasing contrast, ignores + lights. Called \"Color Burn\" in Illustrator and + Photoshop." + [c1 c2 mode] + (let [mode (u/resolve-constant-key mode blend-modes)] + #?(:clj (PApplet/blendColor (unchecked-int c1) (unchecked-int c2) (int mode)) + :cljs (.blendColor (current-graphics) c1 c2 mode)))) + +#?(:clj + (defn + ^{:requires-bindings true + :processing-name "blendMode()" + :category "Image" + :subcategory "Rendering" + :added "2.0"} + blend-mode + "Blends the pixels in the display window according to the defined mode. + There is a choice of the following modes to blend the source pixels (A) + with the ones of pixels already in the display window (B): + + :blend - linear interpolation of colours: C = A*factor + B + :add - additive blending with white clip: + C = min(A*factor + B, 255) + :subtract - subtractive blending with black clip: + C = max(B - A*factor, 0) + :darkest - only the darkest colour succeeds: + C = min(A*factor, B) + :lightest - only the lightest colour succeeds: + C = max(A*factor, B) + :exclusion - similar to :difference, but less extreme. + :multiply - Multiply the colors, result will always be darker. + :screen - Opposite multiply, uses inverse values of the colors. + :replace - the pixels entirely replace the others and don't utilize + alpha (transparency) values + + Note: :hard-light, :soft-light, :dodge, :overlay, :dodge, :burn, :difference + modes are not supported by this function. + + factor is alpha value of pixel being drawed" + ([mode] + (let [mode (u/resolve-constant-key mode blend-modes)] + (.blendMode (current-graphics) mode))))) + +(defn + ^{:requires-bindings true + :processing-name "blue()" + :category "Color" + :subcategory "Creating & Reading" + :added "1.0"} + blue + "Extracts the blue value from a color, scaled to match current color-mode. + Returns a float." + [color] + (.blue (current-graphics) (unchecked-int color))) + +(defn + ^{:requires-bindings true + :processing-name "box()" + :category "Shape" + :subcategory "3D Primitives" + :added "1.0"} + box + "Creates an extruded rectangle." + ([size] (.box (current-graphics) (float size))) + ([width height depth] (.box (current-graphics) (float width) (float height) (float depth)))) + +(defn + ^{:requires-bindings true + :processing-name "brightness()" + :category "Color" + :subcategory "Creating & Reading" + :added "1.0"} + brightness + "Extracts the brightness value from a color. Returns a float." + [color] + (.brightness (current-graphics) (unchecked-int color))) + +(defn + ^{:requires-bindings true + :processing-name "camera()" + :category "Lights, Camera" + :subcategory "Camera" + :added "1.0"} + camera + "Sets the position of the camera through setting the eye position, + the center of the scene, and which axis is facing upward. Moving the + eye position and the direction it is pointing (the center of the + scene) allows the images to be seen from different angles. The + version without any parameters sets the camera to the default + position, pointing to the center of the display window with the Y + axis as up. The default values are: + + eyeX: (/ (width) 2.0) + eyeY: (/ (height) 2.0) + eyeZ: (/ (/ (height) 2.0) (tan (/ (* Math/PI 60.0) 360.0))) + centerX: (/ (width) 2.0) + centerY: (/ (height) 2.0) + centerZ: 0 + upX: 0 + upY: 1 + upZ: 0 + + Similar imilar to gluLookAt() in OpenGL, but it first clears the + current camera settings." + ([] (.camera (current-graphics))) + ([eyeX eyeY eyeZ centerX centerY centerZ upX upY upZ] + (.camera (current-graphics) (float eyeX) (float eyeY) (float eyeZ) + (float centerX) (float centerY) (float centerZ) + (float upX) (float upY) (float upZ)))) + +(defn + ^{:requires-bindings false + :processing-name "ceil()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + ceil + "Calculates the closest int value that is greater than or equal to + the value of the parameter. For example, (ceil 9.03) returns the + value 10." + [n] + #?(:clj (PApplet/ceil (float n)) + :cljs (.ceil (ap/current-applet) n))) + +#?(:clj + (defn + ^{:requires-bindings true + :processing-name "clear()" + :category "Color" + :subcategory "Setting" + :added "2.4.0"} + clear + "Clears the pixels within a buffer. This function only works on + graphics objects created with the (create-graphics) function meaning + that you should call it only inside (with-graphics) macro. Unlike + the main graphics context (the display window), pixels in additional + graphics areas created with (create-graphics) can be entirely or + partially transparent. This function clears everything in a graphics + object to make all of the pixels 100% transparent." + [] + (.clear (current-graphics)))) + +#?(:clj + (defn + ^{:requires-bindings true + :processing-name "clip()" + :category "Rendering" + :subcategory nil + :added "2.4.0"} + clip + "Limits the rendering to the boundaries of a rectangle defined by + the parameters. The boundaries are drawn based on the state of + the (image-mode) fuction, either :corner, :corners, or :center. + To disable use (no-clip)." + [x y w h] + (.clip (current-graphics) (float x) (float y) (float w) (float h)))) + +(defn + ^{:requires-bindings true + :processing-name "color()" + :category "Color" + :subcategory "Creating & Reading" + :added "1.0"} + color + "Creates an integer representation of a color The parameters are + interpreted as RGB or HSB values depending on the current + color-mode. The default mode is RGB values from 0 to 255 and + therefore, the function call (color 255 204 0) will return a bright + yellow. Args are cast to floats. + + r - red or hue value + g - green or saturation value + b - blue or brightness value + a - alpha value" + ([gray] (.color (current-graphics) (float gray))) + ([gray alpha] (.color (current-graphics) (float gray) (float alpha))) + ([r g b] (.color (current-graphics) (float r) (float g) (float b))) + ([r g b a] (.color (current-graphics) (float r) (float g) (float b) (float a)))) + +(defn + ^{:requires-bindings true + :processing-name "colorMode()" + :category "Color" + :subcategory "Creating & Reading" + :added "1.0"} + color-mode + "Changes the way Processing interprets color data. Available modes + are :rgb and :hsb.By default, the parameters for fill, stroke, + background, and color are defined by values between 0 and 255 using + the :rgb color model. The color-mode fn is used to change the + numerical range used for specifying colors and to switch color + systems. For example, calling + (color-mode :rgb 1.0) will specify that values are specified between + 0 and 1. The limits for defining colors are altered by setting the + parameters range1, range2, range3, and range 4." + ([mode] + (let [mode (u/resolve-constant-key mode color-modes)] + (.colorMode (current-graphics) (int mode)))) + ([mode max] + (let [mode (u/resolve-constant-key mode color-modes)] + (.colorMode (current-graphics) (int mode) (float max)))) + ([mode max-x max-y max-z] + (let [mode (u/resolve-constant-key mode color-modes)] + (.colorMode (current-graphics) (int mode) (float max-x) (float max-y) (float max-z)))) + ([mode max-x max-y max-z max-a] + (let [mode (u/resolve-constant-key mode color-modes)] + (.colorMode (current-graphics) (int mode) (float max-x) (float max-y) (float max-z) (float max-a))))) + +#?(:clj + (defn + ^{:requires-bindings false + :processing-name "constrain()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + constrain-float + "Constrains a value to not exceed a maximum and minimum value. All + args are cast to floats." + [amt low high] + (PApplet/constrain (float amt) (float low) (float high)))) + +#?(:clj + (defn + ^{:requires-bindings false + :processing-name "constrain()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + constrain-int + "Constrains a value to not exceed a maximum and minimum value. All + args are cast to ints." + [amt low high] + (PApplet/constrain (int amt) (int low) (int high)))) + + +(defn + ^{:requires-bindings false + :processing-name "constrain()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + constrain + "Constrains a value to not exceed a maximum and minimum value." + [amt low high] + #?(:clj + (if (u/int-like? amt) + (constrain-int amt low high) + (constrain-float amt low high)) + :cljs (.constrain (ap/current-applet) amt low high))) + +(defn + ^{:requires-bindings true + :processing-name "copy()" + :category "Image" + :subcategory "Pixels" + :added "1.0"} + copy + "Copies a region of pixels from the one image to another. If src-img + is not specified it defaults to current-graphics. If dest-img is not + specified - it defaults to current-graphics. If the source + and destination regions aren't the same size, it will automatically + resize the source pixels to fit the specified target region. No + alpha information is used in the process, however if the source + image has an alpha channel set, it will be copied as well. " + ([[sx sy swidth sheight] [dx dy dwidth dheight]] + (.copy (current-graphics) + (int sx) (int sy) (int swidth) (int sheight) + (int dx) (int dy) (int dwidth) (int dheight))) + + ([^PImage src-img [sx sy swidth sheight] [dx dy dwidth dheight]] + (copy src-img (current-graphics) [sx sy swidth sheight] [dx dy dwidth dheight])) + + ([^PImage src-img ^PImage dest-img [sx sy swidth sheight] [dx dy dwidth dheight]] + (.copy dest-img src-img (int sx) (int sy) (int swidth) (int sheight) + (int dx) (int dy) (int dwidth) (int dheight)))) + +(defn + ^{:requires-bindings false + :processing-name "cos()" + :category "Math" + :subcategory "Trigonometry" + :added "1.0"} + cos + "Calculates the cosine of an angle. This function expects the values + of the angle parameter to be provided in radians (values from 0 to + Math/PI*2). Values are returned in the range -1 to 1." + [angle] + #?(:clj (PApplet/cos (float angle)) + :cljs (.cos (ap/current-applet) angle))) + +#?(:clj + (defn + ^{:requires-bindings false + :processing-name nil + :category "Typography" + :subcategory "Loading & Displaying" + :added "1.0"} + font-available? + "Returns true if font (specified as a string) is available on this + system, false otherwise" + [font-str] + (if (some #{font-str} (available-fonts)) + true + false))) + +(defn + ^{:requires-bindings true + :processing-name "createFont()" + :category "Typography" + :subcategory "Loading & Displaying" + :added "1.0"} + create-font + "Dynamically converts a font to the format used by Processing (a + PFont) from either a font name that's installed on the computer, or + from a .ttf or .otf file inside the sketches 'data' folder. This + function is an advanced feature for precise control. + + Use available-fonts to obtain the names for the fonts recognized by + the computer and are compatible with this function. + + The size parameter states the font size you want to generate. The + smooth parameter specifies if the font should be antialiased or not, + and the charset parameter is an array of chars that specifies the + characters to generate. + + This function creates a bitmapped version of a font It loads a font + by name, and converts it to a series of images based on the size of + the font. When possible, the text function will use a native font + rather than the bitmapped version created behind the scenes with + create-font. For instance, when using the default renderer + setting (JAVA2D), the actual native version of the font will be + employed by the sketch, improving drawing quality and + performance. With the :p2d, :p3d, and :opengl renderer settings, the + bitmapped version will be used. While this can drastically improve + speed and appearance, results are poor when exporting if the sketch + does not include the .otf or .ttf file, and the requested font is + not available on the machine running the sketch." + ([name size] (.createFont (ap/current-applet) (str name) (float size))) + ([name size smooth] (.createFont (ap/current-applet) (str name) (float size) smooth)) + ([name size smooth ^chars charset] + (.createFont (ap/current-applet) (str name) (float size) smooth charset))) + +(defn + ^{:requires-bindings true + :processing-name "createGraphics()" + :category "Image" + :subcategory "Rendering" + :added "1.0"} + create-graphics + "Creates and returns a new PGraphics object of the types :p2d, :p3d, + :java2d, :pdf. By default :java2d is used. Use this class if you + need to draw into an off-screen graphics buffer. It's not possible + to use create-graphics with the :opengl renderer, because it doesn't + allow offscreen use. The :pdf renderer requires the filename parameter. + + Note: don't use create-graphics in draw in clojurescript, it leaks memory. + You should create graphic in setup and reuse it in draw instead of creating + a new one. + + It's important to call any drawing commands between (.beginDraw graphics) and + (.endDraw graphics) statements or use with-graphics macro. This is also true + for any commands that affect drawing, such as smooth or color-mode. + + If you're using :pdf renderer - don't forget to call (.dispose graphics) + as last command inside with-graphics macro, otherwise graphics won't be + saved. + + Unlike the main drawing surface which is completely opaque, surfaces + created with create-graphics can have transparency. This makes it + possible to draw into a graphics and maintain the alpha channel. By + using save to write a PNG or TGA file, the transparency of the + graphics object will be honored." + ([w h] + (.createGraphics (ap/current-applet) (int w) (int h) #?(:cljs :p2d))) + ([w h renderer] + (.createGraphics (ap/current-applet) (int w) (int h) (ap/resolve-renderer renderer))) + ([w h renderer path] + (.createGraphics (ap/current-applet) (int w) (int h) (ap/resolve-renderer renderer) + #?(:clj (u/absolute-path path) + :cljs path)))) + +(defn + ^{:requires-bindings true + :processing-name "createImage()" + :category "Image" + :subcategory nil + :added "1.0"} + create-image + "Creates a new PImage (the datatype for storing images). This + provides a fresh buffer of pixels to play with. Set the size of the + buffer with the width and height parameters. The format parameter + defines how the pixels are stored. See the PImage reference for more + information. + + Possible formats: :rgb, :argb, :alpha (grayscale alpha channel) + + Prefer using create-image over initialising new PImage instances + directly." + [w h format] + (let [format (u/resolve-constant-key format image-formats)] + (.createImage (ap/current-applet) (int w) (int h) (int format)))) + +(defn + ^{:requires-bindings true + :processing-name "PGraphics.fillColor" + :processing-link "http://processing.github.io/processing-javadocs/core/processing/core/PGraphics.html#fillColor" + :category "Color" + :subcategory "Creating & Reading"} + current-fill + "Return the current fill color." + [] + (.-fillColor (current-graphics))) + +(defn + ^{:requires-bindings true + :processing-name "PGraphics.strokeColor" + :processing-link "http://processing.github.io/processing-javadocs/core/processing/core/PGraphics.html#strokeColor" + :category "Color" + :subcategory "Creating & Reading"} + current-stroke + "Return the current stroke color." + [] + (.-strokeColor (current-graphics))) + +(defn + ^{:requires-bindings true + :processing-name "cursor()" + :category "Environment" + :subcategory nil + :added "1.0"} + cursor + "Sets the cursor to a predefined symbol or makes it + visible if already hidden (after no-cursor was called). + + Available modes: :arrow, :cross, :hand, :move, :text, :wait + + See cursor-image for specifying a generic image as the cursor + symbol." + ([] (.cursor (ap/current-applet))) + ([cursor-mode] + (let [cursor-mode (u/resolve-constant-key cursor-mode cursor-modes)] + (.cursor (ap/current-applet) + #?(:clj (int cursor-mode) + :cljs (str cursor-mode)))))) + +(defn + ^{:requires-bindings true + :processing-name "cursor()" + :category "Environment" + :subcategory nil + :added "1.0"} + cursor-image + "Set the cursor to a predefined image. The horizontal and vertical + active spots of the cursor may be specified with hx and hy. + It is recommended to make the size 16x16 or 32x32 pixels." + ([^PImage img] (.cursor (ap/current-applet) img)) + ([^PImage img hx hy] (.cursor (ap/current-applet) img (int hx) (int hy)))) + +(defn + ^{:requires-bindings true + :processing-name "curve()" + :category "Shape" + :subcategory "Curves" + :added "1.0"} + curve + "Draws a curved line on the screen. The first and second parameters + specify the beginning control point and the last two parameters + specify the ending control point. The middle parameters specify the + start and stop of the curve. Longer curves can be created by putting + a series of curve fns together or using curve-vertex. An additional + fn called curve-tightness provides control for the visual quality of + the curve. The curve fn is an implementation of Catmull-Rom + splines." + ([x1 y1 x2 y2 x3 y3 x4 y4] + (.curve (current-graphics) + (float x1) (float y1) + (float x2) (float y2) + (float x3) (float y3) + (float x4) (float y4))) + ([x1 y1 z1 x2 y2 z2 x3 y3 z3 x4 y4 z4] + (.curve (current-graphics) + (float x1) (float y1) (float z1) + (float x2) (float y2) (float z2) + (float x3) (float y3) (float z3) + (float x4) (float y4) (float z4)))) + +(defn + ^{:requires-bindings true + :processing-name "curveDetail()" + :category "Shape" + :subcategory "Curves" + :added "1.0"} + curve-detail + "Sets the resolution at which curves display. The default value is + 20. This function is only useful when using the :p3d or :opengl + renderer as the default (:java2d) renderer does not use this + information." + [detail] + (.curveDetail (current-graphics) (int detail))) + +(defn + ^{:requires-bindings true + :processing-name "curvePoint()" + :category "Shape" + :subcategory "Curves" + :added "1.0"} + curve-point + "Evalutes the curve at point t for points a, b, c, d. The parameter + t varies between 0 and 1, a and d are points on the curve, and b c + and are the control points. This can be done once with the x + coordinates and a second time with the y coordinates to get the + location of a curve at t." + [a b c d t] + (.curvePoint (current-graphics) (float a) (float b) (float c) (float d) (float t))) + +(defn + ^{:requires-bindings true + :processing-name "curveTangent()" + :category "Shape" + :subcategory "Curves" + :added "1.0"} + curve-tangent + "Calculates the tangent of a point on a curve. + See: http://en.wikipedia.org/wiki/Tangent" + [a b c d t] + (.curveTangent (current-graphics) (float a) (float b) (float c) (float d) (float t))) + +(defn + ^{:requires-bindings true + :processing-name "curveTightness()" + :category "Shape" + :subcategory "Curves" + :added "1.0"} + curve-tightness + "Modifies the quality of forms created with curve and + curve-vertex. The parameter squishy determines how the curve fits + to the vertex points. The value 0.0 is the default value for + squishy (this value defines the curves to be Catmull-Rom splines) + and the value 1.0 connects all the points with straight + lines. Values within the range -5.0 and 5.0 will deform the curves + but will leave them recognizable and as values increase in + magnitude, they will continue to deform." + [ti] + (.curveTightness (current-graphics) (float ti))) + +(defn + ^{:requires-bindings true + :processing-name "curveVertex()" + :category "Shape" + :subcategory "Vertex" + :added "1.0"} + curve-vertex + "Specifies vertex coordinates for curves. This function may only be + used between begin-shape and end-shape and only when there is no + mode keyword specified to begin-shape. The first and last points in a + series of curve-vertex lines will be used to guide the beginning and + end of a the curve. A minimum of four points is required to draw a + tiny curve between the second and third points. Adding a fifth point + with curve-vertex will draw the curve between the second, third, and + fourth points. The curve-vertex function is an implementation of + Catmull-Rom splines." + ([x y] (.curveVertex (current-graphics) (float x) (float y))) + ([x y z] (.curveVertex (current-graphics) (float x) (float y) (float z)))) + +(defn + ^{:requires-bindings false + :processing-name "day()" + :category "Input" + :subcategory "Time & Date" + :added "1.0"} + day + "Get the current day of the month (1 through 31)." + [] + #?(:clj (PApplet/day) + :cljs (.day (ap/current-applet)))) + +(defn + ^{:requires-bindings false + :processing-name "degrees()" + :category "Math" + :subcategory "Trigonometry" + :added "1.0"} + degrees + "Converts a radian measurement to its corresponding value in + degrees. Radians and degrees are two ways of measuring the same + thing. There are 360 degrees in a circle and (* 2 Math/PI) radians + in a circle. For example, (= 90° (/ Math/PI 2) 1.5707964). All + trigonometric methods in Processing require their parameters to be + specified in radians." + [radians] + #?(:clj (PApplet/degrees (float radians)) + :cljs (.degrees (ap/current-applet) radians))) + +(defn + ^{:requires-bindings true + :processing-name "delay()" + :processing-link nil + :category "Structure" + :subcategory nil + :added "1.0"} + delay-frame + "Forces the program to stop running for a specified time. Delay + times are specified in thousandths of a second, therefore the + function call (delay 3000) will stop the program for three + seconds. Because the screen is updated only at the end of draw, + the program may appear to 'freeze', because the screen will not + update when the delay fn is used. This function has no affect + inside setup." + [freeze-ms] + (.delay (ap/current-applet) (int freeze-ms))) + +(defn + ^{:requires-bindings true + :processing-name "directionalLight()" + :category "Lights, Camera" + :subcategory "Lights" + :added "1.0"} + directional-light + "Adds a directional light. Directional light comes from one + direction and is stronger when hitting a surface squarely and weaker + if it hits at a gentle angle. After hitting a surface, a + directional lights scatters in all directions. Lights need to be + included in the draw fn to remain persistent in a looping + program. Placing them in the setup fn of a looping program will cause + them to only have an effect the first time through the loop. The + affect of the r, g, and b parameters is determined by the current + color mode. The nx, ny, and nz parameters specify the direction the + light is facing. For example, setting ny to -1 will cause the + geometry to be lit from below (the light is facing directly upward)" + [r g b nx ny nz] + (.directionalLight (current-graphics) (float r) (float g) (float b) + (float nx) (float ny) (float nz))) + +(defn + ^{:requires-bindings false + :processing-name "dist()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + dist + "Calculates the distance between two points" + ([x1 y1 x2 y2] + #?(:clj (PApplet/dist (float x1) (float y1) (float x2) (float y2)) + :cljs (.dist (ap/current-applet) x1 y1 x2 y2))) + ([x1 y1 z1 x2 y2 z2] + #?(:clj (PApplet/dist (float x1) (float y1) (float z1) (float x2) (float y2) (float z2)) + :cljs (.dist (ap/current-applet) x1 y1 z1 x2 y2 z2)))) + +(defmacro + ^{:requires-bindings true + :processing-name nil + :category "Output" + :subcategory "Files" + :added "2.5"} + do-record + "Macro for drawing on graphics which saves result in the file at the end. + Similar to 'with-graphics' macro. do-record assumed to be used with :pdf + graphics. Example: + + (q/do-record (q/create-graphics 200 200 :pdf \"output.pdf\") + (q/fill 250 0 0) + (q/ellipse 100 100 150 150)) + " + [graphics & body] + `(let [gr# ~graphics] + (with-graphics gr# + ~@body) + (.dispose gr#))) + +(defn + ^{:requires-bindings true + :processing-name "ellipse()" + :category "Shape" + :subcategory "2D Primitives" + :added "1.0"} + ellipse + "Draws an ellipse (oval) in the display window. An ellipse with an + equal width and height is a circle. The origin may be changed with + the ellipse-mode function" + [x y width height] + (.ellipse (current-graphics) (float x) (float y) (float width) (float height))) + +(defn + ^{:requires-bindings true + :processing-name "ellipseMode()" + :category "Shape" + :subcategory "Attributes" + :added "1.0"} + ellipse-mode + "Modifies the origin of the ellispse according to the specified mode: + + :center - specifies the location of the ellipse as + the center of the shape. (Default). + :radius - similar to center, but the width and height parameters to + ellipse specify the radius of the ellipse, rather than the + diameter. + :corner - draws the shape from the upper-left corner of its bounding + box. + :corners - uses the four parameters to ellipse to set two opposing + corners of the ellipse's bounding box." + [mode] + (let [mode (u/resolve-constant-key mode ellipse-modes)] + (.ellipseMode (current-graphics) (int mode)))) + +(defn + ^{:requires-bindings true + :processing-name "emissive()" + :category "Lights, Camera" + :subcategory "Material Properties" + :added "1.0"} + emissive-float + "Sets the emissive color of the material used for drawing shapes + drawn to the screen. Used in combination with ambient, specular, and + shininess in setting the material properties of shapes. Converts all + args to floats" + ([float-val] (.emissive (current-graphics) (float float-val))) + ([r g b] (.emissive (current-graphics) (float r) (float g) (float b)))) + +(defn + ^{:requires-bindings true + :processing-name "emissive()" + :category "Lights, Camera" + :subcategory "Material Properties" + :added "1.0"} + emissive-int + "Sets the emissive color of the material used for drawing shapes + drawn to the screen. Used in combination with ambient, specular, and + shininess in setting the material properties of shapes. Converts all + args to ints" + [int-val] (.emissive (current-graphics) (int int-val))) + + +(defn + ^{:requires-bindings true + :processing-name "emissive()" + :category "Lights, Camera" + :subcategory "Material Properties" + :added "1.0"} + emissive + "Sets the emissive color of the material used for drawing shapes + drawn to the screen. Used in combination with ambient, specular, and + shininess in setting the material properties of shapes. + + If passed one arg - it is assumed to be an int (i.e. a color), + multiple args are converted to floats." + ([c] + #?(:clj (if (u/int-like? c) (emissive-int c) (emissive-float c)) + :cljs (emissive-float c))) + ([r g b] (emissive-float r g b))) + +(defn + ^{:requires-bindings true + :processing-name "endCamera()" + :category "Lights, Camera" + :subcategory "Camera" + :added "1.0"} + end-camera + "Unsets the matrix mode from the camera matrix. See begin-camera." + [] + (.endCamera (current-graphics))) + + +(defn + ^{:requires-bindings true + :processing-name "endContour()" + :category "Shape" + :subcategory "Vertex" + :added "2.0"} + end-contour + "Use the begin-contour and end-contour function to create negative + shapes within shapes. These functions can only be within a + begin-shape/end-shape pair and they only work with the :p2d and :p3d + renderers." + [] + (.endContour (current-graphics))) + +(defn + ^{:requires-bindings true + :processing-name "endRaw()" + :category "Output" + :subcategory "Files" + :added "1.0"} + end-raw + "Complement to begin-raw; they must always be used together. See + the begin-raw docstring for details." + [] + (.endRaw (current-graphics))) + + +(defn + ^{:requires-bindings true + :processing-name "endShape()" + :category "Shape" + :subcategory "Vertex" + :added "1.0"} + end-shape + "May only be called after begin-shape. When end-shape is called, + all of image data defined since the previous call to begin-shape is + written into the image buffer. The keyword :close may be passed to + close the shape (to connect the beginning and the end)." + ([] (.endShape (current-graphics))) + ([mode] + (when-not (= :close mode) + #?(:clj (throw (Exception. (str "Unknown mode value: " mode ". Expected :close"))) + :cljs nil)) + (.endShape (current-graphics) + #?(:clj PApplet/CLOSE + :cljs 2)))) + +(defn + ^{:requires-bindings true + :processing-name "exit()" + :category "Structure" + :subcategory nil + :added "1.0"} + exit + "Quits/stops/exits the program. Rather than terminating + immediately, exit will cause the sketch to exit after draw has + completed (or after setup completes if called during the setup + method). " + [] + (.exit (ap/current-applet))) + +(defn + ^{:requires-bindings false + :processing-name "exp()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + exp + "Returns Euler's number e (2.71828...) raised to the power of the + value parameter." + [val] + #?(:clj (PApplet/exp (float val)) + :cljs (.exp (ap/current-applet) val))) + +#?(:cljs + (defn- clear-no-fill-cljs + "Sets custom property on graphcs object indicating that it has + fill color." + [graphics] + (aset graphics no-fill-prop false))) + +(defn + ^{:requires-bindings true + :processing-name "fill()" + :category "Color" + :subcategory "Setting" + :added "1.0"} + fill-float + "Sets the color used to fill shapes. For example, (fill 204 102 0), + will specify that all subsequent shapes will be filled with orange." + ([gray] + (.fill (current-graphics) (float gray)) + #?(:cljs (clear-no-fill-cljs (current-graphics)))) + ([gray alpha] + (.fill (current-graphics) (float gray) (float alpha)) + #?(:cljs (clear-no-fill-cljs (current-graphics)))) + ([r g b] + (.fill (current-graphics) (float r) (float g) (float b)) + #?(:cljs (clear-no-fill-cljs (current-graphics)))) + ([r g b alpha] + (.fill (current-graphics) (float r) (float g) (float b) (float alpha)) + #?(:cljs (clear-no-fill-cljs (current-graphics))))) + +(defn + ^{:requires-bindings true + :processing-name "fill()" + :category "Color" + :subcategory "Setting" + :added "1.0"} + fill-int + "Sets the color used to fill shapes." + ([rgb] + (.fill (current-graphics) (unchecked-int rgb)) + #?(:cljs (clear-no-fill-cljs (current-graphics)))) + ([rgb alpha] + (.fill (current-graphics) (unchecked-int rgb) (float alpha)) + #?(:cljs (clear-no-fill-cljs (current-graphics))))) + +(defn + ^{:requires-bindings true + :processing-name "fill()" + :category "Color" + :subcategory "Setting" + :added "1.0"} + fill + "Sets the color used to fill shapes." + ([rgb] + #?(:clj (if (u/int-like? rgb) (fill-int rgb) (fill-float rgb)) + :cljs (fill-float rgb))) + + ([rgb alpha] + #?(:clj (if (u/int-like? rgb) (fill-int rgb alpha) (fill-float rgb alpha)) + :cljs (fill-float rgb alpha))) + + ([r g b] (fill-float r g b)) + ([r g b a] (fill-float r g b a))) + +#?(:clj + (defn + ^{:requires-bindings true + :processing-name "displayDensity()" + :category "Environment" + :subcategory nil + :added "2.4.0"} + display-density + "This function returns the number 2 if the screen is a high-density + screen (called a Retina display on OS X or high-dpi on Windows and + Linux) and a 1 if not. This information is useful for a program to + adapt to run at double the pixel density on a screen that supports + it. Can be used in conjunction with (pixel-density)" + ([] (.displayDensity (ap/current-applet))) + ([display] (PApplet/displayDensity display)))) + +(defn + ^{:requires-bindings true + :processing-name "filter()" + :category "Image" + :subcategory "Pixels" + :added "1.0"} + display-filter + "Originally named filter in Processing Language. + Filters the display window with the specified mode and level. + Level defines the quality of the filter and mode may be one of the + following keywords: + + :threshold - converts the image to black and white pixels depending + if they are above or below the threshold defined by + the level parameter. The level must be between + 0.0 (black) and 1.0 (white). If no level is specified, + 0.5 is used. + :gray - converts any colors in the image to grayscale + equivalents. Doesn't work with level. + :invert - sets each pixel to its inverse value. Doesn't work with + level. + :posterize - limits each channel of the image to the number of + colors specified as the level parameter. The parameter can + be set to values between 2 and 255, but results are most + noticeable in the lower ranges. + :blur - executes a Guassian blur with the level parameter + specifying the extent of the blurring. If no level + parameter is used, the blur is equivalent to Guassian + blur of radius 1. + :opaque - sets the alpha channel to entirely opaque. Doesn't work + with level. + :erode - reduces the light areas. Doesn't work with level. + :dilate - increases the light areas. Doesn't work with level." + ([mode] + (.filter (current-graphics) + (int (u/resolve-constant-key mode filter-modes)))) + + ([mode level] + (let [mode (u/resolve-constant-key mode filter-modes)] + (.filter (current-graphics) (int mode) (float level))))) + +#?(:clj + (defn + ^{:requires-bindings true + :processing-name "filter()" + :category "Image" + :subcategory "Pixels" + :added "2.0"} + filter-shader + "Originally named filter in Processing Language. + Filters the display window with given shader (only in :p2d and :p3d modes)." + [^PShader shader-obj] (.filter (current-graphics) shader-obj))) + +(defn + ^{:requires-bindings false + :processing-name "floor()" + :category "Math" + :subcategory "Calculation" + :added "2.0"} + floor + "Calculates the closest int value that is less than or equal to the + value of the parameter. For example, (floor 9.03) returns the value 9." + [n] + #?(:clj (PApplet/floor (float n)) + :cljs (.floor (ap/current-applet) n))) + +(defn + ^{:requires-bindings true + :processing-name "focused" + :category "Environment" + :subcategory nil + :added "1.0"} + focused + "Returns a boolean value representing whether the applet has focus." + [] (.-focused (ap/current-applet))) + +(defn + ^{:requires-bindings true + :processing-name "frameCount" + :category "Environment" + :subcategory nil + :added "1.0"} + frame-count + "The system variable frameCount contains the number of frames + displayed since the program started. Inside setup() the value is 0 + and after the first iteration of draw it is 1, etc." + [] + #?(:clj (.frameCount (ap/current-applet)) + :cljs (.-frameCount (ap/current-applet)))) + +(defn + ^{:requires-bindings true + :processing-name "frameRate" + :category "Environment" + :subcategory nil + :added "1.0"} + current-frame-rate + "Returns the current framerate" + [] + #?(:clj (.frameRate (ap/current-applet)) + :cljs (.-__frameRate (ap/current-applet)))) + +(defn + ^{:requires-bindings true + :processing-name "frameRate()" + :category "Environment" + :subcategory nil + :added "1.0"} + frame-rate + "Specifies a new target framerate (number of frames to be displayed every + second). If the processor is not fast enough to maintain the + specified rate, it will not be achieved. For example, the function + call (frame-rate 30) will attempt to refresh 30 times a second. It + is recommended to set the frame rate within setup. The default rate + is 60 frames per second." + [new-rate] + (do + #?(:cljs (reset! (.-target-frame-rate (ap/current-applet)) new-rate)) + (.frameRate (ap/current-applet) (float new-rate)))) + +(defn + ^{:requires-bindings true + :processing-name "frustum()" + :category "Lights, Camera" + :subcategory "Camera" + :added "1.0"} + frustum + "Sets a perspective matrix defined through the parameters. Works + like glFrustum, except it wipes out the current perspective matrix + rather than muliplying itself with it." + [left right bottom top near far] + (.frustum (current-graphics) (float left) (float right) (float bottom) (float top) + (float near) (float far))) + +(defn + ^{:requires-bindings true + :processing-name "get()" + :category "Image" + :subcategory "Pixels" + :added "1.0"} + get-pixel + "Reads the color of any pixel or grabs a section of an image. If no + parameters are specified, a copy of entire image is returned. Get the + value of one pixel by specifying an x,y coordinate. Get a section of + the image by specifying an additional width and height parameter. + If the pixel requested is outside of the image window, black is returned. + The numbers returned are scaled according to the current color ranges, + but only RGB values are returned by this function. For example, even though + you may have drawn a shape with (color-mode :hsb), the numbers returned + will be in RGB. + + Getting the color of a single pixel with (get x y) is easy, but not + as fast as grabbing the data directly using the pixels fn. + + If no img specified - current-graphics is used." + ([] (get-pixel (current-graphics))) + ([^PImage img] (.get img)) + ([x y] (get-pixel (current-graphics) x y)) + ([^PImage img x y] (.get img (int x) (int y))) + ([x y w h] (get-pixel (current-graphics) x y w h)) + ([^PImage img x y w h] (.get img (int x) (int y) (int w) (int h)))) + +(defn + ^{:requires-bindings true + :processing-name "green()" + :category "Color" + :subcategory "Creating & Reading" + :added "1.0"} + green + "Extracts the green value from a color, scaled to match current + color-mode. This value is always returned as a float so be careful + not to assign it to an int value." + [col] + (.green (current-graphics) (unchecked-int col))) + +(defn + ^{:require-binding false + :processing-name "hex()" + :category "Data" + :subcategory "Conversion"} + hex + "Converts a byte, char, int, or color to a String containing the + equivalent hexadecimal notation. For example color(0, 102, 153) will + convert to the String \"FF006699\". This function can help make your + geeky debugging sessions much happier. " + ([val] + #?(:clj (PApplet/hex (int val)) + :cljs (.hex (ap/current-applet) val))) + ([val num-digits] + #?(:clj (PApplet/hex (int val) (int num-digits)) + :cljs (.hex (ap/current-applet) val num-digits)))) + +(defn + ^{:requires-bindings true + :processing-name "getHeight()" + :processing-link nil + :category "Environment" + :subcategory nil + :added "1.0"} + height + "Height of the display window. The value of height is zero until + size is called." + [] + (.-height (ap/current-applet))) + +(defn + ^{:requires-bindings true + :processing-name "hint()" + :processing-link nil + :category "Rendering" + :subcategory nil + :added "1.0"} + hint + "Set various hints and hacks for the renderer. This is used to + handle obscure rendering features that cannot be implemented in a + consistent manner across renderers. Many options will often graduate + to standard features instead of hints over time. + + Options: + + :enable-native-fonts - Use the native version fonts when they are + installed, rather than the bitmapped version from a .vlw + file. This is useful with the default (or JAVA2D) renderer + setting, as it will improve font rendering speed. This is not + enabled by default, because it can be misleading while testing + because the type will look great on your machine (because you have + the font installed) but lousy on others' machines if the identical + font is unavailable. This option can only be set per-sketch, and + must be called before any use of text-font. + + :disable-native-fonts - Disables native font support. + + :disable-depth-test - Disable the zbuffer, allowing you to draw on + top of everything at will. When depth testing is disabled, items + will be drawn to the screen sequentially, like a painting. This + hint is most often used to draw in 3D, then draw in 2D on top of + it (for instance, to draw GUI controls in 2D on top of a 3D + interface). Starting in release 0149, this will also clear the + depth buffer. Restore the default with :enable-depth-test + but note that with the depth buffer cleared, any 3D drawing that + happens later in draw will ignore existing shapes on the screen. + + :enable-depth-test - Enables the zbuffer. + + :enable-depth-sort - Enable primitive z-sorting of triangles and + lines in :p3d and :opengl rendering modes. This can slow + performance considerably, and the algorithm is not yet perfect. + + :disable-depth-sort - Disables hint :enable-depth-sort + + :disable-opengl-errors - Speeds up the OPENGL renderer setting + by not checking for errors while running. + + :enable-opengl-errors - Turns on OpenGL error checking + + :enable-depth-mask + :disable-depth-mask + + :enable-optimized-stroke + :disable-optimized-stroke + :enable-retina-pixels + :disable-retina-pixels + :enable-stroke-perspective + :disable-stroke-perspective + :enable-stroke-pure + :disable-stroke-pure + :enable-texture-mipmaps + :disable-texture-mipmaps +" + [hint-type] + (let [hint-type (if (keyword? hint-type) + (get hint-options hint-type) + hint-type)] + (.hint (current-graphics) (int hint-type)))) + +(defn + ^{:requires-bindings false + :processing-name "hour()" + :category "Input" + :subcategory "Time & Date" + :added "1.0"} + hour + "Returns the current hour as a value from 0 - 23." + [] + #?(:clj (PApplet/hour) + :cljs (.hour (ap/current-applet)))) + +(defn + ^{:requires-bindings true + :processing-name "hue()" + :category "Color" + :subcategory "Creating & Reading" + :added "1.0"} + hue + "Extracts the hue value from a color." + [col] + (.hue (current-graphics) (unchecked-int col))) + + +(defn + ^{:requires-bindings true + :processing-name "image()" + :category "Image" + :subcategory "Loading & Displaying" + :added "1.0"} + image + "Displays images to the screen. Processing currently works with GIF, + JPEG, and Targa images. The color of an image may be modified with + the tint function and if a GIF has transparency, it will maintain + its transparency. The img parameter specifies the image to display + and the x and y parameters define the location of the image from its + upper-left corner. The image is displayed at its original size + unless the width and height parameters specify a different size. The + image-mode fn changes the way the parameters work. A call to + (image-mode :corners) will change the width and height parameters to + define the x and y values of the opposite corner of the image. + + Starting with release 0124, when using the default (JAVA2D) + renderer, smooth will also improve image quality of resized + images." + (#?(:clj [^PImage img x y] + :cljs [img x y]) + (.image (current-graphics) img (float x) (float y))) + + (#?(:clj [^PImage img x y c d] + :cljs [img x y c d]) + (.image (current-graphics) img (float x) (float y) (float c) (float d)))) + +(defn + ^{:requires-bindings true + :processing-name "PImage.filter()" + :category "Image" + :subcategory "Pixels" + :added "2.0"} + image-filter + "Originally named filter in Processing Language. + Filters given image with the specified mode and level. + Level defines the quality of the filter and mode may be one of + the following keywords: + + :threshold - converts the image to black and white pixels depending + if they are above or below the threshold defined by + the level parameter. The level must be between + 0.0 (black) and 1.0 (white). If no level is specified, + 0.5 is used. + :gray - converts any colors in the image to grayscale + equivalents. Doesn't work with level. + :invert - sets each pixel to its inverse value. Doesn't work with + level. + :posterize - limits each channel of the image to the number of + colors specified as the level parameter. The parameter can + be set to values between 2 and 255, but results are most + noticeable in the lower ranges. + :blur - executes a Guassian blur with the level parameter + specifying the extent of the blurring. If no level + parameter is used, the blur is equivalent to Guassian + blur of radius 1. + :opaque - sets the alpha channel to entirely opaque. Doesn't work + with level. + :erode - reduces the light areas. Doesn't work with level. + :dilate - increases the light areas. Doesn't work with level." + ([^PImage img mode] + (let [mode (u/resolve-constant-key mode filter-modes)] + (.filter img (int mode)))) + ([^PImage img mode level] + (let [mode (u/resolve-constant-key mode filter-modes)] + (.filter img (int mode) (float level))))) + +(defn + ^{:requires-bindings true + :processing-name "imageMode()" + :category "Image" + :subcategory "Loading & Displaying" + :added "1.0"} + image-mode + "Modifies the location from which images draw. The default mode is :corner. + Available modes are: + + :corner - specifies the location to be the upper left corner and + uses the fourth and fifth parameters of image to set the + image's width and height. + + :corners - uses the second and third parameters of image to set the + location of one corner of the image and uses the fourth + and fifth parameters to set the opposite corner. + + :center - draw images centered at the given x and y position." + [mode] + (let [mode (u/resolve-constant-key mode image-modes)] + (.imageMode (current-graphics) (int mode)))) + +(defn + ^{:requires-bindings true + :processing-name "keyCode" + :category "Input" + :subcategory "Keyboard" + :added "1.0"} + key-code + "The variable keyCode is used to detect special keys such as the UP, + DOWN, LEFT, RIGHT arrow keys and ALT, CONTROL, SHIFT. When checking + for these keys, it's first necessary to check and see if the key is + coded. This is done with the conditional (= (key) CODED). + + The keys included in the ASCII specification (BACKSPACE, TAB, ENTER, + RETURN, ESC, and DELETE) do not require checking to see if they key + is coded, and you should simply use the key variable instead of + key-code If you're making cross-platform projects, note that the + ENTER key is commonly used on PCs and Unix and the RETURN key is + used instead on Macintosh. Check for both ENTER and RETURN to make + sure your program will work for all platforms. + + For users familiar with Java, the values for UP and DOWN are simply + shorter versions of Java's KeyEvent.VK_UP and + KeyEvent.VK_DOWN. Other keyCode values can be found in the Java + KeyEvent reference." + [] + (.-keyCode (ap/current-applet))) + +#?(:clj + (defn + ^{:requires-bindings true + :processing-name nil + :category "Input" + :subcategory "Keyboard" + :added "2.4.0"} + key-modifiers + "Set of key modifiers that were pressed when event happened. + Possible modifiers :ctrl, :alt, :shift, :meta. Not available in + ClojureScript." + [] + (let [modifiers + (if-let [^processing.event.Event + event (-> (ap/current-applet) meta :key-event deref)] + [(if (.isAltDown event) :alt nil) + (if (.isShiftDown event) :shift nil) + (if (.isControlDown event) :control nil) + (if (.isMetaDown event) :meta nil)] + [])] + (set (remove nil? modifiers))))) + +(defn + ^{:requires-bindings true + :processing-name "keyPressed" + :category "Input" + :subcategory "Keyboard" + :added "1.0"} + key-pressed? + "true if any key is currently pressed, false otherwise." + [] + #?(:clj (.-keyPressed (ap/current-applet)) + :cljs (.-__keyPressed (ap/current-applet)))) + +(defn + ^{:requires-bindings true + :processing-name "lightFalloff()" + :category "Lights, Camera" + :subcategory "Lights" + :added "1.0"} + light-falloff + "Sets the falloff rates for point lights, spot lights, and ambient + lights. The parameters are used to determine the falloff with the + following equation: + + d = distance from light position to vertex position + falloff = 1 / (CONSTANT + d * LINEAR + (d*d) * QUADRATIC) + + Like fill, it affects only the elements which are created after it + in the code. The default value is (light-falloff 1.0 0.0 0.0). + Thinking about an ambient light with a falloff can be tricky. It is + used, for example, if you wanted a region of your scene to be lit + ambiently one color and another region to be lit ambiently by + another color, you would use an ambient light with location and + falloff. You can think of it as a point light that doesn't care + which direction a surface is facing." + [constant linear quadratic] + (.lightFalloff (current-graphics) (float constant) (float linear) (float quadratic))) + +(defn + ^{:requires-bindings true + :processing-name "lerpColor()" + :category "Color" + :subcategory "Creating & Reading" + :added "1.0"} + lerp-color + "Calculates a color or colors between two color at a specific + increment. The amt parameter is the amount to interpolate between + the two values where 0.0 equal to the first point, 0.1 is very near + the first point, 0.5 is half-way in between, etc." + [c1 c2 amt] + (.lerpColor (current-graphics) (unchecked-int c1) (unchecked-int c2) (float amt))) + +(defn + ^{:requires-bindings false + :processing-name "lerp()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + lerp + "Calculates a number between two numbers at a specific + increment. The amt parameter is the amount to interpolate between + the two values where 0.0 equal to the first point, 0.1 is very near + the first point, 0.5 is half-way in between, etc. The lerp function + is convenient for creating motion along a straight path and for + drawing dotted lines." + [start stop amt] + #?(:clj (PApplet/lerp (float start) (float stop) (float amt)) + :cljs (.lerp (ap/current-applet) start stop amt))) + +(defn + ^{:requires-bindings true + :processing-name "lights()" + :category "Lights, Camera" + :subcategory "Lights" + :added "1.0"} + lights + "Sets the default ambient light, directional light, falloff, and + specular values. The defaults are: + + (ambient-light 128 128 128) + (directional-light 128 128 128 0 0 -1) + (light-falloff 1 0 0) + (light-specular 0 0 0). + + Lights need to be included in the draw to remain persistent in a + looping program. Placing them in the setup of a looping program + will cause them to only have an effect the first time through the + loop." + [] + (.lights (current-graphics))) + +(defn + ^{:requires-bindings true + :processing-name "lightSpecular()" + :category "Lights, Camera" + :subcategory "Lights" + :added "1.0"} + light-specular + "Sets the specular color for lights. Like fill, it affects only the + elements which are created after it in the code. Specular refers to + light which bounces off a surface in a perferred direction (rather + than bouncing in all directions like a diffuse light) and is used + for creating highlights. The specular quality of a light interacts + with the specular material qualities set through the specular and + shininess functions." + [r g b] + (.lightSpecular (current-graphics) (float r) (float g) (float b))) + +(defn + ^{:requires-bindings true + :processing-name "line()" + :category "Shape" + :subcategory "2D Primitives" + :added "1.0"} + line + "Draws a line (a direct path between two points) to the screen. The + version of line with four parameters draws the line in 2D. To color + a line, use the stroke function. A line cannot be filled, therefore + the fill method will not affect the color of a line. 2D lines are + drawn with a width of one pixel by default, but this can be changed + with the stroke-weight function. The version with six parameters + allows the line to be placed anywhere within XYZ space. " + ([p1 p2] (apply line (concat p1 p2))) + ([x1 y1 x2 y2] (.line (current-graphics) (float x1) (float y1) (float x2) (float y2))) + ([x1 y1 z1 x2 y2 z2] + (.line (current-graphics) (float x1) (float y1) (float z1) + (float x2) (float y2) (float z2)))) + +(defn + ^{:requires-bindings true + :processing-name "loadFont()" + :category "Typography" + :subcategory "Loading & Displaying" + :added "1.0"} + load-font + "Loads a font into a variable of type PFont. To load correctly, + fonts must be located in the data directory of the current sketch. + To create a font to use with Processing use the create-font fn. + + Like load-image and other methods that load data, the load-font fn + should not be used inside draw, because it will slow down the sketch + considerably, as the font will be re-loaded from the disk (or + network) on each frame. + + For most renderers, Processing displays fonts using the .vlw font + format, which uses images for each letter, rather than defining them + through vector data. When hint :enable-native-fonts is used with the + JAVA2D renderer, the native version of a font will be used if it is + installed on the user's machine. + + Using create-font (instead of load-font) enables vector data to be + used with the JAVA2D (default) renderer setting. This can be helpful + when many font sizes are needed, or when using any renderer based on + JAVA2D, such as the PDF library." + [filename] + (.loadFont (ap/current-applet) (str filename))) + +(defn + ^{:requires-bindings true + :processing-name "loadImage()" + :category "Image" + :subcategory "Loading & Displaying" + :added "1.0"} + load-image + "Loads an image into a variable of type PImage. Four types of + images ( .gif, .jpg, .tga, .png) images may be loaded. To load + correctly, images must be located in the data directory of the + current sketch. In most cases, load all images in setup to preload + them at the start of the program. Loading images inside draw will + reduce the speed of a program. + + The filename parameter can also be a URL to a file found online. + + If an image is not loaded successfully, the null value is returned + and an error message will be printed to the console. The error + message does not halt the program, however the null value may cause + a NullPointerException if your code does not check whether the value + returned from load-image is nil. + + Depending on the type of error, a PImage object may still be + returned, but the width and height of the image will be set to + -1. This happens if bad image data is returned or cannot be decoded + properly. Sometimes this happens with image URLs that produce a 403 + error or that redirect to a password prompt, because load-image + will attempt to interpret the HTML as image data." + [filename] + (.loadImage (ap/current-applet) (str filename))) + +(defn + ^{:requires-bindings true + :processing-name "loadShader()" + :category "Rendering" + :subcategory "Shaders" + :added "2.0"} + load-shader + "Loads a shader into the PShader object. Shaders are compatible with the + P2D and P3D renderers, but not with the default renderer." + ([fragment-filename] + (.loadShader (current-graphics) fragment-filename)) + ([fragment-filename vertex-filename] + (.loadShader (current-graphics) fragment-filename vertex-filename))) + +(defn + ^{:requires-bindings true + :processing-name "loadShape()" + :category "Shape" + :subcategory "Loading & Displaying" + :added "1.0"} + load-shape + "Load a geometry from a file as a PShape." + [filename] + (.loadShape (ap/current-applet) filename)) + +(defn + ^{:requires-bindings false + :processing-name "log()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + log + "Calculates the natural logarithm (the base-e logarithm) of a + number. This function expects the values greater than 0.0." + [val] + #?(:clj (PApplet/log (float val)) + :cljs (.log (ap/current-applet) val))) + +(defn + ^{:requires-bindings false + :processing-name "mag()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + mag + "Calculates the magnitude (or length) of a vector. A vector is a + direction in space commonly used in computer graphics and linear + algebra. Because it has no start position, the magnitude of a vector + can be thought of as the distance from coordinate (0,0) to its (x,y) + value. Therefore, mag is a shortcut for writing (dist 0 0 x y)." + ([a b] + #?(:clj (PApplet/mag (float a) (float b)) + :cljs (.mag (ap/current-applet) a b))) + ([a b c] + #?(:clj (PApplet/mag (float a) (float b) (float c)) + :cljs (.mag (ap/current-applet) a b c)))) + +(defn + ^{:requires-bindings false + :processing-name "map()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + map-range + "Re-maps a number from one range to another. + + Numbers outside the range are not clamped to 0 and 1, because + out-of-range values are often intentional and useful." + [val low1 high1 low2 high2] + #?(:clj (PApplet/map (float val) (float low1) (float high1) (float low2) (float high2)) + :cljs (.map (ap/current-applet) val low1 high1 low2 high2))) + +#?(:clj + (defn + ^{:requires-bindings false + :processing-name "PImage.mask()" + :category "Image" + :subcategory "Loading & Displaying" + :added "1.0"} + mask-image + "Masks part of an image from displaying by loading another image and + using it as an alpha channel. This mask image should only contain + grayscale data, but only the blue color channel is used. The mask + image needs to be the same size as the image to which it is + applied. + + If single argument function is used - masked image is sketch itself + or graphics if used inside with-graphics macro. If you're passing + graphics to this function - it works only with :p3d and :opengl renderers. + + This method is useful for creating dynamically generated alpha + masks." + ([^PImage mask] (mask-image (current-graphics) mask)) + ([^PImage img ^PImage mask] (.mask img mask)))) + +(defn + ^{:requires-bindings true + :processing-name "millis()" + :category "Input" + :subcategory "Time & Date" + :added "1.0"} + millis + "Returns the number of milliseconds (thousandths of a second) since + starting the sketch. This information is often used for timing + animation sequences." + [] + (.millis (ap/current-applet))) + +(defn + ^{:requires-bindings false + :processing-name "minute()" + :category "Input" + :subcategory "Time & Date" + :added "1.0"} + minute + "Returns the current minute as a value from 0 - 59" + [] + #?(:clj (PApplet/minute) + :cljs (.minute (ap/current-applet)))) + +(defn + ^{:requires-bindings true + :processing-name "modelX()" + :category "Lights, Camera" + :subcategory "Coordinates" + :added "1.0"} + model-x + "Returns the three-dimensional x, y, z position in model space. This + returns the x value for a given coordinate based on the current set + of transformations (scale, rotate, translate, etc.) The x value can + be used to place an object in space relative to the location of the + original point once the transformations are no longer in use." + [x y z] + (.modelX (current-graphics) (float x) (float y) (float z))) + +(defn + ^{:requires-bindings true + :processing-name "modelY()" + :category "Lights, Camera" + :subcategory "Coordinates" + :added "1.0"} + model-y + "Returns the three-dimensional x, y, z position in model space. This + returns the y value for a given coordinate based on the current set + of transformations (scale, rotate, translate, etc.) The y value can + be used to place an object in space relative to the location of the + original point once the transformations are no longer in use." + [x y z] + (.modelY (current-graphics) (float x) (float y) (float z))) + +(defn + ^{:requires-bindings true + :processing-name "modelZ()" + :category "Lights, Camera" + :subcategory "Coordinates" + :added "1.0"} + model-z + "Returns the three-dimensional x, y, z position in model space. This + returns the z value for a given coordinate based on the current set + of transformations (scale, rotate, translate, etc.) The z value can + be used to place an object in space relative to the location of the + original point once the transformations are no longer in use." + [x y z] + (.modelZ (current-graphics) (float x) (float y) (float z))) + +(defn + ^{:requires-bindings false + :processing-name "month()" + :category "Input" + :subcategory "Time & Date" + :added "1.0"} + month + "Returns the current month as a value from 1 - 12." + [] + #?(:clj (PApplet/month) + :cljs (.month (ap/current-applet)))) + +(defn + ^{:requires-bindings true + :processing-name "mouseButton" + :category "Input" + :subcategory "Mouse" + :added "1.0"} + mouse-button + "The value of the system variable mouseButton is either :left, :right, + or :center depending on which button is pressed. nil if no button pressed" + [] + (let [button-code (.-mouseButton (ap/current-applet))] + #?(:clj + (condp = button-code + PConstants/LEFT :left + PConstants/RIGHT :right + PConstants/CENTER :center + nil) + + :cljs + (condp = button-code + 37 :left + 39 :right + 3 :center + nil)))) + +(defn + ^{:requires-bindings true + :processing-name "mousePressed" + :category "Input" + :subcategory "Mouse" + :added "1.0"} + mouse-pressed? + "Variable storing if a mouse button is pressed. The value of the + system variable mousePressed is true if a mouse button is pressed + and false if a button is not pressed." + [] + #?(:clj (.-mousePressed (ap/current-applet)) + :cljs (.-__mousePressed (ap/current-applet)))) + +(defn + ^{:requires-bindings true + :processing-name "mouseX" + :category "Input" + :subcategory "Mouse" + :added "1.0"} + mouse-x + "Current horizontal coordinate of the mouse." + [] + (.-mouseX (ap/current-applet))) + +(defn + ^{:requires-bindings true + :processing-name "mouseY" + :category "Input" + :subcategory "Mouse" + :added "1.0"} + mouse-y + "Current vertical coordinate of the mouse." + [] + (.-mouseY (ap/current-applet))) + +#?(:clj + (defn + ^{:requires-bindings true + :processing-name "noClip()" + :category "Rendering" + :subcategory nil + :added "2.4.0"} + no-clip + "Disables the clipping previously started by the clip() function." + [] + (.noClip (current-graphics)))) + +(defn + ^{:requires-bindings true + :processing-name "noCursor()" + :category "Environment" + :subcategory nil + :added "1.0"} + no-cursor + "Hides the cursor from view. Will not work when running the in full + screen (Present) mode." + [] + (.noCursor (ap/current-applet))) + +(defn + ^{:requires-bindings true + :processing-name "noFill()" + :category "Color" + :subcategory "Setting" + :added "1.0"} + no-fill + "Disables filling geometry. If both no-stroke and no-fill are called, + nothing will be drawn to the screen." [] + (.noFill (current-graphics)) + #?(:cljs (aset (current-graphics) no-fill-prop true))) + +(defn + ^{:requires-bindings true + :processing-name "random2d()" + :category "Math" + :subcategory "Random" + :added "2.6"} + random-2d + "Returns a new 2D unit vector in a random direction" [] + (let [theta (.random (ap/current-applet) TWO-PI)] + [(Math/cos theta) (Math/sin theta)])) + +(defn + ^{:requires-bindings true + :processing-name "random3d()" + :category "Math" + :subcategory "Random" + :added "2.6"} + random-3d + "Returns a new 3D unit vector in a random direction" [] + (let [theta (.random (ap/current-applet) TWO-PI) + phi (.random (ap/current-applet) (- HALF-PI) HALF-PI) + vx (* (Math/cos theta) (Math/sin phi)) + vy (* (Math/sin theta) (Math/sin phi)) + vz (Math/cos phi)] + [vx vy vz])) + +(defn + ^{:requires-bindings true + :processing-name "noise()" + :category "Math" + :subcategory "Random" + :added "1.0"} + noise + "Returns the Perlin noise value at specified coordinates. Perlin + noise is a random sequence generator producing a more natural + ordered, harmonic succession of numbers compared to the standard + random function. It was invented by Ken Perlin in the 1980s and + been used since in graphical applications to produce procedural + textures, natural motion, shapes, terrains etc. + + The main difference to the random function is that Perlin noise is + defined in an infinite n-dimensional space where each pair of + coordinates corresponds to a fixed semi-random value (fixed only for + the lifespan of the program). The resulting value will always be + between 0.0 and 1.0. Processing can compute 1D, 2D and 3D noise, + depending on the number of coordinates given. The noise value can be + animated by moving through the noise space and the 2nd and 3rd + dimensions can also be interpreted as time. + + The actual noise is structured similar to an audio signal, in + respect to the function's use of frequencies. Similar to the concept + of harmonics in physics, perlin noise is computed over several + octaves which are added together for the final result. + + Another way to adjust the character of the resulting sequence is the + scale of the input coordinates. As the function works within an + infinite space the value of the coordinates doesn't matter as such, + only the distance between successive coordinates does (eg. when + using noise within a loop). As a general rule the smaller the + difference between coordinates, the smoother the resulting noise + sequence will be. Steps of 0.005-0.03 work best for most + applications, but this will differ depending on use." + ([x] (.noise (ap/current-applet) (float x))) + ([x y] (.noise (ap/current-applet) (float x) (float y))) + ([x y z] (.noise (ap/current-applet) (float x) (float y) (float z)))) + +(defn + ^{:requires-bindings true + :processing-name "noiseDetail()" + :category "Math" + :subcategory "Random" + :added "1.0"} + noise-detail + "Adjusts the character and level of detail produced by the Perlin + noise function. Similar to harmonics in physics, noise is computed + over several octaves. Lower octaves contribute more to the output + signal and as such define the overal intensity of the noise, whereas + higher octaves create finer grained details in the noise + sequence. By default, noise is computed over 4 octaves with each + octave contributing exactly half than its predecessor, starting at + 50% strength for the 1st octave. This falloff amount can be changed + by adding an additional function parameter. Eg. a falloff factor of + 0.75 means each octave will now have 75% impact (25% less) of the + previous lower octave. Any value between 0.0 and 1.0 is valid, + however note that values greater than 0.5 might result in greater + than 1.0 values returned by noise. + + By changing these parameters, the signal created by the noise + function can be adapted to fit very specific needs and + characteristics." + ([octaves] (.noiseDetail (ap/current-applet) (int octaves))) + ([octaves falloff] (.noiseDetail (ap/current-applet) (int octaves) (float falloff)))) + +(defn + ^{:requires-bindings true + :processing-name "noiseSeed()" + :category "Math" + :subcategory "Random" + :added "1.0"} + noise-seed + "Sets the seed value for noise. By default, noise produces different + results each time the program is run. Set the value parameter to a + constant to return the same pseudo-random numbers each time the + software is run." + [val] + (.noiseSeed (ap/current-applet) (int val))) + +(defn + ^{:requires-bindings true + :processing-name "noLights()" + :category "Lights, Camera" + :subcategory "Lights" + :added "1.0"} + no-lights + "Disable all lighting. Lighting is turned off by default and enabled + with the lights fn. This function can be used to disable lighting so + that 2D geometry (which does not require lighting) can be drawn + after a set of lighted 3D geometry." + [] + (.noLights (current-graphics))) + +(defn + ^{:requires-bindings true + :processing-name "noLoop()" + :category "Structure" + :subcategory nil + :added "1.0"} + no-loop + "Stops Processing from continuously executing the code within + draw. If start-loop is called, the code in draw will begin to run + continuously again. If using no-loop in setup, it should be the last + line inside the block. + + When no-loop is used, it's not possible to manipulate or access the + screen inside event handling functions such as mouse-pressed or + key-pressed. Instead, use those functions to call redraw or + loop which will run draw, which can update the screen + properly. This means that when no-loop has been called, no drawing + can happen, and functions like save-frame may not be used. + + Note that if the sketch is resized, redraw will be called to + update the sketch, even after no-oop has been + specified. Otherwise, the sketch would enter an odd state until + loop was called." + [] + (.noLoop (ap/current-applet))) + +(defn + ^{:requires-bindings true + :processing-name "norm()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + norm + "Normalize a value to exist between 0 and 1 (inclusive)." + [val start stop] + #?(:clj (PApplet/norm (float val) (float start) (float stop)) + :cljs (.norm (ap/current-applet) val start stop))) + +(defn + ^{:requires-bindings true + :processing-name "normal()" + :category "Lights, Camera" + :subcategory "Lights" + :added "1.0"} + normal + "Sets the current normal vector. This is for drawing three + dimensional shapes and surfaces and specifies a vector perpendicular + to the surface of the shape which determines how lighting affects + it. Processing attempts to automatically assign normals to shapes, + but since that's imperfect, this is a better option when you want + more control. This function is identical to glNormal3f() in OpenGL." + [nx ny nz] + (.normal (current-graphics) (float nx) (float ny) (float nz))) + +(defn + ^{:requires-bindings true + :processing-name "noSmooth()" + :category "Shape" + :subcategory "Attributes" + :added "1.0"} + no-smooth + "Draws all geometry with jagged (aliased) edges. Must be called inside + :settings handler." + [] (.noSmooth (current-graphics))) + +(defn + ^{:requires-bindings true + :processing-name "noStroke()" + :category "Color" + :subcategory "Setting" + :added "1.0"} + no-stroke + "Disables drawing the stroke (outline). If both no-stroke and + no-fill are called, nothing will be drawn to the screen." + [] + (.noStroke (current-graphics))) + +(defn + ^{:requires-bindings true + :processing-name "noTint()" + :category "Image" + :subcategory "Loading & Displaying" + :added "1.0"} + no-tint + "Removes the current fill value for displaying images and reverts to + displaying images with their original hues." + [] + (.noTint (current-graphics))) + +(defn + ^{:requires-bindings true + :processing-name "ortho()" + :category "Lights, Camera" + :subcategory "Camera" + :added "1.0"} + ortho + "Sets an orthographic projection and defines a parallel clipping + volume. All objects with the same dimension appear the same size, + regardless of whether they are near or far from the camera. The + parameters to this function specify the clipping volume where left + and right are the minimum and maximum x values, top and bottom are + the minimum and maximum y values, and near and far are the minimum + and maximum z values. If no parameters are given, the default is + used: (ortho 0 width 0 height -10 10)" + ([] (.ortho (current-graphics))) + ([left right bottom top] + (.ortho (current-graphics) (float left) (float right) (float bottom) (float top))) + ([left right bottom top near far] + (.ortho (current-graphics) (float left) (float right) (float bottom) (float top) (float near) (float far)))) + +(defn + ^{:requires-bindings true + :processing-name "perspective()" + :category "Lights, Camera" + :subcategory "Camera" + :added "1.0"} + perspective + "Sets a perspective projection applying foreshortening, making + distant objects appear smaller than closer ones. The parameters + define a viewing volume with the shape of truncated pyramid. Objects + near to the front of the volume appear their actual size, while + farther objects appear smaller. This projection simulates the + perspective of the world more accurately than orthographic + projection. The version of perspective without parameters sets the + default perspective and the version with four parameters allows the + programmer to set the area precisely. The default values are: + perspective(PI/3.0, width/height, cameraZ/10.0, cameraZ*10.0) where + cameraZ is ((height/2.0) / tan(PI*60.0/360.0));" + ([] (.perspective (current-graphics))) + ([fovy aspect z-near z-far] + (.perspective (current-graphics) (float fovy) (float aspect) + (float z-near) (float z-far)))) + +#?(:clj + (defn + ^{:requires-bindings true + :processing-name "pixelDensity()" + :category "Environment" + :subcategory nil + :added "2.4.0"} + pixel-density + "It makes it possible for Processing to render using all of the pixels + on high resolutions screens like Apple Retina displays and Windows + High-DPI displays. Possible values 1 or 2. Must be called only from + :settings handler. To get density of the current screen you can use + (display-density) function." + [density] + (.pixelDensity (ap/current-applet) density))) + +(defn + ^{:requires-bindings true + :processing-name "pixels[]" + :category "Image" + :subcategory "Pixels" + :added "1.0"} + pixels + "Array containing the values for all the pixels in the display + window or image. This array is therefore the size of the display window. If + this array is modified, the update-pixels fn must be called to update + the changes. Calls .loadPixels before obtaining the pixel array." + ([] (pixels (current-graphics))) + + #?(:clj + ([^PImage img] + (.loadPixels img) + (.-pixels img)) + + :cljs + ([img] + (.loadPixels img) + (let [pix-array (.toArray (.-pixels img))] + (set! (.-stored-pix-array img) pix-array) + pix-array)))) + +(defn + ^{:requires-bindings true + :processing-name "pmouseX" + :category "Input" + :subcategory "Mouse" + :added "1.0"} + pmouse-x + "Horizontal coordinate of the mouse in the previous frame" + [] + (.-pmouseX (ap/current-applet))) + +(defn + ^{:requires-bindings true + :processing-name "pmouseY" + :category "Input" + :subcategory "Mouse" + :added "1.0"} + pmouse-y + "Vertical coordinate of the mouse in the previous frame" + [] + (.-pmouseY (ap/current-applet))) + +(defn + ^{:requires-bindings true + :processing-name "point()" + :category "Shape" + :subcategory "2D Primitives" + :added "1.0"} + point + "Draws a point, a coordinate in space at the dimension of one + pixel. The first parameter is the horizontal value for the point, + the second value is the vertical value for the point, and the + optional third value is the depth value. Drawing this shape in 3D + using the z parameter requires the :P3D or :opengl renderer to be + used." + ([x y] (.point (current-graphics) (float x)(float y))) + ([x y z] (.point (current-graphics) (float x) (float y) (float z)))) + +(defn + ^{:requires-bindings true + :processing-name "pointLight()" + :category "Lights, Camera" + :subcategory "Lights" + :added "1.0"} + point-light + "Adds a point light. Lights need to be included in the draw() to + remain persistent in a looping program. Placing them in the setup() + of a looping program will cause them to only have an effect the + first time through the loop. The affect of the r, g, and b + parameters is determined by the current color mode. The x, y, and z + parameters set the position of the light" + [r g b x y z] + (.pointLight (current-graphics) (float r) (float g) (float b) (float x) (float y) (float z))) + +(defn + ^{:requires-bindings true + :processing-name "popMatrix()" + :category "Transform" + :subcategory nil + :added "1.0"} + pop-matrix + "Pops the current transformation matrix off the matrix + stack. Understanding pushing and popping requires understanding the + concept of a matrix stack. The push-matrix fn saves the current + coordinate system to the stack and pop-matrix restores the prior + coordinate system. push-matrix and pop-matrix are used in conjuction + with the other transformation methods and may be embedded to control + the scope of the transformations." + [] + (.popMatrix (current-graphics))) + +(defn + ^{:requires-bindings true + :processing-name "popStyle()" + :category "Structure" + :subcategory nil + :added "1.0"} + pop-style + "Restores the prior settings on the 'style stack'. Used in + conjunction with push-style. Together they allow you to change the + style settings and later return to what you had. When a new style is + started with push-style, it builds on the current style information. + The push-style and pop-style functions can be nested to provide more + control" + [] + (.popStyle (current-graphics))) + +(defn + ^{:requires-bindings false + :processing-name "pow()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + pow + "Facilitates exponential expressions. The pow() function is an + efficient way of multiplying numbers by themselves (or their + reciprocal) in large quantities. For example, (pow 3 5) is + equivalent to the expression (* 3 3 3 3 3) and (pow 3 -5) is + equivalent to (/ 1 (* 3 3 3 3 3))." + [num exponent] + #?(:clj (PApplet/pow (float num) (float exponent)) + :cljs (.pow (ap/current-applet) num exponent))) + +(defn + ^{:requires-bindings true + :processing-name "printCamera()" + :category "Lights, Camera" + :subcategory "Camera" + :added "1.0"} + print-camera + "Prints the current camera matrix to std out. Useful for debugging." + [] + (.printCamera (current-graphics))) + +(defn + ^{:requires-bindings true + :processing-name "printMatrix()" + :category "Transform" + :subcategory nil + :added "1.0"} + print-matrix + "Prints the current matrix to std out. Useful for debugging." + [] + (.printMatrix (current-graphics))) + +(defn + ^{:requires-bindings true + :processing-name "printProjection()" + :category "Lights, Camera" + :subcategory "Camera" + :added "1.0"} + print-projection + "Prints the current projection matrix to std out. Useful for + debugging" + [] + (.printProjection (current-graphics))) + +(defn + ^{:requires-bindings true + :processing-name "pushMatrix()" + :category "Transform" + :subcategory nil + :added "1.0"} + push-matrix + "Pushes the current transformation matrix onto the matrix + stack. Understanding push-matrix and pop-matrix requires + understanding the concept of a matrix stack. The push-matrix + function saves the current coordinate system to the stack and + pop-matrix restores the prior coordinate system. push-matrix and + pop-matrix are used in conjuction with the other transformation + methods and may be embedded to control the scope of the + transformations." + [] + (.pushMatrix (current-graphics))) + +(defn + ^{:requires-bindings true + :processing-name "pushStyle()" + :category "Structure" + :subcategory nil + :added "1.0"} + push-style + "Saves the current style settings onto a 'style stack'. Use with + pop-style which restores the prior settings. Note that these + functions are always used together. They allow you to change the + style settings and later return to what you had. When a new style is + started with push-style, it builds on the current style + information. The push-style and pop-style fns can be embedded to + provide more control. + + The style information controlled by the following functions are + included in the style: fill, stroke, tint, stroke-weight, + stroke-cap, stroke-join, image-mode, rect-mode, ellipse-mode, + shape-mode, color-mode, text-align, text-font, text-mode, text-size, + text-leading, emissive, specular, shininess, and ambient" + [] + (.pushStyle (current-graphics))) + +(defn + ^{:requires-bindings true + :processing-name "quad()" + :category "Shape" + :subcategory "2D Primitives" + :added "1.0"} + quad + "A quad is a quadrilateral, a four sided polygon. It is similar to a + rectangle, but the angles between its edges are not constrained to + be ninety degrees. The first pair of parameters (x1,y1) sets the + first vertex and the subsequent pairs should proceed clockwise or + counter-clockwise around the defined shape." + [x1 y1 x2 y2 x3 y3 x4 y4] + (.quad (current-graphics) + (float x1) (float y1) + (float x2) (float y2) + (float x3) (float y3) + (float x4) (float y4))) + +(defn + ^{:requires-bindings true + :processing-name "quadraticVertex()" + :category "Shape" + :subcategory "Vertex" + :added "2.0"} + quadratic-vertex + "Specifies vertex coordinates for quadratic Bezier curves. Each call to + quadratic-vertex defines the position of one control points and one + anchor point of a Bezier curve, adding a new segment to a line or shape. + The first time quadratic-vertex is used within a begin-shape call, it + must be prefaced with a call to vertex to set the first anchor point. + This function must be used between begin-shape and end-shape and only + when there is no MODE parameter specified to begin-shape. Using the 3D + version requires rendering with :p3d." + ([cx cy x3 y3] + (.quadraticVertex (current-graphics) (float cx) (float cy) (float x3) (float y3))) + ([cx cy cz x3 y3 z3] + (.quadraticVertex (current-graphics) (float cx) (float cy) (float cz) (float x3) (float y3) (float z3)))) + +(defn + ^{:requires-bindings false + :processing-name "radians()" + :category "Math" + :subcategory "Trigonometry" + :added "1.0"} + radians + "Converts a degree measurement to its corresponding value in + radians. Radians and degrees are two ways of measuring the same + thing. There are 360 degrees in a circle and 2*PI radians in a + circle. For example, 90° = PI/2 = 1.5707964. All trigonometric + methods in Processing require their parameters to be specified in + radians." + [degrees] + #?(:clj (PApplet/radians (float degrees)) + :cljs (.radians (ap/current-applet) degrees))) + +(defn + ^{:requires-bindings true + :processing-name "random()" + :category "Math" + :subcategory "Random" + :added "1.0"} + random + "Generates random numbers. Each time the random function is called, + it returns an unexpected value within the specified range. If one + parameter is passed to the function it will return a float between + zero and the value of the high parameter. The function call (random + 5) returns values between 0 and 5 (starting at zero, up to but not + including 5). If two parameters are passed, it will return a float + with a value between the parameters. The function call + (random -5 10.2) returns values starting at -5 up to (but not + including) 10.2." + ([max] (.random (ap/current-applet) (float max))) + ([min max] (.random (ap/current-applet) (float min) (float max)))) + +(defn + ^{:requires-bindings true + :processing-name "randomGaussian()" + :category "Math" + :subcategory "Random" + :added "2.0"} + random-gaussian + "Returns a float from a random series of numbers having a mean of 0 and + standard deviation of 1. Each time the randomGaussian() function is called, + it returns a number fitting a Gaussian, or normal, distribution. + There is theoretically no minimum or maximum value that randomGaussian() + might return. Rather, there is just a very low probability that values far + from the mean will be returned; and a higher probability that numbers near + the mean will be returned. ." + [] + (.randomGaussian (ap/current-applet))) + +(defn + ^{:requires-bindings true + :processing-name "randomSeed()" + :category "Math" + :subcategory "Random" + :added "1.0"} + random-seed + "Sets the seed value for random. By default, random produces + different results each time the program is run. Set the value + parameter to a constant to return the same pseudo-random numbers + each time the software is run." + [w] + (.randomSeed (ap/current-applet) (float w))) + +(defn + ^{:requires-bindings true + :processing-name "key" + :category "Input" + :subcategory "Keyboard" + :added "1.0"} + raw-key + "Contains the value of the most recent key on the keyboard that was + used (either pressed or released). + + For non-ASCII keys, use the keyCode variable. The keys included in + the ASCII specification (BACKSPACE, TAB, ENTER, RETURN, ESC, and + DELETE) do not require checking to see if they key is coded, and you + should simply use the key variable instead of keyCode If you're + making cross-platform projects, note that the ENTER key is commonly + used on PCs and Unix and the RETURN key is used instead on + Macintosh. Check for both ENTER and RETURN to make sure your program + will work for all platforms." + [] + (.-key (ap/current-applet))) + +(defn + ^{:requires-bindings true + :processing-name "rect()" + :category "Shape" + :subcategory "2D Primitives" + :added "1.0"} + rect + "Draws a rectangle to the screen. A rectangle is a four-sided shape + with every angle at ninety degrees. By default, the first two + parameters set the location of the upper-left corner, the third + sets the width, and the fourth sets the height. These parameters + may be changed with rect-mode. + + To draw a rounded rectangle, add a fifth parameter, which is used as + the radius value for all four corners. To use a different radius value + for each corner, include eight parameters." + ([x y width height] + (.rect (current-graphics) (float x) (float y) (float width) (float height))) + ([x y width height r] + (.rect (current-graphics) (float x) (float y) (float width) (float height) (float r))) + ([x y width height top-left-r top-right-r bottom-right-r bottom-left-r] + (.rect (current-graphics) (float x) (float y) (float width) (float height) + (float top-left-r) (float top-right-r) (float bottom-right-r) (float bottom-left-r)))) + +(defn + ^{:requires-bindings true + :processing-name "rectMode()" + :category "Shape" + :subcategory "Attributes" + :added "1.0"} + rect-mode + "Modifies the location from which rectangles draw. The default mode + is :corner. Available modes are: + + + :corner - Specifies the location to be the upper left corner of the + shape and uses the third and fourth parameters of rect to + specify the width and height. + + :corners - Uses the first and second parameters of rect to set the + location of one corner and uses the third and fourth + parameters to set the opposite corner. + + :center - Draws the image from its center point and uses the third + and forth parameters of rect to specify the image's width + and height. + + :radius - Draws the image from its center point and uses the third + and forth parameters of rect() to specify half of the + image's width and height." + + [mode] + (let [mode (u/resolve-constant-key mode rect-modes)] + (.rectMode (current-graphics) (int mode)))) + +(defn + ^{:requires-bindings true + :processing-name "red()" + :category "Color" + :subcategory "Creating & Reading" + :added "1.0"} + red + "Extracts the red value from a color, scaled to match current color-mode." + [c] + (.red (current-graphics) (unchecked-int c))) + +(defn + ^{:requires-bindings true + :processing-name "redraw()" + :category "Structure" + :subcategory nil + :added "1.0"} + redraw + "Executes the code within the draw fn one time. This functions + allows the program to update the display window only when necessary, + for example when an event registered by mouse-pressed or + key-pressed occurs. + + In structuring a program, it only makes sense to call redraw + within events such as mouse-pressed. This is because redraw does + not run draw immediately (it only sets a flag that indicates an + update is needed). + + Calling redraw within draw has no effect because draw is + continuously called anyway." + [] + (.redraw (ap/current-applet))) + +(defn + ^{:requires-bindings true + :processing-name "requestImage()" + :category "Image" + :subcategory "Loading & Displaying" + :added "1.0"} + request-image + "This function load images on a separate thread so that your sketch + does not freeze while images load during setup. While the image is + loading, its width and height will be 0. If an error occurs while + loading the image, its width and height will be set to -1. You'll + know when the image has loaded properly because its width and height + will be greater than 0. Asynchronous image loading (particularly + when downloading from a server) can dramatically improve + performance." + [filename] (.requestImage (ap/current-applet) (str filename))) + +(defn + ^{:requires-bindings true + :processing-name "resetMatrix()" + :category "Transform" + :subcategory nil + :added "1.0"} + reset-matrix + "Replaces the current matrix with the identity matrix. The + equivalent function in OpenGL is glLoadIdentity()" + [] + (.resetMatrix (current-graphics))) + +#?(:clj + (def ^{:private true} + shader-modes {:points PApplet/POINTS + :lines PApplet/LINES + :triangles PApplet/TRIANGLES})) + +#?(:clj + (defn + ^{:requires-bindings true + :processing-name "resetShader()" + :category "Rendering" + :subcategory "Shaders" + :added "2.0"} + reset-shader + "Restores the default shaders. Code that runs after (reset-shader) will + not be affected by previously defined shaders. Optional 'kind' parameter - + type of shader, either :points, :lines, or :triangles" + ([] (.resetShader (current-graphics))) + ([kind] + (let [mode (u/resolve-constant-key kind shader-modes)] + (.resetShader (current-graphics) mode))))) + +(defn + ^{:requires-bindings true + :processing-name "resize()" + :category "Image" + :processing-link "http://processing.org/reference/PImage_resize_.html" + :added "2.1.0"} + resize + "Resize the image to a new width and height. + To make the image scale proportionally, use 0 as the value for the wide or + high parameter. For instance, to make the width of an image 150 pixels, + and change the height using the same proportion, use resize(150, 0). + + Even though a PGraphics is technically a PImage, it is not possible + to rescale the image data found in a PGraphics. + (It's simply not possible to do this consistently across renderers: + technically infeasible with P3D, or what would it even do with PDF?) + If you want to resize PGraphics content, first get a copy of its image data + using the get() method, and call resize() on the PImage that is returned." + [^PImage img w h] + (.resize img w h)) + +(defn + ^{:requires-bindings true + :processing-name "rotate()" + :category "Transform" + :subcategory nil + :added "1.0"} + rotate + "Rotates a shape the amount specified by the angle parameter. Angles + should be specified in radians (values from 0 to TWO-PI) or + converted to radians with the radians function. + + Objects are always rotated around their relative position to the + origin and positive numbers rotate objects in a clockwise + direction. Transformations apply to everything that happens after + and subsequent calls to the function accumulates the effect. For + example, calling (rotate HALF-PI) and then (rotate HALF-PI) is the + same as (rotate PI). All tranformations are reset when draw begins + again. + + Technically, rotate multiplies the current transformation matrix by + a rotation matrix. This function can be further controlled by the + push-matrix and pop-matrix." + ([angle] (.rotate (current-graphics) (float angle))) + ([angle vx vy vz] (.rotate (current-graphics) (float angle) + (float vx) (float vy) (float vz)))) + +(defn + ^{:requires-bindings true + :processing-name "rotateX()" + :category "Transform" + :subcategory nil + :added "1.0"} + rotate-x + "Rotates a shape around the x-axis the amount specified by the angle + parameter. Angles should be specified in radians (values from 0 to + (* PI 2)) or converted to radians with the radians function. Objects + are always rotated around their relative position to the origin and + positive numbers rotate objects in a counterclockwise + direction. Transformations apply to everything that happens after + and subsequent calls to the function accumulates the effect. For + example, calling (rotate-x HALF-PI) and then (rotate-x HALF-PI) is + the same as (rotate-x PI). If rotate-x is called within the draw fn, + the transformation is reset when the loop begins again. This + function requires either the :p3d or :opengl renderer." + [angle] + (.rotateX (current-graphics) (float angle))) + +(defn + ^{:requires-bindings true + :processing-name "rotateY()" + :category "Transform" + :subcategory nil + :added "1.0"} + rotate-y + "Rotates a shape around the y-axis the amount specified by the angle + parameter. Angles should be specified in radians (values from 0 + to (* PI 2)) or converted to radians with the radians function. + Objects are always rotated around their relative position to the + origin and positive numbers rotate objects in a counterclockwise + direction. Transformations apply to everything that happens after + and subsequent calls to the function accumulates the effect. For + example, calling (rotate-y HALF-PI) and then (rotate-y HALF-PI) is + the same as (rotate-y PI). If rotate-y is called within the draw fn, + the transformation is reset when the loop begins again. This + function requires either the :p3d or :opengl renderer." + [angle] + (.rotateY (current-graphics) (float angle))) + +(defn + ^{:requires-bindings true + :processing-name "rotateZ()" + :category "Transform" + :subcategory nil + :added "1.0"} + rotate-z + "Rotates a shape around the z-axis the amount specified by the angle + parameter. Angles should be specified in radians (values from 0 + to (* PI 2)) or converted to radians with the radians function. + Objects are always rotated around their relative position to the + origin and positive numbers rotate objects in a counterclockwise + direction. Transformations apply to everything that happens after + and subsequent calls to the function accumulates the effect. For + example, calling (rotate-z HALF-PI) and then (rotate-z HALF-PI) is + the same as (rotate-z PI). If rotate-y is called within the draw fn, + the transformation is reset when the loop begins again. This + function requires either the :p3d or :opengl renderer." + [angle] + (.rotateZ (current-graphics) (float angle))) + +(defn + ^{:requires-bindings false + :processing-name "round()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + round + "Calculates the integer closest to the value parameter. For example, + (round 9.2) returns the value 9." + [val] + #?(:clj (PApplet/round (float val)) + :cljs (.round (ap/current-applet) val))) + +(defn + ^{:requires-bindings true + :processing-name "saturation()" + :category "Color" + :subcategory "Creating & Reading" + :added "1.0"} + saturation + "Extracts the saturation value from a color." + [c] + (.saturation (current-graphics) (unchecked-int c))) + +(defn + ^{:requires-bindings true + :processing-name "save()" + :category "Output" + :subcategory "Image" + :added "1.0"} + save + "Saves an image from the display window. Images are saved in TIFF, + TARGA, JPEG, and PNG format depending on the extension within the + filename parameter. For example, image.tif will have a TIFF image + and image.png will save a PNG image. If no extension is included in + the filename, the image will save in TIFF format and .tif will be + added to the name. All images saved from the main drawing window + will be opaque. To save images without a background, use + create-graphics." + [filename] + (.save (current-graphics) (str filename))) + +(defn + ^{:requires-bindings true + :processing-name "saveFrame()" + :category "Output" + :subcategory "Image" + :added "1.0"} + save-frame + "Saves an image identical to the current display window as a + file. May be called multple times - each file saved will have a + unique name. Name and image formate may be modified by passing a + string parameter of the form \"foo-####.ext\" where foo- can be any + arbitrary string, #### will be replaced with the current frame id + and .ext is one of .tiff, .targa, .png, .jpeg or .jpg + + Examples: + (save-frame) + (save-frame \"pretty-pic-####.jpg\")" + ([] (.saveFrame (ap/current-applet))) + ([name] (.saveFrame (ap/current-applet) (str name)))) + +(defn + ^{:requires-bindings true + :processing-name "scale()" + :category "Transform" + :subcategory nil + :added "1.0"} + scale + "Increases or decreases the size of a shape by expanding and + contracting vertices. Objects always scale from their relative + origin to the coordinate system. Scale values are specified as + decimal percentages. For example, the function call (scale 2) + increases the dimension of a shape by 200%. Transformations apply to + everything that happens after and subsequent calls to the function + multiply the effect. For example, calling (scale 2) and then + (scale 1.5) is the same as (scale 3). If scale is called within + draw, the transformation is reset when the loop begins again. Using + this fuction with the z parameter requires specfying :p3d or :opengl + as the renderer. This function can be further controlled by + push-matrix and pop-matrix." + ([s] (.scale (current-graphics) (float s))) + ([sx sy] (.scale (current-graphics) (float sx) (float sy))) + ([sx sy sz] (.scale (current-graphics) (float sx) (float sy) (float sz)))) + +#?(:clj + (defn- ^java.awt.Dimension current-screen + [] + (let [default-toolkit (java.awt.Toolkit/getDefaultToolkit)] + (.getScreenSize default-toolkit)))) + +#?(:clj + (defn + ^{:requires-bindings false + :processing-name nil + :category "Environment" + :subcategory nil + :added "1.0"} + screen-width + "Returns the width of the main screen in pixels." + [] + (.width (current-screen)))) + +#?(:clj + (defn + ^{:requires-bindings false + :processing-name nil + :category "Environment" + :subcategory nil + :added "1.0"} + screen-height + "Returns the height of the main screen in pixels." + [] + (.height (current-screen)))) + +(defn + ^{:requires-bindings true + :processing-name "screenX()" + :category "Lights, Camera" + :subcategory "Coordinates" + :added "1.0"} + screen-x + "Takes a three-dimensional x, y, z position and returns the x value + for where it will appear on a (two-dimensional) screen, once + affected by translate, scale or any other transformations" + ([x y] (.screenX (current-graphics) (float x) (float y))) + ([x y z] (.screenX (current-graphics) (float x) (float y) (float z)))) + +(defn + ^{:requires-bindings true + :processing-name "screenY()" + :category "Lights, Camera" + :subcategory "Coordinates" + :added "1.0"} + screen-y + "Takes a three-dimensional x, y, z position and returns the y value + for where it will appear on a (two-dimensional) screen, once + affected by translate, scale or any other transformations" + ([x y] (.screenY (current-graphics) (float x) (float y))) + ([x y z] (.screenY (current-graphics) (float x) (float y) (float z)))) + +(defn + ^{:requires-bindings true + :processing-name "screenZ()" + :category "Lights, Camera" + :subcategory "Coordinates" + :added "1.0"} + screen-z + "Given an x, y, z coordinate, returns its z value. + This value can be used to determine if an x, y, z coordinate is in + front or in back of another (x, y, z) coordinate. The units are + based on how the zbuffer is set up, and don't relate to anything + 'real'. They're only useful for in comparison to another value + obtained from screen-z, or directly out of the zbuffer" + [x y z] + (.screenZ (current-graphics) (float x) (float y) (float z))) + +(defn + ^{:requires-bindings false + :processing-name "second()" + :category "Input" + :subcategory "Time & Date" + :added "1.0"} + seconds + "Returns the current second as a value from 0 - 59." + [] + #?(:clj (PApplet/second) + :cljs (.second (ap/current-applet)))) + +(defn + ^{:requires-bindings true + :processing-name "set()" + :category "Image" + :subcategory "Pixels" + :added "1.0"} + set-pixel + "Changes the color of any pixel in the display window. The x and y + parameters specify the pixel to change and the color parameter + specifies the color value. The color parameter is affected by the + current color mode (the default is RGB values from 0 to 255). + + Setting the color of a single pixel with (set x, y) is easy, but not + as fast as putting the data directly into pixels[]. + + This function ignores imageMode(). + + Due to what appears to be a bug in Apple's Java implementation, the + point() and set() methods are extremely slow in some circumstances + when used with the default renderer. Using :p2d or :p3d will fix the + problem. Grouping many calls to point or set-pixel together can also + help. (Bug 1094)" + ([x y c] (set-pixel (current-graphics) x y c)) + ([^PImage img x y c] + (.set img (int x) (int y) (int c)))) + +(defn + ^{:requires-bindings true + :processing-name "set()" + :category "Image" + :subcategory "Pixels" + :added "1.0"} + set-image + "Writes an image directly into the display window. The x and y + parameters define the coordinates for the upper-left corner of the + image." + [x y ^PImage src] + (.set (current-graphics) (int x) (int y) src)) + +#?(:clj + (defn + ^{:requires-bindings true + :processing-name "shader()" + :category "Rendering" + :subcategory "Shaders" + :added "2.0"} + shader + "Applies the shader specified by the parameters. It's compatible with the :p2d + and :p3drenderers, but not with the default :java2d renderer. Optional 'kind' + parameter - type of shader, either :points, :lines, or :triangles" + ([shader] (.shader (current-graphics) shader)) + ([shader kind] + (let [mode (u/resolve-constant-key kind shader-modes)] + (.shader (current-graphics) shader mode))))) + +(defn + ^{:requires-bindings true + :processing-name "shape()" + :category "Shape" + :subcategory "Loading & Displaying" + :added "1.0"} + shape + "Displays shapes to the screen. The shapes must have been loaded + with load-shape. Processing currently works with SVG shapes + only. The sh parameter specifies the shape to display and the x and + y parameters define the location of the shape from its upper-left + corner. The shape is displayed at its original size unless the width + and height parameters specify a different size. The shape-mode + fn changes the way the parameters work. A call to + (shape-mode :corners), for example, will change the width and height + parameters to define the x and y values of the opposite corner of + the shape. + + Note complex shapes may draw awkwardly with the renderers :p2d, :p3d, and + :opengl. Those renderers do not yet support shapes that have holes + or complicated breaks." + ([^PShape sh] (.shape (current-graphics) sh)) + ([^PShape sh x y] (.shape (current-graphics) sh (float x) (float y))) + ([^PShape sh x y width height] (.shape (current-graphics) sh (float x) (float y) (float width) (float height)))) + +(defn + ^{:requires-bindings true + :processing-name "shearX()" + :category "Transform" + :subcategory nil + :added "1.0"} + shear-x + "Shears a shape around the x-axis the amount specified by the angle + parameter. Angles should be specified in radians (values from 0 to + PI*2) or converted to radians with the radians() function. Objects + are always sheared around their relative position to the origin and + positive numbers shear objects in a clockwise direction. + Transformations apply to everything that happens after and + subsequent calls to the function accumulates the effect. For + example, calling (shear-x (/ PI 2)) and then (shear-x (/ PI 2)) is + the same as (shear-x PI). If shear-x is called within the draw fn, + the transformation is reset when the loop begins again. This + function works in P2D or JAVA2D mode. + + Technically, shear-x multiplies the current transformation matrix + by a rotation matrix. This function can be further controlled by the + push-matrix and pop-matrix fns." + [angle] + (.shearX (current-graphics) (float angle))) + +(defn + ^{:requires-bindings true + :processing-name "shearY()" + :category "Transform" + :subcategory nil + :added "1.0"} + shear-y + "Shears a shape around the y-axis the amount specified by the angle + parameter. Angles should be specified in radians (values from 0 to + PI*2) or converted to radians with the radians() function. Objects + are always sheared around their relative position to the origin and + positive numbers shear objects in a clockwise direction. + Transformations apply to everything that happens after and + subsequent calls to the function accumulates the effect. For + example, calling (shear-y (/ PI 2)) and then (shear-y (/ PI 2)) is + the same as (shear-y PI). If shear-y is called within the draw fn, + the transformation is reset when the loop begins again. This + function works in P2D or JAVA2D mode. + + Technically, shear-y multiplies the current transformation matrix + by a rotation matrix. This function can be further controlled by the + push-matrix and pop-matrix fns." + [angle] + (.shearY (current-graphics) (float angle))) + +(defn ^{:requires-bindings true + :processing-name "shapeMode()" + :category "Shape" + :subcategory "Loading & Displaying" + :added "1.0"} + shape-mode + "Modifies the location from which shapes draw. Available modes are + :corner, :corners and :center. Default is :corner. + + :corner - specifies the location to be the upper left corner of the + shape and uses the third and fourth parameters of shape + to specify the width and height. + + :corners - uses the first and second parameters of shape to set + the location of one corner and uses the third and fourth + parameters to set the opposite corner. + + :center - draws the shape from its center point and uses the third + and forth parameters of shape to specify the width and + height. " + [mode] + (let [mode (u/resolve-constant-key mode p-shape-modes)] + (.shapeMode (current-graphics) (int mode)))) + +(defn + ^{:requires-bindings true + :processing-name "shininess()" + :category "Lights, Camera" + :subcategory "Material Properties" + :added "1.0"} + shininess + "Sets the amount of gloss in the surface of shapes. Used in + combination with ambient, specular, and emissive in setting + the material properties of shapes." + [shine] + (.shininess (current-graphics) (float shine))) + +(defn + ^{:requires-bindings false + :processing-name "sin()" + :category "Math" + :subcategory "Trigonometry" + :added "1.0"} + sin + "Calculates the sine of an angle. This function expects the values + of the angle parameter to be provided in radians (values from 0 to + 6.28). A float within the range -1 to 1 is returned." + [angle] + #?(:clj (PApplet/sin (float angle)) + :cljs (.sin (ap/current-applet) angle))) + +(defn + ^{:requires-bindings true + :processing-name "smooth()" + :category "Shape" + :subcategory "Attributes" + :added "1.0"} + smooth + "Draws all geometry with smooth (anti-aliased) edges. This will slow + down the frame rate of the application, but will enhance the visual + refinement. + + Must be called inside :settings handler. + + The level parameter (int) increases the level of smoothness with the + P2D and P3D renderers. This is the level of over sampling applied to + the graphics buffer. The value '2' will double the rendering size + before scaling it down to the display size. This is called '2x + anti-aliasing.' The value 4 is used for 4x anti-aliasing and 8 is + specified for 8x anti-aliasing. If level is set to 0, it will disable + all smoothing; it's the equivalent of the function noSmooth(). + The maximum anti-aliasing level is determined by the hardware of the + machine that is running the software. + + Note that smooth will also improve image quality of resized images." + ([] (.smooth #?(:clj (ap/current-applet) + :cljs (current-graphics)))) + ([level] (.smooth #?(:clj (ap/current-applet) + :cljs (current-graphics)) + (int level)))) + +(defn + ^{:requires-bindings true + :processing-name "specular()" + :category "Lights, Camera" + :subcategory "Material Properties" + :added "1.0"} + specular + "Sets the specular color of the materials used for shapes drawn to + the screen, which sets the color of hightlights. Specular refers to + light which bounces off a surface in a perferred direction (rather + than bouncing in all directions like a diffuse light). Used in + combination with emissive, ambient, and shininess in setting + the material properties of shapes." + ([gray] (.specular (current-graphics) (float gray))) + ([x y z] (.specular (current-graphics) (float x) (float y) (float z)))) + +(defn + ^{:requires-bindings true + :processing-name "sphere()" + :category "Shape" + :subcategory "3D Primitives" + :added "1.0"} + sphere + "Generates a hollow ball made from tessellated triangles." + [radius] (.sphere (current-graphics) (float radius))) + +(defn + ^{:requires-bindings true + :processing-name "sphereDetail()" + :category "Shape" + :subcategory "3D Primitives" + :added "1.0"} + sphere-detail + "Controls the detail used to render a sphere by adjusting the number + of vertices of the sphere mesh. The default resolution is 30, which + creates a fairly detailed sphere definition with vertices every + 360/30 = 12 degrees. If you're going to render a great number of + spheres per frame, it is advised to reduce the level of detail using + this function. The setting stays active until sphere-detail is + called again with a new parameter and so should not be called prior + to every sphere statement, unless you wish to render spheres with + different settings, e.g. using less detail for smaller spheres or + ones further away from the camera. To controla the detail of the + horizontal and vertical resolution independently, use the version of + the functions with two parameters." + ([res] (.sphereDetail (current-graphics) (int res))) + ([ures vres] (.sphereDetail (current-graphics) (int ures) (int vres)))) + +(defn + ^{:requires-bindings true + :processing-name "spotLight()" + :category "Lights, Camera" + :subcategory "Lights" + :added "1.0"} + spot-light + "Adds a spot light. Lights need to be included in the draw to + remain persistent in a looping program. Placing them in the setup + of a looping program will cause them to only have an effect the + first time through the loop. The affect of the r, g, and b + parameters is determined by the current color mode. The x, y, and z + parameters specify the position of the light and nx, ny, nz specify + the direction or light. The angle parameter affects angle of the + spotlight cone." + ([r g b x y z nx ny nz angle concentration] + (.spotLight (current-graphics) r g b x y z nx ny nz angle concentration)) + ([[r g b] [x y z] [nx ny nz] angle concentration] + (.spotLight (current-graphics) r g b x y z nx ny nz angle concentration))) + +(defn + ^{:requires-bindings false + :processing-name "sq()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + sq + "Squares a number (multiplies a number by itself). The result is + always a positive number, as multiplying two negative numbers always + yields a positive result. For example, -1 * -1 = 1." + [a] + #?(:clj (PApplet/sq (float a)) + :cljs (.sq (ap/current-applet) a))) + +(defn + ^{:requires-bindings false + :processing-name "sqrt()" + :category "Math" + :subcategory "Calculation" + :added "1.0"} + sqrt + "Calculates the square root of a number. The square root of a number + is always positive, even though there may be a valid negative + root. The square root s of number a is such that (= a (* s s)) . It + is the opposite of squaring." + [a] + #?(:clj (PApplet/sqrt (float a)) + :cljs (.sqrt (ap/current-applet) a))) + +(defn + ^{:requires-bindings true + :processing-name "loop()" + :category "Structure" + :subcategory nil + :added "1.0"} + start-loop + "Causes Processing to continuously execute the code within + draw. If no-loop is called, the code in draw stops executing." + [] + (.loop (ap/current-applet))) + +(defn + ^{:requires-bindings true + :processing-name "stroke()" + :category "Color" + :subcategory "Setting" + :added "1.0"} + stroke-float + "Sets the color used to draw lines and borders around + shapes. Converts all args to floats" + ([gray] (.stroke (current-graphics) (float gray))) + ([gray alpha] (.stroke (current-graphics) (float gray) (float alpha))) + ([x y z] (.stroke (current-graphics) (float x) (float y) (float z))) + ([x y z a] (.stroke (current-graphics) (float x) (float y) (float z) (float a)))) + +(defn + ^{:requires-bindings true + :processing-name "stroke()" + :category "Color" + :subcategory "Setting" + :added "1.0"} + stroke-int + "Sets the color used to draw lines and borders around + shapes. Converts rgb to int and alpha to a float." + ([rgb] (.stroke (current-graphics) (unchecked-int rgb))) + ([rgb alpha] (.stroke (current-graphics) (unchecked-int rgb) (float alpha)))) + +(defn + ^{:requires-bindings true + :processing-name "stroke()" + :category "Color" + :subcategory "Setting" + :added "1.0"} + stroke + "Sets the color used to draw lines and borders around shapes. This + color is either specified in terms of the RGB or HSB color depending + on the current color-mode (the default color space is RGB, with + each value in the range from 0 to 255)." + ([rgb] + #?(:clj (if (u/int-like? rgb) (stroke-int rgb) (stroke-float rgb)) + :cljs (stroke-float rgb))) + + ([rgb alpha] + #?(:clj (if (u/int-like? rgb) (stroke-int rgb alpha) (stroke-float rgb alpha)) + :cljs (stroke-float rgb alpha))) + + ([x y z] (stroke-float x y z)) + ([x y z a] (stroke-float x y z a))) + +(defn + ^{:requires-bindings true + :processing-name "strokeCap()" + :category "Shape" + :subcategory "Attributes" + :added "1.0"} + stroke-cap + "Sets the style for rendering line endings. These ends are either + squared, extended, or rounded and specified with the corresponding + parameters :square, :project, and :round. The default cap is :round." + [cap-mode] + (let [cap-mode (u/resolve-constant-key cap-mode stroke-cap-modes)] + (.strokeCap (current-graphics) + #?(:clj (int cap-mode) + :cljs (str cap-mode))))) + +(defn + ^{:requires-bindings true + :processing-name "strokeJoin()" + :category "Shape" + :subcategory "Attributes" + :added "1.0"} + stroke-join + "Sets the style of the joints which connect line + segments. These joints are either mitered, beveled, or rounded and + specified with the corresponding parameters :miter, :bevel, and + :round. The default joint is :miter. + + This function is not available with the :p2d, :p3d, or :opengl + renderers." + [join-mode] + (let [join-mode (u/resolve-constant-key join-mode stroke-join-modes)] + (.strokeJoin (current-graphics) + #?(:clj (int join-mode) + :cljs (str join-mode))))) + +(defn + ^{:requires-bindings true + :processing-name "strokeWeight()" + :category "Shape" + :subcategory "Attributes" + :added "1.0"} + stroke-weight + "Sets the width of the stroke used for lines, points, and the border + around shapes. All widths are set in units of pixels. " + [weight] + (.strokeWeight (current-graphics) (float weight))) + +(defn + ^{:requires-bindings false + :processing-name "tan()" + :category "Math" + :subcategory "Trigonometry" + :added "1.0"} + tan + "Calculates the ratio of the sine and cosine of an angle. This + function expects the values of the angle parameter to be provided in + radians (values from 0 to PI*2). Values are returned in the range + infinity to -infinity." + [angle] + #?(:clj (PApplet/tan (float angle)) + :cljs (.tan (ap/current-applet) angle))) + +(defn + ^{:requires-bindings true + :category "Environment" + :subcategory nil + :added "1.5.0"} + target-frame-rate + "Returns the target framerate specified with the fn frame-rate" + [] + #?(:clj @(ap/target-frame-rate) + :cljs @(.-target-frame-rate (ap/current-applet)))) + +(defn- no-fill? + "Returns whether fill is disabled for current graphics." + [^PGraphics graphics] + #?(:clj (not (.-fill graphics)) + :cljs (true? (aget graphics no-fill-prop)))) + +(defn + ^{:requires-bindings true + :processing-name "text()" + :category "Typography" + :subcategory "Loading & Displaying" + :added "1.0"} + text-char + "Draws a char to the screen in the specified position. See text fn + for more details." + ([c x y] + (when-not (no-fill? (current-graphics)) + (.text (current-graphics) (char c) (float x) (float y)))) + ([c x y z] + (when-not (no-fill? (current-graphics)) + (.text (current-graphics) (char c) (float x) (float y) (float z))))) + +(defn + ^{:requires-bindings true + :processing-name "text()" + :category "Typography" + :subcategory "Loading & Displaying" + :added "1.0"} + text-num + "Draws a number to the screen in the specified position. See text fn + for more details." + ([num x y] + (when-not (no-fill? (current-graphics)) + (.text (current-graphics) (float num) (float x) (float y)))) + ([num x y z] + (when-not (no-fill? (current-graphics)) + (.text (current-graphics) (float num) (float x) (float y) (float z))))) + +(defn + ^{:requires-bindings true + :processing-name "text()" + :category "Typography" + :subcategory "Loading & Displaying" + :added "1.0"} + text + "Draws text to the screen in the position specified by the x and y + parameters and the optional z parameter. A default font will be used + unless a font is set with the text-font fn. Change the color of the + text with the fill fn. The text displays in relation to the + text-align fn, which gives the option to draw to the left, right, and + center of the coordinates. + + The x1, y1, x2 and y2 parameters define a + rectangular area to display within and may only be used with string + data. For text drawn inside a rectangle, the coordinates are + interpreted based on the current rect-mode setting." + ([^String s x y] + (when-not (no-fill? (current-graphics)) + (.text (current-graphics) s (float x) (float y)))) + ([^String s x y z] + (when-not (no-fill? (current-graphics)) + (.text (current-graphics) s (float x) (float y) (float z)))) + ([^String s x1 y1 x2 y2] + (when-not (no-fill? (current-graphics)) + (.text (current-graphics) s (float x1) (float y1) (float x2) (float y2))))) + +(defn + ^{:requires-bindings true + :processing-name "textAlign()" + :category "Typography" + :subcategory "Attributes" + :added "1.0"} + text-align + "Sets the current alignment for drawing text. Available modes are: + + horizontal - :left, :center, and :right + vertical - :top, :bottom, :center, and :baseline + + An optional second parameter specifies the vertical alignment + mode. :baseline is the default. The :top and :center parameters are + straightforward. The :bottom parameter offsets the line based on the + current text-descent. For multiple lines, the final line will be + aligned to the bottom, with the previous lines appearing above it. + + When using text with width and height parameters, :baseline is + ignored, and treated as :top. (Otherwise, text would by default draw + outside the box, since :baseline is the default setting. :baseline is + not a useful drawing mode for text drawn in a rectangle.) + + The vertical alignment is based on the value of text-ascent, which + many fonts do not specify correctly. It may be necessary to use a + hack and offset by a few pixels by hand so that the offset looks + correct. To do this as less of a hack, use some percentage of + text-ascent or text-descent so that the hack works even if you + change the size of the font." + ([align] + (let [align (u/resolve-constant-key align horizontal-alignment-modes)] + (.textAlign (current-graphics) (int align)))) + ([align-x align-y] + (let [align-x (u/resolve-constant-key align-x horizontal-alignment-modes) + align-y (u/resolve-constant-key align-y vertical-alignment-modes)] + (.textAlign (current-graphics) (int align-x) (int align-y))))) + +(defn + ^{:requires-bindings true + :processing-name "textAscent()" + :category "Typography" + :subcategory "Metrics" + :added "1.0"} + text-ascent + "Returns the ascent of the current font at its current size. This + information is useful for determining the height of the font above + the baseline. For example, adding the text-ascent and text-descent + values will give you the total height of the line." + [] + (.textAscent (current-graphics))) + +(defn + ^{:requires-bindings true + :processing-name "textDescent()" + :category "Typography" + :subcategory "Metrics" + :added "1.0"} + text-descent + "Returns descent of the current font at its current size. This + information is useful for determining the height of the font below + the baseline. For example, adding the text-ascent and text-descent + values will give you the total height of the line." + [] + (.textDescent (current-graphics))) + +(defn + ^{:requires-bindings true + :processing-name "textFont()" + :category "Typography" + :subcategory "Loading & Displaying" + :added "1.0"} + text-font + "Sets the current font that will be drawn with the text + function. Fonts must be loaded with load-font before it can be + used. This font will be used in all subsequent calls to the text + function. If no size parameter is input, the font will appear at its + original size until it is changed with text-size. + + Because fonts are usually bitmaped, you should create fonts at the + sizes that will be used most commonly. Using textFont without the + size parameter will result in the cleanest-looking text. + + With the default (JAVA2D) and PDF renderers, it's also possible to + enable the use of native fonts via the command + (hint :enable-native-fonts). This will produce vector text in JAVA2D + sketches and PDF output in cases where the vector data is available: + when the font is still installed, or the font is created via the + create-font fn" + ([^PFont font] (.textFont (current-graphics) font)) + ([^PFont font size] (.textFont (current-graphics) font (int size)))) + +(defn + ^{:requires-bindings true + :processing-name "textLeading()" + :category "Typography" + :subcategory "Attributes" + :added "1.0"} + text-leading + "Sets the spacing between lines of text in units of pixels. This + setting will be used in all subsequent calls to the text function." + [leading] + (.textLeading (current-graphics) (float leading))) + +(defn + ^{:requires-bindings true + :processing-name "textMode()" + :category "Typography" + :subcategory "Attributes" + :added "1.0"} + text-mode + "Sets the way text draws to the screen - available modes + are :model and :shape + + In the default configuration (the :model mode), it's possible to + rotate, scale, and place letters in two and three dimensional space. + + The :shape mode draws text using the glyph outlines of individual + characters rather than as textures. This mode is only supported with + the PDF and OPENGL renderer settings. With the PDF renderer, you + must specify the :shape text-mode before any other drawing occurs. + If the outlines are not available, then :shape will be ignored and + :model will be used instead. + + The :shape option in OPENGL mode can be combined with begin-raw to + write vector-accurate text to 2D and 3D output files, for instance + DXF or PDF. :shape is not currently optimized for OPENGL, so if + recording shape data, use :model until you're ready to capture the + geometry with begin-raw." + [mode] + (let [mode (u/resolve-constant-key mode text-modes)] + (.textMode (current-graphics) (int mode)))) + +(defn + ^{:requires-bindings true + :processing-name "textSize()" + :category "Typography" + :subcategory "Attributes" + :added "1.0"} + text-size + "Sets the current font size. This size will be used in all + subsequent calls to the text fn. Font size is measured in + units of pixels." + [size] + (.textSize (current-graphics) (float size))) + +(defn + ^{:requires-bindings true + :processing-name "texture()" + :category "Shape" + :subcategory "Vertex" + :added "1.0"} + texture + "Sets a texture to be applied to vertex points. The texture fn must + be called between begin-shape and end-shape and before any calls to + vertex. + + When textures are in use, the fill color is ignored. Instead, use + tint to specify the color of the texture as it is applied to the + shape." + #?(:clj [^PImage img] + :cljs [img]) + (.texture (current-graphics) img)) + +(defn + ^{:requires-bindings true + :processing-name "textureMode()" + :category "Shape" + :subcategory "Vertex" + :added "1.0"} + texture-mode + "Sets the coordinate space for texture mapping. There are two + options, :image and :normal. + + :image refers to the actual coordinates of the image and :normal + refers to a normalized space of values ranging from 0 to 1. The + default mode is :image. In :image, if an image is 100 x 200 pixels, + mapping the image onto the entire size of a quad would require the + points (0,0) (0,100) (100,200) (0,200). The same mapping in + NORMAL_SPACE is (0,0) (0,1) (1,1) (0,1)." + [mode] + (let [mode (u/resolve-constant-key mode texture-modes)] + (.textureMode (current-graphics) (int mode)))) + +#?(:clj + (defn + ^{:requires-bindings true + :processing-name "textureWrap()" + :category "Shape" + :subcategory "Vertex" + :added "2.0"} + texture-wrap + "Defines if textures repeat or draw once within a texture map. The two + parameters are :clamp (the default behavior) and :repeat. This function + only works with the :p2d and :p3d renderers." + [mode] + (let [mode (u/resolve-constant-key mode texture-wrap-modes)] + (.textureWrap (current-graphics) mode)))) + +(defn + ^{:requires-bindings true + :processing-name "textWidth()" + :category "Typography" + :subcategory "Attributes" + :added "1.0"} + text-width + "Calculates and returns the width of any text string." + [^String data] + (.textWidth (current-graphics) data)) + +(defn + ^{:requires-bindings true + :processing-name "tint()" + :category "Image" + :subcategory "Loading & Displaying" + :added "1.0"} + tint-float + "Sets the fill value for displaying images. Images can be tinted to + specified colors or made transparent by setting the alpha. + + To make an image transparent, but not change it's color, use white + as the tint color and specify an alpha value. For instance, + tint(255, 128) will make an image 50% transparent (unless + colorMode() has been used). + + The value for the parameter gray must be less than or equal to the + current maximum value as specified by colorMode(). The default + maximum value is 255. + + Also used to control the coloring of textures in 3D." + ([gray] (.tint (current-graphics) (float gray))) + ([gray alpha] (.tint (current-graphics) (float gray) (float alpha))) + ([r g b] (.tint (current-graphics) (float r)(float g) (float b))) + ([r g b a] (.tint (current-graphics) (float g) (float g) (float b) (float a)))) + +(defn + ^{:requires-bindings true + :processing-name "tint()" + :category "Image" + :subcategory "Loading & Displaying" + :added "1.0"} + tint-int + "Sets the fill value for displaying images. Images can be tinted to + specified colors or made transparent by setting the alpha. + + To make an image transparent, but not change it's color, use white + as the tint color and specify an alpha value. For instance, + tint(255, 128) will make an image 50% transparent (unless + colorMode() has been used). + + The value for the parameter gray must be less than or equal to the + current maximum value as specified by colorMode(). The default + maximum value is 255. + + Also used to control the coloring of textures in 3D." + ([rgb] (.tint (current-graphics) (unchecked-int rgb))) + ([rgb alpha] (.tint (current-graphics) (unchecked-int rgb) (float alpha)))) + +(defn + ^{:requires-bindings true + :processing-name "tint()" + :category "Image" + :subcategory "Loading & Displaying" + :added "1.0"} + tint + "Sets the fill value for displaying images. Images can be tinted to + specified colors or made transparent by setting the alpha. + + To make an image transparent, but not change it's color, use white + as the tint color and specify an alpha value. For instance, + tint(255, 128) will make an image 50% transparent (unless + colorMode() has been used). + + The value for the parameter gray must be less than or equal to the + current maximum value as specified by colorMode(). The default + maximum value is 255. + + Also used to control the coloring of textures in 3D." + #?(:clj ([rgb] (if (u/int-like? rgb) (tint-int rgb) (tint-float rgb))) + :cljs ([rgb] (.tint (current-graphics) rgb))) + #?(:clj ([rgb alpha] (if (u/int-like? rgb) (tint-int rgb alpha) (tint-float rgb alpha))) + :cljs ([rgb alpha] (.tint (current-graphics) rgb alpha))) + ([r g b] (tint-float r g b)) + ([r g b a] (tint-float r g b a))) + +(defn + ^{:requires-bindings true + :processing-name "translate()" + :category "Transform" + :subcategory nil + :added "1.0"} + translate + "Specifies an amount to displace objects within the display + window. The x parameter specifies left/right translation, the y + parameter specifies up/down translation, and the z parameter + specifies translations toward/away from the screen. Transformations + apply to everything that happens after and subsequent calls to the + function accumulates the effect. For example, calling (translate 50 + 0) and then (translate 20, 0) is the same as (translate 70, 0). If + translate is called within draw, the transformation is reset when + the loop begins again. This function can be further controlled by + the push-matrix and pop-matrix." + ([v] (apply translate v)) + ([tx ty] (.translate (current-graphics) (float tx) (float ty))) + ([tx ty tz] (.translate (current-graphics) (float tx) (float ty) (float tz)))) + +(defn + ^{:requires-bindings true + :processing-name "triangle()" + :category "Shape" + :subcategory "2D Primitives" + :added "1.0"} + triangle + "A triangle is a plane created by connecting three points. The first + two arguments specify the first point, the middle two arguments + specify the second point, and the last two arguments specify the + third point." + [x1 y1 x2 y2 x3 y3] + (.triangle (current-graphics) + (float x1) (float y1) + (float x2) (float y2) + (float x3) (float y3))) + +(defn + ^{:require-binding false + :processing-name "unbinary()" + :category "Data" + :subcategory "Conversion" + :added "1.0"} + unbinary + "Unpack a binary string to an integer. See binary for converting + integers to strings." + [str-val] + #?(:clj (PApplet/unbinary (str str-val)) + :cljs (.unbinary (ap/current-applet) (str str-val)))) + +(defn + ^{:require-binding false + :processing-name "hex()" + :category "Data" + :subcategory "Conversion"} + unhex + "Converts a String representation of a hexadecimal number to its + equivalent integer value." + [hex-str] + #?(:clj (PApplet/unhex (str hex-str)) + :cljs (.unhex (ap/current-applet) (str hex-str)))) + +(defn + ^{:requires-bindings true + :processing-name "updatePixels()" + :category "Image" + :subcategory "Pixels" + :added "1.0"} + update-pixels + "Updates the display window or image with the data in the pixels array. + Use in conjunction with (pixels). If you're only reading pixels from + the array, there's no need to call update-pixels unless there are + changes. + + Certain renderers may or may not seem to require pixels or + update-pixels. However, the rule is that any time you want to + manipulate the pixels array, you must first call pixels, and + after changes have been made, call update-pixels. Even if the + renderer may not seem to use this function in the current Processing + release, this will always be subject to change." + ([] (update-pixels (current-graphics))) + #?(:clj + ([^PImage img] (.updatePixels img)) + + :cljs + ([img] + (when-let [pix-array (.-stored-pix-array img)] + (.set (.-pixels img) pix-array) + (set! (.-stored-pix-array img) nil)) + (.updatePixels img)))) + +(defn + ^{:requires-bindings true + :processing-name "vertex()" + :category "Shape" + :subcategory "Vertex" + :added "1.0"} + vertex + "All shapes are constructed by connecting a series of + vertices. vertex is used to specify the vertex coordinates for + points, lines, triangles, quads, and polygons and is used + exclusively within the begin-shape and end-shape fns. + + Drawing a vertex in 3D using the z parameter requires the :p3d or + :opengl renderers to be used. + + This function is also used to map a texture onto the geometry. The + texture fn declares the texture to apply to the geometry and the u + and v coordinates set define the mapping of this texture to the + form. By default, the coordinates used for u and v are specified in + relation to the image's size in pixels, but this relation can be + changed with texture-mode." + ([x y] (.vertex (current-graphics) (float x) (float y))) + ([x y z] (.vertex (current-graphics) (float x) (float y) (float z))) + ([x y u v] (.vertex (current-graphics) (float x) (float y) (float u) (float v))) + ([x y z u v] + (.vertex (current-graphics) (float x) (float y) (float z) (float u) (float v)))) + +(defn + ^{:requires-bindings false + :processing-name "year()" + :category "Input" + :subcategory "Time & Date" + :added "1.0"} + year + "Returns the current year as an integer (2003, 2004, 2005, etc)." + [] + #?(:clj (PApplet/year) + :cljs (.year (ap/current-applet)))) + +(defn + ^{:requires-bindings true + :processing-name "getWidth()" + :processing-link nil + :category "Environment" + :subcategory nil + :added "1.0"} + width + "Width of the display window. The value of width is zero until size is + called." + [] + (.-width (ap/current-applet))) + +(defmacro + ^{:requires-bindings true + :processing-name nil + :category "Color" + :subcategory "Utility Macros" + :added "1.7"} + with-fill + "Temporarily set the fill color for the body of this macro. + The code outside of with-fill form will have the previous fill color set. + + The fill color has to be in a vector! + Example: (with-fill [255] ...) + (with-fill [10 80 98] ...)" + [fill-args & body] + `(let [old-fill# (quil.core/current-fill)] + (apply quil.core/fill ~fill-args) + ~@body + (quil.core/fill old-fill#))) + +(defmacro + ^{:requires-bindings true + :processing-name nil + :category "Color" + :subcategory "Utility Macros" + :added "1.7"} + with-stroke + "Temporarily set the stroke color for the body of this macro. + The code outside of with-stroke form will have the previous stroke color set. + + The stroke color has to be in a vector! + Example: (with-stroke [255] ...) + (with-stroke [10 80 98] ...)" + [stroke-args & body] + `(let [old-stroke# (quil.core/current-stroke)] + (apply quil.core/stroke ~stroke-args) + ~@body + (quil.core/stroke old-stroke#))) + +(defmacro + ^{:requires-bindings true + :processing-name nil + :category "Transform" + :subcategory "Utility Macros" + :added "1.0"} + with-translation + "Performs body with translation, restores current transformation on + exit." + [translation-vector & body] + `(let [tr# ~translation-vector] + (quil.core/push-matrix) + (try + (quil.core/translate tr#) + ~@body + (finally + (quil.core/pop-matrix))))) + +(defmacro + ^{:requires-bindings true + :processing-name nil + :category "Transform" + :subcategory "Utility Macros" + :added "1.0"} + with-rotation + "Performs body with rotation, restores current transformation on exit. + Accepts a vector [angle] or [angle x-axis y-axis z-axis]. + + Example: + (with-rotation [angle] + (vertex 1 2))" + [rotation & body] + `(let [tr# ~rotation] + (quil.core/push-matrix) + (try + (apply quil.core/rotate tr#) + ~@body + (finally + (quil.core/pop-matrix))))) + +(defmacro + ^{:requires-bindings true + :processing-name nil + :category "Rendering" + :added "1.7"} + with-graphics + "All subsequent calls of any drawing function will draw on given + graphics. 'with-graphics' cannot be nested (you can draw simultaneously + only on 1 graphics)" + [graphics & body] + `(let [gr# ~graphics] + (binding [quil.core/*graphics* gr#] + (.beginDraw gr#) + ~@body + (.endDraw gr#)))) + +(defn ^{:requires-bindings false + :category "Environment" + :subcategory nil + :added "1.0"} + sketch + "Create and start a new visualisation applet. Can be used to create + new sketches programmatically. See documentation for 'defsketch' for + list of available options." + [& opts] + #?(:clj (apply ap/applet opts) + :cljs (apply ap/sketch opts))) + +(defmacro ^{:requires-bindings false + :category "Environment" + :subcategory nil + :added "1.0"} + defsketch + "Define and start a sketch and bind it to a var with the symbol + app-name. If any of the options to the various callbacks are + symbols, it wraps them in a call to var to ensure they aren't + inlined and that redefinitions to the original fns are reflected in + the visualisation. + + Available options: + + :size - A vector of width and height for the sketch or :fullscreen. + Defaults to [500 300]. If you're using :fullscreen you may + want to enable present mode - :features [:present] + + :renderer - Specifies the renderer type. One of :p2d, :p3d, :java2d, + :opengl, :pdf). Defaults to :java2d. :dxf renderer + can't be used as sketch renderer. Use begin-raw method + instead. In clojurescript only :p2d and :p3d renderers + are supported. + + :output-file - Specifies an output file path. Only used in :pdf mode. + Not supported in clojurescript. + + :title - A string which will be displayed at the top of + the sketch window. Not supported in clojurescript. + + :features - A vector of keywords customizing sketch behaviour. + Supported features: + + :keep-on-top - Sketch window will always be above other + windows. Note: some platforms might not + support always-on-top windows. + Not supported in clojurescript. + + :exit-on-close - Shutdown JVM when sketch is closed. + Not supported in clojurescript. + + :resizable - Makes sketch resizable. + Not supported in clojurescript. + + :no-safe-fns - Do not catch and print exceptions thrown + inside functions provided to sketch (like + draw, mouse-click, key-pressed and + other). By default all exceptions thrown + inside these functions are catched. This + prevents sketch from breaking when bad + function was provided and allows you to + fix it and reload it on fly. You can + disable this behaviour by enabling + :no-safe-fns feature. + Not supported in clojurescript. + + :present - Switch to present mode (fullscreen without + borders, OS panels). You may want to use + this feature together with :size :fullscreen. + Not supported in clojurescript. + + :no-start - Disables autostart if sketch was created using + defsketch macro. To start sketch you have to + call function created defsketch. + Supported only in clojurescript. + + :global-key-events - Allows a sketch to receive any + keyboard event sent to the page, + regardless of whether the canvas it is + loaded in has focus or not. + Supported only in clojurescript. + + Usage example: :features [:keep-on-top :present] + + :bgcolor - Sets background color for unused space in present mode. + Color is specified in hex format: #XXXXXX. + Example: :bgcolor \"#00FFFF\" (cyan background) + Not supported in clojurescript. + + :display - Sets what display should be used by this sketch. + Displays are numbered starting from 0. Example: :display 1. + Not supported in clojurescript. + + :setup - A function to be called once when setting the sketch up. + + :draw - A function to be repeatedly called at most n times per + second where n is the target frame-rate set for + the visualisation. + + :host - String id of canvas element or DOM element itself. + Specifies host for the sketch. Must be specified in sketch, + may be omitted in defsketch. If ommitted in defsketch, + :host is set to the name of the sketch. If element with + specified id is not found on the page and page is empty - + new canvas element will be created. Used in clojurescript. + + :focus-gained - Called when the sketch gains focus. + Not supported in clojurescript. + + :focus-lost - Called when the sketch loses focus. + Not supported in clojurescript. + + :mouse-entered - Called when the mouse enters the sketch window. + + :mouse-exited - Called when the mouse leaves the sketch window + + :mouse-pressed - Called every time a mouse button is pressed. + + :mouse-released - Called every time a mouse button is released. + + :mouse-clicked - called once after a mouse button has been pressed + and then released. + + :mouse-moved - Called every time the mouse moves and a button is + not pressed. + + :mouse-dragged - Called every time the mouse moves and a button is + pressed. + + :mouse-wheel - Called every time mouse wheel is rotated. + Takes 1 argument - wheel rotation, an int. + Negative values if the mouse wheel was rotated + up/away from the user, and positive values + if the mouse wheel was rotated down/ towards the user + + :key-pressed - Called every time any key is pressed. + + :key-released - Called every time any key is released. + + :key-typed - Called once every time non-modifier keys are + pressed. + + :on-close - Called once, when sketch is closed + Not supported in clojurescript. + + :middleware - Vector of middleware to be applied to the sketch. + Middleware will be applied in the same order as in comp + function: [f g] will be applied as (f (g options)). + + :settings - cousin of :setup. A function to be called once when + setting sketch up. Should be used only for (smooth) and + (no-smooth). Due to Processing limitations these functions + cannot be used neither in :setup nor in :draw." + [app-name & options] + #?(:clj + (if (u/clj-compilation?) + `(ap/defapplet ~app-name ~@options) + `(quil.sketch/defsketch ~app-name ~@options)) + :cljs + `(quil.sketch$macros/defsketch ~app-name ~@options))) + +(defn ^{:requires-bindings false + :processing-name nil + :category "Input" + :subcategory "Keyboard" + :added "1.6"} + key-coded? + "Returns true if char c is a 'coded' char i.e. it is necessary to + fetch the key-code as an integer and use that to determine the + specific key pressed. See key-keyword." + [c] + #?(:clj (= PConstants/CODED (int c)) + ; See https://github.com/google/closure-compiler/issues/1676 + :cljs (= 65535 (.charCodeAt (js/String c))))) + +(defn ^{:requires-bindings true + :processing-name nil + :category "Input" + :subcategory "Keyboard" + :added "1.6"} + key-as-keyword + "Returns a keyword representing the currently pressed key. Modifier + keys are represented as: :up, :down, :left, :right, :alt, :control, + :shift, :command, :f1-24" + [] + (let [key-char (raw-key) + code (key-code)] + (if (key-coded? key-char) + (get KEY-CODES code :unknown-key) + ; Workaround for closure compiler incorrect string casts. + ; See https://github.com/google/closure-compiler/issues/1676 + (keyword #?(:clj (str key-char) + :cljs (js/String key-char)))))) + +#?(:clj + (defn + ^{:requires-bindings false + :processing-name nil + :category "Debugging" + :added "1.6"} + debug + "Prints msg and then sleeps the current thread for delay-ms. Useful + for debugging live running sketches. delay-ms defaults to 300. " + ([msg] (debug msg 300)) + ([msg delay-ms] + (println msg) + (Thread/sleep delay-ms)))) + +;;; doc utils + +#?(:clj + (def ^{:private true} + fn-metas + "Returns a seq of metadata maps for all fns related to the original + Processing API (but may not have a direct Processing API equivalent)." + (->> *ns* ns-publics vals (map meta)))) + +#?(:clj + (defn show-cats + "Print out a list of all the categories and subcategories, + associated index nums and fn count (in parens)." + [] + (doseq [[cat-idx cat] (docs/sorted-category-map fn-metas)] + (println cat-idx (:name cat)) + (doseq [[subcat-idx subcat] (:subcategories cat)] + (println " " subcat-idx (:name subcat)))))) + +#?(:clj + (defn show-fns + "If given a number, print all the functions within category or + subcategory specified by the category index (use show-cats to see a + list of index nums). + + If given a string or a regular expression, print all the functions + whose name or category name contains that string. + + If a category is specified, it will not print out the fns in any of + cat's subcategories." + [q] + (letfn [(list-category [cid c & {:keys [only]}] + (let [category-fns (:fns c) + display-fns (if (nil? only) + category-fns + (clojure.set/intersection + (set only) (set category-fns))) + names (sort (map str display-fns))] + (when-not (empty? names)) + (println cid (:name c)) + (docs/pprint-wrapped-lines names :fromcolumn 4))) + (show-fns-by-cat-idx [cat-idx] + (let [c (get (docs/all-category-map fn-metas) (str cat-idx))] + (list-category cat-idx c))) + (show-fns-by-name-regex [re] + (doseq [[cid c] (sort-by key (docs/all-category-map fn-metas))] + (let [in-cat-name? (re-find re (:name c)) + matching-fns (filter #(re-find re (str %)) (:fns c)) + in-fn-names? (not (empty? matching-fns))] + (cond + in-cat-name? (list-category cid c) ;; print an entire category + in-fn-names? (list-category cid c :only matching-fns)))))] + (cond + (string? q) (show-fns-by-name-regex (re-pattern (str "(?i)" q))) + (isa? (type q) java.util.regex.Pattern) (show-fns-by-name-regex q) + :else (show-fns-by-cat-idx q))))) + +#?(:clj + (defn show-meths + "Takes a string representing the start of a method name in the + original Processing API and prints out all matches alongside the + Processing-core equivalent." + [orig-name] + (let [res (docs/matching-processing-methods fn-metas orig-name)] + (u/print-definition-list res)))) |