Colorful Aizawa attractor - OpenProcessing

mySketch
xxxxxxxxxx
 
// Based on:
// Title: Colorful Dots in Aizama Attractor
// Author: FAL
// https://www.openprocessing.org/sketch/452137
// Made with Processing 3.3.6
/* Log:
    26. Sep. 2017  First version.
    30. Sep. 2017  Bug fix (CIELAB -> XYZ conversion method)
     1. Oct. 2017  Bug fix (Detected that calculation by processing.js may not be correct if you write float suffix (e.g. 2.4f), therefore deleted all suffixes)
*/
​
/* 
I just made some changes in the equations that define the attractor and the colors.
*/
private static final float IDEAL_FRAME_RATE = 40.0;
​
final float ambientLightBrightness = 208.0;
final float directionalLightBrightness = 48.0;
​
NaiveActorSystem myActorSystem;
ViewAngleController viewer;
boolean paused;
​
void setup() {
  size(640, 640, P3D);
  frameRate(IDEAL_FRAME_RATE);
  sphereDetail(10);
  
  initialize();
}
​
void draw() {
  background(0.0);
  
  
  ambientLight(ambientLightBrightness, ambientLightBrightness, ambientLightBrightness);
  directionalLight(directionalLightBrightness, directionalLightBrightness, directionalLightBrightness, 0, 0, -1);
  
  viewer.applyPerspective();
  viewer.translateCoordinates();
  viewer.rotateCoordinates();
  
  noFill();
  stroke(224.0, 160.0, 224.0);
  box(40.0);
​
  scale(15);
​
  myActorSystem.run();
  
}
​
void mouseDragged() {
  if (paused) return;
  viewer.processMouseDragged();
}
​
void keyPressed() {
  if (key == ' ') {
    if (paused) loop();
    else noLoop();
    paused = !paused;
  }
​
  if(key == CODED && keyCode == 123) initialize();  // F12 key
}
​
void initialize() {
  // prepare field
  final ForceFieldPhysicsSystem myPhysicsSystem = new ForceFieldPhysicsSystem();
  myPhysicsSystem.forceFieldList.add(new AizawaField(0.36234542326327834, 0.5802488849206496, 0.3954677594122402, 3.3793866809512525, 0.2240981262099423, 0.018774755037479406, 0.0, 0.0, -0.2, IDEAL_FRAME_RATE, 0.39));
  myActorSystem = new NaiveActorSystem(myPhysicsSystem, 1024);
​
  // prepare view angle controller
  viewer = new ViewAngleController(radians(75.0), radians(-15.0), PI / 30.0, QUARTER_PI, IDEAL_FRAME_RATE, 0.0);
  viewer.addMouseDragChecker(new HorizontalMouseDragChecker(new AddZRotation(), -0.3));
  viewer.addMouseDragChecker(new VerticalMouseDragChecker(new AddXRotation(), -0.3));
​
  // prepare particle displayers
  final ArrayList<PhysicsBodyDisplayer> displayerList = new ArrayList<PhysicsBodyDisplayer>();
  final int anglePartitionCount = 24;
  final float lightness = 88.0;
  final float distanceFromZero = 64.0;
  for(int i = 0; i < anglePartitionCount; i++) {
    final float hueAngle = i * TWO_PI / anglePartitionCount;
    displayerList.add(new SphereDisplayer(0.02, cielabColor(lightness, distanceFromZero * cos(hueAngle), distanceFromZero * sin(hueAngle))));
  }
​
  // prepare particles
  final int particleNumber = 800;
  for (int i = 0; i < particleNumber; i++) {
    final NaiveBodyActor3D newActor = new NaiveBodyActor3D();
    final float distance = pow(random(1.0), 0.5) * 10.0;
    final float theta = random(TWO_PI);
    final float phi = random(TWO_PI);
    newActor.xPosition = distance * cos(theta) * cos(phi);
    newActor.yPosition = distance * cos(theta) * sin(phi);
    newActor.zPosition = distance * sin(theta);
​
    newActor.displayer = displayerList.get(int(map(theta, 0.0, TWO_PI, 0.0, displayerList.size())));;
    
    myActorSystem.registerNewActor(newActor);
  }
}
​
//////Actor
​
// This tab is dependent on Physics.pde
// Last update: 1. Oct. 2017
​
interface IActor
{
  // Layer: PhysicsSystem
  public void addToPhysicsSystem(PhysicsSystem sys);
​
  // Layer: ActorSystem
  public void act();
  public void display();
}
​
abstract class ActorSystem
{
  final ArrayList<IActor> actorList; 
  final PhysicsSystem currentPhysicsSystem;
​
  ActorSystem(PhysicsSystem sys, int initialCapacity) {
    currentPhysicsSystem = sys;
    actorList = new ArrayList<IActor>(initialCapacity);
  }
  ActorSystem(PhysicsSystem sys) {
    this(sys, 16);
  }
​
  abstract void registerNewActor(IActor obj);
  abstract void run();
}
​
final class NaiveActorSystem
  extends ActorSystem
{
  NaiveActorSystem(PhysicsSystem sys, int initialCapacity) {
    super(sys, initialCapacity);
  }
  NaiveActorSystem(PhysicsSystem sys) {
    this(sys, 16);
  }
​
  void registerNewActor(IActor obj) {
    actorList.add(obj);
    obj.addToPhysicsSystem(currentPhysicsSystem);
  }
​
  void run() {
    currentPhysicsSystem.update();
​
    for (IActor currentObject : actorList) {
      currentObject.act();
      currentObject.display();
    }
  }
}
​
​
​
final class NaiveBodyActor3D
  extends PhysicsBody3D
  implements IActor
{
  PhysicsBodyDisplayer displayer;
  int properFrameCount;
​
  NaiveBodyActor3D() {
    super();
    initialize();
  }
​
  void addToPhysicsSystem(PhysicsSystem sys) {
    sys.bodyList.add(this);
  }
​
  public void initialize() {
    super.initialize();
    displayer = null;
    properFrameCount = 0;
  }
​
  public void act() {
    properFrameCount++;
  }
​
  public void display() {
    displayer.display(this);
  }
}
​
​
​
abstract class PhysicsBodyDisplayer
{
  abstract void display(PhysicsBody parentBody);
}
​
// immutable
final class SphereDisplayer
  extends PhysicsBodyDisplayer
{
  final float radius;
  final color sphereColor;
​
  SphereDisplayer(float sz, color col) {
    radius = sz;
    sphereColor = col;
  }
​
  void display(PhysicsBody parentBody) {
    noStroke();
    fill(sphereColor);
    pushMatrix();
    translate(parentBody.xPosition, parentBody.yPosition, parentBody.zPosition);
    sphere(radius);
    popMatrix();
  }
}
​
//////CIELAB
​
// Last update: 1. Oct. 2017
​
// But still I'm not sure if these conversions are really correct!!
​
// for converting directly without creating instances
color cielabColor(float lValue, float aValue, float bValue) {
  // D65/2° standard illuminant.
  final float tristimulusValueX = 0.95047;
  final float tristimulusValueY = 1.00000;
  final float tristimulusValueZ = 1.08883;
​
  final float yFactor = (lValue + 16.0) / 116.0;
  final float xFactor = yFactor + aValue / 500.0;
  final float zFactor = yFactor - bValue / 200.0;
​
  final float xValue = constrain(tristimulusValueX * toXyzColorFunc(xFactor), 0.0, 1.0);
  final float yValue = constrain(tristimulusValueY * toXyzColorFunc(yFactor), 0.0, 1.0);
  final float zValue = constrain(tristimulusValueZ * toXyzColorFunc(zFactor), 0.0, 1.0);
​
  final float redFactor =   ( 3.2404542 * xValue - 1.5371385 * yValue - 0.4985314 * zValue);
  final float greenFactor = (-0.9692660 * xValue + 1.8760108 * yValue + 0.0415560 * zValue);
  final float blueFactor =  ( 0.0556434 * xValue - 0.2040259 * yValue + 1.0572252 * zValue);
​
  return color(degamma(constrain(redFactor, 0.0, 1.0)) * 255.0, degamma(constrain(greenFactor, 0.0, 1.0)) * 255.0, degamma(constrain(blueFactor, 0.0, 1.0)) * 255.0);
}
​
float toXyzColorFunc(float value) {
  final float delta = 6.0 / 29.0;
    if (value > delta) return value * value * value;
    else return (value - 16.0 / 116.0) * 3.0 * delta * delta;
}
​
float degamma(float value) {
  if (value <= 0.0031308) return 12.92 * value;
  else return 1.055 * pow(value, 1.0 / 2.4) - 0.055;
}
​
/////Physics
​
// This tab is independent.
// Last update: 1. Oct. 2017
​
class PhysicsBody
{
  float xPosition, yPosition;
  float xVelocity, yVelocity;
  float xAcceleration, yAcceleration;
​
  // z is used only in the subclass Physics3D
  float zPosition;
  float zVelocity;
  float zAcceleration;
​
  float mass;
  float radius;    // Body is regarded as a simple sphere
​
  boolean isPositionLocked;
​
  PhysicsBody(float x, float y, float m, float r) {
    xPosition = x;
    yPosition = y;
    mass = m;
    radius = r;
  }
  PhysicsBody(float x, float y) {
    this(0.0, 0.0, 1.0, 1.0);
  }
  PhysicsBody() {
    this(0.0, 0.0);
  }
​
  void initialize() {
    xPosition = 0.0;
    yPosition = 0.0;
    xVelocity = 0.0;
    yVelocity = 0.0;
    xAcceleration = 0.0;
    yAcceleration = 0.0;
    mass = 1.0;
    radius = 1.0;
    isPositionLocked = false;
  }
​
  void applyForce(float xForce, float yForce, float zForce) {
    if (this.isPositionLocked) return;
    xAcceleration += xForce / mass;
    yAcceleration += yForce / mass;
  }
​
  void update() {
    if (this.isPositionLocked) return;
​
    xVelocity += xAcceleration;
    xAcceleration = 0;
    yVelocity += yAcceleration;
    yAcceleration = 0;
    xPosition += xVelocity;
    yPosition += yVelocity;
  }
​
  void lockPosition() {
    isPositionLocked = true;
    xVelocity = 0.0;
    yVelocity = 0.0;
    xAcceleration = 0.0;
    yAcceleration = 0.0;
  }
​
  final void unlockPosition() {
    isPositionLocked = false;
  }
}
​
class PhysicsBody3D
  extends PhysicsBody
{
  PhysicsBody3D(float x, float y, float z, float m, float r) {
    super(x, y, m, r);
    zPosition = z;
  }
  PhysicsBody3D(float x, float y, float z) {
    this(0.0, 0.0, 0.0, 1.0, 1.0);
  }
  PhysicsBody3D() {
    this(0.0, 0.0, 0.0);
  }
​
  void initialize() {
    super.initialize();
    zPosition = 0.0;
    zVelocity = 0.0;
    zAcceleration = 0.0;
  }
​
  void applyForce(float xForce, float yForce, float zForce) {
    super.applyForce(xForce, yForce, zForce);
    zAcceleration += zForce / mass;
  }
​
  void update() {
    if (this.isPositionLocked) return;
    super.update();
    zVelocity += zAcceleration;
    zAcceleration = 0;
    zPosition += zVelocity;
  }
​
  void lockPosition() {
    super.lockPosition();
    zVelocity = 0.0;
    zAcceleration = 0.0;
  }
}
​
​
class PhysicsSystem
{
  final ArrayList<PhysicsBody> bodyList;
​
  PhysicsSystem(int initialCapacity) {
    bodyList = new ArrayList<PhysicsBody>(initialCapacity);
  }
  PhysicsSystem() {
    this(1024);
  }
​
  void update() {
    for (PhysicsBody currentObject : bodyList) {
      currentObject.update();
    }
  }
}
​
​
​
final class ForceFieldPhysicsSystem
  extends PhysicsSystem
{
  final ArrayList<PhysicsForceField> forceFieldList;
​
  ForceFieldPhysicsSystem(int initialCapacity) {
    super(initialCapacity);
    forceFieldList = new ArrayList<PhysicsForceField>(initialCapacity / 16);
  }
  ForceFieldPhysicsSystem() {
    this(1024);
  }
​
  void update() {
    for (PhysicsForceField currentObject : forceFieldList) {
      currentObject.update(bodyList);
    }
    super.update();
  }
}
​
​
abstract class PhysicsForceField
{
  void update(ArrayList<PhysicsBody> bodyList) {
    for (PhysicsBody eachBody : bodyList) {
      affect(eachBody);
    }
  }
  
  abstract void affect(PhysicsBody body);
}
​
final class GravityForceField
  extends PhysicsForceField
{
  final float gravityAcceleration;
​
  GravityForceField(float g) {
    gravityAcceleration = g;
  }
  GravityForceField() {
    this(9.80665 / sq(60.0));
  }
​
  void affect(PhysicsBody body) {
    body.yAcceleration += gravityAcceleration;
  }
}
​
​
////AizawaField
​
final class AizawaField
  extends PhysicsForceField
{
  final float a, b, c, d, e, f;  // constants
  final float referenceXPosition, referenceYPosition, referenceZPosition;
  final float unitSpeed;
​
  AizawaField(float _a, float _b, float _c, float _d, float _e, float _f, float refX, float refY, float refZ, float fRate, float speedFactor) {
    a = _a;
    b = _b;
    c = _c;
    d = _d;
    e = _e;
    f = _f;
    referenceXPosition = refX;
    referenceYPosition = refY;
    referenceZPosition = refZ;
    unitSpeed = speedFactor / fRate;
  }
  AizawaField() {
    this(0.36234542326327834, 0.5802488849206496, 0.3954677594122402, 3.3793866809512525, 0.2240981262099423, 0.018774755037479406, 0.0, 0.0, 0.0, 60.0, 1.0);
  }
​
  void affect(PhysicsBody body) {
    final float x = body.xPosition - referenceXPosition;
    final float y = body.yPosition - referenceYPosition;
    final float z = body.zPosition - referenceZPosition;
    
    body.xVelocity = ((z-b) * x - d*y) * unitSpeed;
    body.yVelocity = (d * x + (z-b) * y) * unitSpeed;
    body.zVelocity = (c + a*z - z * z * z /3 -( x * x +y * y )*(1+ e * z)+ f * z * x * x * x) * unitSpeed;
  }
}
​
/////View angle
​
// This tab is independent.
// Last update: 1. Oct. 2017
​
final class ViewAngleController
{
  final float unitAngleVelocity;
​
  float fieldOfViewAngle;
  final float initialFieldOfViewAngle;
  final float aspectRatio;
  final float cameraXPosition, cameraYPosition;
  float cameraZPosition;
  float nearestClippingPlaneZPosition, farthestClippingPlaneZPosition;
​
  final float centerXPosition, centerYPosition, centerZPosition;
​
  float xRotationAngle, yRotationAngle, zRotationAngle;
  final float initialXRotationAngle, initialZRotationAngle;
​
  final ArrayList<UncodedKeyChecker> keyCheckerList = new ArrayList<UncodedKeyChecker>();
  final ArrayList<KeyCodeChecker> keyCodeCheckerList = new ArrayList<KeyCodeChecker>();
  final ArrayList<MouseDragChecker> mouseDragCheckerList = new ArrayList<MouseDragChecker>();
  boolean checksUncodedKey, checksCodedKey, checksMouseDrag;
​
  ViewAngleController(float initXRot, float initZRot, float initFov, float angleVelocityPerSecond, float idealFrameRate, float centerYPositionOffset) {
    // constants
    unitAngleVelocity = angleVelocityPerSecond / idealFrameRate;
​
    // perspective
    aspectRatio = float(width) / float(height);
    cameraXPosition = width * 0.5;
    cameraYPosition = height * 0.5;
​
    // translation
    centerXPosition = width * 0.5;
    centerYPosition = height * 0.5 + centerYPositionOffset;
    centerZPosition = 0.0;
​
    // rotation
    initialXRotationAngle = initXRot;
    initialZRotationAngle = initZRot;
    initialFieldOfViewAngle = initFov;
​
    initialize();
  }
  ViewAngleController() {
    this(QUARTER_PI, 0.0, PI / 3.0, QUARTER_PI, 60.0, 0.0);
  }
​
  void initialize() {
    setFieldOfViewAngle(initialFieldOfViewAngle);
​
    xRotationAngle = initialXRotationAngle;
    yRotationAngle = 0.0;
    zRotationAngle = initialZRotationAngle;
  }
​
  void addKeyChecker(UncodedKeyChecker checker) {
    keyCheckerList.add(checker);
    checksUncodedKey = true;
  }
  void addKeyCodeChecker(KeyCodeChecker checker) {
    keyCodeCheckerList.add(checker);
    checksCodedKey = true;
  }
  void addMouseDragChecker(MouseDragChecker checker) {
    mouseDragCheckerList.add(checker);
    checksMouseDrag = true;
  }  
​
  void addFieldOfViewAngle(float v) {
    setFieldOfViewAngle(fieldOfViewAngle + v * unitAngleVelocity);
  }
  void setFieldOfViewAngle(float v) {
    fieldOfViewAngle = v;
    cameraZPosition = cameraYPosition / tan(fieldOfViewAngle * 0.5);
    nearestClippingPlaneZPosition = cameraZPosition * 0.05;
    farthestClippingPlaneZPosition = cameraZPosition * 10.0;
  }
​
  void addXRotationAngle(float v) {
    xRotationAngle += v * unitAngleVelocity;
  }
  void addYRotationAngle(float v) {
    yRotationAngle += v * unitAngleVelocity;
  }
  void addZRotationAngle(float v) {
    zRotationAngle += v * unitAngleVelocity;
  }
​
  void applyPerspective() {
    perspective(fieldOfViewAngle, aspectRatio, nearestClippingPlaneZPosition, farthestClippingPlaneZPosition);
  }
  void translateCoordinates() {
    translate(centerXPosition, centerYPosition, centerZPosition);
  }
  void rotateCoordinates() {
    rotateX(xRotationAngle);
    rotateY(yRotationAngle);
    rotateZ(zRotationAngle);
  }
​
  void checkKey() {
    if (!keyPressed) return;
    processKey();
  }
  void processKey() {
    if (checksCodedKey && key == CODED) {
      for (KeyCodeChecker eachChecker : keyCodeCheckerList) {
        eachChecker.checkKeyCode(keyCode, this);
      }
    }
    
    if (checksUncodedKey) {
      for (UncodedKeyChecker eachChecker : keyCheckerList) {
        eachChecker.checkKey(key, this);
      }
    }
  }
  
  void processMouseDragged() {
    if (checksMouseDrag == false) return;
    
      for (MouseDragChecker eachChecker : mouseDragCheckerList) {
        eachChecker.check(this);
      }
  }
}
​
​
​
abstract class InputChecker
{
  final ViewAngleKeyEventHandler handler;
​
  InputChecker(ViewAngleKeyEventHandler _handler) {
    handler = _handler;
  }
​
  void execute(ViewAngleController controller) {
    execute(controller, 1.0);
  }
  void execute(ViewAngleController controller, float angleVelocityFactor) {
    handler.execute(controller, angleVelocityFactor);
  }
}
​
final class UncodedKeyChecker
  extends InputChecker
{
  final char triggerKey;
​
  UncodedKeyChecker(char _triggerKey, ViewAngleKeyEventHandler _handler) {
    super(_handler);
    triggerKey = _triggerKey;
  }
​
  void checkKey(char currentKey, ViewAngleController controller) {
    if (currentKey == triggerKey) execute(controller);
  }
}
​
final class KeyCodeChecker
  extends InputChecker
{
  final int triggerKeyCode;
​
  KeyCodeChecker(int _triggerKeyCode, ViewAngleKeyEventHandler _handler) {
    super(_handler);
    triggerKeyCode = _triggerKeyCode;
  }
​
  void checkKeyCode(int currentKeyCode, ViewAngleController controller) {
    if (currentKeyCode == triggerKeyCode) execute(controller);
  }
}
​
abstract class MouseDragChecker
  extends InputChecker
{
  final float sensitivity;
​
  MouseDragChecker(ViewAngleKeyEventHandler _handler, float _sensitivity) {
    super(_handler);
    sensitivity = _sensitivity;
  }
​
  abstract void check(ViewAngleController controller);
}
​
final class VerticalMouseDragChecker
  extends MouseDragChecker
{
  VerticalMouseDragChecker(ViewAngleKeyEventHandler _handler, float _sensitivity) {
    super(_handler, _sensitivity);
  }
​
  void check(ViewAngleController controller) {
    execute(controller, (mouseY - pmouseY) * sensitivity);
  }
}
final class HorizontalMouseDragChecker
  extends MouseDragChecker
{
  HorizontalMouseDragChecker(ViewAngleKeyEventHandler _handler, float _sensitivity) {
    super(_handler, _sensitivity);
  }
​
  void check(ViewAngleController controller) {
    execute(controller, (mouseX - pmouseX) * sensitivity);
  }
}
​
​
​
abstract class ViewAngleKeyEventHandler
{
  abstract void execute(ViewAngleController controller, float angleVelocityFactor);
​
  void execute(ViewAngleController controller) {
    execute(controller, 1.0);
  }
}
​
class AddXRotation
  extends ViewAngleKeyEventHandler
{
  void execute(ViewAngleController controller, float angleVelocityFactor) {
    controller.addXRotationAngle(angleVelocityFactor);
  }
}
​
class AddYRotation
  extends ViewAngleKeyEventHandler
{
  void execute(ViewAngleController controller, float angleVelocityFactor) {
    controller.addYRotationAngle(angleVelocityFactor);
  }
}
​
class AddZRotation
  extends ViewAngleKeyEventHandler
{
  void execute(ViewAngleController controller, float angleVelocityFactor) {
    controller.addZRotationAngle(angleVelocityFactor);
  }
}
​
class AddFieldOfViewAngle
  extends ViewAngleKeyEventHandler
{
  void execute(ViewAngleController controller, float angleVelocityFactor) {
    controller.addFieldOfViewAngle(angleVelocityFactor);
  }
}