--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/examples/E02_squares.nim	Tue Jan 24 10:22:38 2023 +0700
@@ -0,0 +1,94 @@
+import std/times
+import std/strutils
+import std/math
+import std/random
+
+import semicongine
+
+type
+  VertexDataA = object
+    position11: PositionAttribute[Vec2]
+    color22: ColorAttribute[Vec3]
+    index: GenericAttribute[uint32]
+  Uniforms = object
+    t: Descriptor[float32]
+
+var
+  pipeline: RenderPipeline[VertexDataA, Uniforms]
+  uniformdata = Uniforms(t: Descriptor[float32](value: 0'f32))
+
+proc globalUpdate(engine: var Engine, dt: float32) =
+  uniformdata.t.value += dt
+  engine.vulkan.device.updateUniformData(pipeline, uniformdata)
+
+when isMainModule:
+  randomize()
+  var myengine = igniteEngine("Squares")
+  const
+    COLUMNS = 10
+    ROWS = 10
+    WIDTH = 2'f32 / COLUMNS
+    HEIGHT = 2'f32 / ROWS
+  var
+    vertices: array[COLUMNS * ROWS * 4, Vec2]
+    colors: array[COLUMNS * ROWS * 4, Vec3]
+    iValues: array[COLUMNS * ROWS * 4, uint32]
+    indices: array[COLUMNS * ROWS * 2, array[3, uint16]]
+
+  for row in 0 ..< ROWS:
+    for col in 0 ..< COLUMNS:
+      let
+        y: float32 = (row * 2 / COLUMNS) - 1
+        x: float32 = (col * 2 / ROWS) - 1
+        color = Vec3([(x + 1) / 2, (y + 1) / 2, 0'f32])
+        squareIndex = row * COLUMNS + col
+        vertIndex = squareIndex * 4
+      vertices[vertIndex + 0] = Vec2([x, y])
+      vertices[vertIndex + 1] = Vec2([x + WIDTH, y])
+      vertices[vertIndex + 2] = Vec2([x + WIDTH, y + HEIGHT])
+      vertices[vertIndex + 3] = Vec2([x, y + HEIGHT])
+      colors[vertIndex + 0] = color
+      colors[vertIndex + 1] = color
+      colors[vertIndex + 2] = color
+      colors[vertIndex + 3] = color
+      iValues[vertIndex + 0] = uint32(squareIndex)
+      iValues[vertIndex + 1] = uint32(squareIndex)
+      iValues[vertIndex + 2] = uint32(squareIndex)
+      iValues[vertIndex + 3] = uint32(squareIndex)
+      indices[squareIndex * 2 + 0] = [uint16(vertIndex + 0), uint16(vertIndex +
+          1), uint16(vertIndex + 2)]
+      indices[squareIndex * 2 + 1] = [uint16(vertIndex + 2), uint16(vertIndex +
+          3), uint16(vertIndex + 0)]
+
+
+  type PIndexedMesh = IndexedMesh[VertexDataA,
+      uint16] # required so we can use ctor with ref/on heap
+  var squaremesh = PIndexedMesh(
+    vertexData: VertexDataA(
+      position11: PositionAttribute[Vec2](data: @vertices),
+      color22: ColorAttribute[Vec3](data: @colors),
+      index: GenericAttribute[uint32](data: @iValues),
+    ),
+    indices: @indices
+  )
+  var scene = newThing("scene", newThing("squares", squaremesh))
+
+  const vertexShader = generateVertexShaderCode[VertexDataA, Uniforms](
+    """
+    float pos_weight = index / 100.0; // add some gamma correction?
+    float t = sin(uniforms.t * 0.5) * 0.5 + 0.5;
+    float v = min(1, max(0, pow(pos_weight - t, 2)));
+    v = pow(1 - v, 3000);
+    out_color = vec3(in_color.r, in_color.g, v * 0.5);
+    """
+  )
+  const fragmentShader = generateFragmentShaderCode[VertexDataA]()
+  pipeline = setupPipeline[VertexDataA, Uniforms, uint16](
+    myengine,
+    scene,
+    vertexShader,
+    fragmentShader
+  )
+  myengine.run(pipeline, globalUpdate)
+  pipeline.trash()
+  myengine.trash()