Module: RLSL::UniformTypes::ValueNormalizer

Included in:
RLSL::UniformTypes
Defined in:
lib/rlsl/types/value_normalizer.rb

Instance Method Summary collapse

Instance Method Details

#normalize_bool(value, name:, shader_name: nil) ⇒ Object

Raises:

  • (ArgumentError) 


42
43
44
45
46
47
48
 
# File 'lib/rlsl/types/value_normalizer.rb', line 42

def normalize_bool(value, name:, shader_name: nil)
  return value if value == true || value == false
  return false if value == 0
  return true if value == 1

  raise ArgumentError, invalid_uniform_message(name, :bool, value, shader_name)
end

#normalize_value(type, value, name:, shader_name: nil) ⇒ Object 



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/rlsl/types/value_normalizer.rb', line 16

def normalize_value(type, value, name:, shader_name: nil)
  return value if type.nil?

  spec = fetch(type)
  raise ArgumentError, unsupported_runtime_type_message(type, shader_name) unless spec.runtime_supported?

  case spec.wrapper_kind
  when :float
    Float(value)
  when :int
    Integer(value)
  when :bool
    normalize_bool(value, name: name, shader_name: shader_name)
  when :vector
    normalize_vector(value, spec.vector_size, name: name, shader_name: shader_name)
  else
    raise ArgumentError, unsupported_runtime_type_message(type, shader_name)
  end
rescue TypeError
  raise ArgumentError, invalid_uniform_message(name, type, value, shader_name)
rescue ArgumentError => e
  raise e if e.message.start_with?("Invalid value for uniform", "Unsupported runtime uniform type")

  raise ArgumentError, invalid_uniform_message(name, type, value, shader_name)
end

#normalize_values(uniform_types, uniforms, shader_name: nil) ⇒ Object 



6
7
8
9
10
11
12
13
14
 
# File 'lib/rlsl/types/value_normalizer.rb', line 6

def normalize_values(uniform_types, uniforms, shader_name: nil)
  uniform_types.each_with_object({}) do |(name, type), normalized|
    unless uniforms.key?(name)
      raise ArgumentError, missing_uniform_message(name, shader_name)
    end

    normalized[name] = normalize_value(type, uniforms[name], name: name, shader_name: shader_name)
  end
end

#normalize_vector(value, vector_size, name:, shader_name: nil) ⇒ Object 



50
51
52
53
54
55
56
 
# File 'lib/rlsl/types/value_normalizer.rb', line 50

def normalize_vector(value, vector_size, name:, shader_name: nil)
  unless value.is_a?(Array) && value.length == vector_size
    raise ArgumentError, invalid_vector_message(name, vector_size, value, shader_name)
  end

  value.map { |component| Float(component) }
end