vizcore 1.0.0 → 1.1.0

data/lib/vizcore/dsl/mapping_resolver.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../shape"
+
 module Vizcore
   module DSL
     # Resolves `map` definitions into concrete per-layer parameter values.
@@ -11,17 +13,19 @@ module Vizcore
       # @param scene_layers [Array<Hash>]
       # @param audio [Hash]
       # @return [Array<Hash>] normalized layer payloads with resolved params
-      def resolve_layers(scene_layers:, audio:)
+      def resolve_layers(scene_layers:, audio:, time: 0.0, frame: 0, resolution: [1280, 720], globals: {}, custom_shape_overrides: {})
         normalize_scene_layers(scene_layers).map do |layer|
-          resolve_layer(layer, audio)
+          resolve_layer(layer, audio, time: time, frame: frame, resolution: resolution, globals: globals, custom_shape_overrides: custom_shape_overrides)
         end
       end
 
       private
 
-      def resolve_layer(layer, audio)
-        params = (layer[:params] || {}).dup
+      def resolve_layer(layer, audio, time:, frame:, resolution:, globals:, custom_shape_overrides:)
+        params = deep_dup(layer[:params] || {})
+        apply_custom_shape_overrides!(params, layer_name: layer[:name], custom_shape_overrides: custom_shape_overrides)
         merge_resolved_mappings!(params, resolve_mappings(layer[:mappings], audio, layer_name: layer[:name]))
+        expand_dynamic_custom_shapes!(params, layer: layer, audio: audio, time: time, frame: frame, resolution: resolution, globals: globals)
 
         output = {
           name: layer.fetch(:name).to_s,
@@ -57,6 +61,95 @@ module Vizcore
         end
       end
 
+      def expand_dynamic_custom_shapes!(params, layer:, audio:, time:, frame:, resolution:, globals:)
+        descriptors = Array(params.delete(:custom_shapes) || params.delete("custom_shapes"))
+        return if descriptors.empty?
+
+        params[:shapes] = Array(params[:shapes])
+        controls = []
+        descriptors.each_with_index do |descriptor, index|
+          start_index = params[:shapes].length
+          expanded = expand_dynamic_custom_shape(descriptor, layer: layer, palette: params[:palette], audio: audio, time: time, frame: frame, resolution: resolution, globals: globals)
+          params[:shapes].concat(expanded)
+          controls << custom_shape_control_descriptor(descriptor, index: index, start_index: start_index, count: expanded.length)
+        end
+        params[:custom_shape_controls] = controls unless controls.empty?
+      end
+
+      def expand_dynamic_custom_shape(descriptor, layer:, palette:, audio:, time:, frame:, resolution:, globals:)
+        values = Hash(descriptor)
+        renderer = values.fetch(:renderer)
+        shape_name = values[:name] || renderer
+        primitives = Vizcore::Shape.expand_custom_shape(
+          renderer,
+          params: Hash(values[:params] || {}),
+          shape_id: values[:shape_id],
+          layer_name: layer[:name],
+          palette: Array(palette),
+          audio: audio,
+          time: time,
+          frame: frame,
+          resolution: resolution,
+          globals: globals,
+          shape_name: shape_name
+        )
+        primitives.each { |primitive| apply_custom_shape_attributes!(primitive, values) }
+      end
+
+      def custom_shape_control_descriptor(descriptor, index:, start_index:, count:)
+        values = Hash(descriptor)
+        {
+          index: index,
+          name: (values[:name] || values["name"] || "custom_shape").to_s,
+          params: deep_dup(Hash(values[:params] || values["params"] || {})),
+          param_schema: Array(values[:param_schema] || values["param_schema"]).map { |entry| deep_dup(entry) },
+          shape_indices: (start_index...(start_index + count)).to_a
+        }
+      end
+
+      def apply_custom_shape_overrides!(params, layer_name:, custom_shape_overrides:)
+        layer_overrides = custom_shape_layer_overrides(custom_shape_overrides, layer_name)
+        return if layer_overrides.empty?
+
+        descriptors = Array(params[:custom_shapes] || params["custom_shapes"])
+        layer_overrides.each do |index, values|
+          descriptor = descriptors[Integer(index)]
+          next unless descriptor && values.is_a?(Hash)
+
+          descriptor[:params] ||= {}
+          values.each do |param_name, value|
+            key = param_name.to_sym
+            descriptor[:params][key] = value
+          end
+        rescue ArgumentError, TypeError
+          next
+        end
+      end
+
+      def custom_shape_layer_overrides(overrides, layer_name)
+        values = Hash(overrides)
+        name = layer_name.to_s
+        Hash(values[name] || values[layer_name.to_sym] || {})
+      rescue TypeError
+        {}
+      end
+
+      def apply_custom_shape_attributes!(primitive, descriptor)
+        style = Hash(descriptor[:style] || {})
+        style.each do |key, value|
+          symbol_key = key.to_sym
+          if symbol_key == :opacity && primitive.key?(:opacity)
+            primitive[:opacity] = numeric(style[:opacity] || style["opacity"], :opacity) * numeric(primitive[:opacity], :opacity)
+          else
+            primitive[symbol_key] = deep_dup(value) unless primitive.key?(symbol_key)
+          end
+        end
+
+        transform = Hash(descriptor[:transform] || {})
+        primitive[:transform] = compose_shape_transform(transform, primitive[:transform]) unless transform.empty?
+        primitive
+      end
+
       def assign_nested_param(container, path, value)
         key = path.shift
         if path.empty?
@@ -65,6 +158,7 @@ module Vizcore
         end
 
         next_container = nested_value(container, key)
+        next_container = create_nested_container(container, key, path.first) if next_container.nil?
         return unless next_container
 
         assign_nested_param(next_container, path, value)
@@ -77,6 +171,13 @@ module Vizcore
         nil
       end
 
+      def create_nested_container(container, key, next_key)
+        return unless container.is_a?(Hash)
+
+        value = integer_key?(next_key) ? [] : {}
+        container[key.to_sym] = value
+      end
+
       def assign_nested_value(container, key, value)
         if container.is_a?(Array) && integer_key?(key)
           container[key.to_i] = value
@@ -89,6 +190,46 @@ module Vizcore
         value.match?(/\A\d+\z/)
       end
 
+      def compose_shape_transform(parent, child)
+        return deep_dup(child || {}) unless parent
+
+        child ||= {}
+        output = deep_dup(parent)
+        output[:translate] = add_shape_xy(parent[:translate], child[:translate]) if child.key?(:translate)
+        output[:origin] = child[:origin] if child.key?(:origin)
+        output[:rotate] = numeric(parent[:rotate] || 0, :rotate) + numeric(child[:rotate] || 0, :rotate) if child.key?(:rotate)
+        output[:scale] = multiply_shape_scale(parent[:scale], child[:scale]) if child.key?(:scale)
+        output
+      end
+
+      def add_shape_xy(parent, child)
+        parent ||= {}
+        child ||= {}
+        {
+          x: numeric(parent[:x] || parent["x"] || 0, :"translate.x") + numeric(child[:x] || child["x"] || 0, :"translate.x"),
+          y: numeric(parent[:y] || parent["y"] || 0, :"translate.y") + numeric(child[:y] || child["y"] || 0, :"translate.y")
+        }
+      end
+
+      def multiply_shape_scale(parent, child)
+        parent = shape_scale_pair(parent)
+        child = shape_scale_pair(child)
+        { x: parent[:x] * child[:x], y: parent[:y] * child[:y] }
+      end
+
+      def shape_scale_pair(value)
+        return { x: numeric(value[:x] || value["x"] || 1, :"scale.x"), y: numeric(value[:y] || value["y"] || 1, :"scale.y") } if value.is_a?(Hash)
+
+        scale = numeric(value || 1, :scale)
+        { x: scale, y: scale }
+      end
+
+      def numeric(value, name)
+        Float(value)
+      rescue ArgumentError, TypeError
+        raise ArgumentError, "param #{name} must be numeric"
+      end
+
       def resolve_source_value(source, audio)
         case source[:kind]&.to_sym
         when :amplitude
@@ -193,6 +334,19 @@ module Vizcore
         Array(scene_layers).map { |layer| deep_symbolize(layer) }
       end
 
+      def deep_dup(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, entry), output|
+            output[key] = deep_dup(entry)
+          end
+        when Array
+          value.map { |entry| deep_dup(entry) }
+        else
+          value
+        end
+      end
+
       def deep_symbolize(value)
         case value
         when Hash

data/lib/vizcore/layer_catalog.rb

@@ -151,10 +151,12 @@ module Vizcore
         aliases: %i[shapes shape_layer],
         params: COMMON_PARAMS.merge(
           shapes: "Array<Hash>",
+          shape_schema_version: "Integer",
+          units: "Symbol",
           color_shift: "Float"
         ),
-        mappable_params: %i[color_shift opacity],
-        description: "Declarative 2D circle and line primitives rendered by the browser."
+        mappable_params: %i[color_shift opacity shapes],
+        description: "Declarative and Ruby-generated 2D circle, line, rect, polygon, polyline, path, and star primitives rendered by the browser."
       ),
       Capability.new(
         type: :mesh,

data/lib/vizcore/renderer/scene_frame_source.rb

@@ -22,6 +22,7 @@ module Vizcore
         @input_manager.start
         @capture_size = capture_size
         @pipeline = build_pipeline
+        @frame_count = 0
         self
       end
 
@@ -30,7 +31,13 @@ module Vizcore
         ensure_started!
 
         audio = @pipeline.call(@input_manager.capture_frame(@capture_size))
-        layers = Vizcore::DSL::MappingResolver.new.resolve_layers(scene_layers: @scene[:layers], audio: audio)
+        @frame_count += 1
+        layers = Vizcore::DSL::MappingResolver.new.resolve_layers(
+          scene_layers: @scene[:layers],
+          audio: audio,
+          time: frame_time,
+          frame: @frame_count
+        )
 
         {
           scene: { name: @scene[:name], layers: layers },
@@ -82,6 +89,12 @@ module Vizcore
         )
       end
 
+      def frame_time
+        return 0.0 unless @frame_rate
+
+        (@frame_count - 1).fdiv(@frame_rate)
+      end
+
       def audio_normalize_settings
         Hash(@definition[:analysis] || {})[:audio_normalize]
       rescue StandardError