diff options
| author | Brian Picciano <mediocregopher@gmail.com> | 2021-07-31 11:35:39 -0600 |
|---|---|---|
| committer | Brian Picciano <mediocregopher@gmail.com> | 2021-07-31 11:35:39 -0600 |
| commit | f1998c321a4eec6d75b58d84aa8610971bf21979 (patch) | |
| tree | a90783eb296cc50e1c48433f241624f26b99be27 /src/assets/viz/1/quil/core.cljc | |
| parent | 03a35dcc38b055f15df160bd300969e3b703d4b1 (diff) | |
move static files into static sub-dir, refactor nix a bit
Diffstat (limited to 'src/assets/viz/1/quil/core.cljc')
| -rw-r--r-- | src/assets/viz/1/quil/core.cljc | 4993 |
1 files changed, 0 insertions, 4993 deletions
diff --git a/src/assets/viz/1/quil/core.cljc b/src/assets/viz/1/quil/core.cljc deleted file mode 100644 index dcdaa94..0000000 --- a/src/assets/viz/1/quil/core.cljc +++ /dev/null @@ -1,4993 +0,0 @@ -(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)))) |