Module: RLSL::Prism::Builtins::FunctionRegistry

Defined in:
lib/rlsl/prism/builtins/function_registry.rb

Constant Summary collapse

ALL_TARGETS = 
%i[c glsl wgsl msl].freeze
META_TYPES = 
%i[any same first second third].freeze
FUNCTIONS = 
{
  vec2: { args: %i[any any], returns: :vec2, variadic: true, min_args: 1 },
  vec3: { args: %i[any any any], returns: :vec3, variadic: true, min_args: 1 },
  vec4: { args: %i[any any any any], returns: :vec4, variadic: true, min_args: 1 },

  mat2: { args: %i[any any any any], returns: :mat2, variadic: true, min_args: 1 },
  mat3: { args: %i[any any any any any any any any any], returns: :mat3, variadic: true, min_args: 1 },
  mat4: { args: %i[any any any any any any any any any any any any any any any any], returns: :mat4, variadic: true, min_args: 1 },

  sin: { args: [:float], returns: :float },
  cos: { args: [:float], returns: :float },
  tan: { args: [:float], returns: :float },
  asin: { args: [:float], returns: :float },
  acos: { args: [:float], returns: :float },
  atan: { args: %i[float float], returns: :float, variadic: true, min_args: 1 },
  atan2: { args: %i[float float], returns: :float },

  pow: { args: %i[float float], returns: :float },
  exp: { args: [:float], returns: :float },
  log: { args: [:float], returns: :float },
  sqrt: { args: [:any], returns: :same },

  abs: { args: [:any], returns: :same },
  sign: { args: [:any], returns: :same },
  floor: { args: [:any], returns: :same },
  ceil: { args: [:any], returns: :same },
  fract: { args: [:any], returns: :same },
  mod: { args: %i[any float], returns: :first },
  min: { args: %i[any any], returns: :first },
  max: { args: %i[any any], returns: :first },
  clamp: { args: %i[any any any], returns: :first },
  mix: { args: %i[any any float], returns: :first },
  step: { args: %i[float any], returns: :second },
  smoothstep: { args: %i[float float any], returns: :third },

  length: { args: [:any], returns: :float },
  distance: { args: %i[any any], returns: :float },
  dot: { args: %i[any any], returns: :float },
  cross: { args: %i[vec3 vec3], returns: :vec3 },
  normalize: { args: [:any], returns: :same },
  reflect: { args: %i[any any], returns: :first },
  refract: { args: %i[any any float], returns: :first },

  hash21: { args: [:vec2], returns: :float },
  hash22: { args: [:vec2], returns: :vec2 },

  lessThan: { args: %i[any any], returns: :bool },
  lessThanEqual: { args: %i[any any], returns: :bool },
  greaterThan: { args: %i[any any], returns: :bool },
  greaterThanEqual: { args: %i[any any], returns: :bool },
  equal: { args: %i[any any], returns: :bool },
  notEqual: { args: %i[any any], returns: :bool },

  inverse: { args: [:any], returns: :same, targets: %i[glsl wgsl msl] },
  transpose: { args: [:any], returns: :same, targets: %i[glsl wgsl msl] },
  determinant: { args: [:any], returns: :float, targets: %i[glsl wgsl msl] },

  texture2D: { args: %i[sampler2D vec2], returns: :vec4 },
  texture: { args: %i[sampler2D vec2], returns: :vec4 },
  textureLod: { args: %i[sampler2D vec2 float], returns: :vec4 }
}.freeze

Class Method Summary collapse

Class Method Details

.explicit_type?(type) ⇒ Boolean

Returns:



108
109
110
 
# File 'lib/rlsl/prism/builtins/function_registry.rb', line 108

def explicit_type?(type)
  type.is_a?(Symbol) && !META_TYPES.include?(type)
end

.explicit_types(name) ⇒ Object 



89
90
91
92
93
94
95
96
 
# File 'lib/rlsl/prism/builtins/function_registry.rb', line 89

def explicit_types(name)
  signature = function_signature(name)
  return [] unless signature

  ([signature[:returns]] + Array(signature[:args])).filter_map do |type|
    type if explicit_type?(type)
  end.uniq
end

.function?(name) ⇒ Boolean

Returns:



74
75
76
 
# File 'lib/rlsl/prism/builtins/function_registry.rb', line 74

def function?(name)
  FUNCTIONS.key?(name.to_sym)
end

.function_signature(name) ⇒ Object 



78
79
80
 
# File 'lib/rlsl/prism/builtins/function_registry.rb', line 78

def function_signature(name)
  FUNCTIONS[name.to_sym]
end

.resolve_return_type(rule, arg_types) ⇒ Object 



98
99
100
101
102
103
104
105
106
 
# File 'lib/rlsl/prism/builtins/function_registry.rb', line 98

def resolve_return_type(rule, arg_types)
  case rule
  when :same then arg_types.first
  when :first then arg_types.first
  when :second then arg_types[1]
  when :third then arg_types[2]
  when Symbol then rule
  end
end

.supported_on_target?(name, target) ⇒ Boolean

Returns:



82
83
84
85
86
87
 
# File 'lib/rlsl/prism/builtins/function_registry.rb', line 82

def supported_on_target?(name, target)
  signature = function_signature(name)
  return false unless signature

  Array(signature[:targets] || ALL_TARGETS).include?(target.to_sym)
end