ephys.idl

// spec: https://webidl.spec.whatwg.org/

// notes:
// - by default, objects are taken as pointers
//   use [Value] to indicate the object itself
// - int is a long (32 bits)
// - use [NoDelete] for abstract classes as they do not have a destructor

//////// Math ////////

[Prefix="ephys::"]
interface Vec2 {
  attribute float x;
  attribute float y;

  void Vec2();
  void Vec2([Const] float x, [Const] float y);
  void Vec2([Const, Ref] Vec2 x);

  void set([Const] float x, [Const] float y);

  float norm();
  float norm2();
  [Ref] Vec2 normalize();

  [Operator="+=", Ref] Vec2 add([Const, Ref] Vec2 v);
  [Operator="-=", Ref] Vec2 sub([Const, Ref] Vec2 v);
  [Operator="*=", Ref] Vec2 mult(float k);
};

[Prefix="ephys::"]
interface Mat2 {
  attribute float[] data;

  void Mat2();
  void Mat2(float d11, float d12,
            float d21, float d22);
  void Mat2([Const, Ref] Mat2 m);

  [Value] static Mat2 zero();
  [Value] static Mat2 identity();

  float at(unsigned long m, unsigned long n);
  void set(unsigned long m, unsigned long n, float val);

  [Operator="+=", Ref] Mat2 add([Const, Ref] Mat2 m);
  [Operator="-=", Ref] Mat2 sub([Const, Ref] Mat2 m);
  [Operator="*=", Ref] Mat2 mult([Const, Ref] Mat2 m);

  float determinant();

  [Value] Mat2 inverse();
  [Ref] Mat2 invert();

  [Value] Mat2 transpose();
};

[Prefix="ephys::"]
interface Mat3 {
  void Mat3();
  void Mat3(float d11, float d12, float d13,
            float d21, float d22, float d23);
  void Mat3([Const, Ref] Mat3 m);

  [Value] static Mat3 identity();

  float at(unsigned long m, unsigned long n);
  void set(unsigned long m, unsigned long n, float val);

  float determinant();

  [Value] Mat3 inverse();
  [Ref] Mat3 invert();
};

//////// Collider Base Class ////////
[Prefix="ephys::", NoDelete]
interface Collider {
  [Value] Vec2 origin();

  Rigidbody getBody();
  [Value] Mat3 getTransform();
  [Value] Mat3 getInvTransform();

  void setTransform([Const, Ref] Mat3 transform);
  void setInvTransform([Const, Ref] Mat3 invTransform);

  [Value] Vec2 collider2Object([Const, Ref] Vec2 v);
  [Value] Vec2 object2Collider([Const, Ref] Vec2 v);
  [Value] Vec2 rotCollider2Object([Const, Ref] Vec2 v);
  [Value] Vec2 rotObject2Collider([Const, Ref] Vec2 v);
};

//////// Rigidbodies ////////

[Prefix="ephys::"]
interface Rigidbody {
  void Rigidbody();

  [Value] Vec2 getPos();
  [Value] Vec2 getVel();
  [Value] Vec2 getAcc();
  float getAngle();
  float getAngVel();
  float getMass();
  float getInvMass();
  float getInertia();
  float getInvInertia();
  float getLinearDamping();
  float getAngularDamping();
  Collider getCollider();
  float getRestitution();
  [Value] Mat3 getTransform();
  [Value] Mat3 getInvTransform();
  boolean getStatic();

  void setPos([Const, Ref] Vec2 pos);
  void setVel([Const, Ref] Vec2 vel);
  void setAcc([Const, Ref] Vec2 acc);
  void setAngle(float angle);
  void setAngVel(float angVel);
  void setMass(float mass);
  void setInvMass(float invMass);
  void setInertia(float inertia);
  void setInvInertia(float invInertia);
  void setLinearDamping(float linearDamping);
  void setAngularDamping(float angularDamping);
  void setCollider([Ref] Collider collider);
  void setRestitution(float restitution);
  void setStatic(float isStatic);

  [Value] Vec2 world2Local([Const, Ref] Vec2 pos);
  [Value] Vec2 local2World([Const, Ref] Vec2 pos);

  void addForce([Const, Ref] Vec2 force);
  void addForceAt([Const, Ref] Vec2 force, [Const, Ref] Vec2 point);
  void addForceAtLocal([Const, Ref] Vec2 force, [Const, Ref] Vec2 point);

  void addTorque(float torque);

  void clearAccums();

  void step(float dt);
};

//////// Contacts ////////

[NoDelete]
interface ContactList {};

[Prefix="ephys::", NoDelete]
interface ContactGenerator {
  [Ref] ContactList generateContacts();
};

//////// Collision ////////
[Prefix="ephys::"]
interface CircleCollider : Collider {
  attribute float radius;

  void CircleCollider(float radius, [Ref] Rigidbody body, [Const, Ref] optional Mat3 transform);

  [Value] Vec2 origin();
  Rigidbody getBody();
  [Value] Mat3 getTransform();
  [Value] Mat3 getInvTransform();
  void setTransform([Const, Ref] Mat3 transform);
  void setInvTransform([Const, Ref] Mat3 invTransform);

  [Value] Vec2 collider2Object([Const, Ref] Vec2 v);
  [Value] Vec2 object2Collider([Const, Ref] Vec2 v);
  [Value] Vec2 rotCollider2Object([Const, Ref] Vec2 v);
  [Value] Vec2 rotObject2Collider([Const, Ref] Vec2 v);
};

[Prefix="ephys::"]
interface BoxCollider : Collider {
  [Value] attribute Vec2 halfSize;

  void BoxCollider([Const, Ref] Vec2 halfSize, [Ref] Rigidbody body, [Const, Ref] optional Mat3 transform);

  [Value] Vec2 origin();
  Rigidbody getBody();
  [Value] Mat3 getTransform();
  [Value] Mat3 getInvTransform();
  void setTransform([Const, Ref] Mat3 transform);
  void setInvTransform([Const, Ref] Mat3 invTransform);

  [Value] Vec2 collider2Object([Const, Ref] Vec2 v);
  [Value] Vec2 object2Collider([Const, Ref] Vec2 v);
  [Value] Vec2 rotCollider2Object([Const, Ref] Vec2 v);
  [Value] Vec2 rotObject2Collider([Const, Ref] Vec2 v);
};

[Prefix="ephys::", NoDelete]
interface IntersectionDetector {
  static boolean circleCircle([Const, Ref] CircleCollider c1, [Const, Ref] CircleCollider c2);
  static boolean boxCircle([Const, Ref] BoxCollider bc, [Const, Ref] CircleCollider cc);
  static boolean boxBox([Const, Ref] BoxCollider b1, [Const, Ref] BoxCollider b2);
};

//////// Force Generators ////////
[Prefix="ephys::", NoDelete]
interface ForceGenerator {
  void updateForce([Ref] Rigidbody body, float dt);
};

[Prefix="ephys::"]
interface Gravity : ForceGenerator {
  void Gravity([Const, Ref] Vec2 gravity);
  
  void updateForce([Ref] Rigidbody body, float dt);
};

[Prefix="ephys::"]
interface Spring : ForceGenerator {
  attribute float k;
  attribute float length;

  void Spring([Ref] Rigidbody end, [Const, Ref] Vec2 anchor, [Const, Ref] Vec2 endAnchor, float k, float length);

  [Value] Rigidbody getEnd();
  void setEnd([Const, Ref] Rigidbody body);

  void updateForce([Ref] Rigidbody body, float dt);
};

//////// Physics World ////////
[Prefix="ephys::"]
interface World {
  void World();

  void addBody([Ref] Rigidbody body);
  void removeBody([Ref] Rigidbody body);

  void addFGen([Ref] ForceGenerator fgen, [Ref] Rigidbody body);
  void removeFGen([Ref] ForceGenerator fgen, [Ref] Rigidbody body);

  void addContactGen([Ref] ContactGenerator cgen);
  void removeContactGen([Ref] ContactGenerator cgen);

  void step(float dt);
};

//////// Particles ////////

[Prefix="ephys::"]
interface Particle {
  void Particle(optional float mass, optional float damping);

  [Value] Vec2 getPos();
  [Value] Vec2 getVel();
  [Value] Vec2 getAcc();
  float getMass();
  float getInvMass();
  float getDamping();

  void setPos([Const, Ref] Vec2 pos);
  void setVel([Const, Ref] Vec2 vel);
  void setAcc([Const, Ref] Vec2 acc);
  void setMass(float mass);
  void setInvMass(float mass);
  void setDamping(float damping);

  void addForce([Const, Ref] Vec2 force);
  void addImpulse([Const, Ref] Vec2 impulse);

  void clearForceAccum();

  void setStatic();
  boolean isStatic();

  void step(float dt);
};

//////// Particle Force Generators ////////

[Prefix="ephys::", NoDelete]
interface ParticleForceGenerator {
  void updateForce([Ref] Particle particle, float dt);
};

[Prefix="ephys::"]
interface ParticleGravity : ParticleForceGenerator {
  void ParticleGravity([Const, Ref] Vec2 gravity);
  void updateForce([Ref] Particle particle, float dt);
};
[Prefix="ephys::"]
interface ParticleDrag : ParticleForceGenerator {
  void ParticleDrag(float k1, float k2);
  void updateForce([Ref] Particle particle, float dt);
};
[Prefix="ephys::"]
interface ParticleSpring : ParticleForceGenerator {
  attribute float k;
  attribute float length;
  void ParticleSpring([Ref] Particle end, float k, float length);
  void setEnd([Const, Ref] Particle particle);
  [Value] Particle getEnd();
  void updateForce([Ref] Particle particle, float dt);
};

//////// Particle Contacts ////////
[NoDelete]
interface PContactList {};

[Prefix="ephys::", NoDelete]
interface ParticleContactGenerator {
  [Ref] PContactList generateContacts();
};

//////// Particle Links ////////
[Prefix="ephys::", NoDelete]
interface ParticleLink : ParticleContactGenerator {
  void setParticle(unsigned long index, [Ref] Particle particle);
  [Ref] Particle getParticle(unsigned long index);

  [Ref] PContactList generateContacts();
};

[Prefix="ephys::"]
interface ParticleCable : ParticleLink {
  attribute float length;
  attribute float restitution;

  void ParticleCable(float length, float restitution);
  
  void setParticle(unsigned long index, [Ref] Particle particle);
  [Ref] Particle getParticle(unsigned long index);
  
  [Ref] PContactList generateContacts();
};

[Prefix="ephys::"]
interface ParticleRod : ParticleLink {
  attribute float length;

  void ParticleRod(float length);
  
  void setParticle(unsigned long index, [Ref] Particle particle);
  [Ref] Particle getParticle(unsigned long index);
  
  [Ref] PContactList generateContacts();
};

//////// Particle World ////////
[Prefix="ephys::"]
interface ParticleWorld {
  void ParticleWorld(optional unsigned long iterations);

  void addParticle([Ref] Particle particle);
  void removeParticle([Ref] Particle particle);

  void addPFGen([Ref] Particle particle, [Ref] ParticleForceGenerator fgen);
  void removePFGen([Ref] Particle particle, [Ref] ParticleForceGenerator fgen);

  void addPContactGenerator([Ref] ParticleContactGenerator pcg);
  void removePContactGenerator([Ref] ParticleContactGenerator pcg);
  
  [Ref] PContactList generateContacts();

  void step(float dt);
};