zaniah 0.2.0 → 0.3.0

data/lib/zaniah/gpu/open_gl.rb

@@ -12,42 +12,63 @@ module Zaniah
         #version 330 core
         layout(location=0) in vec4 rect;
         layout(location=1) in vec4 tint;
-        layout(location=2) in vec4 corners;
-        layout(location=3) in vec4 border_color;
-        layout(location=4) in vec4 extra;
-        layout(location=5) in vec4 source;
+        layout(location=2) in vec4 tint2;
+        layout(location=3) in vec4 corners;
+        layout(location=4) in vec4 border_color;
+        layout(location=5) in vec4 edges_source;
+        layout(location=6) in vec4 gradient_data;
+        layout(location=7) in vec4 gradient_center_kind;
+        layout(location=8) in vec4 matrix;
+        layout(location=9) in vec4 translation_flags;
         uniform vec2 viewport;
         out vec2 local_position; out vec2 size; out vec4 color; out vec4 radii;
-        out vec4 border; out vec4 info; out vec2 uv;
+        out vec4 secondary; out vec4 border; out vec4 widths; out vec4 gradient;
+        out vec4 center_kind; out vec2 uv; out float dash;
         void main() {
           vec2 vertices[4] = vec2[4](vec2(0,0),vec2(1,0),vec2(0,1),vec2(1,1));
           vec2 corner = vertices[gl_VertexID];
           vec2 position = rect.xy + corner * rect.zw;
-          if (extra.y == 3) position = gl_VertexID == 0 ? rect.xy : gl_VertexID == 1 ? rect.zw : corners.xy;
+          if (gradient_center_kind.w == 3) position = gl_VertexID == 0 ? rect.xy : gl_VertexID == 1 ? rect.zw : corners.xy;
+          position = vec2(matrix.x * position.x + matrix.z * position.y + translation_flags.x,
+                          matrix.y * position.x + matrix.w * position.y + translation_flags.y);
           gl_Position = vec4(position.x / viewport.x * 2 - 1, 1 - position.y / viewport.y * 2, 0, 1);
           local_position = corner * rect.zw; size = rect.zw; color = tint;
-          radii = corners; border = border_color; info = extra; uv = source.xy + corner * source.zw;
+          secondary = tint2; radii = corners; border = border_color; widths = edges_source;
+          gradient = gradient_data; center_kind = gradient_center_kind;
+          uv = edges_source.xy + corner * edges_source.zw; dash = translation_flags.w;
         }
       GLSL
       FRAGMENT = <<~GLSL.freeze
         #version 330 core
         in vec2 local_position; in vec2 size; in vec4 color; in vec4 radii;
-        in vec4 border; in vec4 info; in vec2 uv;
+        in vec4 secondary; in vec4 border; in vec4 widths; in vec4 gradient;
+        in vec4 center_kind; in vec2 uv; in float dash;
         uniform sampler2D atlas;
         out vec4 output_color;
         void main() {
           vec4 result = color;
-          if (info.y == 0) {
+          if (center_kind.w == 0) {
+            if (gradient.x > 0) {
+              vec2 normalized = local_position / size;
+              float raw = gradient.x == 1
+                ? dot(normalized - 0.5, vec2(cos(radians(gradient.w)), sin(radians(gradient.w)))) + 0.5
+                : length(normalized - center_kind.xy) / center_kind.z;
+              result = mix(color, secondary, clamp((raw - gradient.y) / max(gradient.z - gradient.y, 0.000001), 0, 1));
+            }
             float radius = local_position.y < size.y/2 ? (local_position.x < size.x/2 ? radii.x : radii.y) : (local_position.x < size.x/2 ? radii.w : radii.z);
             radius = clamp(radius, 0, min(size.x,size.y)/2);
             vec2 q = abs(local_position - size/2) - size/2 + radius;
             float distance = length(max(q,0)) + min(max(q.x,q.y),0) - radius;
             float coverage = clamp(0.5 - distance, 0, 1);
-            if (info.x > 0 && distance >= -info.x) result = border;
+            vec4 edge_distance = vec4(local_position.y, size.x-local_position.x, size.y-local_position.y, local_position.x);
+            float edge = min(min(edge_distance.x,edge_distance.y),min(edge_distance.z,edge_distance.w));
+            float border_width = edge == edge_distance.x ? widths.x : edge == edge_distance.y ? widths.y : edge == edge_distance.z ? widths.z : widths.w;
+            float coordinate = edge == edge_distance.x || edge == edge_distance.z ? local_position.x : local_position.y;
+            if (border_width > 0 && distance >= -border_width && !(dash == 1 && mod(coordinate,6) >= 3)) result = border;
             result.a *= coverage;
-          } else if (info.y == 1 || info.y == 2) {
+          } else if (center_kind.w == 1 || center_kind.w == 2) {
             vec4 sample_color = texture(atlas,uv);
-            if (info.y == 1) result.a *= sample_color.r; else result *= sample_color;
+            if (center_kind.w == 1) result.a *= sample_color.r; else result *= sample_color;
           }
           output_color = vec4(result.rgb * result.a, result.a);
         }
@@ -62,7 +83,7 @@ module Zaniah
         @vao, @buffer = generate(:glGenVertexArrays), generate(:glGenBuffers)
         gl(:glBindVertexArray, [I], V, @vao)
         gl(:glBindBuffer, [I, I], V, 0x8892, @buffer)
-        6.times do |location|
+        10.times do |location|
           gl(:glEnableVertexAttribArray, [I], V, location)
           gl(:glVertexAttribDivisor, [I, I], V, location, 1)
         end
@@ -148,7 +169,7 @@ module Zaniah
             clip = clip ? Bounds.new(0, 0, @width, @height).intersect(clip) : Bounds.new(0, 0, @width, @height)
             next unless clip.width.positive? && clip.height.positive?
             gl(:glScissor, [I] * 4, V, (clip.x * @scale).to_i, ((@height - clip.bottom) * @scale).to_i, (clip.width * @scale).to_i, (clip.height * @scale).to_i)
-            6.times do |location|
+            10.times do |location|
               gl(:glVertexAttribPointer, [I, I, I, I, I, P], V, location, 4, 0x1406, 0, InstancePacking::STRIDE * 4, (first * InstancePacking::STRIDE + location * 4) * 4)
             end
             native_texture(texture || @white)

data/lib/zaniah/gpu/software.rb

@@ -14,6 +14,7 @@ module Zaniah
         @width, @height = width.to_i, height.to_i
         @viewport = Bounds.new(0, 0, @width, @height)
         @pixels = "\0".b * (@width * @height * 4)
+        @gradient_cache ||= {}
       end
 
       def create_texture(width, height, **options) = Texture.new(width, height, **options)
@@ -43,25 +44,48 @@ module Zaniah
       private
 
       def draw_quad(data, offset, clip)
-        x, y, width, height, red, green, blue, alpha, top_left, top_right, bottom_right, bottom_left, border, border_red, border_green, border_blue, border_alpha = data.slice(offset, Scene::QUAD_STRIDE)
-        bounds = Bounds.new(x, y, width, height).intersect(clip)
-        colors = [[red, green, blue, alpha], [border_red, border_green, border_blue, border_alpha]]
+        values = data.slice(offset, Scene::QUAD_STRIDE)
+        x, y, width, height = values.first(4)
+        color, secondary = values[4, 4], values[8, 4]
+        radii, border_color, borders = values[12, 4], values[16, 4], values[20, 4]
+        gradient = values[24, 7]
+        matrix = Transform.new(*values[32, 6])
+        bounds = transformed_bounds(x, y, width, height, matrix).intersect(clip)
+        if matrix.b.zero? && matrix.c.zero? && borders.all?(&:zero?) && color[3] == 1 &&
+            radii.all?(&:zero?) && gradient[0].zero? &&
+            [bounds.x, bounds.y, bounds.width, bounds.height].all? { |value| value == value.to_i }
+          fill_rect(bounds, *color.first(3))
+          return
+        end
+        gradient = gradient_parameters(gradient)
+        if matrix == Transform.identity && borders.all?(&:zero?) && radii.all?(&:zero?) &&
+            color[3] == 1 && secondary[3] == 1 && gradient[0].positive? &&
+            [x, y, width, height].all? { |value| value == value.to_i }
+          fill_cached_gradient(bounds, x.to_i, y.to_i, width.to_i, height.to_i, color, secondary, gradient)
+          return
+        end
+        inverse = matrix.inverse
         top, bottom = [bounds.y.floor, 0].max, [bounds.bottom.ceil, @height].min
         left, right = [bounds.x.floor, 0].max, [bounds.right.ceil, @width].min
         pixel_y = top
         while pixel_y < bottom
           pixel_x = left
           while pixel_x < right
-            center_x, center_y = pixel_x + 0.5, pixel_y + 0.5
-            radius = center_y < y + height / 2.0 ? (center_x < x + width / 2.0 ? top_left : top_right) : (center_x < x + width / 2.0 ? bottom_left : bottom_right)
+            point = inverse.apply(Point.new(pixel_x + 0.5, pixel_y + 0.5))
+            local_x, local_y = point.x - x, point.y - y
+            radius = local_y < height / 2.0 ? (local_x < width / 2.0 ? radii[0] : radii[1]) : (local_x < width / 2.0 ? radii[3] : radii[2])
             radius = radius.clamp(0, [width, height].min / 2.0)
-            quad_x = (center_x - x - width / 2.0).abs - width / 2.0 + radius
-            quad_y = (center_y - y - height / 2.0).abs - height / 2.0 + radius
+            quad_x = (local_x - width / 2.0).abs - width / 2.0 + radius
+            quad_y = (local_y - height / 2.0).abs - height / 2.0 + radius
             distance = Math.sqrt([quad_x, 0].max**2 + [quad_y, 0].max**2) + [[quad_x, quad_y].max, 0].min - radius
             coverage = (0.5 - distance).clamp(0, 1)
             if coverage.positive?
-              color = colors[border.positive? && distance >= -border ? 1 : 0]
-              blend(pixel_x, pixel_y, color[0], color[1], color[2], color[3] * coverage)
+              fill = gradient[0].zero? ? color : mix(color, secondary, gradient_offset(gradient, local_x, local_y, width, height))
+              edge = [local_y, width - local_x, height - local_y, local_x].each_with_index.min_by(&:first).last
+              border = borders[edge]
+              dashed = values[39] == 1 && ((edge.odd? ? local_y : local_x) % 6) >= 3
+              fill = border_color if border.positive? && distance >= -border && !dashed
+              blend(pixel_x, pixel_y, fill[0], fill[1], fill[2], fill[3] * coverage)
             end
             pixel_x += 1
           end
@@ -69,15 +93,62 @@ module Zaniah
         end
       end
 
+      def fill_rect(bounds, red, green, blue)
+        left, right = [bounds.x.to_i, 0].max, [bounds.right.to_i, @width].min
+        top, bottom = [bounds.y.to_i, 0].max, [bounds.bottom.to_i, @height].min
+        return if left >= right || top >= bottom
+        row = [red, green, blue, 1].map { |value| (value.clamp(0, 1) * 255).round }.pack("C4") * (right - left)
+        (top...bottom).each { |pixel_y| @pixels[pixel_y * @width * 4 + left * 4, row.bytesize] = row }
+      end
+
+      def fill_cached_gradient(bounds, x, y, width, height, color, secondary, gradient)
+        return if width <= 0 || height <= 0
+        @gradient_cache.clear if @gradient_cache.length >= 256
+        key = [width, height, color, secondary, gradient]
+        tile = @gradient_cache[key] ||= gradient_tile(width, height, color, secondary, gradient)
+        left, right = [bounds.x.ceil, 0].max, [bounds.right.floor, @width].min
+        top, bottom = [bounds.y.ceil, 0].max, [bounds.bottom.floor, @height].min
+        return if left >= right || top >= bottom
+        bytes = (right - left) * 4
+        (top...bottom).each do |pixel_y|
+          source = ((pixel_y - y) * width + left - x) * 4
+          @pixels[pixel_y * @width * 4 + left * 4, bytes] = tile.byteslice(source, bytes)
+        end
+      end
+
+      def gradient_tile(width, height, left, right, gradient)
+        kind, first, scale, cosine, sine, center_x, center_y, radius = gradient
+        starts = left.first(3).map { |value| value * 255 }
+        deltas = 3.times.map { |index| (right[index] - left[index]) * 255 }
+        bytes = String.new(capacity: width * height * 4, encoding: Encoding::BINARY)
+        height.times do |pixel_y|
+          ny = (pixel_y + 0.5) / height
+          width.times do |pixel_x|
+            nx = (pixel_x + 0.5) / width
+            raw = kind == 1 ? (nx - 0.5) * cosine + (ny - 0.5) * sine + 0.5 : Math.hypot(nx - center_x, ny - center_y) / radius
+            amount = ((raw - first) * scale).clamp(0, 1)
+            bytes << (starts[0] + deltas[0] * amount).round.clamp(0, 255)
+            bytes << (starts[1] + deltas[1] * amount).round.clamp(0, 255)
+            bytes << (starts[2] + deltas[2] * amount).round.clamp(0, 255)
+            bytes << 255
+          end
+        end
+        bytes.freeze
+      end
+
       def draw_sprite(scene, offset, clip)
-        x, y, width, height, red, green, blue, alpha, id, source_x, source_y, source_width, source_height = scene.sprite_data.slice(offset, 13)
+        x, y, width, height, red, green, blue, alpha, id, source_x, source_y, source_width, source_height = scene.sprite_data.slice(offset, Scene::SPRITE_STRIDE)
         return if width <= 0 || height <= 0
         texture = scene.textures.fetch(id)
-        bounds = Bounds.new(x, y, width, height).intersect(clip)
+        matrix = scene.sprite_transform(offset)
+        inverse = matrix.inverse
+        bounds = transformed_bounds(x, y, width, height, matrix).intersect(clip)
         ([bounds.y.ceil, 0].max...[bounds.bottom.ceil, @height].min).each do |pixel_y|
           ([bounds.x.ceil, 0].max...[bounds.right.ceil, @width].min).each do |pixel_x|
-            texture_x = (source_x + (pixel_x + 0.5 - x) * source_width / width).floor.clamp(0, texture.width - 1)
-            texture_y = (source_y + (pixel_y + 0.5 - y) * source_height / height).floor.clamp(0, texture.height - 1)
+            point = inverse.apply(Point.new(pixel_x + 0.5, pixel_y + 0.5))
+            next unless point.x >= x && point.y >= y && point.x < x + width && point.y < y + height
+            texture_x = (source_x + (point.x - x) * source_width / width).floor.clamp(0, texture.width - 1)
+            texture_y = (source_y + (point.y - y) * source_height / height).floor.clamp(0, texture.height - 1)
             index = texture_y * texture.width + texture_x
             if texture.format == :r8
               blend(pixel_x, pixel_y, red, green, blue, alpha * texture.data.getbyte(index) / 255.0)
@@ -93,7 +164,12 @@ module Zaniah
       end
 
       def draw_triangle(data, offset, clip)
-        x0, y0, x1, y1, x2, y2, red, green, blue, alpha = data.slice(offset, 10)
+        x0, y0, x1, y1, x2, y2, red, green, blue, alpha, *transform = data.slice(offset, 16)
+        matrix = Transform.new(*transform)
+        x0, y0, x1, y1, x2, y2 = [[x0, y0], [x1, y1], [x2, y2]].flat_map do |x, y|
+          point = matrix.apply(Point.new(x, y))
+          [point.x, point.y]
+        end
         area = (x1 - x0) * (y2 - y0) - (y1 - y0) * (x2 - x0)
         return if area.zero?
         bounds = Bounds.new([x0, x1, x2].min, [y0, y1, y2].min,
@@ -121,6 +197,32 @@ module Zaniah
         end
         @pixels.setbyte(index + 3, (combined_alpha * 255).round)
       end
+
+      def transformed_bounds(x, y, width, height, matrix)
+        points = [[x, y], [x + width, y], [x, y + height], [x + width, y + height]].map do |px, py|
+          matrix.apply(Point.new(px, py))
+        end
+        left, right = points.map(&:x).minmax
+        top, bottom = points.map(&:y).minmax
+        Bounds.new(left, top, right - left, bottom - top)
+      end
+
+      def gradient_parameters(values)
+        kind, first, last, angle, center_x, center_y, radius = values
+        radians = angle * Math::PI / 180
+        [kind, first, 1.0 / [last - first, Float::EPSILON].max, Math.cos(radians), Math.sin(radians), center_x, center_y, radius]
+      end
+
+      def gradient_offset(gradient, x, y, width, height)
+        kind, first, scale, cosine, sine, center_x, center_y, radius = gradient
+        nx, ny = x / width, y / height
+        raw = kind == 1 ? (nx - 0.5) * cosine + (ny - 0.5) * sine + 0.5 : Math.hypot(nx - center_x, ny - center_y) / radius
+        ((raw - first) * scale).clamp(0, 1)
+      end
+
+      def mix(left, right, amount)
+        4.times.map { |index| left[index] + (right[index] - left[index]) * amount }
+      end
     end
   end
 end

data/lib/zaniah/gpu/vulkan/scene.frag

@@ -0,0 +1,51 @@
+#version 450
+
+layout(location = 0) in vec2 local_position;
+layout(location = 1) in vec2 primitive_size;
+layout(location = 2) in vec4 color;
+layout(location = 3) in vec4 secondary;
+layout(location = 4) in vec4 radii;
+layout(location = 5) in vec4 border;
+layout(location = 6) in vec4 widths;
+layout(location = 7) in vec4 gradient;
+layout(location = 8) in vec4 center_kind;
+layout(location = 9) in float dash;
+
+layout(set = 0, binding = 0) uniform sampler2D atlas;
+layout(location = 0) out vec4 fragment_color;
+
+void main() {
+  vec4 fill = color;
+  if (center_kind.w == 0.0) {
+    if (gradient.x > 0.0) {
+      vec2 normalized = local_position / primitive_size;
+      float raw = gradient.x == 1.0
+        ? dot(normalized - 0.5, vec2(cos(radians(gradient.w)), sin(radians(gradient.w)))) + 0.5
+        : length(normalized - center_kind.xy) / center_kind.z;
+      fill = mix(color, secondary,
+        clamp((raw - gradient.y) / max(gradient.z - gradient.y, 0.000001), 0.0, 1.0));
+    }
+    float radius = local_position.y < primitive_size.y / 2.0
+      ? (local_position.x < primitive_size.x / 2.0 ? radii.x : radii.y)
+      : (local_position.x < primitive_size.x / 2.0 ? radii.w : radii.z);
+    radius = clamp(radius, 0.0, min(primitive_size.x, primitive_size.y) / 2.0);
+    vec2 q = abs(local_position - primitive_size / 2.0) - primitive_size / 2.0 + radius;
+    float distance = length(max(q, 0.0)) + min(max(q.x, q.y), 0.0) - radius;
+    float coverage = clamp(0.5 - distance, 0.0, 1.0);
+    vec4 edge_distance = vec4(local_position.y, primitive_size.x - local_position.x,
+                              primitive_size.y - local_position.y, local_position.x);
+    float edge = min(min(edge_distance.x, edge_distance.y), min(edge_distance.z, edge_distance.w));
+    float border_width = edge == edge_distance.x ? widths.x
+      : edge == edge_distance.y ? widths.y : edge == edge_distance.z ? widths.z : widths.w;
+    float coordinate = edge == edge_distance.x || edge == edge_distance.z ? local_position.x : local_position.y;
+    if (border_width > 0.0 && distance >= -border_width &&
+        !(dash == 1.0 && mod(coordinate, 6.0) >= 3.0)) fill = border;
+    fill.a *= coverage;
+  } else if (center_kind.w == 1.0 || center_kind.w == 2.0) {
+    vec2 uv = widths.xy + local_position / primitive_size * widths.zw;
+    vec4 sample_color = texture(atlas, uv);
+    if (center_kind.w == 1.0) fill.a *= sample_color.r;
+    else fill *= sample_color;
+  }
+  fragment_color = vec4(fill.rgb * fill.a, fill.a);
+}

data/lib/zaniah/gpu/vulkan/scene.vert

@@ -0,0 +1,50 @@
+#version 450
+
+layout(location = 0) in vec4 instance_bounds;
+layout(location = 1) in vec4 instance_color;
+layout(location = 2) in vec4 instance_secondary;
+layout(location = 3) in vec4 instance_radii;
+layout(location = 4) in vec4 instance_border;
+layout(location = 5) in vec4 instance_widths;
+layout(location = 6) in vec4 instance_gradient;
+layout(location = 7) in vec4 instance_center_kind;
+layout(location = 8) in vec4 instance_matrix;
+layout(location = 9) in vec4 instance_translation;
+
+layout(push_constant) uniform Viewport { vec2 size; } viewport;
+
+layout(location = 0) out vec2 local_position;
+layout(location = 1) out vec2 primitive_size;
+layout(location = 2) out vec4 color;
+layout(location = 3) out vec4 secondary;
+layout(location = 4) out vec4 radii;
+layout(location = 5) out vec4 border;
+layout(location = 6) out vec4 widths;
+layout(location = 7) out vec4 gradient;
+layout(location = 8) out vec4 center_kind;
+layout(location = 9) out float dash;
+
+void main() {
+  vec2 corners[4] = vec2[4](vec2(0, 0), vec2(1, 0), vec2(0, 1), vec2(1, 1));
+  vec2 corner = corners[gl_VertexIndex];
+  vec2 size = instance_bounds.zw;
+  vec2 position = instance_bounds.xy + corner * size;
+  if (instance_center_kind.w == 3.0) {
+    position = gl_VertexIndex == 0 ? instance_bounds.xy
+      : gl_VertexIndex == 1 ? instance_bounds.zw : instance_radii.xy;
+  }
+  position = vec2(instance_matrix.x * position.x + instance_matrix.z * position.y + instance_translation.x,
+                  instance_matrix.y * position.x + instance_matrix.w * position.y + instance_translation.y);
+  gl_Position = vec4(position.x / viewport.size.x * 2.0 - 1.0,
+                     position.y / viewport.size.y * 2.0 - 1.0, 0.0, 1.0);
+  local_position = corner * size;
+  primitive_size = size;
+  color = instance_color;
+  secondary = instance_secondary;
+  radii = instance_radii;
+  border = instance_border;
+  widths = instance_widths;
+  gradient = instance_gradient;
+  center_kind = instance_center_kind;
+  dash = instance_translation.w;
+}