Spring factory

The Scrawl-canvas particle physics engine is a simple system designed to allow developers a way to add particle-based effects to their canvas animation scenes. The physics engine is built on top of the following components:

• Particle objects, which represent a 3-dimensional coordinate - based on a Scrawl-canvas Vector object - and include a history of recent positions which we can use to determine how to display that particle on screen.
• History arrays which can be pooled (reused) to cut down on Array creation and distruction during the animation.
• Force objects which define the general and occasional forces to be applied to each particle in the system as the animation progresses - a gravity force object is pre-defined by Scrawl-canvas.
• Spring objects used to define a constraint (connection) between two particles in a system.
• World objects where we can store attributes and values used by various objects; these attributes can be set up so that they will be inherited by clones of the World object. We can also influence the speed of the physics animation here.

We do not have to handle particle generation and manipulation ourselves. Instead, Scrawl-canvas gives us three dedicated entitys which we use to add particle animation effects to the canvas scene. These entitys are:

• Tracer - this entity generates a single non-recycled (in other words: long lasting) particle with a history, which we can use to display trace effects in the animation.
• Emitter - an entity which generates a stream of short-lived, recycled particles, each with its own history. Emitters are highly versatile entitys which can generate a wide range of effects.
• Net - a (generally) larger entity which uses both forces and springs to manage the animation of its non-recycled particles. Note that other artefacts can use Net particles as a reference for their own positioning.

Particle physics

The Scrawl-canvas particle physics engine system is based on a fairly classical understanding of particle kinetics (applying forces and constraints to a small, spherical object in 3D space) and kinematics (the movement of the small object in response to the forces and constraints applied to it).

A Scrawl-canvas Spring object connects together two Particle objects, linking them together with a set of constraints which together exert a spring force on the Particles.

• Currently Scrawl-canvas offers only the spring constraint for connecting Particles; it does not (yet) define joint or other types of constraint.
• The Net entity is, at the moment, the only entity which makes use of Spring objects.

The Spring factory uses the Base mixin, thus Spring objects can be cloned and killed like other Scrawl-canvas objects. Spring objects are stored in the scrawl.library.spring section of the Scrawl-canvas library object.

Demos:

• particles-008 - Net entity: generation and basic functionality, including Spring objects
• particles-009 - Net particles: drag-and-drop functionality
• particles-010 - Net entity: using a shape path as a net template

Imports

Spring constructor

Spring prototype

Mixins

Spring attributes

• Attributes defined in the base mixin: name.

particleFrom, particleTo - String name of a Particle, or the Particle object itself. These attributes hold references to the Particle objects involved in this constraint.

springConstant - float Number. Larger values make the spring stiffer. Suggested values: 5 - 300

damperConstant - float Number. Larger values forces the spring to take a longer time to come to equilibrium. Suggested values: 5 - 50

restLength - The spring’s ideal length - the further away from its ideal, the more force the spring will apply to its connected body objects to get them back to their optimal distance

Packet management

Clone management

No additional clone functionality required

Kill management

Get, Set, deltaSet

particleFrom, particleTo

Prototype functions

applySpring - internal function

Factory

scrawl.makeNet({

    name: 'test-net',

    generate: function () {

        let { name, particleStore, springs, springConstant, damperConstant } = this;

        let leftParticle, rightParticle;

        // generate particles
        leftParticle = makeParticle({

            name: `${name}-left`,

            positionX: 0,
            positionY: 0,
        });

        rightParticle = leftParticle.clone({

            name: `${name}-right`,
            positionX: 100,
        });

        leftParticle.run(0, 0, false);
        rightParticle.run(0, 0, false);

        particleStore.push(leftParticle, rightParticle);

        // generate spring
        let mySpring = makeSpring({

            name: `${name}-link-${i}-${i+1}`,

            particleFrom: leftParticle,
            particleTo: rightParticle,

            springConstant, 
            damperConstant,

            restLength: 100,
        });

        springs.push(mySpring);
    },

    ...

}).run();

Exports