stagecraft 1.0.0

data/lib/stagecraft/renderer/shaders/pbr.wgsl

@@ -0,0 +1,251 @@
+//#include "common.wgsl"
+
+const PI = 3.14159265359;
+
+struct MaterialUniforms {
+  base_color: vec4f,
+  factors: vec4f,
+  emissive: vec4f,
+  texture_flags: vec4u,
+  emissive_map_flag: u32,
+  alpha_cutoff: f32,
+  _padding: vec2f,
+  uv_sets: vec4u,
+  emissive_uv_set: u32,
+  _uv_padding0: u32,
+  _uv_padding1: u32,
+  _uv_padding2: u32,
+  base_color_uv_transform: mat3x3f,
+  mr_uv_transform: mat3x3f,
+  normal_uv_transform: mat3x3f,
+  occlusion_uv_transform: mat3x3f,
+  emissive_uv_transform: mat3x3f,
+};
+
+@group(1) @binding(0) var<uniform> material: MaterialUniforms;
+@group(1) @binding(1) var base_color_sampler: sampler;
+@group(1) @binding(2) var base_color_map: texture_2d<f32>;
+@group(1) @binding(3) var mr_sampler: sampler;
+@group(1) @binding(4) var mr_map: texture_2d<f32>;
+@group(1) @binding(5) var normal_sampler: sampler;
+@group(1) @binding(6) var normal_map: texture_2d<f32>;
+@group(1) @binding(7) var occlusion_sampler: sampler;
+@group(1) @binding(8) var occlusion_map: texture_2d<f32>;
+@group(1) @binding(9) var emissive_sampler: sampler;
+@group(1) @binding(10) var emissive_map: texture_2d<f32>;
+
+struct VertexInput {
+  @location(0) position: vec3f,
+//#if HAS_NORMAL
+  @location(1) normal: vec3f,
+//#endif
+//#if HAS_UV
+  @location(2) uv: vec2f,
+//#endif
+//#if HAS_UV1
+  @location(7) uv1: vec2f,
+//#endif
+//#if HAS_TANGENT
+  @location(3) tangent: vec4f,
+//#endif
+//#if HAS_VERTEX_COLOR
+//#if COLOR_VEC3
+  @location(4) color: vec3f,
+//#else
+  @location(4) color: vec4f,
+//#endif
+//#endif
+//#if SKINNED
+  @location(5) joint: vec4u,
+  @location(6) weight: vec4f,
+//#endif
+};
+
+struct VertexOutput {
+  @builtin(position) position: vec4f,
+  @location(0) world_position: vec3f,
+  @location(1) normal: vec3f,
+  @location(2) uv: vec2f,
+  @location(3) color: vec4f,
+//#if HAS_TANGENT
+  @location(4) tangent: vec4f,
+//#endif
+  @location(5) uv1: vec2f,
+};
+
+@vertex fn vs_main(input: VertexInput) -> VertexOutput {
+  var output: VertexOutput;
+  var local_position = vec4f(input.position, 1.0);
+//#if SKINNED
+  let skin = input.weight.x * joints[input.joint.x] +
+             input.weight.y * joints[input.joint.y] +
+             input.weight.z * joints[input.joint.z] +
+             input.weight.w * joints[input.joint.w];
+  local_position = skin * local_position;
+//#endif
+  let world = object.model * local_position;
+  output.position = frame.view_proj * world;
+  output.world_position = world.xyz;
+//#if HAS_NORMAL
+  var local_normal = input.normal;
+//#if SKINNED
+  local_normal = (skin * vec4f(local_normal, 0.0)).xyz;
+//#endif
+  output.normal = normalize((object.normal_matrix * vec4f(local_normal, 0.0)).xyz);
+//#else
+  output.normal = vec3f(0.0, 1.0, 0.0);
+//#endif
+//#if HAS_UV
+  output.uv = input.uv;
+//#else
+  output.uv = vec2f(0.0);
+//#endif
+//#if HAS_UV1
+  output.uv1 = input.uv1;
+//#else
+  output.uv1 = output.uv;
+//#endif
+//#if HAS_VERTEX_COLOR
+//#if COLOR_VEC3
+  output.color = vec4f(input.color, 1.0);
+//#else
+  output.color = input.color;
+//#endif
+//#else
+  output.color = vec4f(1.0);
+//#endif
+//#if HAS_TANGENT
+  var local_tangent = input.tangent.xyz;
+//#if SKINNED
+  local_tangent = (skin * vec4f(local_tangent, 0.0)).xyz;
+//#endif
+  let world_tangent = normalize((object.model * vec4f(local_tangent, 0.0)).xyz);
+  output.tangent = vec4f(world_tangent, input.tangent.w);
+//#endif
+  return output;
+}
+
+fn distribution_ggx(n_dot_h: f32, roughness: f32) -> f32 {
+  let a = roughness * roughness;
+  let a2 = a * a;
+  let denominator = n_dot_h * n_dot_h * (a2 - 1.0) + 1.0;
+  return a2 / max(PI * denominator * denominator, 0.0001);
+}
+
+fn geometry_schlick(n_dot_v: f32, roughness: f32) -> f32 {
+  let r = roughness + 1.0;
+  let k = (r * r) / 8.0;
+  return n_dot_v / max(n_dot_v * (1.0 - k) + k, 0.0001);
+}
+
+fn fresnel_schlick(cos_theta: f32, f0: vec3f) -> vec3f {
+  return f0 + (vec3f(1.0) - f0) * pow(1.0 - cos_theta, 5.0);
+}
+
+fn cotangent_frame(surface_normal: vec3f, position: vec3f, uv: vec2f) -> mat3x3f {
+  let position_dx = dpdx(position);
+  let position_dy = dpdy(position);
+  let uv_dx = dpdx(uv);
+  let uv_dy = dpdy(uv);
+  let position_dy_perp = cross(position_dy, surface_normal);
+  let position_dx_perp = cross(surface_normal, position_dx);
+  let tangent = position_dy_perp * uv_dx.x + position_dx_perp * uv_dy.x;
+  let bitangent = position_dy_perp * uv_dx.y + position_dx_perp * uv_dy.y;
+  let squared_scale = max(dot(tangent, tangent), dot(bitangent, bitangent));
+  let inverse_scale = inverseSqrt(max(squared_scale, 1.0e-8));
+  return mat3x3f(
+    tangent * inverse_scale,
+    bitangent * inverse_scale,
+    surface_normal
+  );
+}
+
+@fragment fn fs_main(
+  input: VertexOutput,
+  @builtin(front_facing) front_facing: bool
+) -> @location(0) vec4f {
+  var base = material.base_color * input.color;
+  if (material.texture_flags.x != 0u) {
+    let source_uv = select(input.uv, input.uv1, material.uv_sets.x != 0u);
+    let uv = (material.base_color_uv_transform * vec3f(source_uv, 1.0)).xy;
+    base *= textureSample(base_color_map, base_color_sampler, uv);
+  }
+//#if ALPHA_MASK
+  if (base.a < material.alpha_cutoff) { discard; }
+//#endif
+  var metallic = material.factors.x;
+  var roughness = max(material.factors.y, 0.04);
+  if (material.texture_flags.y != 0u) {
+    let source_uv = select(input.uv, input.uv1, material.uv_sets.y != 0u);
+    let uv = (material.mr_uv_transform * vec3f(source_uv, 1.0)).xy;
+    let mr = textureSample(mr_map, mr_sampler, uv);
+    metallic *= mr.b;
+    roughness *= mr.g;
+  }
+  var normal = normalize(input.normal);
+//#if DOUBLE_SIDED
+  normal *= select(-1.0, 1.0, front_facing);
+//#endif
+  if (material.texture_flags.z != 0u) {
+    let source_uv = select(input.uv, input.uv1, material.uv_sets.z != 0u);
+    let uv = (material.normal_uv_transform * vec3f(source_uv, 1.0)).xy;
+    var mapped = textureSample(normal_map, normal_sampler, uv).xyz * 2.0 - 1.0;
+    mapped = vec3f(mapped.xy * material.factors.z, mapped.z);
+//#if HAS_TANGENT
+    let bitangent = normalize(cross(normal, input.tangent.xyz)) * input.tangent.w;
+    normal = normalize(mat3x3f(input.tangent.xyz, bitangent, normal) * mapped);
+//#else
+    normal = normalize(cotangent_frame(normal, input.world_position, uv) * mapped);
+//#endif
+  }
+  let view_direction = normalize(frame.camera_pos - input.world_position);
+  let f0 = mix(vec3f(0.04), base.rgb, metallic);
+  var result = frame.ambient * base.rgb * (1.0 - metallic);
+
+  for (var index = 0u; index < frame.light_count; index = index + 1u) {
+    let light = lights[index];
+    var light_direction = -light.direction;
+    var attenuation = 1.0;
+    if (light.kind != 0u) {
+      let to_light = light.position - input.world_position;
+      let distance = length(to_light);
+      light_direction = to_light / max(distance, 0.0001);
+      let ratio = distance / max(light.range, 0.0001);
+      attenuation = pow(clamp(1.0 - pow(ratio, 4.0), 0.0, 1.0), 2.0) /
+                    max(distance * distance, 0.0001);
+      if (light.kind == 2u) {
+        let angle = dot(-light_direction, light.direction);
+        attenuation *= smoothstep(light.cone.y, light.cone.x, angle);
+      }
+    }
+    let halfway = normalize(view_direction + light_direction);
+    let n_dot_l = max(dot(normal, light_direction), 0.0);
+    let n_dot_v = max(dot(normal, view_direction), 0.0);
+    let n_dot_h = max(dot(normal, halfway), 0.0);
+    let h_dot_v = max(dot(halfway, view_direction), 0.0);
+    let fresnel = fresnel_schlick(h_dot_v, f0);
+    let specular = distribution_ggx(n_dot_h, roughness) *
+                   geometry_schlick(n_dot_v, roughness) *
+                   geometry_schlick(n_dot_l, roughness) * fresnel /
+                   max(4.0 * n_dot_v * n_dot_l, 0.0001);
+    let diffuse = (vec3f(1.0) - fresnel) * (1.0 - metallic) * base.rgb / PI;
+    var visibility = 1.0;
+    if (light.kind == 0u && index == 0u && object.receive_shadow != 0u) {
+      visibility = shadow_visibility(input.world_position);
+    }
+    result += (diffuse + specular) * light.color * n_dot_l * attenuation * visibility;
+  }
+  var emissive = material.emissive.rgb * material.emissive.a;
+  if (material.emissive_map_flag != 0u) {
+    let source_uv = select(input.uv, input.uv1, material.emissive_uv_set != 0u);
+    let uv = (material.emissive_uv_transform * vec3f(source_uv, 1.0)).xy;
+    emissive *= textureSample(emissive_map, emissive_sampler, uv).rgb;
+  }
+  if (material.texture_flags.w != 0u) {
+    let source_uv = select(input.uv, input.uv1, material.uv_sets.w != 0u);
+    let uv = (material.occlusion_uv_transform * vec3f(source_uv, 1.0)).xy;
+    result *= mix(1.0, textureSample(occlusion_map, occlusion_sampler, uv).r,
+                  material.factors.w);
+  }
+  return vec4f(result + emissive, base.a);
+}

data/lib/stagecraft/renderer/shaders/shadow.wgsl

@@ -0,0 +1,37 @@
+struct FrameUniforms {
+  view_proj: mat4x4f,
+  camera_pos: vec3f,
+  time: f32,
+  ambient: vec3f,
+  light_count: u32,
+  light_vp: mat4x4f,
+};
+
+struct ObjectUniforms {
+  model: mat4x4f,
+  normal_matrix: mat4x4f,
+};
+
+@group(0) @binding(0) var<uniform> frame: FrameUniforms;
+@group(2) @binding(0) var<uniform> object: ObjectUniforms;
+@group(2) @binding(1) var<storage, read> joints: array<mat4x4f>;
+
+struct VertexInput {
+  @location(0) position: vec3f,
+//#if SKINNED
+  @location(5) joint: vec4u,
+  @location(6) weight: vec4f,
+//#endif
+};
+
+@vertex fn vs_main(input: VertexInput) -> @builtin(position) vec4f {
+  var local_position = vec4f(input.position, 1.0);
+//#if SKINNED
+  let skin = input.weight.x * joints[input.joint.x] +
+             input.weight.y * joints[input.joint.y] +
+             input.weight.z * joints[input.joint.z] +
+             input.weight.w * joints[input.joint.w];
+  local_position = skin * local_position;
+//#endif
+  return frame.light_vp * object.model * local_position;
+}

data/lib/stagecraft/renderer/shaders/skinning.wgsl

@@ -0,0 +1,6 @@
+fn skin_matrix(joint: vec4u, weight: vec4f) -> mat4x4f {
+  return weight.x * joints[joint.x] +
+         weight.y * joints[joint.y] +
+         weight.z * joints[joint.z] +
+         weight.w * joints[joint.w];
+}

data/lib/stagecraft/renderer/shaders/tonemap.wgsl

@@ -0,0 +1,37 @@
+@group(0) @binding(0) var hdr_texture: texture_2d<f32>;
+@group(0) @binding(1) var hdr_sampler: sampler;
+
+struct VertexOutput {
+  @builtin(position) position: vec4f,
+  @location(0) uv: vec2f,
+};
+
+@vertex fn vs_main(@builtin(vertex_index) index: u32) -> VertexOutput {
+  let positions = array<vec2f, 3>(
+    vec2f(-1.0, -1.0),
+    vec2f(3.0, -1.0),
+    vec2f(-1.0, 3.0)
+  );
+  var output: VertexOutput;
+  output.position = vec4f(positions[index], 0.0, 1.0);
+  output.uv = output.position.xy * vec2f(0.5, -0.5) + vec2f(0.5);
+  return output;
+}
+
+fn aces(color: vec3f) -> vec3f {
+  let a = 2.51;
+  let b = 0.03;
+  let c = 2.43;
+  let d = 0.59;
+  let e = 0.14;
+  return clamp((color * (a * color + b)) / (color * (c * color + d) + e), vec3f(0.0), vec3f(1.0));
+}
+
+@fragment fn fs_main(input: VertexOutput) -> @location(0) vec4f {
+  var color = aces(textureSample(hdr_texture, hdr_sampler, input.uv).rgb);
+//#if ENCODE_SRGB
+  color = select(12.92 * color, 1.055 * pow(color, vec3f(1.0 / 2.4)) - 0.055,
+                 color > vec3f(0.0031308));
+//#endif
+  return vec4f(color, 1.0);
+}

data/lib/stagecraft/renderer/shaders/unlit.wgsl

@@ -0,0 +1,89 @@
+//#include "common.wgsl"
+
+struct MaterialUniforms {
+  color: vec4f,
+  use_map: u32,
+  alpha_cutoff: f32,
+  uv_set: u32,
+  _padding: f32,
+  uv_transform: mat3x3f,
+};
+
+@group(1) @binding(0) var<uniform> material: MaterialUniforms;
+@group(1) @binding(1) var material_sampler: sampler;
+@group(1) @binding(2) var color_map: texture_2d<f32>;
+
+struct VertexInput {
+  @location(0) position: vec3f,
+//#if HAS_UV
+  @location(2) uv: vec2f,
+//#endif
+//#if HAS_UV1
+  @location(7) uv1: vec2f,
+//#endif
+//#if HAS_VERTEX_COLOR
+//#if COLOR_VEC3
+  @location(4) color: vec3f,
+//#else
+  @location(4) color: vec4f,
+//#endif
+//#endif
+//#if SKINNED
+  @location(5) joint: vec4u,
+  @location(6) weight: vec4f,
+//#endif
+};
+
+struct VertexOutput {
+  @builtin(position) position: vec4f,
+  @location(0) uv: vec2f,
+  @location(1) uv1: vec2f,
+  @location(2) color: vec4f,
+};
+
+@vertex fn vs_main(input: VertexInput) -> VertexOutput {
+  var output: VertexOutput;
+  var local_position = vec4f(input.position, 1.0);
+//#if SKINNED
+  let skin = input.weight.x * joints[input.joint.x] +
+             input.weight.y * joints[input.joint.y] +
+             input.weight.z * joints[input.joint.z] +
+             input.weight.w * joints[input.joint.w];
+  local_position = skin * local_position;
+//#endif
+  let world = object.model * local_position;
+  output.position = frame.view_proj * world;
+//#if HAS_UV
+  output.uv = input.uv;
+//#else
+  output.uv = vec2f(0.0);
+//#endif
+//#if HAS_UV1
+  output.uv1 = input.uv1;
+//#else
+  output.uv1 = output.uv;
+//#endif
+//#if HAS_VERTEX_COLOR
+//#if COLOR_VEC3
+  output.color = vec4f(input.color, 1.0);
+//#else
+  output.color = input.color;
+//#endif
+//#else
+  output.color = vec4f(1.0);
+//#endif
+  return output;
+}
+
+@fragment fn fs_main(input: VertexOutput) -> @location(0) vec4f {
+  var color = material.color * input.color;
+  if (material.use_map != 0u) {
+    let source_uv = select(input.uv, input.uv1, material.uv_set != 0u);
+    let uv = (material.uv_transform * vec3f(source_uv, 1.0)).xy;
+    color *= textureSample(color_map, material_sampler, uv);
+  }
+//#if ALPHA_MASK
+  if (color.a < material.alpha_cutoff) { discard; }
+//#endif
+  return color;
+}

data/lib/stagecraft/renderer/shaders.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Stagecraft
+  class Renderer
+    module Shaders
+      ROOT = File.expand_path("shaders", __dir__)
+      DIRECTIVE = %r{\A\s*//#(if|else|endif|include)\b(?:\s+["']?([^"'\s]+)["']?)?\s*\z}
+
+      module_function
+
+      def compose(name, defines: Set.new)
+        @cache ||= {}
+        key = [name.to_s, defines.to_a.map(&:to_s).sort].freeze
+        @cache[key] ||= process(read(name), defines.map(&:to_s).to_set, [name.to_s]).freeze
+      end
+
+      def clear_cache
+        @cache = {}
+      end
+
+      def read(name)
+        path = File.expand_path(name.to_s, ROOT)
+        raise ArgumentError, "shader path escapes shader root" unless path.start_with?("#{ROOT}/")
+        raise ArgumentError, "shader not found: #{name}" unless File.file?(path)
+
+        File.read(path)
+      end
+
+      def process(source, defines, stack)
+        enabled = [true]
+        output = []
+        source.each_line do |line|
+          match = DIRECTIVE.match(line)
+          unless match
+            output << line if enabled.last
+            next
+          end
+
+          operation, argument = match.captures
+          case operation
+          when "if"
+            enabled << (enabled.last && defines.include?(argument))
+          when "else"
+            parent_enabled = enabled[-2]
+            enabled[-1] = parent_enabled && !enabled[-1]
+          when "endif"
+            raise Error, "unmatched shader endif in #{stack.last}" if enabled.length == 1
+
+            enabled.pop
+          when "include"
+            next unless enabled.last
+            raise Error, "shader include cycle: #{[*stack, argument].join(" -> ")}" if stack.include?(argument)
+
+            output << process(read(argument), defines, [*stack, argument])
+          end
+        end
+        raise Error, "unterminated shader condition in #{stack.last}" unless enabled.length == 1
+
+        output.join
+      end
+      private_class_method :process
+    end
+  end
+end

data/lib/stagecraft/renderer/stats.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Stagecraft
+  class Renderer
+    class Stats
+      COUNTERS = %i[draw_calls triangles buffers textures pipelines visible_objects culled_objects].freeze
+
+      attr_reader(*COUNTERS)
+
+      def initialize
+        COUNTERS.each { |counter| instance_variable_set(:"@#{counter}", 0) }
+      end
+
+      def reset_frame!
+        @draw_calls = 0
+        @triangles = 0
+        @visible_objects = 0
+        @culled_objects = 0
+        self
+      end
+
+      def increment(counter, amount = 1)
+        raise ArgumentError, "unknown stats counter #{counter.inspect}" unless COUNTERS.include?(counter)
+
+        instance_variable_set(:"@#{counter}", public_send(counter) + amount)
+      end
+
+      def decrement(counter, amount = 1)
+        increment(counter, -amount)
+      end
+
+      def to_h
+        COUNTERS.to_h { |counter| [counter, public_send(counter)] }
+      end
+
+      def to_s
+        to_h.map { |name, value| "#{name}=#{value}" }.join(" ")
+      end
+    end
+  end
+end

data/lib/stagecraft/renderer/uniform_packer.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Stagecraft
+  class Renderer
+    class UniformPacker
+      Field = Data.define(:name, :type, :offset, :size, :alignment, :value)
+      Result = Data.define(:bytes, :fields, :struct_source, :textures)
+
+      TYPE_INFO = {
+        f32: [4, 4], u32: [4, 4],
+        vec2f: [8, 8], vec3f: [16, 12], vec4f: [16, 16],
+        mat4x4f: [16, 64]
+      }.freeze
+
+      def pack(uniforms = nil, struct_name: "MaterialUniforms", **keyword_uniforms)
+        uniforms = (uniforms || {}).merge(keyword_uniforms)
+        offset = 0
+        fields = []
+        textures = []
+        uniforms.each do |name, value|
+          if texture?(value)
+            textures << [name.to_sym, value]
+            next
+          end
+
+          type, normalized = infer(value)
+          alignment, size = TYPE_INFO.fetch(type)
+          offset = align(offset, alignment)
+          fields << Field.new(name: name.to_sym, type:, offset:, size:, alignment:, value: normalized)
+          offset += size
+        end
+        total_size = align(offset, [fields.map(&:alignment).max || 1, 16].max)
+        bytes = "\0".b * total_size
+        fields.each { |field| write(bytes, field) }
+        Result.new(
+          bytes: bytes.freeze,
+          fields: fields.freeze,
+          struct_source: declaration(struct_name, fields),
+          textures: textures.freeze
+        )
+      end
+
+      private
+
+      def infer(value)
+        case value
+        when Integer then [:u32, value]
+        when Numeric then [:f32, value.to_f]
+        when Color then [:vec4f, value.to_a]
+        when Larb::Vec2 then [:vec2f, value.to_a]
+        when Larb::Vec3 then [:vec3f, value.to_a]
+        when Larb::Vec4, Larb::Quat then [:vec4f, value.to_a]
+        when Larb::Mat4 then [:mat4x4f, value.to_a]
+        when Array then infer_array(value)
+        else
+          if value.respond_to?(:to_larb)
+            infer(value.to_larb)
+          else
+            raise ArgumentError, "unsupported uniform #{value.class}"
+          end
+        end
+      end
+
+      def infer_array(value)
+        type = { 2 => :vec2f, 3 => :vec3f, 4 => :vec4f, 16 => :mat4x4f }[value.length]
+        raise ArgumentError, "uniform arrays must contain 2, 3, 4, or 16 numbers" unless type
+        raise ArgumentError, "uniform arrays must be numeric" unless value.all? { |item| item.is_a?(Numeric) }
+
+        [type, value.map(&:to_f)]
+      end
+
+      def texture?(value)
+        value.is_a?(Textures::Texture)
+      end
+
+      def align(value, alignment)
+        ((value + alignment - 1) / alignment) * alignment
+      end
+
+      def write(bytes, field)
+        packed = field.type == :u32 ? [field.value].pack("L<") : Array(field.value).pack("e*")
+        bytes[field.offset, packed.bytesize] = packed
+      end
+
+      def declaration(name, fields)
+        body = fields.map { |field| "  #{field.name}: #{field.type}," }.join("\n")
+        "struct #{name} {\n#{body}\n};"
+      end
+    end
+  end
+end

data/lib/stagecraft/renderer/wgpu_compatibility.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Stagecraft
+  class Renderer
+    module WGPUCompatibility
+      module_function
+
+      def install!
+        return unless defined?(::WGPU::Native::TextureViewDescriptor)
+
+        native = ::WGPU::Native
+        descriptor = native::TextureViewDescriptor
+        return if descriptor.members.include?(:usage)
+
+        native.send(:remove_const, :TextureViewDescriptor)
+        native.const_set(:TextureViewDescriptor, texture_view_descriptor_class(native))
+      end
+
+      def texture_view_descriptor_class(native)
+        Class.new(FFI::Struct) do
+          layout :next_in_chain, :pointer,
+                 :label, native::StringView,
+                 :format, native::TextureFormat,
+                 :dimension, native::TextureViewDimension,
+                 :base_mip_level, :uint32,
+                 :mip_level_count, :uint32,
+                 :base_array_layer, :uint32,
+                 :array_layer_count, :uint32,
+                 :aspect, native::TextureAspect,
+                 :usage, :uint64
+
+          def initialize(*arguments)
+            super
+            self[:usage] = 0
+          end
+        end
+      end
+      private_class_method :texture_view_descriptor_class
+    end
+  end
+end

data/lib/stagecraft/textures/cube_texture.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Stagecraft
+  module Textures
+    class CubeTexture < Texture
+      attr_reader :faces
+
+      def initialize(faces, **)
+        raise ArgumentError, "cube texture requires six faces" unless faces.length == 6
+
+        @faces = faces.freeze
+        super(nil, **)
+      end
+    end
+  end
+end