Working version

src/drawables/drawable-descriptor.ts

@@ -0,0 +1,8 @@
+import { Drawable } from './drawable';
+
+export interface DrawableDescriptor {
+  uniformName: string;
+  countMacroName: string;
+  shaderCombinationSteps: Array<number>;
+  readonly empty: Drawable;
+}

src/drawables/drawable.ts

@@ -0,0 +1,15 @@
+import { mat2d, vec2 } from 'gl-matrix';
+import { DrawableDescriptor } from './drawable-descriptor';
+
+export abstract class Drawable {
+  static get descriptor(): DrawableDescriptor {
+    throw new Error('This getter should be overriden');
+  }
+
+  public abstract distance(target: vec2): number;
+  public abstract serializeToUniforms(
+    uniforms: any,
+    scale: number,
+    transform: mat2d
+  ): void;
+}

src/drawables/lights/circle-light.ts

@@ -0,0 +1,50 @@
+import { mat2d, vec2, vec3 } from 'gl-matrix';
+import { settings } from '../../graphics/settings';
+import { Drawable } from '../drawable';
+import { DrawableDescriptor } from '../drawable-descriptor';
+
+export class CircleLight extends Drawable {
+  public static get descriptor(): DrawableDescriptor {
+    return {
+      uniformName: 'circleLights',
+      countMacroName: 'circleLightCount',
+      shaderCombinationSteps: settings.shaderCombinations.circleLightSteps,
+      empty: new CircleLight(vec2.fromValues(0, 0), 0, vec3.fromValues(0, 0, 0), 0),
+    };
+  }
+
+  constructor(
+    public center: vec2,
+    public lightDrop: number,
+    public color: vec3,
+    public lightness: number
+  ) {
+    super();
+  }
+
+  public distance(_: vec2): number {
+    return 0;
+  }
+
+  public serializeToUniforms(uniforms: any, scale: number, transform: mat2d): void {
+    const { uniformName } = CircleLight.descriptor;
+
+    if (!Object.prototype.hasOwnProperty.call(uniforms, uniformName)) {
+      uniforms[uniformName] = [];
+    }
+
+    uniforms[uniformName].push({
+      center: vec2.transformMat2d(vec2.create(), this.center, transform),
+      lightDrop: this.lightDrop,
+      value: this.value,
+    });
+  }
+
+  public get value(): vec3 {
+    return vec3.scale(
+      vec3.create(),
+      vec3.normalize(this.color, this.color),
+      this.lightness
+    );
+  }
+}

src/drawables/lights/flashlight.ts

@@ -0,0 +1,54 @@
+import { mat2d, vec2, vec3 } from 'gl-matrix';
+import { settings } from '../../graphics/settings';
+import { Drawable } from '../drawable';
+import { DrawableDescriptor } from '../drawable-descriptor';
+
+export class Flashlight extends Drawable {
+  public static get descriptor(): DrawableDescriptor {
+    return {
+      uniformName: 'flashlights',
+      countMacroName: 'flashlightCount',
+      shaderCombinationSteps: settings.shaderCombinations.flashlightSteps,
+      empty: new Flashlight(
+        vec2.fromValues(0, 0),
+        vec2.fromValues(0, 0),
+        0,
+        vec3.fromValues(0, 0, 0),
+        0
+      ),
+    };
+  }
+
+  public constructor(
+    public center: vec2,
+    public direction: vec2,
+    public lightDrop: number,
+    public color: vec3,
+    public lightness: number
+  ) {
+    super();
+  }
+
+  public distance(_: vec2): number {
+    return 0;
+  }
+
+  public serializeToUniforms(uniforms: any, scale: number, transform: mat2d): void {
+    const listName = Flashlight.descriptor.uniformName;
+
+    if (!Object.prototype.hasOwnProperty.call(uniforms, listName)) {
+      uniforms[listName] = [];
+    }
+
+    uniforms[listName].push({
+      center: vec2.transformMat2d(vec2.create(), this.center, transform),
+      direction: this.direction,
+      lightDrop: this.lightDrop,
+      value: this.value,
+    });
+  }
+
+  public get value(): vec3 {
+    return vec3.scale(vec3.create(), this.color, this.lightness);
+  }
+}

src/drawables/shapes/circle.ts

@@ -0,0 +1,36 @@
+import { mat2d, vec2 } from 'gl-matrix';
+import { settings } from '../../graphics/settings';
+import { Drawable } from '../drawable';
+import { DrawableDescriptor } from '../drawable-descriptor';
+
+export class Circle extends Drawable {
+  public static get descriptor(): DrawableDescriptor {
+    return {
+      uniformName: 'circles',
+      countMacroName: 'circleCount',
+      shaderCombinationSteps: settings.shaderCombinations.circleSteps,
+      empty: new Circle(vec2.fromValues(0, 0), 0),
+    };
+  }
+
+  constructor(public center: vec2, public radius: number) {
+    super();
+  }
+
+  public distance(position: vec2): number {
+    return 0;
+  }
+
+  public serializeToUniforms(uniforms: any, scale: number, transform: mat2d): void {
+    const { uniformName } = Circle.descriptor;
+
+    if (!Object.prototype.hasOwnProperty.call(uniforms, uniformName)) {
+      uniforms[uniformName] = [];
+    }
+
+    uniforms[uniformName].push({
+      center: vec2.transformMat2d(vec2.create(), this.center, transform),
+      radius: this.radius * scale,
+    });
+  }
+}