shader

shader
https://processing.org/tutorials/pshader/

 On the other hand, the variables that change from vertex to vertex are called attributes, and in this example we have three different type of attributes per vertex: the xyz position itself, set with the vertex() function, the color specified with fill() and the normal vector. Note that even though there is only one call to the normal() function, each vertex will have its own normal vector, which in this case will be the same across the four vertices.

learn shader by example:
https://github.com/codeanticode/pshader-tutorials

=======================

opengl - shader
http://www.raywenderlich.com/70208/opengl-es-pixel-shaders-tutorial

Build and Share your best shader
https://www.shadertoy.com/

INDEX: NATURE OF CODE

• A
• acceleration  ,  ,  ,  ,  ,  ,  
  • Newton's second law  
  • algorithms for  
  • angular, determining  
  • damping  
  • force accumulation and  
  • rotation  
• acceleration algorithms  ,  ,  ,  
  • constant  
  • interactive  
  • random  
• action selection  
• activation functions of neural networks  
• Adaptation in Natural and Artificial Systems (Holland)  
• add() function (PVector class)  ,  
  • implementation of  
• add() function (Vec2 class)  
• addForce() function (toxiclibs)  
• addition operator  
• additive blend mode  
• addLocal() function (Vec2)  
• addParticle() function (toxiclibs)  
• AI for Game Developers (Bourg/Seemann)  
• Algorithmic Beauty of Plants, The (Prusinkiewicz/Lindenmayer)  
• alignment (flocking)  ,  
  • implementing  
• alphabet (L-system component)  
• amplitude  
• angleBetween() function (PVector class)  
• angles  ,  ,  ,  ,  
  • measuring in degrees  
  • measuring in radians  
  • motion  
  • theta (θ)  
• Angry Birds  
• angular acceleration  
• angular velocity, oscillation with  
• anomaly detection  
• ants, modeling for  
• applyForce() function (Box2D)  
• Aristotle  
• ArrayList class (Java)  ,  ,  ,  ,  
  • Iterator class and  
  • fractals and  
  • generics, using  
  • resizability of  
• arrays  ,  
  • Lévy flights, implementing with  
  • custom distributions, creating with  
• arrays (2D)  
• arriving behavior  ,  
  • steering force and  
• artificial intelligence  ,  
  • pattern recognition  
• Artificial Intelligence: A Modern Approach (Russell/Norvig)  
• atan() function (Processing)  
• atan2() function (Processing)  
• AttractionBehavior class (toxiclibs)  
• autonomous agents  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • action selection  
  • arriving behavior  
  • combinations  
  • complex systems and  
  • desired velocity  
  • dot product  
  • efficiency  
  • flocking  
  • flow field following  
  • key components of  
  • locomotion  
  • path following  
  • steering  
• axiom (L-system component)  
• B
• backpropagation  
• beginContact() function (PBox2D)  
• beginShape() function (Processing)  
• bell curve  ,  
  • mean and  
• bias input, perceptron  
• Big O Notation  
• Big O Notation N-Squared  
• bin-lattice spatial subdivision  
• blend modes  ,  ,  
  • additive  
  • list of  
• body (Box2D element)  ,  ,  ,  ,  ,  ,  ,  ,  
  • BodyDef type  
  • attaching fixture element to  
  • building  
  • bullet setting for  
  • initial settings for  
  • multiple shapes and  
  • object, creating  
  • types of  
• body lists, maintaining in Processing  
• BodyDef type (body element)  ,  ,  
  • STATIC type  
  • configuring  
• boids model  
• bouncing ball sketch  ,  
  • implementing with vectors  
• boundaries  ,  
  • curvy  
  • fixed  
• Bourg, David M.  
• Box2D  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • Fisica  
  • JBox2D and  
  • PBox2D helper class  
  • PVector vs.  
  • Processing and  
  • complex forms in  
  • concave shapes and  
  • coordinate system vs. Processing  
  • core elements  
  • fixed objects in  
  • order of vertices  
  • overhead with  
  • toxiclibs vs.  
  • usage  
• Braitenberg, Valentino  
• brute force method  
• C
• Cantor set  ,  ,  
  • L-systems and  
  • recursion and  
• Cantor, George  
• Cartesian coordinates  ,  
  • polar coordinates, converting from  
• Catto, Erin  
• cellular automaton (automata)  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • Sierpiński triangle  
  • Wolfram algorithm for  
  • Wolfram classification  
  • characteristics of  
  • continuous  
  • defined  
  • elementary  
  • elementary, implementing  
  • historical  
  • image processing  
  • moving cells  
  • nesting  
  • non-rectangular grids and  
  • probabilistic  
  • rulesets, defining  
  • self-replicating cells  
  • time and  
  • two-dimensional  
  • variations of  
• ChainShape class  ,  
  • configuring  
• class (Processing)  ,  ,  ,  
  • constructor   , 
  • defined  
  • functionality  
• code duplication, inheritance and  
• coefficient of friction  ,  
  • mu (μ)  
• cohesion (flocking)  ,  
  • implementing  
• collisions  ,  ,  ,  ,  
  • Box2D and  
  • avoiding in group behavior  
  • beginContact() function (PBox2D)  
  • toxiclibs and  
• combinations  
• complex systems  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • Game of Life as  
  • cellular automata  
  • competition/cooperation component  
  • connectionist computational system  
  • feedback component  
  • group behavior  
  • key principles of  
  • non-linearity component  
  • superorganisms  
• Complexity class (Wolfram classification)  
• Computational Beauty of Nature (Flake)  
• connected systems  ,  
  • force-directed graphs  
  • strings  
• connectionist computational system  
• constrain() function (Processing)  
• constructor  ,  ,  
  • arguments, adding to  
• Contact objects (PBox2D)  
• ContactListener class (JBox2D)  
• continuous (cellular automata)  
• contract() function (Processing)  
• control (of physical objects)  
• Conway's Game of Life (Klise)  
• Conway, John  
• coordinate systems  ,  ,  ,  ,  
  • Box2D vs. Processing  
  • Cartesian  
  • Processing and  
  • polar  
• coordPixelsToWorld() function (PBox2D)  
• coordWorldToPixels() function (PBox2D)  
• Cornell Aeronautical Laboratory  
• cos() function (Processing)  
• cosine lookup tables  
• Crayon Physics  
• createBody() function (PBox2D)  
• createFixture() function (PBox2D)  
• cross() function (PVector class)  
• crossover (natural selection algorithms)  ,  
  • implementing  
• D
• damping  
• dampingRatio setting (Box2D joint element)  
• Darwinian natural selection  
• degrees  ,  
  • radians, converting to  
• delta weight  
• density  
• derivatives  
• Descartes, René  
• desired velocity  ,  
• destroyBody() function (PBox2D)  
• differentiation  
• dissipative force  
• dist() function (PVector class)  
• distance joints  
• DistanceJointDef (Box2D joint type)  
• distributions, custom  
• distributions, non-uniform  ,  ,  ,  ,  ,  
  • Monte Carlo method  
  • Perlin noise  
  • creating with arrays  
  • custom  
  • probability and  
  • qualifying random values  
• distributions, normal  
• div() function (PVector class)  
• dot product (PVector)  ,  ,  
  • defined  
  • theta  
• dot syntax  
• dot() function (PVector class)  
• drag force  
• dynamic (body type)  
• E
• ecosystem simulation genetic algorithms  ,  ,  ,  ,  ,  ,  
  • genotype  
  • lifespans, varying  
  • phenotype  
  • reproduction  
  • selection  
• efficiency  ,  ,  ,  ,  ,  ,  ,  
  • Big O Notation  
  • Big O Notation N-Squared  
  • bin-lattice spatial subdivision  
  • magSq() function (PVector class).  
  • sine/cosine lookup tables  
  • temporary objects and  
• elementary cellular automata  ,  ,  ,  ,  
  • drawing  
  • edge cases and  
  • generations, maintaining integrity of  
  • implementing  
• emitter  
• endContact() function (PBox2D)  
• endShape() function (Processing)  
• equilibrium  
• Euclid  ,  
• Euclidean geometry  ,  
  • fractals and  
• Euclidean vector  
• Euler integration  ,  
  • symplectic Euler (Box2D)  
• Euler, Leonhard  
• evolution  ,  ,  
  • Darwinian natural selection  
  • genetic algorithms  
  • modeling  
• evolutionary computing  
• Evolved Virtual Creatures (Sims)  
• exclusive or (XOR)  
• exit conditions for recursion  
• expand() function (Processing)  
• Exploring Emergence (Resnick/Silverman)  
• extends keyword (Processing)  
• F
• factorial  
• feed-forward model (neural networks)  ,  
  • animating  
• Fisica  
• fitness functions (natural selection algorithms)  ,  ,  ,  ,  ,  ,  
  • avoidance of obstacles and  
  • design your own  
  • ecosystem simulations and  
  • evolving for specific attributes  
  • exponential vs. linear  
  • robotic enslavement of humanity and  
• fixture (Box2D element)  ,  ,  
  • attaching to body element  
  • creating  
• Flake, Gary  
• flocking  ,  ,  ,  
  • bin-lattice spatial subdivision  
  • performance and  
  • rules of  
• Flocks, Herds, and Schools: A Distributed Behavioral Model (Reynolds)  
• flow field following  ,  
  • resolution and  
• fluid resistance, modeling  
• for loops  ,  
  • ArrayList objects and  
  • enhanced  
• force accumulation  
• force-directed graphs  
• forces  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • Hooke's law  
  • Newton's laws of motion  
  • accumulation of  
  • applyForce() function  
  • applying to objects  
  • applying to single objects in a system  
  • autonomous agents and  
  • creating  
  • damping  
  • defined  
  • equilibrium  
  • fluid resistance  
  • friction, modeling  
  • gravity, modeling  
  • models of, building  
  • particle systems with  
  • springs  
  • steering  
  • terminal velocity  
  • trigonometry and  
  • universal gravitational constant  
• forces, modeling  
  • real forces  
• formulae, evaluating in code  
• Fractal Geometry of Nature, The (Mandelbrot)  
• fractals  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • Koch curve  
  • L-systems and  
  • defined  
  • fine structure of  
  • recursion  
  • self-replicating behavior of  
  • stochastic  
  • transformation matrix (Processing)  
  • trees and  
• frequency (of oscillations)  
• frequencyHz setting (Box2D joint element)  
• friction  ,  ,  ,  ,  ,  ,  ,  ,  
  • applying to an object  
  • coefficient of friction  
  • damping  
  • determining direction/magnitude of  
  • formula for  
  • modeling with formulae  
  • mu (μ)  
  • normal force  
  • rho (ρ)  
• functionality  
• functions  
  • static vs. non-static  
• G
• Galileo  
• Game of Life  ,  ,  ,  
  • drawing  
  • rules of  
• Gardner, Martin  
• Gauss, Carl Friedrich  
• Gaussian distribution  
• genetic algorithms  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • Darwinian natural selection  
  • Smart Rockets (Thorp)  
  • building  
  • defined  
  • ecosystem simulation   , 
  • fitness algorithms, modifying  
  • interactive selection  
  • modifying  
  • mutation rate, varying  
  • population maximum, varying  
  • populations, creating  
  • purpose of  
  • selection, implementing  
  • traditional  
• genotype (natural selection algorithms)  ,  ,  
  • ecosystem simulation  
  • modifying  
• geometric vector  
• getAngle() function (PBox2D)  
• getBodyList() function (World class)  
• getBodyPixelCoord() function (PBox2D)  
• getGroundBody() function (Box2D joint element)  
• gravity  ,  ,  ,  ,  ,  ,  
  • GravityBehavior (toxiclibs)  
  • implementing model of  
  • modeling  
  • modeling reality vs. arbitrary values  
  • modeling with trigonometry  
  • placing limits on model of  
  • universal gravitational constant  
• GravityBehavior class (toxiclibs)  
• grid (cellular automata)  
• group behavior  ,  ,  ,  
  • collisions, avoiding  
  • combinations  
  • flocking  
• H
• heading() function (PVector class)  ,  
• heredity (natural selection)  ,  ,  ,  
  • crossover  
  • implementing  
  • mutation  
• historical (cellular automata)  
• Hodgin, Robert  
• Holland, John  
• Hooke's law  ,  
  • formula for expressing  
• Hooke, Robert  
• I
• image processing (cellular automata)  
• image textures  ,  ,  ,  
  • PImage objects (Processing)  
  • PNG format and  
  • blend modes  
• infinite monkey theorem  
• inheritance  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • adding functionality to superclass objects  
  • extends keyword (Processing)  
  • implementing  
  • overriding superclass functions  
  • subclass  
  • super() function (Processing)  
  • superclasses  
  • syntax for  
• integration  ,  ,  
  • Euler integration  
  • Runge-Kutta method  
• Interaction with Groups of Autonomous Characters (Reynolds)  
• interactive selection genetic algorithms  ,  ,  ,  
  • time lag and  
  • user interaction and  
• interfaces  
• iterating  ,  
  • Iterator class (Java)  
  • removing elements in for loops  
• Iterator class (Java)  
• iTunes visualizer  
• J
• Java  
• JBox2D  ,  ,  
  • ContactListener class  
  • full documentation for  
• joint (Box2D element)  ,  ,  ,  ,  
  • distance  
  • mouse type  
  • revolute type  
• K
• kinematic (body type)  ,  
  • MouseJoints and  
• Klise, Steven  
• Koch curve  ,  
  • implementing  
• Kutta, M. W.  
• L
• L-systems  ,  ,  
  • components of  
  • translating into code  
• Laplace, Pierre-Simon  
• Laplacian distribution  
• learning constant  
• Learning Processing (Shiffman)  
• lerp() function (PVector class)  
• limit() function (PVector class)  ,  
• Lindenmayer systems  
• Lindenmayer, Aristid  ,  
• linearly separable problems  
• locations  
  • as vectors  
• lock() function (toxiclibs)  
• locomotion  
• Logical calculus of the ideas imminent in nervous activity, A (McCulloch/Pitts)  
• Los Alamos National Laboratory  
• Lucasfilm Ltd.  
• Lévy flight  ,  ,  
  • implementing with arrays  
  • implementing with qualifying random values  
• M
• m_p variable (Vec2 class)  
• mag() function (PVector class)  ,  
  • magSq() function vs.  
• Magnetosphere  
• magnitude (of vectors)  ,  
  • limiting  
• magSq() function (PVector class).  
• Mandelbrot, Benoit  
• map() function (Processing)  ,  
  • oscillation and  
• Marxer, Ricard  
• mass  ,  ,  
  • modeling  
  • units of measurement, defining  
  • weight vs.  
• mating pools (natural selection)  ,  
  • creating  
  • implementing  
• McCulloch, Warren S.  
• mean  
• methods, static vs. non-static  
• millis() function (Processing)  
• Monster curve  
• Monte Carlo method  
• motion  ,  ,  
  • angular  
  • heading() function (PVector class)  
• mouse joint (Box2D joint type)  
  • setTransform() function  
• mouse joint (Box2D Joint type)  
• moving cells (cellular automata)  
• mu (μ)  ,  
• mult() function (PVector class)  ,  
  • implementation  
• mutation (natural selection algorithms)  ,  ,  
  • implementing  
  • rate of  
• N
• natural fractals  
• natural phenomena  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • Darwinian natural selection  
  • L-systems and  
  • Newton's second law, modeling  
  • Perlin noise and  
  • ants, modeling  
  • autonomous agents  
  • cellular automata  
  • ecosystems, modeling  
  • evolution  
  • flocking  
  • fluid resistance, modeling  
  • forces, modeling   , 
  • fractals  
  • friction  
  • genetic algorithms  
  • gravity   ,  , 
  • group behavior  
  • mass, modeling  
  • modeling reality vs. arbitrary values  
  • modeling with random walks  
  • modeling with the random() function  
  • physics (real world), modeling  
  • pivots, modeling  
  • plant growth, modeling  
  • smoke, modeling with particle systems  
  • trees and  
• natural selection algorithms  ,  ,  ,  ,  ,  
  • fitness functions  
  • mating pools, creating  
  • populations, creating  
  • probability  
  • reproduction  
• naturally ordered sequence of numbers  
• neighborhood (cellular automata)  
• nesting (cellular automata)  
• neural networks  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • activation functions of  
  • animating  
  • backpropagation  
  • connectionist computational system  
  • diagramming  
  • learning and  
  • networks of perceptrons  
  • pattern recognition  
  • perceptron  
  • real vs. simulated  
  • reinforcement learning  
  • supervised learning  
  • unsupervised learning  
  • uses of  
• New Kind of Science, A (Wolfram)  
• new operator (objects)  
• Newton's first law  ,  
  • PVector class and  
• Newton's second law  
• Newton's third law  ,  
  • PVector class and  
• Newton, Isaac  
• nextGaussian() function (Random class)  ,  
  • default mean/standard deviation settings of  
• noise() function (Processing)  ,  
  • arguments for  
• noiseDetail() function (Processing)  
• non-linearly separable problems  
• non-rectangular grids (cellular automata)  
• non-uniform distributions  ,  ,  ,  ,  ,  
  • Monte Carlo method  
  • Perlin noise  
  • creating with arrays  
  • custom  
  • probability and  
  • qualifying random values  
• normal distribution  
• normal force  
• normal points  ,  
  • series of, for path following  
• normalization  ,  
  • mating pools, creating with  
• normalize() function (PVector class)  
• Norvig, Peter  
• O
• object  ,  ,  ,  
  • cells in cellular automata as  
  • defined  
  • interaction between  
  • new operator  
• object-oriented programming  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • cellular automata and  
  • class  
  • classes of user-defined objects, creating  
  • dot syntax  
  • genotype/phenotype objects and  
  • inheritance   , 
  • instances of subclasses, creating  
  • maintaining encapsulation  
  • object  
  • polymorphism   ,  , 
  • references to vs. copies of objects  
  • review of  
  • structures, choosing between  
• optimization  ,  ,  
  • magSq() function (PVector class).  
  • sine/cosine lookup tables  
  • temporary objects and  
• oscillation  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • amplitude  
  • angular velocity and  
  • frequency of  
  • on two axes  
  • period  
  • simple harmonic motion  
  • simulating with sine curves  
  • varying  
  • waves  
• oversampling  
• P
• particle systems  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • ArrayList, using  
  • Verlet integration and  
  • addParticle() function (toxiclibs)  
  • applying force to single particles in  
  • class for, creating  
  • dead particles, checking for  
  • emitter  
  • forces and  
  • lifespan of particles  
  • multiple systems, organizing  
  • origin point (of particles)  
  • particles in  
  • polymorphism, using  
  • purpose of  
  • smoke, modeling  
• particles  ,  ,  ,  ,  ,  ,  
  • VerletParticle2D object (toxiclibs)  
  • applying force to single particles in  
  • death, checking for  
  • lifespan of  
  • testing  
  • toxiclibs implementation of  
• path  
• path following  ,  ,  ,  ,  ,  
  • current distance from path, finding  
  • multiple segments  
  • normal points  
  • pathfinding vs.  
  • target, determining  
• pathfinding  
• pattern recognition  ,  
  • perceptron and  
• PBox2D helper class  ,  ,  ,  
  • coordinate systems, converting between  
  • createWorld() function  
  • getBodyPixelCoord() function (PBox2D)  
• perceptron  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • bias input  
  • error calculations and  
  • implementing  
  • learning constant  
  • linearly separable problems and  
  • networks of  
  • pattern recognition with  
  • steering and  
  • training  
• performance  ,  ,  ,  ,  ,  ,  ,  
  • Big O Notation  
  • Big O Notation N-Squared  
  • bin-lattice spatial subdivision  
  • magSq() function (PVector class).  
  • sine/cosine lookup tables  
  • temporary objects and  
• period  ,  ,  
  • defined in pixels rather than frames  
• Perlin noise  ,  ,  ,  ,  
  • flow field following and  
  • map() function  
  • natural phenomena, modeling with  
  • noise() function (Processing)  
  • two-dimensional  
• phenotype (natural selection algorithms)  ,  ,  
  • ecosystem simulation  
• physics  ,  ,  
  • collisions  
  • modeling  
  • open-source libraries for  
• physics libraries  ,  
  • Box2D  
• pi (π)  
• PI variable (Processing)  
• PImage objects (Processing)  
• Pitts, Walter  
• pivots, modeling  
• plant growth, modeling  
• PNG graphic file format  
• polar coordinates  ,  
  • Cartesian coordinates, converting to  
• PolygonShape class  
  • as list of vectors  
• polymorphism  ,  ,  ,  
  • creating object instances with  
• popMatrix() function (Processing)  
• populations (genetic algorithms)  ,  ,  ,  
  • creating  
  • ecosystem simulations and  
  • elements of  
  • implementing  
• postSolve() function (PBox2D)  
• preSolve() function (PBox2D)  
• probabilistic (cellular automata)  
• probability  ,  ,  ,  ,  ,  ,  ,  
  • cellular automata based on  
  • infinite monkey theorem  
  • mean  
  • natural selection algorithms and  
  • non-uniform distributions and  
  • normal distributions  
  • standard deviation  
• probability of the fittest  
• Processing  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • Box2D and  
  • Box2D objects, adding to projects  
  • JBox2D  
  • OOP online tutorial  
  • PImage objects  
  • Random class  
  • angles, measuring in  
  • atan() function  
  • atan2() function  
  • body lists, maintaining  
  • class inheritance, syntax for  
  • coordinate systems and  
  • coordinate systems vs. Box2D  
  • incorporating images into projects  
  • measuring time in  
  • noise() function  
  • noiseDetail() function  
  • radians() function  
  • review of object-oriented programming with  
  • rotation tutorial  
  • static vs. non-static methods  
  • toxiclibs and  
  • vectors and  
• Prusinkiewicz, Przemysław  
• pseudo-random numbers  ,  
  • Perlin noise and  
• pushMatrix() function (Processing)  
• PVector class (Processing)  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • Box2D vs.  
  • Newton's first law and  
  • Newton's third law and  
  • div() function  
  • function list for  
  • heading() function  
  • limit() function  
  • mag() function  
  • mathematical functions for  
  • mult() function  
  • normalize() function  
  • sub() function  
• Pythagoras  
• Pythagorean theorem  
• Q
• qualifying random values  ,  
  • Monte Carlo method  
• R
• radians  ,  
  • converting from degrees  
• radians() function (Processing)  
• Random class (Processing)  ,  
  • nextGaussian() function  
• Random class (Wolfram classification)  
• random number generators  ,  ,  ,  ,  
  • custom distributions, creating  
  • non-uniform distributions, creating  
  • pseudo-random numbers  
  • random() function  
  • uniform number distributions and  
• random walks  ,  ,  ,  
  • Gaussian  
  • Lévy flight  
  • oversampling  
• random() function  ,  ,  
  • natural phenomena, modeling with  
  • non-uniform distributions, creating with  
• random2D() function (PVector class)  
• random3D() function (PVector class)  
• real forces  
• recursion  ,  ,  ,  ,  
  • ArrayList objects and  
  • exit conditions  
  • factorial  
  • implementing  
• Reeves, William T.  
• reinforcement learning (neural networks)  
• reinforcement learning(neural networks)  
• remove() function (ArrayList class)  
• Repetition class (Wolfram classification)  
• reproduction (natural selection algorithms)  ,  ,  
  • ecosystem simulation  
  • implementing  
• repulsion  
  • group behavior and  
• Resnick, Mitchel  ,  
• resolution, flow field following and  
• rest length (Box2D joint element)  
• revolute joint type (Box2D)  ,  
  • properties, configuring  
• RevoluteJointDef object (Box2D joint element)  
• Reynolds, Craig  ,  
  • path following algorithm  
• rho (ρ)  
• Rosenblatt, Frank  
• rotate() function (PBox2D)  
• rotate() function (PVector class)  
• rotation  ,  
  • pointing towards movement  
• roulette wheel probability method  
• rules (L-system component)  
• rulesets for cellular automata  
• Runge, C.  
• Runge-Kutta method  
• Russell, Stuart J.  
• S
• scalar notation, vs. vector notation  
• scalar projection  
• scalarPixelsToWorld() function (PBox2D)  
• scalarWorldToPixels() function (PBox2D)  
• Schmidt, Karsten  
• Seemann, Glenn  
• selection (natural selection algorithms)  ,  ,  ,  
  • ecosystem simulation  
  • implementing   , 
• self-replicating cells  
• self-similarity of fractals  
• separation (flocking)  ,  
  • implementing  
• setGravity() function (World class)  
• setTransform() function (Box2D)  
• Shape (Box2D element)  ,  ,  ,  ,  
  • defining  
  • friction attribute  
  • local position for  
  • restitution attribute  
• shape (Box2D element)  
• shapes  ,  ,  
  • displaying  
  • moving with polar coordinates  
  • rotating  
• short range relationships  ,  
  • complex systems  
  • flocking behavior and  
• Sierpiński triangle  
• Sierpiński, Wacław  
• sigma (σ)  
• signal processing  
• Silverman, Brian  
• simple harmonic motion  
• Sims, Karl  
• sin() function (Processing)  
• sine lookup tables  
• size() function (ArrayList class)  
• Smart Rockets (Thorp)  
• soft sensors  
• sohcahtoa  
• splice() function (Processing)  
• springs  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • Hooke's law  
  • VerletConstrainedSpring class (toxiclibs)  
  • VerletMinDistanceSpring class (toxiclibs)  
  • VerletSpring class (toxiclibs)  
  • direction of force, determining  
  • lock() function (toxiclibs)  
  • magnitude of force, determining  
  • rest length  
  • toxiclibs and  
• standard deviation  ,  ,  
  • calculating  
  • variance  
• Star Trek II: The Wrath of Khan (1982)  
• state (cellular automata)  
• static (body type)  ,  
• static functions  
• steering behaviors  ,  ,  ,  
  • flow field following  
  • group behavior and  
  • perceptron for  
  • wandering  
• Steering Behaviors for Autonomous Characters (Reynolds)  
• steering force  ,  ,  ,  
  • arriving behavior and  
  • desired velocity  
  • magnitude of  
• steering perceptron  ,  
  • reinforcement learning(neural networks)  
• step() function (Box2D)  
• stochastic fractals  ,  
  • trees as  
• StringBuffer class  
• strings  ,  
  • StringBuffer class vs.  
  • hanging from fixed points  
• sub() function (PVector class)  
• subclass  ,  
  • adding functionality to superclass objects  
• subset() function (Processing)  
• super() function(Processing)  
• superclasses  ,  ,  ,  ,  
  • adding functionality within subclasses  
  • overriding functions from   , 
  • polymorphism and  
• superorganisms  
• supervised learning (neural networks)  
• symplectic Euler (Box2D)  
• T
• tangent  ,  ,  ,  
  • atan() function (arctangent)  
  • atan2() function  
  • heading() function (PVector class)  
• terminal velocity  
• theta (θ)  ,  
  • dot product and  
• Thorp, Jer  
• time  ,  
  • cellular automata and  
  • millis() function, measuring with  
• time series prediction  
• toxiclibs  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • AttractionBehavior class  
  • Box2D vs.  
  • VerletPhysics class  
  • VerletPhysics2D class  
  • attraction/repulsion behaviors and  
  • connected systems  
  • downloading  
  • force-directed graphs  
  • particles, implementing in  
  • springs  
  • world, building  
• traditional genetic algorithms  
• transformation matrix (Processing)  
• Transformations tutorial (Processing)  
• translate() function (PBox2D)  
• trees  
• trigonometry  ,  ,  ,  ,  ,  ,  
  • atan() function  
  • cos() function (Processing)  
  • forces and  
  • sin() function (Processing)  
  • sohcahtoa  
  • tangent  
• Tron (1982)  
• Turtle graphics  
• Turtles, Termites, and Traffic Jams (Resnick)  
• two-dimensional cellular automata  ,  
  • implementing  
• U
• Ulam, Stanisław  
• uniform number distributions  
• Uniformity class (Wolfram classification)  
• unit vectors  
• universal gravitational constant  
• unsupervised learning (neural networks)  
• update() function (toxiclibs)  
• V
• variance  
• variation (natural selection)  
• Vec2 (Box2D element)  ,  ,  ,  ,  ,  
  • adding vectors with  
  • manitude, finding  
  • multiplying vectors with  
  • normalizing vectors  
  • scaling vectors with  
• Vec2D (toxiclibs type)  ,  ,  
  • VerletParticle2D class and  
  • math functions for  
• Vec3D (toxiclibs type)  
• vector notation, vs. scalar notation  
• vectors  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  ,  
  • Processing and  
  • Vec2 (Box2D element)  
  • acceleration  
  • adding  
  • as right triangles  
  • associative/distributive rules for multiplication/division of  
  • bouncing ball sketch  
  • commutative/associative rules of addition/subtraction with  
  • defined  
  • dot product  
  • flow fields, computing for  
  • locations and  
  • magnitude  
  • motion, implementing with  
  • multiplying  
  • normalization  
  • notation  
  • scaling  
  • tangent  
  • unit vectors  
  • velocity and   , 
• Vehicles: Experiments in Synthetic Psychology (Braitenberg)  
• velocity  ,  ,  ,  ,  
  • acceleration  
  • as vector  
  • desired, for autonomous agents  
  • limiting  
• Verlet integration  ,  
  • toxiclibs  
• VerletConstrainedSpring class (toxiclibs)  
• VerletMinDistanceSpring class (toxiclibs)  
• VerletParticle2D object (toxiclibs)  
• VerletPhysics class (toxiclibs)  ,  
  • core elements of  
• VerletPhysics2D class (toxiclibs)  
• VerletSpring class (toxiclibs)  
• viscous force  
• von Neumann, John  
• W
• wandering behavior (Reynolds)  
• waves  ,  ,  
  • angular velocity, defining with  
  • varying  
• weight  ,  
  • mass vs.  
  • neural networks and  
• wheel of fortune probability method  
• Wolfram classification  ,  ,  ,  ,  
  • Complexity class  
  • Random class  
  • Repetition class  
  • Uniformity class  
• Wolfram, Stephen  ,  ,  
  • Wolfram classification  
  • elementary cellular automata algorithm  
• World class (Box2D)  ,  ,  ,  
  • createWorld() function (PBox2D)  
  • getBodyList() function  
• X
• XOR (exclusive or)