Updated glsl-optimizer.
This commit is contained in:
parent
475b0d1cf3
commit
7bca603f15
22
3rdparty/glsl-optimizer/Changelog.md
vendored
22
3rdparty/glsl-optimizer/Changelog.md
vendored
@ -1,9 +1,31 @@
|
||||
GLSL optimizer Change Log
|
||||
=========================
|
||||
|
||||
2015 06
|
||||
-------
|
||||
|
||||
Fixes:
|
||||
|
||||
* Fixed some cases of different precision matrix assignments being miscompiled on Metal.
|
||||
* Fixed yet more issues with translation of weird loops.
|
||||
* Fixed translation of matrix+scalar, matrix-scalar, matrix/scalar operations on Metal.
|
||||
|
||||
|
||||
2015 05
|
||||
-------
|
||||
|
||||
Fixes:
|
||||
|
||||
* Fixes some cases of highp/mediump sampler sampling resulting in resulting temporaries wrongly being lowp.
|
||||
|
||||
|
||||
2015 04
|
||||
-------
|
||||
|
||||
Goodies:
|
||||
* GLES2: support EXT_draw_instanced / gl_InstanceIDEXT.
|
||||
* Support gl_VertexID in GLSL < 1.30 when EXT_gpu_shader4 is used.
|
||||
|
||||
Fixes:
|
||||
|
||||
* Metal: fixed some bugs with translation of weird loops.
|
||||
|
@ -1212,7 +1212,7 @@ emit_inline_matrix_constructor(const glsl_type *type, int ast_precision,
|
||||
*
|
||||
* - Construct a matrix from an arbirary combination of vectors and
|
||||
* scalars. The components of the constructor parameters are assigned
|
||||
* to the matrix in colum-major order until the matrix is full.
|
||||
* to the matrix in column-major order until the matrix is full.
|
||||
*
|
||||
* - Construct a matrix from a single matrix. The source matrix is copied
|
||||
* to the upper left portion of the constructed matrix, and the remaining
|
||||
|
10
3rdparty/glsl-optimizer/src/glsl/ast_to_hir.cpp
vendored
10
3rdparty/glsl-optimizer/src/glsl/ast_to_hir.cpp
vendored
@ -3136,13 +3136,13 @@ process_initializer(ir_variable *var, ast_declaration *decl,
|
||||
|
||||
static void
|
||||
apply_precision_to_variable(const struct ast_type_qualifier& qual,
|
||||
ir_variable *var,
|
||||
ir_variable *var, bool function_param,
|
||||
struct _mesa_glsl_parse_state *state)
|
||||
{
|
||||
if (!state->es_shader)
|
||||
return;
|
||||
if (var->type->is_sampler() && qual.precision == ast_precision_none)
|
||||
var->data.precision = ast_precision_low; // samplers default to low precision
|
||||
if (var->type->is_sampler() && qual.precision == ast_precision_none && !function_param)
|
||||
var->data.precision = ast_precision_low; // samplers default to low precision (outside of function arguments)
|
||||
else
|
||||
var->data.precision = qual.precision;
|
||||
}
|
||||
@ -3548,7 +3548,7 @@ ast_declarator_list::hir(exec_list *instructions,
|
||||
|
||||
apply_type_qualifier_to_variable(& this->type->qualifier, var, state,
|
||||
& loc, false);
|
||||
apply_precision_to_variable(this->type->qualifier, var, state);
|
||||
apply_precision_to_variable(this->type->qualifier, var, false, state);
|
||||
|
||||
if (this->type->qualifier.flags.q.invariant) {
|
||||
if (!is_varying_var(var, state->stage)) {
|
||||
@ -4005,7 +4005,7 @@ ast_parameter_declarator::hir(exec_list *instructions,
|
||||
*/
|
||||
apply_type_qualifier_to_variable(& this->type->qualifier, var, state, & loc,
|
||||
true);
|
||||
apply_precision_to_variable(this->type->qualifier, var, state);
|
||||
apply_precision_to_variable(this->type->qualifier, var, true, state);
|
||||
|
||||
/* From section 4.1.7 of the GLSL 4.40 spec:
|
||||
*
|
||||
|
@ -830,10 +830,12 @@ void
|
||||
builtin_variable_generator::generate_vs_special_vars()
|
||||
{
|
||||
|
||||
if (state->is_version(130, 300))
|
||||
if (state->is_version(130, 300) || state->EXT_gpu_shader4_enable)
|
||||
add_system_value(SYSTEM_VALUE_VERTEX_ID, state->metal_target ? uint_t : int_t, "gl_VertexID", glsl_precision_high);
|
||||
if (state->ARB_draw_instanced_enable)
|
||||
add_system_value(SYSTEM_VALUE_INSTANCE_ID, int_t, "gl_InstanceIDARB", glsl_precision_high);
|
||||
if (state->EXT_draw_instanced_enable)
|
||||
add_system_value(SYSTEM_VALUE_INSTANCE_ID, int_t, "gl_InstanceIDEXT", glsl_precision_high);
|
||||
if (state->ARB_draw_instanced_enable || state->is_version(140, 300))
|
||||
add_system_value(SYSTEM_VALUE_INSTANCE_ID, state->metal_target ? uint_t : int_t, "gl_InstanceID", glsl_precision_high);
|
||||
if (state->AMD_vertex_shader_layer_enable)
|
||||
|
@ -3727,7 +3727,7 @@ _arguments_parse (argument_list_t *arguments,
|
||||
else {
|
||||
if (argument->head == NULL) {
|
||||
/* Don't treat initial whitespace as
|
||||
* part of the arguement. */
|
||||
* part of the argument. */
|
||||
if (node->token->type == SPACE)
|
||||
continue;
|
||||
}
|
||||
@ -4679,6 +4679,9 @@ _glcpp_parser_handle_version_declaration(glcpp_parser_t *parser, intmax_t versio
|
||||
if (extensions->ARB_draw_instanced)
|
||||
add_builtin_define(parser, "GL_ARB_draw_instanced", 1);
|
||||
|
||||
if (extensions->EXT_draw_instanced)
|
||||
add_builtin_define(parser, "GL_EXT_draw_instanced", 1);
|
||||
|
||||
if (extensions->ARB_conservative_depth) {
|
||||
add_builtin_define(parser, "GL_AMD_conservative_depth", 1);
|
||||
add_builtin_define(parser, "GL_ARB_conservative_depth", 1);
|
||||
|
@ -1462,7 +1462,7 @@ _arguments_parse (argument_list_t *arguments,
|
||||
else {
|
||||
if (argument->head == NULL) {
|
||||
/* Don't treat initial whitespace as
|
||||
* part of the arguement. */
|
||||
* part of the argument. */
|
||||
if (node->token->type == SPACE)
|
||||
continue;
|
||||
}
|
||||
@ -2414,6 +2414,9 @@ _glcpp_parser_handle_version_declaration(glcpp_parser_t *parser, intmax_t versio
|
||||
if (extensions->ARB_draw_instanced)
|
||||
add_builtin_define(parser, "GL_ARB_draw_instanced", 1);
|
||||
|
||||
if (extensions->EXT_draw_instanced)
|
||||
add_builtin_define(parser, "GL_EXT_draw_instanced", 1);
|
||||
|
||||
if (extensions->ARB_conservative_depth) {
|
||||
add_builtin_define(parser, "GL_AMD_conservative_depth", 1);
|
||||
add_builtin_define(parser, "GL_ARB_conservative_depth", 1);
|
||||
|
@ -265,6 +265,21 @@ static void propagate_precision_expr(ir_instruction *ir, void *data)
|
||||
|
||||
}
|
||||
|
||||
static void propagate_precision_texture(ir_instruction *ir, void *data)
|
||||
{
|
||||
ir_texture* tex = ir->as_texture();
|
||||
if (!tex)
|
||||
return;
|
||||
|
||||
glsl_precision sampler_prec = tex->sampler->get_precision();
|
||||
if (tex->get_precision() == sampler_prec || sampler_prec == glsl_precision_undefined)
|
||||
return;
|
||||
|
||||
// set precision of ir_texture node to that of the sampler itself
|
||||
tex->set_precision(sampler_prec);
|
||||
((precision_ctx*)data)->res = true;
|
||||
}
|
||||
|
||||
struct undefined_ass_ctx
|
||||
{
|
||||
ir_variable* var;
|
||||
@ -381,8 +396,19 @@ static bool propagate_precision(exec_list* list, bool assign_high_to_undefined)
|
||||
ctx.root_ir = list;
|
||||
foreach_in_list(ir_instruction, ir, list)
|
||||
{
|
||||
visit_tree (ir, propagate_precision_texture, &ctx);
|
||||
visit_tree (ir, propagate_precision_deref, &ctx);
|
||||
bool hadProgress = ctx.res;
|
||||
ctx.res = false;
|
||||
visit_tree (ir, propagate_precision_assign, &ctx);
|
||||
if (ctx.res)
|
||||
{
|
||||
// assignment precision propagation might have added precision
|
||||
// to some variables; need to propagate dereference precision right
|
||||
// after that too.
|
||||
visit_tree (ir, propagate_precision_deref, &ctx);
|
||||
}
|
||||
ctx.res |= hadProgress;
|
||||
visit_tree (ir, propagate_precision_call, &ctx);
|
||||
visit_tree (ir, propagate_precision_expr, &ctx);
|
||||
}
|
||||
|
@ -562,7 +562,9 @@ static const _mesa_glsl_extension _mesa_glsl_supported_extensions[] = {
|
||||
EXT(AMD_vertex_shader_layer, true, false, AMD_vertex_shader_layer),
|
||||
EXT(AMD_vertex_shader_viewport_index, true, false, AMD_vertex_shader_viewport_index),
|
||||
EXT(EXT_draw_buffers, false, true, EXT_draw_buffers),
|
||||
EXT(EXT_draw_instanced, false, true, EXT_draw_instanced),
|
||||
EXT(EXT_frag_depth, false, true, EXT_frag_depth),
|
||||
EXT(EXT_gpu_shader4, true, false, EXT_gpu_shader4),
|
||||
EXT(EXT_separate_shader_objects, false, true, dummy_true),
|
||||
EXT(EXT_shader_framebuffer_fetch, false, true, EXT_shader_framebuffer_fetch),
|
||||
EXT(EXT_shader_integer_mix, true, true, EXT_shader_integer_mix),
|
||||
|
@ -473,8 +473,12 @@ struct _mesa_glsl_parse_state {
|
||||
bool AMD_vertex_shader_viewport_index_warn;
|
||||
bool EXT_draw_buffers_enable;
|
||||
bool EXT_draw_buffers_warn;
|
||||
bool EXT_draw_instanced_enable;
|
||||
bool EXT_draw_instanced_warn;
|
||||
bool EXT_frag_depth_enable;
|
||||
bool EXT_frag_depth_warn;
|
||||
bool EXT_gpu_shader4_enable;
|
||||
bool EXT_gpu_shader4_warn;
|
||||
bool EXT_separate_shader_objects_enable;
|
||||
bool EXT_separate_shader_objects_warn;
|
||||
bool EXT_shader_framebuffer_fetch_enable;
|
||||
|
@ -642,7 +642,7 @@ glsl_type::field_type(const char *name) const
|
||||
return error_type;
|
||||
}
|
||||
|
||||
glsl_precision
|
||||
const glsl_precision
|
||||
glsl_type::field_precision(const char *name) const
|
||||
{
|
||||
if (this->base_type != GLSL_TYPE_STRUCT)
|
||||
|
@ -231,6 +231,10 @@ _mesa_print_ir_glsl(exec_list *instructions,
|
||||
}
|
||||
if (state->ARB_shader_texture_lod_enable)
|
||||
str.asprintf_append ("#extension GL_ARB_shader_texture_lod : enable\n");
|
||||
if (state->ARB_draw_instanced_enable)
|
||||
str.asprintf_append ("#extension GL_ARB_draw_instanced : enable\n");
|
||||
if (state->EXT_gpu_shader4_enable)
|
||||
str.asprintf_append ("#extension GL_EXT_gpu_shader4 : enable\n");
|
||||
if (state->EXT_shader_texture_lod_enable)
|
||||
str.asprintf_append ("#extension GL_EXT_shader_texture_lod : enable\n");
|
||||
if (state->OES_standard_derivatives_enable)
|
||||
@ -242,7 +246,9 @@ _mesa_print_ir_glsl(exec_list *instructions,
|
||||
if (state->es_shader && state->language_version < 300)
|
||||
{
|
||||
if (state->EXT_draw_buffers_enable)
|
||||
str.asprintf_append ("#extension GL_EXT_draw_buffers : require\n");
|
||||
str.asprintf_append ("#extension GL_EXT_draw_buffers : enable\n");
|
||||
if (state->EXT_draw_instanced_enable)
|
||||
str.asprintf_append ("#extension GL_EXT_draw_instanced : enable\n");
|
||||
}
|
||||
if (state->EXT_shader_framebuffer_fetch_enable)
|
||||
str.asprintf_append ("#extension GL_EXT_shader_framebuffer_fetch : enable\n");
|
||||
@ -823,7 +829,7 @@ void ir_print_glsl_visitor::visit(ir_texture *ir)
|
||||
sampler_uv_dim += 1;
|
||||
const bool is_proj = (uv_dim > sampler_uv_dim);
|
||||
const bool is_lod = (ir->op == ir_txl);
|
||||
|
||||
|
||||
#if 0 // BK - disable LOD workarounds.
|
||||
if (is_lod && state->es_shader && state->language_version < 300 && state->stage == MESA_SHADER_FRAGMENT)
|
||||
{
|
||||
@ -855,6 +861,7 @@ void ir_print_glsl_visitor::visit(ir_texture *ir)
|
||||
}
|
||||
#endif // 0
|
||||
|
||||
|
||||
// texture function name
|
||||
//ACS: shadow lookups and lookups with dimensionality included in the name were deprecated in 130
|
||||
if(state->language_version<130)
|
||||
|
@ -101,6 +101,7 @@ struct metal_print_context
|
||||
, paramsStr(ralloc_strdup(buffer, ""))
|
||||
, writingParams(false)
|
||||
, matrixCastsDone(false)
|
||||
, matrixConstructorsDone(false)
|
||||
, shadowSamplerDone(false)
|
||||
, textureCounter(0)
|
||||
, attributeCounter(0)
|
||||
@ -118,6 +119,7 @@ struct metal_print_context
|
||||
string_buffer paramsStr;
|
||||
bool writingParams;
|
||||
bool matrixCastsDone;
|
||||
bool matrixConstructorsDone;
|
||||
bool shadowSamplerDone;
|
||||
int textureCounter;
|
||||
int attributeCounter;
|
||||
@ -940,22 +942,57 @@ void ir_print_metal_visitor::visit(ir_expression *ir)
|
||||
bool op0cast = ir->operands[0] && is_different_precision(arg_prec, ir->operands[0]->get_precision());
|
||||
bool op1cast = ir->operands[1] && is_different_precision(arg_prec, ir->operands[1]->get_precision());
|
||||
bool op2cast = ir->operands[2] && is_different_precision(arg_prec, ir->operands[2]->get_precision());
|
||||
const bool op0matrix = ir->operands[0] && ir->operands[0]->type->is_matrix();
|
||||
const bool op1matrix = ir->operands[1] && ir->operands[1]->type->is_matrix();
|
||||
bool op0castTo1 = false;
|
||||
bool op1castTo0 = false;
|
||||
|
||||
// Metal does not support matrix precision casts, so when any of the arguments is a matrix,
|
||||
// take precision from it. This isn't fully robust now, but oh well.
|
||||
if (op0cast && ir->operands[0]->type->is_matrix() && !op1cast)
|
||||
if (op0cast && op0matrix && !op1cast)
|
||||
{
|
||||
op0cast = false;
|
||||
arg_prec = ir->operands[0]->get_precision();
|
||||
op1cast = ir->operands[1] && is_different_precision(arg_prec, ir->operands[1]->get_precision());
|
||||
}
|
||||
if (op1cast && ir->operands[1]->type->is_matrix() && !op0cast)
|
||||
if (op1cast && op1matrix && !op0cast)
|
||||
{
|
||||
op1cast = false;
|
||||
arg_prec = ir->operands[1]->get_precision();
|
||||
op0cast = ir->operands[0] && is_different_precision(arg_prec, ir->operands[0]->get_precision());
|
||||
}
|
||||
|
||||
// Metal does not have matrix+scalar and matrix-scalar operations; we need to create matrices
|
||||
// out of the non-matrix argument.
|
||||
if (ir->operation == ir_binop_add || ir->operation == ir_binop_sub)
|
||||
{
|
||||
if (op0matrix && !op1matrix)
|
||||
{
|
||||
op1cast = true;
|
||||
op1castTo0 = true;
|
||||
}
|
||||
if (op1matrix && !op0matrix)
|
||||
{
|
||||
op0cast = true;
|
||||
op0castTo1 = true;
|
||||
}
|
||||
if (op1castTo0 || op0castTo1)
|
||||
{
|
||||
if (!ctx.matrixConstructorsDone)
|
||||
{
|
||||
ctx.prefixStr.asprintf_append(
|
||||
"inline float4x4 _xlinit_float4x4(float v) { return float4x4(float4(v), float4(v), float4(v), float4(v)); }\n"
|
||||
"inline float3x3 _xlinit_float3x3(float v) { return float3x3(float3(v), float3(v), float3(v)); }\n"
|
||||
"inline float2x2 _xlinit_float2x2(float v) { return float2x2(float2(v), float2(v)); }\n"
|
||||
"inline half4x4 _xlinit_half4x4(half v) { return half4x4(half4(v), half4(v), half4(v), half4(v)); }\n"
|
||||
"inline half3x3 _xlinit_half3x3(half v) { return half3x3(half3(v), half3(v), half3(v)); }\n"
|
||||
"inline half2x2 _xlinit_half2x2(half v) { return half2x2(half2(v), half2(v)); }\n"
|
||||
);
|
||||
ctx.matrixConstructorsDone = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const bool rescast = is_different_precision(arg_prec, res_prec) && !ir->type->is_boolean();
|
||||
if (rescast)
|
||||
{
|
||||
@ -1000,6 +1037,7 @@ void ir_print_metal_visitor::visit(ir_expression *ir)
|
||||
}
|
||||
else if (is_binop_func_like(ir->operation, ir->type))
|
||||
{
|
||||
// binary operation that must be printed like a function, "foo(a,b)"
|
||||
if (ir->operation == ir_binop_mod)
|
||||
{
|
||||
buffer.asprintf_append ("(");
|
||||
@ -1025,23 +1063,58 @@ void ir_print_metal_visitor::visit(ir_expression *ir)
|
||||
if (ir->operation == ir_binop_mod)
|
||||
buffer.asprintf_append ("))");
|
||||
}
|
||||
else if (ir->get_num_operands() == 2 && ir->operation == ir_binop_div && op0matrix && !op1matrix)
|
||||
{
|
||||
// "matrix/scalar" - Metal does not have it, so print multiply by inverse instead
|
||||
buffer.asprintf_append ("(");
|
||||
ir->operands[0]->accept(this);
|
||||
const bool halfCast = (arg_prec == glsl_precision_medium || arg_prec == glsl_precision_low);
|
||||
buffer.asprintf_append (halfCast ? " * (1.0h/half(" : " * (1.0/(");
|
||||
ir->operands[1]->accept(this);
|
||||
buffer.asprintf_append (")))");
|
||||
}
|
||||
else if (ir->get_num_operands() == 2)
|
||||
{
|
||||
// regular binary operator
|
||||
buffer.asprintf_append ("(");
|
||||
if (ir->operands[0])
|
||||
{
|
||||
if (op0cast)
|
||||
if (op0castTo1)
|
||||
{
|
||||
buffer.asprintf_append ("_xlinit_");
|
||||
print_type_precision(buffer, ir->operands[1]->type, arg_prec, false);
|
||||
buffer.asprintf_append ("(");
|
||||
}
|
||||
else if (op0cast)
|
||||
{
|
||||
print_cast (buffer, arg_prec, ir->operands[0]);
|
||||
}
|
||||
ir->operands[0]->accept(this);
|
||||
if (op0castTo1)
|
||||
{
|
||||
buffer.asprintf_append (")");
|
||||
}
|
||||
}
|
||||
|
||||
buffer.asprintf_append (" %s ", operator_glsl_strs[ir->operation]);
|
||||
|
||||
if (ir->operands[1])
|
||||
{
|
||||
if (op1cast)
|
||||
if (op1castTo0)
|
||||
{
|
||||
buffer.asprintf_append ("_xlinit_");
|
||||
print_type_precision(buffer, ir->operands[0]->type, arg_prec, false);
|
||||
buffer.asprintf_append ("(");
|
||||
}
|
||||
else if (op1cast)
|
||||
{
|
||||
print_cast (buffer, arg_prec, ir->operands[1]);
|
||||
}
|
||||
ir->operands[1]->accept(this);
|
||||
if (op1castTo0)
|
||||
{
|
||||
buffer.asprintf_append (")");
|
||||
}
|
||||
}
|
||||
buffer.asprintf_append (")");
|
||||
}
|
||||
|
@ -256,7 +256,7 @@ namespace {
|
||||
*
|
||||
* As uniforms are added to the active set the number of active uniforms and
|
||||
* the storage requirements for those uniforms are accumulated. The active
|
||||
* uniforms are added the the hash table supplied to the constructor.
|
||||
* uniforms are added to the hash table supplied to the constructor.
|
||||
*
|
||||
* If the same uniform is added multiple times (i.e., once for each shader
|
||||
* target), it will only be accounted once.
|
||||
|
108
3rdparty/glsl-optimizer/src/glsl/loop_analysis.cpp
vendored
108
3rdparty/glsl-optimizer/src/glsl/loop_analysis.cpp
vendored
@ -28,6 +28,8 @@
|
||||
|
||||
static bool is_loop_terminator(ir_if *ir);
|
||||
|
||||
static bool used_outside_loops(exec_node *head, ir_variable *var, bool first_assignment);
|
||||
|
||||
static bool all_expression_operands_are_loop_constant(ir_rvalue *,
|
||||
hash_table *);
|
||||
|
||||
@ -121,13 +123,20 @@ loop_state::get_for_inductor(const ir_variable *ir)
|
||||
}
|
||||
|
||||
void
|
||||
loop_state::insert_non_inductor(ir_variable *var)
|
||||
{
|
||||
// key doesn't matter, just needs to be non-NULL
|
||||
hash_table_insert(this->ht_non_inductors, this, var);
|
||||
}
|
||||
|
||||
bool
|
||||
loop_state::insert_inductor(loop_variable* loopvar, loop_variable_state* state, ir_loop* loop)
|
||||
{
|
||||
ir_variable* var = loopvar->var;
|
||||
|
||||
// Check if this variable is already marked as "sure can't be a private inductor variable"
|
||||
if (hash_table_find(this->ht_non_inductors, var))
|
||||
return;
|
||||
return false;
|
||||
|
||||
// Check if this variable is used after the loop anywhere. If it is, it can't be a
|
||||
// variable that's private to the loop.
|
||||
@ -143,7 +152,7 @@ loop_state::insert_inductor(loop_variable* loopvar, loop_variable_state* state,
|
||||
// add to list of "non inductors", so that next loop does not try
|
||||
// to add it as inductor again
|
||||
hash_table_insert(this->ht_non_inductors, state, var);
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@ -166,12 +175,13 @@ loop_state::insert_inductor(loop_variable* loopvar, loop_variable_state* state,
|
||||
// add to list of "non inductors", so that next loop does not try
|
||||
// to add it as inductor again
|
||||
hash_table_insert(this->ht_non_inductors, state, var);
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
state->private_induction_variable_count++;
|
||||
hash_table_insert(this->ht_inductors, state, var);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@ -245,6 +255,8 @@ public:
|
||||
virtual ir_visitor_status visit(ir_loop_jump *);
|
||||
virtual ir_visitor_status visit(ir_dereference_variable *);
|
||||
|
||||
virtual ir_visitor_status visit(ir_variable *);
|
||||
|
||||
virtual ir_visitor_status visit_enter(ir_call *);
|
||||
|
||||
virtual ir_visitor_status visit_enter(ir_loop *);
|
||||
@ -288,6 +300,28 @@ loop_analysis::visit(ir_loop_jump *ir)
|
||||
}
|
||||
|
||||
|
||||
ir_visitor_status
|
||||
loop_analysis::visit(ir_variable *var)
|
||||
{
|
||||
// if inside a loop, simply continue - we're only interested in variables declared
|
||||
// entirely outside of any loops
|
||||
if (!this->state.is_empty())
|
||||
return visit_continue;
|
||||
|
||||
// Check if this variable is used outside a loop anywhere. If it is, it can't be a
|
||||
// variable that's private to the loop, so can't be an inductor.
|
||||
// This doesn't reject all possible non-inductors, notably anything declared in an
|
||||
// outer loop that isn't an inductor in an inner loop, but it can eliminate some
|
||||
// problem cases
|
||||
if (used_outside_loops(var->next, var, false))
|
||||
{
|
||||
// add to list of "non inductors"
|
||||
loops->insert_non_inductor(var);
|
||||
}
|
||||
|
||||
return visit_continue;
|
||||
}
|
||||
|
||||
ir_visitor_status
|
||||
loop_analysis::visit_enter(ir_call *)
|
||||
{
|
||||
@ -451,11 +485,12 @@ loop_analysis::visit_leave(ir_loop *ir)
|
||||
ir_rvalue *const inc =
|
||||
get_basic_induction_increment(lv->first_assignment, ls->var_hash);
|
||||
if (inc != NULL) {
|
||||
lv->increment = inc;
|
||||
lv->increment = inc;
|
||||
|
||||
lv->remove();
|
||||
ls->induction_variables.push_tail(lv);
|
||||
loops->insert_inductor(lv, ls, ir);
|
||||
if (loops->insert_inductor(lv, ls, ir)) {
|
||||
lv->remove();
|
||||
ls->induction_variables.push_tail(lv);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -699,6 +734,65 @@ is_loop_terminator(ir_if *ir)
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
used_outside_loops(exec_node *head, ir_variable *var, bool first_assignment)
|
||||
{
|
||||
ir_variable_refcount_visitor refs;
|
||||
for (exec_node* node = head;
|
||||
!node->is_tail_sentinel();
|
||||
node = node->next)
|
||||
{
|
||||
ir_instruction *ir = (ir_instruction *) node;
|
||||
if (ir->ir_type == ir_type_variable)
|
||||
continue;
|
||||
|
||||
// ignore the first assignment
|
||||
if (!first_assignment && ir->ir_type == ir_type_assignment)
|
||||
{
|
||||
ir_assignment *assign = ir->as_assignment();
|
||||
ir_variable *assignee = assign->lhs->whole_variable_referenced();
|
||||
|
||||
if(assignee == var)
|
||||
{
|
||||
first_assignment = true;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// we don't want to recurse into loops
|
||||
if (ir->ir_type == ir_type_loop)
|
||||
continue;
|
||||
|
||||
// recurse only for if statements, the other case we would need to recurse is
|
||||
// loops, but we are looking for uses outside of loops.
|
||||
if (ir->ir_type == ir_type_if)
|
||||
{
|
||||
ir_if *irif = ir->as_if();
|
||||
if (used_outside_loops(irif->then_instructions.head, var, first_assignment))
|
||||
return true;
|
||||
if (used_outside_loops(irif->else_instructions.head, var, first_assignment))
|
||||
return true;
|
||||
|
||||
// if we didn't find in each branch with our recursion, skip
|
||||
// otherwise the accept (&refs) below will recurse into loops
|
||||
// and may give a false positive.
|
||||
continue;
|
||||
}
|
||||
|
||||
// we know that we're not inside a loop as we haven't recursed inside,
|
||||
// and we started outside of a loop, so any references to this variable
|
||||
// mean it is used outside of any loops
|
||||
ir->accept (&refs);
|
||||
if (refs.find_variable_entry(var))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
loop_state *
|
||||
analyze_loop_variables(exec_list *instructions)
|
||||
{
|
||||
|
@ -249,7 +249,8 @@ public:
|
||||
loop_variable_state *insert(ir_loop *ir);
|
||||
|
||||
loop_variable_state* get_for_inductor (const ir_variable*);
|
||||
void insert_inductor(loop_variable* loopvar, loop_variable_state* state, ir_loop* loop);
|
||||
bool insert_inductor(loop_variable* loopvar, loop_variable_state* state, ir_loop* loop);
|
||||
void insert_non_inductor(ir_variable *var);
|
||||
|
||||
bool loop_found;
|
||||
|
||||
|
@ -569,8 +569,8 @@ private:
|
||||
* return pack_uvec2_to_uint(uvec2(
|
||||
* round(clamp(VEC2_RVALUE, 0.0f, 1.0f) * 65535.0f)));
|
||||
*
|
||||
* Here it is safe to directly convert the vec2 to uvec2 because the the
|
||||
* vec2 has been clamped to a non-negative range.
|
||||
* Here it is safe to directly convert the vec2 to uvec2 because the vec2
|
||||
* has been clamped to a non-negative range.
|
||||
*/
|
||||
|
||||
assert(vec2_rval->type == glsl_type::vec2_type);
|
||||
|
@ -35,7 +35,7 @@
|
||||
* the built-in varyings have pre-assigned locations. Also, the elimination
|
||||
* of unused gl_TexCoord elements requires its own lowering pass anyway.
|
||||
*
|
||||
* It's implemented by replacing all occurences of dead varyings with
|
||||
* It's implemented by replacing all occurrences of dead varyings with
|
||||
* temporary variables, which creates dead code. It is recommended to run
|
||||
* a dead-code elimination pass after this.
|
||||
*
|
||||
@ -280,7 +280,7 @@ public:
|
||||
*
|
||||
* We're going to break down the gl_TexCoord array into separate
|
||||
* variables. First, add declarations of the new variables all
|
||||
* occurences of gl_TexCoord will be replaced with.
|
||||
* occurrences of gl_TexCoord will be replaced with.
|
||||
*/
|
||||
if (info->lower_texcoord_array) {
|
||||
prepare_array(ir, this->new_texcoord, ARRAY_SIZE(this->new_texcoord),
|
||||
@ -411,7 +411,7 @@ public:
|
||||
* variable dereference representing gl_TexCoord[i].
|
||||
*/
|
||||
if (this->info->lower_texcoord_array) {
|
||||
/* gl_TexCoord[i] occurence */
|
||||
/* gl_TexCoord[i] occurrence */
|
||||
ir_dereference_array *const da = (*rvalue)->as_dereference_array();
|
||||
|
||||
if (da && da->variable_referenced() ==
|
||||
@ -425,7 +425,7 @@ public:
|
||||
|
||||
/* Same for gl_FragData. */
|
||||
if (this->info->lower_fragdata_array) {
|
||||
/* gl_FragData[i] occurence */
|
||||
/* gl_FragData[i] occurrence */
|
||||
ir_dereference_array *const da = (*rvalue)->as_dereference_array();
|
||||
|
||||
if (da && da->variable_referenced() == this->info->fragdata_array) {
|
||||
|
@ -150,7 +150,7 @@ ir_call::generate_inline(ir_instruction *next_ir)
|
||||
parameters[i]->data.precision = param->get_precision();
|
||||
prec_params_max = higher_precision (prec_params_max, (glsl_precision)parameters[i]->data.precision);
|
||||
|
||||
/* Remove the read-only decoration becuase we're going to write
|
||||
/* Remove the read-only decoration because we're going to write
|
||||
* directly to this variable. If the cloned variable is left
|
||||
* read-only and the inlined function is inside a loop, the loop
|
||||
* analysis code will get confused.
|
||||
|
@ -106,6 +106,8 @@ void initialize_context_to_defaults(struct gl_context *ctx, gl_api api)
|
||||
ctx->Extensions.OES_EGL_image_external = true;
|
||||
ctx->Extensions.OES_standard_derivatives = true;
|
||||
|
||||
ctx->Extensions.EXT_draw_instanced = true;
|
||||
ctx->Extensions.EXT_gpu_shader4 = true;
|
||||
ctx->Extensions.EXT_shader_integer_mix = true;
|
||||
ctx->Extensions.EXT_texture3D = true;
|
||||
ctx->Extensions.EXT_texture_array = true;
|
||||
@ -113,6 +115,8 @@ void initialize_context_to_defaults(struct gl_context *ctx, gl_api api)
|
||||
|
||||
ctx->Extensions.NV_texture_rectangle = true;
|
||||
|
||||
ctx->Const.AllowGLSLExtensionDirectiveMidShader = true; // makes it easier to run tests
|
||||
|
||||
ctx->Const.GLSLVersion = 120;
|
||||
|
||||
/* 1.20 minimums. */
|
||||
|
@ -1491,6 +1491,7 @@ struct gl_extensions
|
||||
GLboolean EXT_depth_bounds_test;
|
||||
GLboolean EXT_draw_buffers;
|
||||
GLboolean EXT_draw_buffers2;
|
||||
GLboolean EXT_draw_instanced;
|
||||
GLboolean EXT_framebuffer_blit;
|
||||
GLboolean EXT_framebuffer_multisample;
|
||||
GLboolean EXT_framebuffer_multisample_blit_scaled;
|
||||
|
@ -116,8 +116,8 @@ extern void hash_table_insert(struct hash_table *ht, void *data,
|
||||
* Add an element to a hash table with replacement
|
||||
*
|
||||
* \return
|
||||
* 1 if it did replace the the value (in which case the old key is kept), 0 if
|
||||
* it did not replace the value (in which case the new key is kept).
|
||||
* 1 if it did replace the value (in which case the old key is kept), 0 if it
|
||||
* did not replace the value (in which case the new key is kept).
|
||||
*
|
||||
* \warning
|
||||
* If \c key is already in the hash table, \c data will \b replace the most
|
||||
|
@ -5,7 +5,8 @@ void main ()
|
||||
discard;
|
||||
};
|
||||
a_2 = 4.0;
|
||||
for (int i_1 = 0; i_1 < 10; i_1++, a_2 += 1.0) {
|
||||
for (int i_1 = 0; i_1 < 10; i_1++) {
|
||||
a_2 += 1.0;
|
||||
};
|
||||
while (true) {
|
||||
a_2 += 2.0;
|
||||
|
@ -7,7 +7,8 @@ void main ()
|
||||
discard;
|
||||
};
|
||||
a_2 = 4.0;
|
||||
for (highp int i_1 = 0; i_1 < 10; i_1++, a_2 += 1.0) {
|
||||
for (highp int i_1 = 0; i_1 < 10; i_1++) {
|
||||
a_2 += 1.0;
|
||||
};
|
||||
while (true) {
|
||||
a_2 += 2.0;
|
||||
|
@ -16,7 +16,8 @@ fragment xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]]
|
||||
discard_fragment();
|
||||
};
|
||||
a_2 = 4.0;
|
||||
for (int i_1 = 0; i_1 < 10; i_1++, a_2 += 1.0) {
|
||||
for (int i_1 = 0; i_1 < 10; i_1++) {
|
||||
a_2 += 1.0;
|
||||
};
|
||||
while (true) {
|
||||
a_2 += 2.0;
|
||||
|
@ -5,16 +5,24 @@ void main ()
|
||||
int myIdx_2;
|
||||
r_1 = vec4(0.0, 0.0, 0.0, 0.0);
|
||||
myIdx_2 = 1;
|
||||
for (; myIdx_2 < loopNum; myIdx_2++) {
|
||||
while (true) {
|
||||
if ((myIdx_2 >= loopNum)) {
|
||||
break;
|
||||
};
|
||||
r_1.x = (r_1.x + 1.0);
|
||||
r_1.y = (r_1.y + 2.0);
|
||||
r_1.z = (r_1.z + 3.0);
|
||||
myIdx_2++;
|
||||
};
|
||||
myIdx_2 = 2;
|
||||
for (; myIdx_2 < loopNum; myIdx_2++) {
|
||||
while (true) {
|
||||
if ((myIdx_2 >= loopNum)) {
|
||||
break;
|
||||
};
|
||||
r_1.x = (r_1.x + 1.0);
|
||||
r_1.y = (r_1.y + 2.0);
|
||||
r_1.z = (r_1.z + 3.0);
|
||||
myIdx_2++;
|
||||
};
|
||||
gl_FragColor = r_1;
|
||||
}
|
||||
|
15
3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highp-inES3.txt
vendored
Normal file
15
3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highp-inES3.txt
vendored
Normal file
@ -0,0 +1,15 @@
|
||||
#version 300 es
|
||||
|
||||
// There was a bug where due to xll_tex2Dlod sampling of a _CameraDepthTexture (that is a highp sampler)
|
||||
// was producing a missing cast between half4 and float4 on Metal output.
|
||||
// Shader is a minimal part of Unity's camera motion blur shader that exposes the bug
|
||||
|
||||
vec4 xll_tex2Dlod(sampler2D s, vec4 coord) { return textureLod(s, coord.xy, coord.w); }
|
||||
uniform highp sampler2D _CameraDepthTexture;
|
||||
in highp vec2 varUV;
|
||||
out mediump vec4 _fragData;
|
||||
void main()
|
||||
{
|
||||
highp float z = xll_tex2Dlod(_CameraDepthTexture, vec4(varUV, 0.0, 0.0)).x;
|
||||
_fragData = vec4(z);
|
||||
}
|
17
3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highp-outES3.txt
vendored
Normal file
17
3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highp-outES3.txt
vendored
Normal file
@ -0,0 +1,17 @@
|
||||
#version 300 es
|
||||
uniform highp sampler2D _CameraDepthTexture;
|
||||
in highp vec2 varUV;
|
||||
out mediump vec4 _fragData;
|
||||
void main ()
|
||||
{
|
||||
highp vec4 tmpvar_1;
|
||||
tmpvar_1 = textureLod (_CameraDepthTexture, varUV, 0.0).xxxx;
|
||||
_fragData = tmpvar_1;
|
||||
}
|
||||
|
||||
|
||||
// stats: 0 alu 1 tex 0 flow
|
||||
// inputs: 1
|
||||
// #0: varUV (high float) 2x1 [-1]
|
||||
// textures: 1
|
||||
// #0: _CameraDepthTexture (high 2d) 0x0 [-1]
|
26
3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highp-outES3Metal.txt
vendored
Normal file
26
3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highp-outES3Metal.txt
vendored
Normal file
@ -0,0 +1,26 @@
|
||||
#include <metal_stdlib>
|
||||
using namespace metal;
|
||||
struct xlatMtlShaderInput {
|
||||
float2 varUV;
|
||||
};
|
||||
struct xlatMtlShaderOutput {
|
||||
half4 _fragData [[color(0)]];
|
||||
};
|
||||
struct xlatMtlShaderUniform {
|
||||
};
|
||||
fragment xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]], constant xlatMtlShaderUniform& _mtl_u [[buffer(0)]]
|
||||
, texture2d<float> _CameraDepthTexture [[texture(0)]], sampler _mtlsmp__CameraDepthTexture [[sampler(0)]])
|
||||
{
|
||||
xlatMtlShaderOutput _mtl_o;
|
||||
float4 tmpvar_1;
|
||||
tmpvar_1 = _CameraDepthTexture.sample(_mtlsmp__CameraDepthTexture, (float2)(_mtl_i.varUV), level(0.0)).xxxx;
|
||||
_mtl_o._fragData = half4(tmpvar_1);
|
||||
return _mtl_o;
|
||||
}
|
||||
|
||||
|
||||
// stats: 0 alu 1 tex 0 flow
|
||||
// inputs: 1
|
||||
// #0: varUV (high float) 2x1 [-1]
|
||||
// textures: 1
|
||||
// #0: _CameraDepthTexture (high 2d) 0x0 [-1] loc 0
|
118
3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highpfull-inES3.txt
vendored
Normal file
118
3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highpfull-inES3.txt
vendored
Normal file
@ -0,0 +1,118 @@
|
||||
#version 300 es
|
||||
|
||||
// There was a bug where due to xll_tex2Dlod sampling of a _CameraDepthTexture (that is a highp sampler)
|
||||
// was producing a missing cast between half4 and float4 on Metal output.
|
||||
// Shader is part of Unity's camera motion blur shader.
|
||||
|
||||
vec4 xll_tex2Dlod(sampler2D s, vec4 coord) { return textureLod( s, coord.xy, coord.w); }
|
||||
struct v2f {
|
||||
highp vec4 pos;
|
||||
highp vec2 uv;
|
||||
};
|
||||
uniform highp vec3 _WorldSpaceCameraPos;
|
||||
uniform highp vec4 _ProjectionParams;
|
||||
uniform highp vec4 _ScreenParams;
|
||||
uniform highp vec4 _ZBufferParams;
|
||||
uniform highp vec4 _WorldSpaceLightPos0;
|
||||
uniform highp mat4 _Object2World;
|
||||
uniform highp mat4 _World2Object;
|
||||
uniform highp float _MaxRadiusOrKInPaper;
|
||||
const highp int SmallDiscKernelSamples = 12;
|
||||
const highp vec2[12] SmallDiscKernel = vec2[12]( vec2( -0.326212, -0.40581), vec2( -0.840144, -0.07358), vec2( -0.695914, 0.457137), vec2( -0.203345, 0.620716), vec2( 0.96234, -0.194983), vec2( 0.473434, -0.480026), vec2( 0.519456, 0.767022), vec2( 0.185461, -0.893124), vec2( 0.507431, 0.064425), vec2( 0.89642, 0.412458), vec2( -0.32194, -0.932615), vec2( -0.791559, -0.59771));
|
||||
uniform sampler2D _MainTex;
|
||||
uniform highp sampler2D _CameraDepthTexture;
|
||||
uniform sampler2D _VelTex;
|
||||
uniform sampler2D _NeighbourMaxTex;
|
||||
uniform sampler2D _NoiseTex;
|
||||
uniform sampler2D _TileTexDebug;
|
||||
uniform highp vec4 _MainTex_TexelSize;
|
||||
uniform highp vec4 _CameraDepthTexture_TexelSize;
|
||||
uniform highp vec4 _VelTex_TexelSize;
|
||||
uniform highp mat4 _InvViewProj;
|
||||
uniform highp mat4 _PrevViewProj;
|
||||
uniform highp mat4 _ToPrevViewProjCombined;
|
||||
uniform highp float _Jitter;
|
||||
uniform highp float _VelocityScale;
|
||||
uniform highp float _DisplayVelocityScale;
|
||||
uniform highp float _MaxVelocity;
|
||||
uniform highp float _MinVelocity;
|
||||
uniform highp vec4 _BlurDirectionPacked;
|
||||
uniform highp float _SoftZDistance;
|
||||
highp float Linear01Depth( in highp float z )
|
||||
{
|
||||
return (1.0 / ((_ZBufferParams.x * z) + _ZBufferParams.y));
|
||||
}
|
||||
highp float cone( in highp vec2 px, in highp vec2 py, in highp vec2 v )
|
||||
{
|
||||
return clamp( (1.0 - (length((px - py)) / length(v))), 0.0, 1.0);
|
||||
}
|
||||
highp float cylinder( in highp vec2 x, in highp vec2 y, in highp vec2 v )
|
||||
{
|
||||
highp float lv = length(v);
|
||||
return (1.0 - smoothstep( (0.95 * lv), (1.05 * lv), length((x - y))));
|
||||
}
|
||||
highp float softDepthCompare( in highp float za, in highp float zb )
|
||||
{
|
||||
return clamp( (1.0 - ((za - zb) / _SoftZDistance)), 0.0, 1.0);
|
||||
}
|
||||
highp vec4 ReconstructionDiscBlur( in v2f i )
|
||||
{
|
||||
highp vec2 xf = i.uv;
|
||||
highp vec2 x = i.uv;
|
||||
|
||||
if ((_MainTex_TexelSize.y < 0.0))
|
||||
{
|
||||
xf.y = (1.0 - xf.y);
|
||||
}
|
||||
|
||||
highp vec2 x2 = xf;
|
||||
highp vec2 vn = xll_tex2Dlod(_NeighbourMaxTex, vec4(x2, 0.0, 0.0)).xy;
|
||||
highp vec4 cx = xll_tex2Dlod(_MainTex, vec4(x, 0.0, 0.0));
|
||||
|
||||
highp vec2 vx = xll_tex2Dlod(_VelTex, vec4(xf, 0.0, 0.0)).xy;
|
||||
highp vec4 noise = ((xll_tex2Dlod( _NoiseTex, (vec4(i.uv, 0.0, 0.0) * 11.0)) * 2.0) - 1.0);
|
||||
highp float zx = xll_tex2Dlod(_CameraDepthTexture, vec4(x, 0.0, 0.0)).x;
|
||||
|
||||
zx = (-Linear01Depth( zx));
|
||||
noise *= (_MainTex_TexelSize.xyxy * _Jitter);
|
||||
|
||||
highp float weight = 1.0;
|
||||
highp vec4 sum = (cx * weight);
|
||||
highp vec4 jitteredDir = (vn.xyxy + noise.xyyz);
|
||||
|
||||
jitteredDir = ((max( abs(jitteredDir.xyxy), ((_MainTex_TexelSize.xyxy * _MaxVelocity) * 0.15)) * sign(jitteredDir.xyxy)) * vec4( 1.0, 1.0, -1.0, -1.0));
|
||||
highp int l = 0;
|
||||
for ( ; (l < 12); (l++)) {
|
||||
|
||||
highp vec4 y = (i.uv.xyxy + ((jitteredDir.xyxy * SmallDiscKernel[l].xyxy) * vec4( 1.0, 1.0, -1.0, -1.0)));
|
||||
highp vec4 yf = y;
|
||||
|
||||
if ((_MainTex_TexelSize.y < 0.0)){
|
||||
yf.yw = (1.0 - yf.yw);
|
||||
}
|
||||
|
||||
highp vec2 vy = xll_tex2Dlod( _VelTex, vec4( yf.xy, 0.0, 0.0)).xy;
|
||||
highp float zy = xll_tex2Dlod( _CameraDepthTexture, vec4( y.xy, 0.0, 0.0)).x;
|
||||
zy = (-Linear01Depth( zy));
|
||||
|
||||
highp float f = softDepthCompare( zx, zy);
|
||||
highp float b = softDepthCompare( zy, zx);
|
||||
highp float alphay = (((b * cone( x, y.xy, vx)) + (f * cone( y.xy, x, vy))) + ((cylinder( y.xy, x, vy) * cylinder( x, y.xy, vx)) * 2.0));
|
||||
|
||||
highp vec4 cy = xll_tex2Dlod( _MainTex, vec4( y.xy, 0.0, 0.0));
|
||||
sum += (cy * alphay);
|
||||
weight += alphay;
|
||||
}
|
||||
|
||||
return (sum / weight);
|
||||
}
|
||||
in highp vec2 xlv_TEXCOORD0;
|
||||
out mediump vec4 _fragData;
|
||||
void main() {
|
||||
highp vec4 xl_retval;
|
||||
v2f xlt_i;
|
||||
xlt_i.pos = vec4(0.0);
|
||||
xlt_i.uv = vec2(xlv_TEXCOORD0);
|
||||
xl_retval = ReconstructionDiscBlur(xlt_i);
|
||||
_fragData = vec4(xl_retval);
|
||||
}
|
161
3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highpfull-outES3.txt
vendored
Normal file
161
3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highpfull-outES3.txt
vendored
Normal file
@ -0,0 +1,161 @@
|
||||
#version 300 es
|
||||
uniform highp vec4 _ZBufferParams;
|
||||
uniform sampler2D _MainTex;
|
||||
uniform highp sampler2D _CameraDepthTexture;
|
||||
uniform sampler2D _VelTex;
|
||||
uniform sampler2D _NeighbourMaxTex;
|
||||
uniform sampler2D _NoiseTex;
|
||||
uniform highp vec4 _MainTex_TexelSize;
|
||||
uniform highp float _Jitter;
|
||||
uniform highp float _MaxVelocity;
|
||||
uniform highp float _SoftZDistance;
|
||||
in highp vec2 xlv_TEXCOORD0;
|
||||
out mediump vec4 _fragData;
|
||||
void main ()
|
||||
{
|
||||
highp vec2 tmpvar_1;
|
||||
tmpvar_1 = xlv_TEXCOORD0;
|
||||
highp vec4 jitteredDir_3;
|
||||
highp vec4 sum_4;
|
||||
highp float weight_5;
|
||||
highp float zx_6;
|
||||
highp vec2 vx_7;
|
||||
highp vec2 x_8;
|
||||
highp vec2 xf_9;
|
||||
xf_9 = xlv_TEXCOORD0;
|
||||
x_8 = xlv_TEXCOORD0;
|
||||
if ((_MainTex_TexelSize.y < 0.0)) {
|
||||
xf_9.y = (1.0 - xlv_TEXCOORD0.y);
|
||||
};
|
||||
lowp vec4 tmpvar_10;
|
||||
tmpvar_10 = textureLod (_NeighbourMaxTex, xf_9, 0.0);
|
||||
highp vec2 tmpvar_11;
|
||||
tmpvar_11 = tmpvar_10.xy;
|
||||
lowp vec4 tmpvar_12;
|
||||
tmpvar_12 = textureLod (_MainTex, xlv_TEXCOORD0, 0.0);
|
||||
highp vec4 tmpvar_13;
|
||||
tmpvar_13 = tmpvar_12;
|
||||
lowp vec4 tmpvar_14;
|
||||
tmpvar_14 = textureLod (_VelTex, xf_9, 0.0);
|
||||
highp vec2 tmpvar_15;
|
||||
tmpvar_15 = tmpvar_14.xy;
|
||||
vx_7 = tmpvar_15;
|
||||
highp vec4 tmpvar_16;
|
||||
tmpvar_16.zw = vec2(0.0, 0.0);
|
||||
tmpvar_16.xy = xlv_TEXCOORD0;
|
||||
highp vec4 coord_17;
|
||||
coord_17 = (tmpvar_16 * 11.0);
|
||||
lowp vec4 tmpvar_18;
|
||||
tmpvar_18 = textureLod (_NoiseTex, coord_17.xy, coord_17.w);
|
||||
highp vec4 tmpvar_19;
|
||||
tmpvar_19 = ((tmpvar_18 * 2.0) - 1.0);
|
||||
zx_6 = -((1.0/((
|
||||
(_ZBufferParams.x * textureLod (_CameraDepthTexture, xlv_TEXCOORD0, 0.0).x)
|
||||
+ _ZBufferParams.y))));
|
||||
weight_5 = 1.0;
|
||||
sum_4 = tmpvar_13;
|
||||
highp vec4 tmpvar_20;
|
||||
tmpvar_20 = (tmpvar_11.xyxy + (tmpvar_19 * (_MainTex_TexelSize.xyxy * _Jitter)).xyyz);
|
||||
jitteredDir_3 = ((max (
|
||||
abs(tmpvar_20.xyxy)
|
||||
,
|
||||
((_MainTex_TexelSize.xyxy * _MaxVelocity) * 0.15)
|
||||
) * sign(tmpvar_20.xyxy)) * vec4(1.0, 1.0, -1.0, -1.0));
|
||||
for (highp int l_2 = 0; l_2 < 12; l_2++) {
|
||||
highp float zy_21;
|
||||
highp vec4 yf_22;
|
||||
highp vec4 tmpvar_23;
|
||||
tmpvar_23 = (tmpvar_1.xyxy + ((jitteredDir_3.xyxy * vec2[12](vec2(-0.326212, -0.40581), vec2(-0.840144, -0.07358), vec2(-0.695914, 0.457137), vec2(-0.203345, 0.620716), vec2(0.96234, -0.194983), vec2(0.473434, -0.480026), vec2(0.519456, 0.767022), vec2(0.185461, -0.893124), vec2(0.507431, 0.064425), vec2(0.89642, 0.412458), vec2(-0.32194, -0.932615), vec2(-0.791559, -0.59771))[l_2].xyxy) * vec4(1.0, 1.0, -1.0, -1.0)));
|
||||
yf_22 = tmpvar_23;
|
||||
if ((_MainTex_TexelSize.y < 0.0)) {
|
||||
yf_22.yw = (1.0 - tmpvar_23.yw);
|
||||
};
|
||||
lowp vec4 tmpvar_24;
|
||||
tmpvar_24 = textureLod (_VelTex, yf_22.xy, 0.0);
|
||||
highp vec2 tmpvar_25;
|
||||
tmpvar_25 = tmpvar_24.xy;
|
||||
zy_21 = -((1.0/((
|
||||
(_ZBufferParams.x * textureLod (_CameraDepthTexture, tmpvar_23.xy, 0.0).x)
|
||||
+ _ZBufferParams.y))));
|
||||
highp vec2 x_26;
|
||||
x_26 = (x_8 - tmpvar_23.xy);
|
||||
highp vec2 x_27;
|
||||
x_27 = (tmpvar_23.xy - x_8);
|
||||
highp float tmpvar_28;
|
||||
tmpvar_28 = sqrt(dot (tmpvar_25, tmpvar_25));
|
||||
highp vec2 x_29;
|
||||
x_29 = (tmpvar_23.xy - x_8);
|
||||
highp float edge0_30;
|
||||
edge0_30 = (0.95 * tmpvar_28);
|
||||
highp float tmpvar_31;
|
||||
tmpvar_31 = clamp (((
|
||||
sqrt(dot (x_29, x_29))
|
||||
- edge0_30) / (
|
||||
(1.05 * tmpvar_28)
|
||||
- edge0_30)), 0.0, 1.0);
|
||||
highp float tmpvar_32;
|
||||
tmpvar_32 = sqrt(dot (vx_7, vx_7));
|
||||
highp vec2 x_33;
|
||||
x_33 = (x_8 - tmpvar_23.xy);
|
||||
highp float edge0_34;
|
||||
edge0_34 = (0.95 * tmpvar_32);
|
||||
highp float tmpvar_35;
|
||||
tmpvar_35 = clamp (((
|
||||
sqrt(dot (x_33, x_33))
|
||||
- edge0_34) / (
|
||||
(1.05 * tmpvar_32)
|
||||
- edge0_34)), 0.0, 1.0);
|
||||
highp float tmpvar_36;
|
||||
tmpvar_36 = (((
|
||||
clamp ((1.0 - ((zy_21 - zx_6) / _SoftZDistance)), 0.0, 1.0)
|
||||
*
|
||||
clamp ((1.0 - (sqrt(
|
||||
dot (x_26, x_26)
|
||||
) / sqrt(
|
||||
dot (vx_7, vx_7)
|
||||
))), 0.0, 1.0)
|
||||
) + (
|
||||
clamp ((1.0 - ((zx_6 - zy_21) / _SoftZDistance)), 0.0, 1.0)
|
||||
*
|
||||
clamp ((1.0 - (sqrt(
|
||||
dot (x_27, x_27)
|
||||
) / sqrt(
|
||||
dot (tmpvar_25, tmpvar_25)
|
||||
))), 0.0, 1.0)
|
||||
)) + ((
|
||||
(1.0 - (tmpvar_31 * (tmpvar_31 * (3.0 -
|
||||
(2.0 * tmpvar_31)
|
||||
))))
|
||||
*
|
||||
(1.0 - (tmpvar_35 * (tmpvar_35 * (3.0 -
|
||||
(2.0 * tmpvar_35)
|
||||
))))
|
||||
) * 2.0));
|
||||
lowp vec4 tmpvar_37;
|
||||
tmpvar_37 = textureLod (_MainTex, tmpvar_23.xy, 0.0);
|
||||
highp vec4 tmpvar_38;
|
||||
tmpvar_38 = tmpvar_37;
|
||||
sum_4 = (sum_4 + (tmpvar_38 * tmpvar_36));
|
||||
weight_5 = (weight_5 + tmpvar_36);
|
||||
};
|
||||
highp vec4 tmpvar_39;
|
||||
tmpvar_39 = (sum_4 / weight_5);
|
||||
_fragData = tmpvar_39;
|
||||
}
|
||||
|
||||
|
||||
// stats: 99 alu 8 tex 4 flow
|
||||
// inputs: 1
|
||||
// #0: xlv_TEXCOORD0 (high float) 2x1 [-1]
|
||||
// uniforms: 5 (total size: 0)
|
||||
// #0: _ZBufferParams (high float) 4x1 [-1]
|
||||
// #1: _MainTex_TexelSize (high float) 4x1 [-1]
|
||||
// #2: _Jitter (high float) 1x1 [-1]
|
||||
// #3: _MaxVelocity (high float) 1x1 [-1]
|
||||
// #4: _SoftZDistance (high float) 1x1 [-1]
|
||||
// textures: 5
|
||||
// #0: _MainTex (low 2d) 0x0 [-1]
|
||||
// #1: _CameraDepthTexture (high 2d) 0x0 [-1]
|
||||
// #2: _VelTex (low 2d) 0x0 [-1]
|
||||
// #3: _NeighbourMaxTex (low 2d) 0x0 [-1]
|
||||
// #4: _NoiseTex (low 2d) 0x0 [-1]
|
171
3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highpfull-outES3Metal.txt
vendored
Normal file
171
3rdparty/glsl-optimizer/tests/fragment/bug-sampler-highpfull-outES3Metal.txt
vendored
Normal file
@ -0,0 +1,171 @@
|
||||
#include <metal_stdlib>
|
||||
using namespace metal;
|
||||
constant float2 _xlat_mtl_const1[12] = {float2(-0.326212, -0.40581), float2(-0.840144, -0.07358), float2(-0.695914, 0.457137), float2(-0.203345, 0.620716), float2(0.96234, -0.194983), float2(0.473434, -0.480026), float2(0.519456, 0.767022), float2(0.185461, -0.893124), float2(0.507431, 0.064425), float2(0.89642, 0.412458), float2(-0.32194, -0.932615), float2(-0.791559, -0.59771)};
|
||||
struct xlatMtlShaderInput {
|
||||
float2 xlv_TEXCOORD0;
|
||||
};
|
||||
struct xlatMtlShaderOutput {
|
||||
half4 _fragData [[color(0)]];
|
||||
};
|
||||
struct xlatMtlShaderUniform {
|
||||
float4 _ZBufferParams;
|
||||
float4 _MainTex_TexelSize;
|
||||
float _Jitter;
|
||||
float _MaxVelocity;
|
||||
float _SoftZDistance;
|
||||
};
|
||||
fragment xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]], constant xlatMtlShaderUniform& _mtl_u [[buffer(0)]]
|
||||
, texture2d<half> _MainTex [[texture(0)]], sampler _mtlsmp__MainTex [[sampler(0)]]
|
||||
, texture2d<float> _CameraDepthTexture [[texture(1)]], sampler _mtlsmp__CameraDepthTexture [[sampler(1)]]
|
||||
, texture2d<half> _VelTex [[texture(2)]], sampler _mtlsmp__VelTex [[sampler(2)]]
|
||||
, texture2d<half> _NeighbourMaxTex [[texture(3)]], sampler _mtlsmp__NeighbourMaxTex [[sampler(3)]]
|
||||
, texture2d<half> _NoiseTex [[texture(4)]], sampler _mtlsmp__NoiseTex [[sampler(4)]])
|
||||
{
|
||||
xlatMtlShaderOutput _mtl_o;
|
||||
float2 tmpvar_1;
|
||||
tmpvar_1 = _mtl_i.xlv_TEXCOORD0;
|
||||
float4 jitteredDir_3;
|
||||
float4 sum_4;
|
||||
float weight_5;
|
||||
float zx_6;
|
||||
float2 vx_7;
|
||||
float2 x_8;
|
||||
float2 xf_9;
|
||||
xf_9 = _mtl_i.xlv_TEXCOORD0;
|
||||
x_8 = _mtl_i.xlv_TEXCOORD0;
|
||||
if ((_mtl_u._MainTex_TexelSize.y < 0.0)) {
|
||||
xf_9.y = (1.0 - _mtl_i.xlv_TEXCOORD0.y);
|
||||
};
|
||||
half4 tmpvar_10;
|
||||
tmpvar_10 = _NeighbourMaxTex.sample(_mtlsmp__NeighbourMaxTex, (float2)(xf_9), level(0.0));
|
||||
float2 tmpvar_11;
|
||||
tmpvar_11 = float2(tmpvar_10.xy);
|
||||
half4 tmpvar_12;
|
||||
tmpvar_12 = _MainTex.sample(_mtlsmp__MainTex, (float2)(_mtl_i.xlv_TEXCOORD0), level(0.0));
|
||||
float4 tmpvar_13;
|
||||
tmpvar_13 = float4(tmpvar_12);
|
||||
half4 tmpvar_14;
|
||||
tmpvar_14 = _VelTex.sample(_mtlsmp__VelTex, (float2)(xf_9), level(0.0));
|
||||
float2 tmpvar_15;
|
||||
tmpvar_15 = float2(tmpvar_14.xy);
|
||||
vx_7 = tmpvar_15;
|
||||
float4 tmpvar_16;
|
||||
tmpvar_16.zw = float2(0.0, 0.0);
|
||||
tmpvar_16.xy = _mtl_i.xlv_TEXCOORD0;
|
||||
float4 coord_17;
|
||||
coord_17 = (tmpvar_16 * 11.0);
|
||||
half4 tmpvar_18;
|
||||
tmpvar_18 = _NoiseTex.sample(_mtlsmp__NoiseTex, (float2)(coord_17.xy), level(coord_17.w));
|
||||
float4 tmpvar_19;
|
||||
tmpvar_19 = float4(((tmpvar_18 * (half)2.0) - (half)1.0));
|
||||
zx_6 = -((1.0/((
|
||||
(_mtl_u._ZBufferParams.x * _CameraDepthTexture.sample(_mtlsmp__CameraDepthTexture, (float2)(_mtl_i.xlv_TEXCOORD0), level(0.0)).x)
|
||||
+ _mtl_u._ZBufferParams.y))));
|
||||
weight_5 = 1.0;
|
||||
sum_4 = tmpvar_13;
|
||||
float4 tmpvar_20;
|
||||
tmpvar_20 = (tmpvar_11.xyxy + (tmpvar_19 * (_mtl_u._MainTex_TexelSize.xyxy * _mtl_u._Jitter)).xyyz);
|
||||
jitteredDir_3 = ((max (
|
||||
abs(tmpvar_20.xyxy)
|
||||
,
|
||||
((_mtl_u._MainTex_TexelSize.xyxy * _mtl_u._MaxVelocity) * 0.15)
|
||||
) * sign(tmpvar_20.xyxy)) * float4(1.0, 1.0, -1.0, -1.0));
|
||||
for (int l_2 = 0; l_2 < 12; l_2++) {
|
||||
float zy_21;
|
||||
float4 yf_22;
|
||||
float4 tmpvar_23;
|
||||
tmpvar_23 = (tmpvar_1.xyxy + ((jitteredDir_3.xyxy * _xlat_mtl_const1[l_2].xyxy) * float4(1.0, 1.0, -1.0, -1.0)));
|
||||
yf_22 = tmpvar_23;
|
||||
if ((_mtl_u._MainTex_TexelSize.y < 0.0)) {
|
||||
yf_22.yw = (1.0 - tmpvar_23.yw);
|
||||
};
|
||||
half4 tmpvar_24;
|
||||
tmpvar_24 = _VelTex.sample(_mtlsmp__VelTex, (float2)(yf_22.xy), level(0.0));
|
||||
float2 tmpvar_25;
|
||||
tmpvar_25 = float2(tmpvar_24.xy);
|
||||
zy_21 = -((1.0/((
|
||||
(_mtl_u._ZBufferParams.x * _CameraDepthTexture.sample(_mtlsmp__CameraDepthTexture, (float2)(tmpvar_23.xy), level(0.0)).x)
|
||||
+ _mtl_u._ZBufferParams.y))));
|
||||
float2 x_26;
|
||||
x_26 = (x_8 - tmpvar_23.xy);
|
||||
float2 x_27;
|
||||
x_27 = (tmpvar_23.xy - x_8);
|
||||
float tmpvar_28;
|
||||
tmpvar_28 = sqrt(dot (tmpvar_25, tmpvar_25));
|
||||
float2 x_29;
|
||||
x_29 = (tmpvar_23.xy - x_8);
|
||||
float edge0_30;
|
||||
edge0_30 = (0.95 * tmpvar_28);
|
||||
float tmpvar_31;
|
||||
tmpvar_31 = clamp (((
|
||||
sqrt(dot (x_29, x_29))
|
||||
- edge0_30) / (
|
||||
(1.05 * tmpvar_28)
|
||||
- edge0_30)), 0.0, 1.0);
|
||||
float tmpvar_32;
|
||||
tmpvar_32 = sqrt(dot (vx_7, vx_7));
|
||||
float2 x_33;
|
||||
x_33 = (x_8 - tmpvar_23.xy);
|
||||
float edge0_34;
|
||||
edge0_34 = (0.95 * tmpvar_32);
|
||||
float tmpvar_35;
|
||||
tmpvar_35 = clamp (((
|
||||
sqrt(dot (x_33, x_33))
|
||||
- edge0_34) / (
|
||||
(1.05 * tmpvar_32)
|
||||
- edge0_34)), 0.0, 1.0);
|
||||
float tmpvar_36;
|
||||
tmpvar_36 = (((
|
||||
clamp ((1.0 - ((zy_21 - zx_6) / _mtl_u._SoftZDistance)), 0.0, 1.0)
|
||||
*
|
||||
clamp ((1.0 - (sqrt(
|
||||
dot (x_26, x_26)
|
||||
) / sqrt(
|
||||
dot (vx_7, vx_7)
|
||||
))), 0.0, 1.0)
|
||||
) + (
|
||||
clamp ((1.0 - ((zx_6 - zy_21) / _mtl_u._SoftZDistance)), 0.0, 1.0)
|
||||
*
|
||||
clamp ((1.0 - (sqrt(
|
||||
dot (x_27, x_27)
|
||||
) / sqrt(
|
||||
dot (tmpvar_25, tmpvar_25)
|
||||
))), 0.0, 1.0)
|
||||
)) + ((
|
||||
(1.0 - (tmpvar_31 * (tmpvar_31 * (3.0 -
|
||||
(2.0 * tmpvar_31)
|
||||
))))
|
||||
*
|
||||
(1.0 - (tmpvar_35 * (tmpvar_35 * (3.0 -
|
||||
(2.0 * tmpvar_35)
|
||||
))))
|
||||
) * 2.0));
|
||||
half4 tmpvar_37;
|
||||
tmpvar_37 = _MainTex.sample(_mtlsmp__MainTex, (float2)(tmpvar_23.xy), level(0.0));
|
||||
float4 tmpvar_38;
|
||||
tmpvar_38 = float4(tmpvar_37);
|
||||
sum_4 = (sum_4 + (tmpvar_38 * tmpvar_36));
|
||||
weight_5 = (weight_5 + tmpvar_36);
|
||||
};
|
||||
float4 tmpvar_39;
|
||||
tmpvar_39 = (sum_4 / weight_5);
|
||||
_mtl_o._fragData = half4(tmpvar_39);
|
||||
return _mtl_o;
|
||||
}
|
||||
|
||||
|
||||
// stats: 99 alu 8 tex 4 flow
|
||||
// inputs: 1
|
||||
// #0: xlv_TEXCOORD0 (high float) 2x1 [-1]
|
||||
// uniforms: 5 (total size: 44)
|
||||
// #0: _ZBufferParams (high float) 4x1 [-1] loc 0
|
||||
// #1: _MainTex_TexelSize (high float) 4x1 [-1] loc 16
|
||||
// #2: _Jitter (high float) 1x1 [-1] loc 32
|
||||
// #3: _MaxVelocity (high float) 1x1 [-1] loc 36
|
||||
// #4: _SoftZDistance (high float) 1x1 [-1] loc 40
|
||||
// textures: 5
|
||||
// #0: _MainTex (low 2d) 0x0 [-1] loc 0
|
||||
// #1: _CameraDepthTexture (high 2d) 0x0 [-1] loc 1
|
||||
// #2: _VelTex (low 2d) 0x0 [-1] loc 2
|
||||
// #3: _NeighbourMaxTex (low 2d) 0x0 [-1] loc 3
|
||||
// #4: _NoiseTex (low 2d) 0x0 [-1] loc 4
|
29
3rdparty/glsl-optimizer/tests/fragment/loop-foraliasinductor-inES.txt
vendored
Normal file
29
3rdparty/glsl-optimizer/tests/fragment/loop-foraliasinductor-inES.txt
vendored
Normal file
@ -0,0 +1,29 @@
|
||||
struct v2f {
|
||||
highp vec2 uv;
|
||||
highp vec3 nl;
|
||||
};
|
||||
uniform sampler2D _MainTex;
|
||||
uniform highp vec4 _TerrainTreeLightColors[4];
|
||||
lowp vec4 xlat_main (in v2f i) {
|
||||
lowp vec4 col = texture2D( _MainTex, i.uv);
|
||||
mediump vec3 light = vec3(0.0);
|
||||
if(col.x >= 0.0) {
|
||||
for (float j = 0.0; (j < i.uv.x); (j++)) {
|
||||
light += col.xyz;
|
||||
}
|
||||
}
|
||||
if(col.x >= 1.0) {
|
||||
float j = i.uv.y;
|
||||
j *= sin(j);
|
||||
light += col.xyz*j;
|
||||
}
|
||||
return vec4(light, 1.0);
|
||||
}
|
||||
varying highp vec2 xlv_uv;
|
||||
varying highp vec3 xlv_nl;
|
||||
void main() {
|
||||
v2f i;
|
||||
i.uv = xlv_uv;
|
||||
i.nl = xlv_nl;
|
||||
gl_FragData[0] = xlat_main(i);
|
||||
}
|
36
3rdparty/glsl-optimizer/tests/fragment/loop-foraliasinductor-outES.txt
vendored
Normal file
36
3rdparty/glsl-optimizer/tests/fragment/loop-foraliasinductor-outES.txt
vendored
Normal file
@ -0,0 +1,36 @@
|
||||
uniform sampler2D _MainTex;
|
||||
varying highp vec2 xlv_uv;
|
||||
void main ()
|
||||
{
|
||||
lowp vec4 tmpvar_1;
|
||||
highp vec2 tmpvar_2;
|
||||
tmpvar_2 = xlv_uv;
|
||||
mediump vec3 light_3;
|
||||
lowp vec4 col_4;
|
||||
lowp vec4 tmpvar_5;
|
||||
tmpvar_5 = texture2D (_MainTex, xlv_uv);
|
||||
col_4 = tmpvar_5;
|
||||
light_3 = vec3(0.0, 0.0, 0.0);
|
||||
if ((tmpvar_5.x >= 0.0)) {
|
||||
for (highp float j_6 = 0.0; j_6 < tmpvar_2.x; j_6 += 1.0) {
|
||||
light_3 = (light_3 + col_4.xyz);
|
||||
};
|
||||
};
|
||||
if ((tmpvar_5.x >= 1.0)) {
|
||||
highp float j_7;
|
||||
j_7 = (xlv_uv.y * sin(xlv_uv.y));
|
||||
light_3 = (light_3 + (tmpvar_5.xyz * j_7));
|
||||
};
|
||||
mediump vec4 tmpvar_8;
|
||||
tmpvar_8.w = 1.0;
|
||||
tmpvar_8.xyz = light_3;
|
||||
tmpvar_1 = tmpvar_8;
|
||||
gl_FragData[0] = tmpvar_1;
|
||||
}
|
||||
|
||||
|
||||
// stats: 12 alu 1 tex 4 flow
|
||||
// inputs: 1
|
||||
// #0: xlv_uv (high float) 2x1 [-1]
|
||||
// textures: 1
|
||||
// #0: _MainTex (low 2d) 0x0 [-1]
|
24
3rdparty/glsl-optimizer/tests/fragment/loop-forwronginductor-inES.txt
vendored
Normal file
24
3rdparty/glsl-optimizer/tests/fragment/loop-forwronginductor-inES.txt
vendored
Normal file
@ -0,0 +1,24 @@
|
||||
struct v2f {
|
||||
highp vec2 uv;
|
||||
highp vec3 nl;
|
||||
};
|
||||
uniform sampler2D _MainTex;
|
||||
uniform highp vec4 _TerrainTreeLightColors[4];
|
||||
lowp vec4 xlat_main (in v2f i) {
|
||||
lowp vec4 col = texture2D( _MainTex, i.uv);
|
||||
mediump vec3 light = vec3(0.0);
|
||||
if(col.x >= 0.0) {
|
||||
for (float j = 0.0; (j < i.uv.x); (j++)) {
|
||||
light += col.xyz;
|
||||
}
|
||||
}
|
||||
return vec4(light, 1.0);
|
||||
}
|
||||
varying highp vec2 xlv_uv;
|
||||
varying highp vec3 xlv_nl;
|
||||
void main() {
|
||||
v2f i;
|
||||
i.uv = xlv_uv;
|
||||
i.nl = xlv_nl;
|
||||
gl_FragData[0] = xlat_main(i);
|
||||
}
|
31
3rdparty/glsl-optimizer/tests/fragment/loop-forwronginductor-outES.txt
vendored
Normal file
31
3rdparty/glsl-optimizer/tests/fragment/loop-forwronginductor-outES.txt
vendored
Normal file
@ -0,0 +1,31 @@
|
||||
uniform sampler2D _MainTex;
|
||||
varying highp vec2 xlv_uv;
|
||||
void main ()
|
||||
{
|
||||
lowp vec4 tmpvar_1;
|
||||
highp vec2 tmpvar_2;
|
||||
tmpvar_2 = xlv_uv;
|
||||
mediump vec3 light_3;
|
||||
lowp vec4 col_4;
|
||||
lowp vec4 tmpvar_5;
|
||||
tmpvar_5 = texture2D (_MainTex, xlv_uv);
|
||||
col_4 = tmpvar_5;
|
||||
light_3 = vec3(0.0, 0.0, 0.0);
|
||||
if ((tmpvar_5.x >= 0.0)) {
|
||||
for (highp float j_6 = 0.0; j_6 < tmpvar_2.x; j_6 += 1.0) {
|
||||
light_3 = (light_3 + col_4.xyz);
|
||||
};
|
||||
};
|
||||
mediump vec4 tmpvar_7;
|
||||
tmpvar_7.w = 1.0;
|
||||
tmpvar_7.xyz = light_3;
|
||||
tmpvar_1 = tmpvar_7;
|
||||
gl_FragData[0] = tmpvar_1;
|
||||
}
|
||||
|
||||
|
||||
// stats: 7 alu 1 tex 3 flow
|
||||
// inputs: 1
|
||||
// #0: xlv_uv (high float) 2x1 [-1]
|
||||
// textures: 1
|
||||
// #0: _MainTex (low 2d) 0x0 [-1]
|
94
3rdparty/glsl-optimizer/tests/fragment/matrix-cast-types-inES3.txt
vendored
Normal file
94
3rdparty/glsl-optimizer/tests/fragment/matrix-cast-types-inES3.txt
vendored
Normal file
@ -0,0 +1,94 @@
|
||||
#version 300 es
|
||||
|
||||
// Shader below was causing invalid matrix assignment (different types, i.e. half3x3 vs float3x3)
|
||||
// in the resulting Metal code. Caused by some combination of matrix transposes and other operations
|
||||
// on them.
|
||||
|
||||
mat3 xll_transpose_mf3x3(mat3 m) {
|
||||
return mat3( m[0][0], m[1][0], m[2][0],
|
||||
m[0][1], m[1][1], m[2][1],
|
||||
m[0][2], m[1][2], m[2][2]);
|
||||
}
|
||||
vec3 xll_matrixindex_mf3x3_i (mat3 m, int i) { vec3 v; v.x=m[0][i]; v.y=m[1][i]; v.z=m[2][i]; return v; }
|
||||
struct SurfaceOutput {
|
||||
lowp vec3 Albedo;
|
||||
lowp vec3 Normal;
|
||||
lowp vec3 Emission;
|
||||
mediump float Specular;
|
||||
lowp float Gloss;
|
||||
lowp float Alpha;
|
||||
};
|
||||
struct Input {
|
||||
highp vec2 uv_PanelTex;
|
||||
highp vec2 uv2_DecalTex;
|
||||
};
|
||||
struct v2f_surf {
|
||||
highp vec4 pos;
|
||||
highp vec4 pack0;
|
||||
highp vec4 tSpace0;
|
||||
highp vec4 tSpace1;
|
||||
highp vec4 tSpace2;
|
||||
};
|
||||
uniform highp vec4 _WorldSpaceLightPos0;
|
||||
uniform sampler2D _PanelNorm;
|
||||
uniform sampler2D _DecalNorm;
|
||||
highp vec3 UnityWorldSpaceLightDir( in highp vec3 worldPos ) {
|
||||
return (_WorldSpaceLightPos0.xyz - (worldPos * _WorldSpaceLightPos0.w));
|
||||
}
|
||||
void surf( in Input IN, inout SurfaceOutput o ) {
|
||||
|
||||
lowp vec3 baseNormal = ((texture( _DecalNorm, IN.uv2_DecalTex).xyz * 2.0) - 1.0);
|
||||
lowp vec3 detailNormal = ((texture( _PanelNorm, IN.uv_PanelTex).xyz * 2.0) - 1.0);
|
||||
highp mat3 nBasis = xll_transpose_mf3x3(mat3( vec3( baseNormal.z, baseNormal.y, (-baseNormal.x)), vec3( baseNormal.x, baseNormal.z, (-baseNormal.y)), vec3( baseNormal.x, baseNormal.y, baseNormal.z)));
|
||||
|
||||
lowp vec3 combinedNormal = normalize((((detailNormal.x * xll_matrixindex_mf3x3_i (nBasis, 0)) + (detailNormal.y * xll_matrixindex_mf3x3_i (nBasis, 1))) + (detailNormal.z * xll_matrixindex_mf3x3_i (nBasis, 2))));
|
||||
combinedNormal *= 1.0;
|
||||
o.Normal = combinedNormal;
|
||||
}
|
||||
lowp vec4 frag_surf( in v2f_surf IN ) {
|
||||
Input surfIN;
|
||||
|
||||
surfIN.uv_PanelTex = IN.pack0.xy;
|
||||
surfIN.uv2_DecalTex = IN.pack0.zw;
|
||||
highp vec3 worldPos = vec3( IN.tSpace0.w, IN.tSpace1.w, IN.tSpace2.w);
|
||||
|
||||
lowp vec3 lightDir = normalize(UnityWorldSpaceLightDir( worldPos));
|
||||
|
||||
SurfaceOutput o;
|
||||
o.Albedo = vec3( 0.0);
|
||||
o.Emission = vec3( 0.0);
|
||||
|
||||
o.Specular = 0.0;
|
||||
o.Alpha = 0.0;
|
||||
o.Gloss = 0.0;
|
||||
lowp vec3 normalWorldVertex = vec3( 0.0, 0.0, 1.0);
|
||||
|
||||
surf( surfIN, o);
|
||||
lowp vec3 worldN;
|
||||
worldN.x = dot( IN.tSpace0.xyz, o.Normal);
|
||||
worldN.y = dot( IN.tSpace1.xyz, o.Normal);
|
||||
|
||||
worldN.z = dot( IN.tSpace2.xyz, o.Normal);
|
||||
o.Normal = worldN;
|
||||
|
||||
lowp vec4 res;
|
||||
res.xyz = ((o.Normal * 0.5) + 0.5);
|
||||
res.w = o.Specular;
|
||||
return res;
|
||||
}
|
||||
in highp vec4 xlv_TEXCOORD0;
|
||||
in highp vec4 xlv_TEXCOORD1;
|
||||
in highp vec4 xlv_TEXCOORD2;
|
||||
in highp vec4 xlv_TEXCOORD3;
|
||||
out lowp vec4 _fragData;
|
||||
void main() {
|
||||
lowp vec4 xl_retval;
|
||||
v2f_surf xlt_IN;
|
||||
xlt_IN.pos = vec4(0.0);
|
||||
xlt_IN.pack0 = vec4(xlv_TEXCOORD0);
|
||||
xlt_IN.tSpace0 = vec4(xlv_TEXCOORD1);
|
||||
xlt_IN.tSpace1 = vec4(xlv_TEXCOORD2);
|
||||
xlt_IN.tSpace2 = vec4(xlv_TEXCOORD3);
|
||||
xl_retval = frag_surf( xlt_IN);
|
||||
_fragData = vec4(xl_retval);
|
||||
}
|
78
3rdparty/glsl-optimizer/tests/fragment/matrix-cast-types-outES3.txt
vendored
Normal file
78
3rdparty/glsl-optimizer/tests/fragment/matrix-cast-types-outES3.txt
vendored
Normal file
@ -0,0 +1,78 @@
|
||||
#version 300 es
|
||||
uniform sampler2D _PanelNorm;
|
||||
uniform sampler2D _DecalNorm;
|
||||
in highp vec4 xlv_TEXCOORD0;
|
||||
in highp vec4 xlv_TEXCOORD1;
|
||||
in highp vec4 xlv_TEXCOORD2;
|
||||
in highp vec4 xlv_TEXCOORD3;
|
||||
out lowp vec4 _fragData;
|
||||
void main ()
|
||||
{
|
||||
lowp vec4 res_1;
|
||||
lowp vec3 worldN_2;
|
||||
lowp vec3 combinedNormal_3;
|
||||
lowp vec3 tmpvar_4;
|
||||
tmpvar_4 = ((texture (_DecalNorm, xlv_TEXCOORD0.zw).xyz * 2.0) - 1.0);
|
||||
lowp vec3 tmpvar_5;
|
||||
tmpvar_5 = ((texture (_PanelNorm, xlv_TEXCOORD0.xy).xyz * 2.0) - 1.0);
|
||||
lowp vec3 tmpvar_6;
|
||||
tmpvar_6.x = tmpvar_4.z;
|
||||
tmpvar_6.y = tmpvar_4.y;
|
||||
tmpvar_6.z = -(tmpvar_4.x);
|
||||
lowp vec3 tmpvar_7;
|
||||
tmpvar_7.x = tmpvar_4.x;
|
||||
tmpvar_7.y = tmpvar_4.z;
|
||||
tmpvar_7.z = -(tmpvar_4.y);
|
||||
highp mat3 tmpvar_8;
|
||||
lowp mat3 tmpvar_9;
|
||||
tmpvar_9[uint(0)].x = tmpvar_6.x;
|
||||
tmpvar_9[uint(0)].y = tmpvar_7.x;
|
||||
tmpvar_9[uint(0)].z = tmpvar_4.x;
|
||||
tmpvar_9[1u].x = tmpvar_6.y;
|
||||
tmpvar_9[1u].y = tmpvar_7.y;
|
||||
tmpvar_9[1u].z = tmpvar_4.y;
|
||||
tmpvar_9[2u].x = tmpvar_6.z;
|
||||
tmpvar_9[2u].y = tmpvar_7.z;
|
||||
tmpvar_9[2u].z = tmpvar_4.z;
|
||||
tmpvar_8 = tmpvar_9;
|
||||
highp vec3 v_10;
|
||||
v_10.x = tmpvar_8[0].x;
|
||||
v_10.y = tmpvar_8[1].x;
|
||||
v_10.z = tmpvar_8[2].x;
|
||||
highp vec3 v_11;
|
||||
v_11.x = tmpvar_8[0].y;
|
||||
v_11.y = tmpvar_8[1].y;
|
||||
v_11.z = tmpvar_8[2].y;
|
||||
highp vec3 v_12;
|
||||
v_12.x = tmpvar_8[0].z;
|
||||
v_12.y = tmpvar_8[1].z;
|
||||
v_12.z = tmpvar_8[2].z;
|
||||
combinedNormal_3 = normalize(((
|
||||
(tmpvar_5.x * v_10)
|
||||
+
|
||||
(tmpvar_5.y * v_11)
|
||||
) + (tmpvar_5.z * v_12)));
|
||||
highp float tmpvar_13;
|
||||
tmpvar_13 = dot (xlv_TEXCOORD1.xyz, combinedNormal_3);
|
||||
worldN_2.x = tmpvar_13;
|
||||
highp float tmpvar_14;
|
||||
tmpvar_14 = dot (xlv_TEXCOORD2.xyz, combinedNormal_3);
|
||||
worldN_2.y = tmpvar_14;
|
||||
highp float tmpvar_15;
|
||||
tmpvar_15 = dot (xlv_TEXCOORD3.xyz, combinedNormal_3);
|
||||
worldN_2.z = tmpvar_15;
|
||||
res_1.xyz = ((worldN_2 * 0.5) + 0.5);
|
||||
res_1.w = 0.0;
|
||||
_fragData = res_1;
|
||||
}
|
||||
|
||||
|
||||
// stats: 18 alu 2 tex 0 flow
|
||||
// inputs: 4
|
||||
// #0: xlv_TEXCOORD0 (high float) 4x1 [-1]
|
||||
// #1: xlv_TEXCOORD1 (high float) 4x1 [-1]
|
||||
// #2: xlv_TEXCOORD2 (high float) 4x1 [-1]
|
||||
// #3: xlv_TEXCOORD3 (high float) 4x1 [-1]
|
||||
// textures: 2
|
||||
// #0: _PanelNorm (low 2d) 0x0 [-1]
|
||||
// #1: _DecalNorm (low 2d) 0x0 [-1]
|
93
3rdparty/glsl-optimizer/tests/fragment/matrix-cast-types-outES3Metal.txt
vendored
Normal file
93
3rdparty/glsl-optimizer/tests/fragment/matrix-cast-types-outES3Metal.txt
vendored
Normal file
@ -0,0 +1,93 @@
|
||||
#include <metal_stdlib>
|
||||
using namespace metal;
|
||||
inline float4x4 _xlcast_float4x4(half4x4 v) { return float4x4(float4(v[0]), float4(v[1]), float4(v[2]), float4(v[3])); }
|
||||
inline float3x3 _xlcast_float3x3(half3x3 v) { return float3x3(float3(v[0]), float3(v[1]), float3(v[2])); }
|
||||
inline float2x2 _xlcast_float2x2(half2x2 v) { return float2x2(float2(v[0]), float2(v[1])); }
|
||||
inline half4x4 _xlcast_half4x4(float4x4 v) { return half4x4(half4(v[0]), half4(v[1]), half4(v[2]), half4(v[3])); }
|
||||
inline half3x3 _xlcast_half3x3(float3x3 v) { return half3x3(half3(v[0]), half3(v[1]), half3(v[2])); }
|
||||
inline half2x2 _xlcast_half2x2(float2x2 v) { return half2x2(half2(v[0]), half2(v[1])); }
|
||||
struct xlatMtlShaderInput {
|
||||
float4 xlv_TEXCOORD0;
|
||||
float4 xlv_TEXCOORD1;
|
||||
float4 xlv_TEXCOORD2;
|
||||
float4 xlv_TEXCOORD3;
|
||||
};
|
||||
struct xlatMtlShaderOutput {
|
||||
half4 _fragData [[color(0)]];
|
||||
};
|
||||
struct xlatMtlShaderUniform {
|
||||
};
|
||||
fragment xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]], constant xlatMtlShaderUniform& _mtl_u [[buffer(0)]]
|
||||
, texture2d<half> _PanelNorm [[texture(0)]], sampler _mtlsmp__PanelNorm [[sampler(0)]]
|
||||
, texture2d<half> _DecalNorm [[texture(1)]], sampler _mtlsmp__DecalNorm [[sampler(1)]])
|
||||
{
|
||||
xlatMtlShaderOutput _mtl_o;
|
||||
half4 res_1;
|
||||
half3 worldN_2;
|
||||
half3 combinedNormal_3;
|
||||
half3 tmpvar_4;
|
||||
tmpvar_4 = ((_DecalNorm.sample(_mtlsmp__DecalNorm, (float2)(_mtl_i.xlv_TEXCOORD0.zw)).xyz * (half)2.0) - (half)1.0);
|
||||
half3 tmpvar_5;
|
||||
tmpvar_5 = ((_PanelNorm.sample(_mtlsmp__PanelNorm, (float2)(_mtl_i.xlv_TEXCOORD0.xy)).xyz * (half)2.0) - (half)1.0);
|
||||
half3 tmpvar_6;
|
||||
tmpvar_6.x = tmpvar_4.z;
|
||||
tmpvar_6.y = tmpvar_4.y;
|
||||
tmpvar_6.z = -(tmpvar_4.x);
|
||||
half3 tmpvar_7;
|
||||
tmpvar_7.x = tmpvar_4.x;
|
||||
tmpvar_7.y = tmpvar_4.z;
|
||||
tmpvar_7.z = -(tmpvar_4.y);
|
||||
float3x3 tmpvar_8;
|
||||
half3x3 tmpvar_9;
|
||||
tmpvar_9[0].x = tmpvar_6.x;
|
||||
tmpvar_9[0].y = tmpvar_7.x;
|
||||
tmpvar_9[0].z = tmpvar_4.x;
|
||||
tmpvar_9[1].x = tmpvar_6.y;
|
||||
tmpvar_9[1].y = tmpvar_7.y;
|
||||
tmpvar_9[1].z = tmpvar_4.y;
|
||||
tmpvar_9[2].x = tmpvar_6.z;
|
||||
tmpvar_9[2].y = tmpvar_7.z;
|
||||
tmpvar_9[2].z = tmpvar_4.z;
|
||||
tmpvar_8 = _xlcast_float3x3(tmpvar_9);
|
||||
float3 v_10;
|
||||
v_10.x = tmpvar_8[0].x;
|
||||
v_10.y = tmpvar_8[1].x;
|
||||
v_10.z = tmpvar_8[2].x;
|
||||
float3 v_11;
|
||||
v_11.x = tmpvar_8[0].y;
|
||||
v_11.y = tmpvar_8[1].y;
|
||||
v_11.z = tmpvar_8[2].y;
|
||||
float3 v_12;
|
||||
v_12.x = tmpvar_8[0].z;
|
||||
v_12.y = tmpvar_8[1].z;
|
||||
v_12.z = tmpvar_8[2].z;
|
||||
combinedNormal_3 = normalize(((
|
||||
((half3)((float)tmpvar_5.x * v_10))
|
||||
+
|
||||
((half3)((float)tmpvar_5.y * v_11))
|
||||
) + ((half3)((float)tmpvar_5.z * v_12))));
|
||||
float tmpvar_13;
|
||||
tmpvar_13 = dot (_mtl_i.xlv_TEXCOORD1.xyz, (float3)combinedNormal_3);
|
||||
worldN_2.x = half(tmpvar_13);
|
||||
float tmpvar_14;
|
||||
tmpvar_14 = dot (_mtl_i.xlv_TEXCOORD2.xyz, (float3)combinedNormal_3);
|
||||
worldN_2.y = half(tmpvar_14);
|
||||
float tmpvar_15;
|
||||
tmpvar_15 = dot (_mtl_i.xlv_TEXCOORD3.xyz, (float3)combinedNormal_3);
|
||||
worldN_2.z = half(tmpvar_15);
|
||||
res_1.xyz = ((worldN_2 * (half)0.5) + (half)0.5);
|
||||
res_1.w = half(0.0);
|
||||
_mtl_o._fragData = res_1;
|
||||
return _mtl_o;
|
||||
}
|
||||
|
||||
|
||||
// stats: 18 alu 2 tex 0 flow
|
||||
// inputs: 4
|
||||
// #0: xlv_TEXCOORD0 (high float) 4x1 [-1]
|
||||
// #1: xlv_TEXCOORD1 (high float) 4x1 [-1]
|
||||
// #2: xlv_TEXCOORD2 (high float) 4x1 [-1]
|
||||
// #3: xlv_TEXCOORD3 (high float) 4x1 [-1]
|
||||
// textures: 2
|
||||
// #0: _PanelNorm (low 2d) 0x0 [-1] loc 0
|
||||
// #1: _DecalNorm (low 2d) 0x0 [-1] loc 1
|
30
3rdparty/glsl-optimizer/tests/fragment/matrix-ops-inES3.txt
vendored
Normal file
30
3rdparty/glsl-optimizer/tests/fragment/matrix-ops-inES3.txt
vendored
Normal file
@ -0,0 +1,30 @@
|
||||
#version 300 es
|
||||
out mediump vec4 _fragData;
|
||||
uniform highp float _Speed;
|
||||
uniform highp vec4 _Time;
|
||||
highp vec4 func( in highp vec2 uv )
|
||||
{
|
||||
highp float s = sin(_Speed * _Time.x);
|
||||
highp float c = cos(_Speed * _Time.x);
|
||||
|
||||
highp mat2 rotationMatrix = mat2(c, s, -s, c);
|
||||
// various operations on a matrix
|
||||
rotationMatrix = rotationMatrix * 2.0;
|
||||
rotationMatrix = rotationMatrix - 1.0;
|
||||
rotationMatrix = s - rotationMatrix;
|
||||
rotationMatrix = c + rotationMatrix;
|
||||
rotationMatrix /= s;
|
||||
|
||||
mediump mat2 halfMatrix = mat2(c, s, -s, c);
|
||||
halfMatrix = halfMatrix * 2.0;
|
||||
halfMatrix = halfMatrix - 1.0;
|
||||
halfMatrix = s - halfMatrix;
|
||||
halfMatrix = c + halfMatrix;
|
||||
halfMatrix /= s;
|
||||
|
||||
return vec4((rotationMatrix * uv), (halfMatrix * uv));
|
||||
}
|
||||
in highp vec2 uv;
|
||||
void main() {
|
||||
_fragData = func(uv);
|
||||
}
|
49
3rdparty/glsl-optimizer/tests/fragment/matrix-ops-outES3.txt
vendored
Normal file
49
3rdparty/glsl-optimizer/tests/fragment/matrix-ops-outES3.txt
vendored
Normal file
@ -0,0 +1,49 @@
|
||||
#version 300 es
|
||||
out mediump vec4 _fragData;
|
||||
uniform highp float _Speed;
|
||||
uniform highp vec4 _Time;
|
||||
in highp vec2 uv;
|
||||
void main ()
|
||||
{
|
||||
mediump mat2 halfMatrix_1;
|
||||
highp mat2 rotationMatrix_2;
|
||||
highp float tmpvar_3;
|
||||
highp float tmpvar_4;
|
||||
tmpvar_4 = (_Speed * _Time.x);
|
||||
tmpvar_3 = sin(tmpvar_4);
|
||||
highp float tmpvar_5;
|
||||
tmpvar_5 = cos(tmpvar_4);
|
||||
highp mat2 tmpvar_6;
|
||||
tmpvar_6[uint(0)].x = tmpvar_5;
|
||||
tmpvar_6[uint(0)].y = tmpvar_3;
|
||||
tmpvar_6[1u].x = -(tmpvar_3);
|
||||
tmpvar_6[1u].y = tmpvar_5;
|
||||
rotationMatrix_2 = (tmpvar_6 * 2.0);
|
||||
rotationMatrix_2 = (rotationMatrix_2 - 1.0);
|
||||
rotationMatrix_2 = (tmpvar_3 - rotationMatrix_2);
|
||||
rotationMatrix_2 = (tmpvar_5 + rotationMatrix_2);
|
||||
rotationMatrix_2 = (rotationMatrix_2 / tmpvar_3);
|
||||
highp mat2 tmpvar_7;
|
||||
tmpvar_7[uint(0)].x = tmpvar_5;
|
||||
tmpvar_7[uint(0)].y = tmpvar_3;
|
||||
tmpvar_7[1u].x = -(tmpvar_3);
|
||||
tmpvar_7[1u].y = tmpvar_5;
|
||||
halfMatrix_1 = tmpvar_7;
|
||||
halfMatrix_1 = (halfMatrix_1 * 2.0);
|
||||
halfMatrix_1 = (halfMatrix_1 - 1.0);
|
||||
halfMatrix_1 = (tmpvar_3 - halfMatrix_1);
|
||||
halfMatrix_1 = (tmpvar_5 + halfMatrix_1);
|
||||
halfMatrix_1 = (halfMatrix_1 / tmpvar_3);
|
||||
highp vec4 tmpvar_8;
|
||||
tmpvar_8.xy = (rotationMatrix_2 * uv);
|
||||
tmpvar_8.zw = (halfMatrix_1 * uv);
|
||||
_fragData = tmpvar_8;
|
||||
}
|
||||
|
||||
|
||||
// stats: 17 alu 0 tex 0 flow
|
||||
// inputs: 1
|
||||
// #0: uv (high float) 2x1 [-1]
|
||||
// uniforms: 2 (total size: 0)
|
||||
// #0: _Speed (high float) 1x1 [-1]
|
||||
// #1: _Time (high float) 4x1 [-1]
|
70
3rdparty/glsl-optimizer/tests/fragment/matrix-ops-outES3Metal.txt
vendored
Normal file
70
3rdparty/glsl-optimizer/tests/fragment/matrix-ops-outES3Metal.txt
vendored
Normal file
@ -0,0 +1,70 @@
|
||||
#include <metal_stdlib>
|
||||
using namespace metal;
|
||||
inline float4x4 _xlinit_float4x4(float v) { return float4x4(float4(v), float4(v), float4(v), float4(v)); }
|
||||
inline float3x3 _xlinit_float3x3(float v) { return float3x3(float3(v), float3(v), float3(v)); }
|
||||
inline float2x2 _xlinit_float2x2(float v) { return float2x2(float2(v), float2(v)); }
|
||||
inline half4x4 _xlinit_half4x4(half v) { return half4x4(half4(v), half4(v), half4(v), half4(v)); }
|
||||
inline half3x3 _xlinit_half3x3(half v) { return half3x3(half3(v), half3(v), half3(v)); }
|
||||
inline half2x2 _xlinit_half2x2(half v) { return half2x2(half2(v), half2(v)); }
|
||||
inline float4x4 _xlcast_float4x4(half4x4 v) { return float4x4(float4(v[0]), float4(v[1]), float4(v[2]), float4(v[3])); }
|
||||
inline float3x3 _xlcast_float3x3(half3x3 v) { return float3x3(float3(v[0]), float3(v[1]), float3(v[2])); }
|
||||
inline float2x2 _xlcast_float2x2(half2x2 v) { return float2x2(float2(v[0]), float2(v[1])); }
|
||||
inline half4x4 _xlcast_half4x4(float4x4 v) { return half4x4(half4(v[0]), half4(v[1]), half4(v[2]), half4(v[3])); }
|
||||
inline half3x3 _xlcast_half3x3(float3x3 v) { return half3x3(half3(v[0]), half3(v[1]), half3(v[2])); }
|
||||
inline half2x2 _xlcast_half2x2(float2x2 v) { return half2x2(half2(v[0]), half2(v[1])); }
|
||||
struct xlatMtlShaderInput {
|
||||
float2 uv;
|
||||
};
|
||||
struct xlatMtlShaderOutput {
|
||||
half4 _fragData [[color(0)]];
|
||||
};
|
||||
struct xlatMtlShaderUniform {
|
||||
float _Speed;
|
||||
float4 _Time;
|
||||
};
|
||||
fragment xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]], constant xlatMtlShaderUniform& _mtl_u [[buffer(0)]])
|
||||
{
|
||||
xlatMtlShaderOutput _mtl_o;
|
||||
half2x2 halfMatrix_1;
|
||||
float2x2 rotationMatrix_2;
|
||||
float tmpvar_3;
|
||||
float tmpvar_4;
|
||||
tmpvar_4 = (_mtl_u._Speed * _mtl_u._Time.x);
|
||||
tmpvar_3 = sin(tmpvar_4);
|
||||
float tmpvar_5;
|
||||
tmpvar_5 = cos(tmpvar_4);
|
||||
float2x2 tmpvar_6;
|
||||
tmpvar_6[0].x = tmpvar_5;
|
||||
tmpvar_6[0].y = tmpvar_3;
|
||||
tmpvar_6[1].x = -(tmpvar_3);
|
||||
tmpvar_6[1].y = tmpvar_5;
|
||||
rotationMatrix_2 = (tmpvar_6 * 2.0);
|
||||
rotationMatrix_2 = (rotationMatrix_2 - _xlinit_float2x2(1.0));
|
||||
rotationMatrix_2 = (_xlinit_float2x2(tmpvar_3) - rotationMatrix_2);
|
||||
rotationMatrix_2 = (_xlinit_float2x2(tmpvar_5) + rotationMatrix_2);
|
||||
rotationMatrix_2 = (rotationMatrix_2 * (1.0/(tmpvar_3)));
|
||||
float2x2 tmpvar_7;
|
||||
tmpvar_7[0].x = tmpvar_5;
|
||||
tmpvar_7[0].y = tmpvar_3;
|
||||
tmpvar_7[1].x = -(tmpvar_3);
|
||||
tmpvar_7[1].y = tmpvar_5;
|
||||
halfMatrix_1 = _xlcast_half2x2(tmpvar_7);
|
||||
halfMatrix_1 = (halfMatrix_1 * (half)2.0);
|
||||
halfMatrix_1 = (halfMatrix_1 - _xlinit_half2x2(1.0));
|
||||
halfMatrix_1 = _xlcast_half2x2(((float2x2)(_xlinit_half2x2(tmpvar_3) - halfMatrix_1)));
|
||||
halfMatrix_1 = _xlcast_half2x2(((float2x2)(_xlinit_half2x2(tmpvar_5) + halfMatrix_1)));
|
||||
halfMatrix_1 = _xlcast_half2x2(((float2x2)(halfMatrix_1 * (1.0h/half(tmpvar_3)))));
|
||||
float4 tmpvar_8;
|
||||
tmpvar_8.xy = (rotationMatrix_2 * _mtl_i.uv);
|
||||
tmpvar_8.zw = ((float2)(halfMatrix_1 * (half2)_mtl_i.uv));
|
||||
_mtl_o._fragData = half4(tmpvar_8);
|
||||
return _mtl_o;
|
||||
}
|
||||
|
||||
|
||||
// stats: 17 alu 0 tex 0 flow
|
||||
// inputs: 1
|
||||
// #0: uv (high float) 2x1 [-1]
|
||||
// uniforms: 2 (total size: 32)
|
||||
// #0: _Speed (high float) 1x1 [-1] loc 0
|
||||
// #1: _Time (high float) 4x1 [-1] loc 16
|
@ -1,4 +1,4 @@
|
||||
#extension GL_EXT_draw_buffers : require
|
||||
#extension GL_EXT_draw_buffers : enable
|
||||
void main ()
|
||||
{
|
||||
gl_FragData[0] = vec4(0.0, 0.0, 0.0, 0.0);
|
||||
|
@ -12,7 +12,8 @@ void main ()
|
||||
discard;
|
||||
};
|
||||
c_1 = 0.0;
|
||||
for (highp int i_2 = tmpvar_3; i_2 < 4; i_2++, c_1 = (c_1 + xx)) {
|
||||
for (highp int i_2 = tmpvar_3; i_2 < 4; i_2++) {
|
||||
c_1 = (c_1 + xx);
|
||||
};
|
||||
lowp vec4 tmpvar_4;
|
||||
tmpvar_4 = vec4(c_1);
|
||||
|
@ -5,13 +5,13 @@ uniform mediump float _EmberFadeStart;
|
||||
varying mediump vec2 xlv_TEXCOORD0;
|
||||
void main ()
|
||||
{
|
||||
mediump float x_1;
|
||||
x_1 = ((_EmberFadeStart - 0.05) / (_EmberFadeStart - _EmberFadeEnd));
|
||||
lowp float tmpvar_2;
|
||||
tmpvar_2 = clamp (x_1, 0.0, 1.0);
|
||||
lowp float tmpvar_1;
|
||||
mediump float tmpvar_2;
|
||||
tmpvar_2 = clamp (((_EmberFadeStart - 0.05) / (_EmberFadeStart - _EmberFadeEnd)), 0.0, 1.0);
|
||||
tmpvar_1 = tmpvar_2;
|
||||
lowp vec4 tmpvar_3;
|
||||
tmpvar_3.w = 1.0;
|
||||
tmpvar_3.xyz = mix (texture2D (_MainTex, xlv_TEXCOORD0).xyz, texture2D (_BurntTex, xlv_TEXCOORD0).xyz, vec3(tmpvar_2));
|
||||
tmpvar_3.xyz = mix (texture2D (_MainTex, xlv_TEXCOORD0).xyz, texture2D (_BurntTex, xlv_TEXCOORD0).xyz, vec3(tmpvar_1));
|
||||
gl_FragColor = tmpvar_3;
|
||||
}
|
||||
|
||||
|
@ -11,21 +11,17 @@ void main ()
|
||||
lowp vec4 tmpvar_2;
|
||||
tmpvar_2 = texture2D (texlow, varUV.xy);
|
||||
c_1 = tmpvar_2;
|
||||
mediump vec4 tmpvar_3;
|
||||
tmpvar_3 = texture2D (texmed, varUV.xy);
|
||||
c_1 = (c_1 + texture2D (texmed, varUV.xy));
|
||||
highp vec4 tmpvar_3;
|
||||
tmpvar_3 = texture2D (texhigh, varUV.xy);
|
||||
c_1 = (c_1 + tmpvar_3);
|
||||
highp vec4 tmpvar_4;
|
||||
tmpvar_4 = texture2D (texhigh, varUV.xy);
|
||||
lowp vec4 tmpvar_4;
|
||||
tmpvar_4 = textureCube (cubelow, varUV.xyz);
|
||||
c_1 = (c_1 + tmpvar_4);
|
||||
lowp vec4 tmpvar_5;
|
||||
tmpvar_5 = textureCube (cubelow, varUV.xyz);
|
||||
c_1 = (c_1 + textureCube (cubemed, varUV.xyz));
|
||||
highp vec4 tmpvar_5;
|
||||
tmpvar_5 = textureCube (cubehigh, varUV.xyz);
|
||||
c_1 = (c_1 + tmpvar_5);
|
||||
mediump vec4 tmpvar_6;
|
||||
tmpvar_6 = textureCube (cubemed, varUV.xyz);
|
||||
c_1 = (c_1 + tmpvar_6);
|
||||
highp vec4 tmpvar_7;
|
||||
tmpvar_7 = textureCube (cubehigh, varUV.xyz);
|
||||
c_1 = (c_1 + tmpvar_7);
|
||||
gl_FragData[0] = c_1;
|
||||
}
|
||||
|
||||
|
@ -13,21 +13,17 @@ void main ()
|
||||
lowp vec4 tmpvar_2;
|
||||
tmpvar_2 = texture (texlow, varUV.xy);
|
||||
c_1 = tmpvar_2;
|
||||
mediump vec4 tmpvar_3;
|
||||
tmpvar_3 = texture (texmed, varUV.xy);
|
||||
c_1 = (c_1 + texture (texmed, varUV.xy));
|
||||
highp vec4 tmpvar_3;
|
||||
tmpvar_3 = texture (texhigh, varUV.xy);
|
||||
c_1 = (c_1 + tmpvar_3);
|
||||
highp vec4 tmpvar_4;
|
||||
tmpvar_4 = texture (texhigh, varUV.xy);
|
||||
lowp vec4 tmpvar_4;
|
||||
tmpvar_4 = texture (cubelow, varUV.xyz);
|
||||
c_1 = (c_1 + tmpvar_4);
|
||||
lowp vec4 tmpvar_5;
|
||||
tmpvar_5 = texture (cubelow, varUV.xyz);
|
||||
c_1 = (c_1 + texture (cubemed, varUV.xyz));
|
||||
highp vec4 tmpvar_5;
|
||||
tmpvar_5 = texture (cubehigh, varUV.xyz);
|
||||
c_1 = (c_1 + tmpvar_5);
|
||||
mediump vec4 tmpvar_6;
|
||||
tmpvar_6 = texture (cubemed, varUV.xyz);
|
||||
c_1 = (c_1 + tmpvar_6);
|
||||
highp vec4 tmpvar_7;
|
||||
tmpvar_7 = texture (cubehigh, varUV.xyz);
|
||||
c_1 = (c_1 + tmpvar_7);
|
||||
_fragData = c_1;
|
||||
}
|
||||
|
||||
|
@ -21,21 +21,17 @@ fragment xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]]
|
||||
half4 tmpvar_2;
|
||||
tmpvar_2 = texlow.sample(_mtlsmp_texlow, (float2)(_mtl_i.varUV.xy));
|
||||
c_1 = tmpvar_2;
|
||||
half4 tmpvar_3;
|
||||
tmpvar_3 = texmed.sample(_mtlsmp_texmed, (float2)(_mtl_i.varUV.xy));
|
||||
c_1 = (c_1 + tmpvar_3);
|
||||
float4 tmpvar_4;
|
||||
tmpvar_4 = float4(texhigh.sample(_mtlsmp_texhigh, (float2)(_mtl_i.varUV.xy)));
|
||||
c_1 = half4(((float4)c_1 + tmpvar_4));
|
||||
half4 tmpvar_5;
|
||||
tmpvar_5 = cubelow.sample(_mtlsmp_cubelow, (float3)(_mtl_i.varUV.xyz));
|
||||
c_1 = (c_1 + tmpvar_5);
|
||||
half4 tmpvar_6;
|
||||
tmpvar_6 = cubemed.sample(_mtlsmp_cubemed, (float3)(_mtl_i.varUV.xyz));
|
||||
c_1 = (c_1 + tmpvar_6);
|
||||
float4 tmpvar_7;
|
||||
tmpvar_7 = float4(cubehigh.sample(_mtlsmp_cubehigh, (float3)(_mtl_i.varUV.xyz)));
|
||||
c_1 = half4(((float4)c_1 + tmpvar_7));
|
||||
c_1 = (c_1 + texmed.sample(_mtlsmp_texmed, (float2)(_mtl_i.varUV.xy)));
|
||||
float4 tmpvar_3;
|
||||
tmpvar_3 = texhigh.sample(_mtlsmp_texhigh, (float2)(_mtl_i.varUV.xy));
|
||||
c_1 = half4(((float4)c_1 + tmpvar_3));
|
||||
half4 tmpvar_4;
|
||||
tmpvar_4 = cubelow.sample(_mtlsmp_cubelow, (float3)(_mtl_i.varUV.xyz));
|
||||
c_1 = (c_1 + tmpvar_4);
|
||||
c_1 = (c_1 + cubemed.sample(_mtlsmp_cubemed, (float3)(_mtl_i.varUV.xyz)));
|
||||
float4 tmpvar_5;
|
||||
tmpvar_5 = cubehigh.sample(_mtlsmp_cubehigh, (float3)(_mtl_i.varUV.xyz));
|
||||
c_1 = half4(((float4)c_1 + tmpvar_5));
|
||||
_mtl_o._fragData = c_1;
|
||||
return _mtl_o;
|
||||
}
|
||||
|
@ -53,116 +53,116 @@ void main ()
|
||||
highp float range_37;
|
||||
highp float lumaN_38;
|
||||
highp float lumaS_39;
|
||||
highp vec4 rgbyM_40;
|
||||
highp vec2 posM_41;
|
||||
posM_41 = xlv_TEXCOORD0;
|
||||
highp vec2 posM_40;
|
||||
posM_40 = xlv_TEXCOORD0;
|
||||
highp vec4 tmpvar_41;
|
||||
lowp vec4 tmpvar_42;
|
||||
tmpvar_42 = impl_low_texture2DLodEXT (_MainTex, xlv_TEXCOORD0, 0.0);
|
||||
rgbyM_40 = tmpvar_42;
|
||||
tmpvar_41 = tmpvar_42;
|
||||
highp vec4 tmpvar_43;
|
||||
tmpvar_43.zw = vec2(0.0, 0.0);
|
||||
tmpvar_43.xy = (xlv_TEXCOORD0 + (vec2(0.0, 1.0) * _MainTex_TexelSize.xy));
|
||||
lowp vec4 tmpvar_44;
|
||||
tmpvar_44 = impl_low_texture2DLodEXT (_MainTex, tmpvar_43.xy, 0.0);
|
||||
highp vec4 rgba_45;
|
||||
rgba_45 = tmpvar_44;
|
||||
lumaS_39 = rgba_45.w;
|
||||
highp vec4 tmpvar_44;
|
||||
lowp vec4 tmpvar_45;
|
||||
tmpvar_45 = impl_low_texture2DLodEXT (_MainTex, tmpvar_43.xy, 0.0);
|
||||
tmpvar_44 = tmpvar_45;
|
||||
lumaS_39 = tmpvar_44.w;
|
||||
highp vec4 tmpvar_46;
|
||||
tmpvar_46.zw = vec2(0.0, 0.0);
|
||||
tmpvar_46.xy = (xlv_TEXCOORD0 + (vec2(1.0, 0.0) * _MainTex_TexelSize.xy));
|
||||
lowp vec4 tmpvar_47;
|
||||
tmpvar_47 = impl_low_texture2DLodEXT (_MainTex, tmpvar_46.xy, 0.0);
|
||||
highp float tmpvar_48;
|
||||
highp vec4 rgba_49;
|
||||
rgba_49 = tmpvar_47;
|
||||
tmpvar_48 = rgba_49.w;
|
||||
highp vec4 tmpvar_47;
|
||||
lowp vec4 tmpvar_48;
|
||||
tmpvar_48 = impl_low_texture2DLodEXT (_MainTex, tmpvar_46.xy, 0.0);
|
||||
tmpvar_47 = tmpvar_48;
|
||||
highp float tmpvar_49;
|
||||
tmpvar_49 = tmpvar_47.w;
|
||||
highp vec4 tmpvar_50;
|
||||
tmpvar_50.zw = vec2(0.0, 0.0);
|
||||
tmpvar_50.xy = (xlv_TEXCOORD0 + (vec2(0.0, -1.0) * _MainTex_TexelSize.xy));
|
||||
lowp vec4 tmpvar_51;
|
||||
tmpvar_51 = impl_low_texture2DLodEXT (_MainTex, tmpvar_50.xy, 0.0);
|
||||
highp vec4 rgba_52;
|
||||
rgba_52 = tmpvar_51;
|
||||
lumaN_38 = rgba_52.w;
|
||||
highp vec4 tmpvar_51;
|
||||
lowp vec4 tmpvar_52;
|
||||
tmpvar_52 = impl_low_texture2DLodEXT (_MainTex, tmpvar_50.xy, 0.0);
|
||||
tmpvar_51 = tmpvar_52;
|
||||
lumaN_38 = tmpvar_51.w;
|
||||
highp vec4 tmpvar_53;
|
||||
tmpvar_53.zw = vec2(0.0, 0.0);
|
||||
tmpvar_53.xy = (xlv_TEXCOORD0 + (vec2(-1.0, 0.0) * _MainTex_TexelSize.xy));
|
||||
lowp vec4 tmpvar_54;
|
||||
tmpvar_54 = impl_low_texture2DLodEXT (_MainTex, tmpvar_53.xy, 0.0);
|
||||
highp float tmpvar_55;
|
||||
highp vec4 rgba_56;
|
||||
rgba_56 = tmpvar_54;
|
||||
tmpvar_55 = rgba_56.w;
|
||||
highp vec4 tmpvar_54;
|
||||
lowp vec4 tmpvar_55;
|
||||
tmpvar_55 = impl_low_texture2DLodEXT (_MainTex, tmpvar_53.xy, 0.0);
|
||||
tmpvar_54 = tmpvar_55;
|
||||
highp float tmpvar_56;
|
||||
tmpvar_56 = tmpvar_54.w;
|
||||
highp float tmpvar_57;
|
||||
tmpvar_57 = max (max (rgba_52.w, rgba_56.w), max (max (rgba_49.w, rgba_45.w), rgbyM_40.w));
|
||||
range_37 = (tmpvar_57 - min (min (rgba_52.w, rgba_56.w), min (
|
||||
min (rgba_49.w, rgba_45.w)
|
||||
, rgbyM_40.w)));
|
||||
tmpvar_57 = max (max (tmpvar_51.w, tmpvar_54.w), max (max (tmpvar_47.w, tmpvar_44.w), tmpvar_41.w));
|
||||
range_37 = (tmpvar_57 - min (min (tmpvar_51.w, tmpvar_54.w), min (
|
||||
min (tmpvar_47.w, tmpvar_44.w)
|
||||
, tmpvar_41.w)));
|
||||
if ((range_37 < max (0.0833, (tmpvar_57 * 0.166)))) {
|
||||
tmpvar_2 = rgbyM_40;
|
||||
tmpvar_2 = tmpvar_41;
|
||||
} else {
|
||||
highp vec4 tmpvar_58;
|
||||
tmpvar_58.zw = vec2(0.0, 0.0);
|
||||
tmpvar_58.xy = (xlv_TEXCOORD0 - _MainTex_TexelSize.xy);
|
||||
lowp vec4 tmpvar_59;
|
||||
tmpvar_59 = impl_low_texture2DLodEXT (_MainTex, tmpvar_58.xy, 0.0);
|
||||
highp vec4 rgba_60;
|
||||
rgba_60 = tmpvar_59;
|
||||
highp vec4 tmpvar_59;
|
||||
lowp vec4 tmpvar_60;
|
||||
tmpvar_60 = impl_low_texture2DLodEXT (_MainTex, tmpvar_58.xy, 0.0);
|
||||
tmpvar_59 = tmpvar_60;
|
||||
highp vec4 tmpvar_61;
|
||||
tmpvar_61.zw = vec2(0.0, 0.0);
|
||||
tmpvar_61.xy = (xlv_TEXCOORD0 + _MainTex_TexelSize.xy);
|
||||
lowp vec4 tmpvar_62;
|
||||
tmpvar_62 = impl_low_texture2DLodEXT (_MainTex, tmpvar_61.xy, 0.0);
|
||||
highp vec4 rgba_63;
|
||||
rgba_63 = tmpvar_62;
|
||||
highp vec4 tmpvar_62;
|
||||
lowp vec4 tmpvar_63;
|
||||
tmpvar_63 = impl_low_texture2DLodEXT (_MainTex, tmpvar_61.xy, 0.0);
|
||||
tmpvar_62 = tmpvar_63;
|
||||
highp vec4 tmpvar_64;
|
||||
tmpvar_64.zw = vec2(0.0, 0.0);
|
||||
tmpvar_64.xy = (xlv_TEXCOORD0 + (vec2(1.0, -1.0) * _MainTex_TexelSize.xy));
|
||||
lowp vec4 tmpvar_65;
|
||||
tmpvar_65 = impl_low_texture2DLodEXT (_MainTex, tmpvar_64.xy, 0.0);
|
||||
highp vec4 rgba_66;
|
||||
rgba_66 = tmpvar_65;
|
||||
highp vec4 tmpvar_65;
|
||||
lowp vec4 tmpvar_66;
|
||||
tmpvar_66 = impl_low_texture2DLodEXT (_MainTex, tmpvar_64.xy, 0.0);
|
||||
tmpvar_65 = tmpvar_66;
|
||||
highp vec4 tmpvar_67;
|
||||
tmpvar_67.zw = vec2(0.0, 0.0);
|
||||
tmpvar_67.xy = (xlv_TEXCOORD0 + (vec2(-1.0, 1.0) * _MainTex_TexelSize.xy));
|
||||
lowp vec4 tmpvar_68;
|
||||
tmpvar_68 = impl_low_texture2DLodEXT (_MainTex, tmpvar_67.xy, 0.0);
|
||||
highp vec4 rgba_69;
|
||||
rgba_69 = tmpvar_68;
|
||||
lumaNS_36 = (rgba_52.w + rgba_45.w);
|
||||
lumaWE_35 = (rgba_56.w + rgba_49.w);
|
||||
highp vec4 tmpvar_68;
|
||||
lowp vec4 tmpvar_69;
|
||||
tmpvar_69 = impl_low_texture2DLodEXT (_MainTex, tmpvar_67.xy, 0.0);
|
||||
tmpvar_68 = tmpvar_69;
|
||||
lumaNS_36 = (tmpvar_51.w + tmpvar_44.w);
|
||||
lumaWE_35 = (tmpvar_54.w + tmpvar_47.w);
|
||||
subpixRcpRange_34 = (1.0/(range_37));
|
||||
lumaNESE_33 = (rgba_66.w + rgba_63.w);
|
||||
lumaNWSW_32 = (rgba_60.w + rgba_69.w);
|
||||
lumaNESE_33 = (tmpvar_65.w + tmpvar_62.w);
|
||||
lumaNWSW_32 = (tmpvar_59.w + tmpvar_68.w);
|
||||
lengthSign_31 = fxaaQualityRcpFrame_1.x;
|
||||
horzSpan_30 = ((abs(
|
||||
((-2.0 * rgba_56.w) + lumaNWSW_32)
|
||||
((-2.0 * tmpvar_54.w) + lumaNWSW_32)
|
||||
) + (
|
||||
(abs(((-2.0 * rgbyM_40.w) + lumaNS_36)) * 2.0)
|
||||
(abs(((-2.0 * tmpvar_41.w) + lumaNS_36)) * 2.0)
|
||||
+
|
||||
abs(((-2.0 * rgba_49.w) + lumaNESE_33))
|
||||
abs(((-2.0 * tmpvar_47.w) + lumaNESE_33))
|
||||
)) >= (abs(
|
||||
((-2.0 * rgba_45.w) + (rgba_69.w + rgba_63.w))
|
||||
((-2.0 * tmpvar_44.w) + (tmpvar_68.w + tmpvar_62.w))
|
||||
) + (
|
||||
(abs(((-2.0 * rgbyM_40.w) + lumaWE_35)) * 2.0)
|
||||
(abs(((-2.0 * tmpvar_41.w) + lumaWE_35)) * 2.0)
|
||||
+
|
||||
abs(((-2.0 * rgba_52.w) + (rgba_60.w + rgba_66.w)))
|
||||
abs(((-2.0 * tmpvar_51.w) + (tmpvar_59.w + tmpvar_65.w)))
|
||||
)));
|
||||
subpixA_29 = (((lumaNS_36 + lumaWE_35) * 2.0) + (lumaNWSW_32 + lumaNESE_33));
|
||||
if (!(horzSpan_30)) {
|
||||
lumaN_38 = tmpvar_55;
|
||||
lumaN_38 = tmpvar_56;
|
||||
};
|
||||
if (!(horzSpan_30)) {
|
||||
lumaS_39 = tmpvar_48;
|
||||
lumaS_39 = tmpvar_49;
|
||||
};
|
||||
if (horzSpan_30) {
|
||||
lengthSign_31 = fxaaQualityRcpFrame_1.y;
|
||||
};
|
||||
subpixB_28 = ((subpixA_29 * 0.0833333) - rgbyM_40.w);
|
||||
gradientN_27 = (lumaN_38 - rgbyM_40.w);
|
||||
gradientS_26 = (lumaS_39 - rgbyM_40.w);
|
||||
lumaNN_25 = (lumaN_38 + rgbyM_40.w);
|
||||
lumaSS_24 = (lumaS_39 + rgbyM_40.w);
|
||||
subpixB_28 = ((subpixA_29 * 0.0833333) - tmpvar_41.w);
|
||||
gradientN_27 = (lumaN_38 - tmpvar_41.w);
|
||||
gradientS_26 = (lumaS_39 - tmpvar_41.w);
|
||||
lumaNN_25 = (lumaN_38 + tmpvar_41.w);
|
||||
lumaSS_24 = (lumaS_39 + tmpvar_41.w);
|
||||
pairN_23 = (abs(gradientN_27) >= abs(gradientS_26));
|
||||
highp float tmpvar_70;
|
||||
tmpvar_70 = max (abs(gradientN_27), abs(gradientS_26));
|
||||
@ -195,25 +195,25 @@ void main ()
|
||||
posP_20.x = (posB_22.x + tmpvar_72);
|
||||
posP_20.y = (posB_22.y + tmpvar_73);
|
||||
subpixD_19 = ((-2.0 * tmpvar_71) + 3.0);
|
||||
lowp vec4 tmpvar_74;
|
||||
tmpvar_74 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
highp vec4 rgba_75;
|
||||
rgba_75 = tmpvar_74;
|
||||
lumaEndN_18 = rgba_75.w;
|
||||
highp vec4 tmpvar_74;
|
||||
lowp vec4 tmpvar_75;
|
||||
tmpvar_75 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
tmpvar_74 = tmpvar_75;
|
||||
lumaEndN_18 = tmpvar_74.w;
|
||||
subpixE_17 = (tmpvar_71 * tmpvar_71);
|
||||
lowp vec4 tmpvar_76;
|
||||
tmpvar_76 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
highp vec4 rgba_77;
|
||||
rgba_77 = tmpvar_76;
|
||||
lumaEndP_16 = rgba_77.w;
|
||||
highp vec4 tmpvar_76;
|
||||
lowp vec4 tmpvar_77;
|
||||
tmpvar_77 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
tmpvar_76 = tmpvar_77;
|
||||
lumaEndP_16 = tmpvar_76.w;
|
||||
if (!(pairN_23)) {
|
||||
lumaNN_25 = lumaSS_24;
|
||||
};
|
||||
gradientScaled_15 = (tmpvar_70 / 4.0);
|
||||
subpixF_14 = (subpixD_19 * subpixE_17);
|
||||
lumaMLTZero_13 = ((rgbyM_40.w - (lumaNN_25 * 0.5)) < 0.0);
|
||||
lumaEndN_18 = (rgba_75.w - (lumaNN_25 * 0.5));
|
||||
lumaEndP_16 = (rgba_77.w - (lumaNN_25 * 0.5));
|
||||
lumaMLTZero_13 = ((tmpvar_41.w - (lumaNN_25 * 0.5)) < 0.0);
|
||||
lumaEndN_18 = (tmpvar_74.w - (lumaNN_25 * 0.5));
|
||||
lumaEndP_16 = (tmpvar_76.w - (lumaNN_25 * 0.5));
|
||||
doneN_12 = (abs(lumaEndN_18) >= gradientScaled_15);
|
||||
doneP_11 = (abs(lumaEndP_16) >= gradientScaled_15);
|
||||
if (!(doneN_12)) {
|
||||
@ -231,18 +231,18 @@ void main ()
|
||||
};
|
||||
if (doneNP_10) {
|
||||
if (!(doneN_12)) {
|
||||
lowp vec4 tmpvar_78;
|
||||
tmpvar_78 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
highp vec4 rgba_79;
|
||||
rgba_79 = tmpvar_78;
|
||||
lumaEndN_18 = rgba_79.w;
|
||||
highp vec4 tmpvar_78;
|
||||
lowp vec4 tmpvar_79;
|
||||
tmpvar_79 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
tmpvar_78 = tmpvar_79;
|
||||
lumaEndN_18 = tmpvar_78.w;
|
||||
};
|
||||
if (!(doneP_11)) {
|
||||
lowp vec4 tmpvar_80;
|
||||
tmpvar_80 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
highp vec4 rgba_81;
|
||||
rgba_81 = tmpvar_80;
|
||||
lumaEndP_16 = rgba_81.w;
|
||||
highp vec4 tmpvar_80;
|
||||
lowp vec4 tmpvar_81;
|
||||
tmpvar_81 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
tmpvar_80 = tmpvar_81;
|
||||
lumaEndP_16 = tmpvar_80.w;
|
||||
};
|
||||
if (!(doneN_12)) {
|
||||
lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
|
||||
@ -267,18 +267,18 @@ void main ()
|
||||
};
|
||||
if (doneNP_10) {
|
||||
if (!(doneN_12)) {
|
||||
lowp vec4 tmpvar_82;
|
||||
tmpvar_82 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
highp vec4 rgba_83;
|
||||
rgba_83 = tmpvar_82;
|
||||
lumaEndN_18 = rgba_83.w;
|
||||
highp vec4 tmpvar_82;
|
||||
lowp vec4 tmpvar_83;
|
||||
tmpvar_83 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
tmpvar_82 = tmpvar_83;
|
||||
lumaEndN_18 = tmpvar_82.w;
|
||||
};
|
||||
if (!(doneP_11)) {
|
||||
lowp vec4 tmpvar_84;
|
||||
tmpvar_84 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
highp vec4 rgba_85;
|
||||
rgba_85 = tmpvar_84;
|
||||
lumaEndP_16 = rgba_85.w;
|
||||
highp vec4 tmpvar_84;
|
||||
lowp vec4 tmpvar_85;
|
||||
tmpvar_85 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
tmpvar_84 = tmpvar_85;
|
||||
lumaEndP_16 = tmpvar_84.w;
|
||||
};
|
||||
if (!(doneN_12)) {
|
||||
lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
|
||||
@ -303,18 +303,18 @@ void main ()
|
||||
};
|
||||
if (doneNP_10) {
|
||||
if (!(doneN_12)) {
|
||||
lowp vec4 tmpvar_86;
|
||||
tmpvar_86 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
highp vec4 rgba_87;
|
||||
rgba_87 = tmpvar_86;
|
||||
lumaEndN_18 = rgba_87.w;
|
||||
highp vec4 tmpvar_86;
|
||||
lowp vec4 tmpvar_87;
|
||||
tmpvar_87 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
tmpvar_86 = tmpvar_87;
|
||||
lumaEndN_18 = tmpvar_86.w;
|
||||
};
|
||||
if (!(doneP_11)) {
|
||||
lowp vec4 tmpvar_88;
|
||||
tmpvar_88 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
highp vec4 rgba_89;
|
||||
rgba_89 = tmpvar_88;
|
||||
lumaEndP_16 = rgba_89.w;
|
||||
highp vec4 tmpvar_88;
|
||||
lowp vec4 tmpvar_89;
|
||||
tmpvar_89 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
tmpvar_88 = tmpvar_89;
|
||||
lumaEndP_16 = tmpvar_88.w;
|
||||
};
|
||||
if (!(doneN_12)) {
|
||||
lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
|
||||
@ -339,18 +339,18 @@ void main ()
|
||||
};
|
||||
if (doneNP_10) {
|
||||
if (!(doneN_12)) {
|
||||
lowp vec4 tmpvar_90;
|
||||
tmpvar_90 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
highp vec4 rgba_91;
|
||||
rgba_91 = tmpvar_90;
|
||||
lumaEndN_18 = rgba_91.w;
|
||||
highp vec4 tmpvar_90;
|
||||
lowp vec4 tmpvar_91;
|
||||
tmpvar_91 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
tmpvar_90 = tmpvar_91;
|
||||
lumaEndN_18 = tmpvar_90.w;
|
||||
};
|
||||
if (!(doneP_11)) {
|
||||
lowp vec4 tmpvar_92;
|
||||
tmpvar_92 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
highp vec4 rgba_93;
|
||||
rgba_93 = tmpvar_92;
|
||||
lumaEndP_16 = rgba_93.w;
|
||||
highp vec4 tmpvar_92;
|
||||
lowp vec4 tmpvar_93;
|
||||
tmpvar_93 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
tmpvar_92 = tmpvar_93;
|
||||
lumaEndP_16 = tmpvar_92.w;
|
||||
};
|
||||
if (!(doneN_12)) {
|
||||
lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
|
||||
@ -375,18 +375,18 @@ void main ()
|
||||
};
|
||||
if (doneNP_10) {
|
||||
if (!(doneN_12)) {
|
||||
lowp vec4 tmpvar_94;
|
||||
tmpvar_94 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
highp vec4 rgba_95;
|
||||
rgba_95 = tmpvar_94;
|
||||
lumaEndN_18 = rgba_95.w;
|
||||
highp vec4 tmpvar_94;
|
||||
lowp vec4 tmpvar_95;
|
||||
tmpvar_95 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
tmpvar_94 = tmpvar_95;
|
||||
lumaEndN_18 = tmpvar_94.w;
|
||||
};
|
||||
if (!(doneP_11)) {
|
||||
lowp vec4 tmpvar_96;
|
||||
tmpvar_96 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
highp vec4 rgba_97;
|
||||
rgba_97 = tmpvar_96;
|
||||
lumaEndP_16 = rgba_97.w;
|
||||
highp vec4 tmpvar_96;
|
||||
lowp vec4 tmpvar_97;
|
||||
tmpvar_97 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
tmpvar_96 = tmpvar_97;
|
||||
lumaEndP_16 = tmpvar_96.w;
|
||||
};
|
||||
if (!(doneN_12)) {
|
||||
lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
|
||||
@ -411,18 +411,18 @@ void main ()
|
||||
};
|
||||
if (doneNP_10) {
|
||||
if (!(doneN_12)) {
|
||||
lowp vec4 tmpvar_98;
|
||||
tmpvar_98 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
highp vec4 rgba_99;
|
||||
rgba_99 = tmpvar_98;
|
||||
lumaEndN_18 = rgba_99.w;
|
||||
highp vec4 tmpvar_98;
|
||||
lowp vec4 tmpvar_99;
|
||||
tmpvar_99 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
tmpvar_98 = tmpvar_99;
|
||||
lumaEndN_18 = tmpvar_98.w;
|
||||
};
|
||||
if (!(doneP_11)) {
|
||||
lowp vec4 tmpvar_100;
|
||||
tmpvar_100 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
highp vec4 rgba_101;
|
||||
rgba_101 = tmpvar_100;
|
||||
lumaEndP_16 = rgba_101.w;
|
||||
highp vec4 tmpvar_100;
|
||||
lowp vec4 tmpvar_101;
|
||||
tmpvar_101 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
tmpvar_100 = tmpvar_101;
|
||||
lumaEndP_16 = tmpvar_100.w;
|
||||
};
|
||||
if (!(doneN_12)) {
|
||||
lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
|
||||
@ -447,18 +447,18 @@ void main ()
|
||||
};
|
||||
if (doneNP_10) {
|
||||
if (!(doneN_12)) {
|
||||
lowp vec4 tmpvar_102;
|
||||
tmpvar_102 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
highp vec4 rgba_103;
|
||||
rgba_103 = tmpvar_102;
|
||||
lumaEndN_18 = rgba_103.w;
|
||||
highp vec4 tmpvar_102;
|
||||
lowp vec4 tmpvar_103;
|
||||
tmpvar_103 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
tmpvar_102 = tmpvar_103;
|
||||
lumaEndN_18 = tmpvar_102.w;
|
||||
};
|
||||
if (!(doneP_11)) {
|
||||
lowp vec4 tmpvar_104;
|
||||
tmpvar_104 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
highp vec4 rgba_105;
|
||||
rgba_105 = tmpvar_104;
|
||||
lumaEndP_16 = rgba_105.w;
|
||||
highp vec4 tmpvar_104;
|
||||
lowp vec4 tmpvar_105;
|
||||
tmpvar_105 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
tmpvar_104 = tmpvar_105;
|
||||
lumaEndP_16 = tmpvar_104.w;
|
||||
};
|
||||
if (!(doneN_12)) {
|
||||
lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
|
||||
@ -483,18 +483,18 @@ void main ()
|
||||
};
|
||||
if (doneNP_10) {
|
||||
if (!(doneN_12)) {
|
||||
lowp vec4 tmpvar_106;
|
||||
tmpvar_106 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
highp vec4 rgba_107;
|
||||
rgba_107 = tmpvar_106;
|
||||
lumaEndN_18 = rgba_107.w;
|
||||
highp vec4 tmpvar_106;
|
||||
lowp vec4 tmpvar_107;
|
||||
tmpvar_107 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
tmpvar_106 = tmpvar_107;
|
||||
lumaEndN_18 = tmpvar_106.w;
|
||||
};
|
||||
if (!(doneP_11)) {
|
||||
lowp vec4 tmpvar_108;
|
||||
tmpvar_108 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
highp vec4 rgba_109;
|
||||
rgba_109 = tmpvar_108;
|
||||
lumaEndP_16 = rgba_109.w;
|
||||
highp vec4 tmpvar_108;
|
||||
lowp vec4 tmpvar_109;
|
||||
tmpvar_109 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
tmpvar_108 = tmpvar_109;
|
||||
lumaEndP_16 = tmpvar_108.w;
|
||||
};
|
||||
if (!(doneN_12)) {
|
||||
lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
|
||||
@ -519,18 +519,18 @@ void main ()
|
||||
};
|
||||
if (doneNP_10) {
|
||||
if (!(doneN_12)) {
|
||||
lowp vec4 tmpvar_110;
|
||||
tmpvar_110 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
highp vec4 rgba_111;
|
||||
rgba_111 = tmpvar_110;
|
||||
lumaEndN_18 = rgba_111.w;
|
||||
highp vec4 tmpvar_110;
|
||||
lowp vec4 tmpvar_111;
|
||||
tmpvar_111 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
tmpvar_110 = tmpvar_111;
|
||||
lumaEndN_18 = tmpvar_110.w;
|
||||
};
|
||||
if (!(doneP_11)) {
|
||||
lowp vec4 tmpvar_112;
|
||||
tmpvar_112 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
highp vec4 rgba_113;
|
||||
rgba_113 = tmpvar_112;
|
||||
lumaEndP_16 = rgba_113.w;
|
||||
highp vec4 tmpvar_112;
|
||||
lowp vec4 tmpvar_113;
|
||||
tmpvar_113 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
tmpvar_112 = tmpvar_113;
|
||||
lumaEndP_16 = tmpvar_112.w;
|
||||
};
|
||||
if (!(doneN_12)) {
|
||||
lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
|
||||
@ -555,18 +555,18 @@ void main ()
|
||||
};
|
||||
if (doneNP_10) {
|
||||
if (!(doneN_12)) {
|
||||
lowp vec4 tmpvar_114;
|
||||
tmpvar_114 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
highp vec4 rgba_115;
|
||||
rgba_115 = tmpvar_114;
|
||||
lumaEndN_18 = rgba_115.w;
|
||||
highp vec4 tmpvar_114;
|
||||
lowp vec4 tmpvar_115;
|
||||
tmpvar_115 = impl_low_texture2DLodEXT (_MainTex, posN_21, 0.0);
|
||||
tmpvar_114 = tmpvar_115;
|
||||
lumaEndN_18 = tmpvar_114.w;
|
||||
};
|
||||
if (!(doneP_11)) {
|
||||
lowp vec4 tmpvar_116;
|
||||
tmpvar_116 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
highp vec4 rgba_117;
|
||||
rgba_117 = tmpvar_116;
|
||||
lumaEndP_16 = rgba_117.w;
|
||||
highp vec4 tmpvar_116;
|
||||
lowp vec4 tmpvar_117;
|
||||
tmpvar_117 = impl_low_texture2DLodEXT (_MainTex, posP_20, 0.0);
|
||||
tmpvar_116 = tmpvar_117;
|
||||
lumaEndP_16 = tmpvar_116.w;
|
||||
};
|
||||
if (!(doneN_12)) {
|
||||
lumaEndN_18 = (lumaEndN_18 - (lumaNN_25 * 0.5));
|
||||
@ -629,16 +629,16 @@ void main ()
|
||||
highp float tmpvar_121;
|
||||
tmpvar_121 = max (tmpvar_120, subpixH_3);
|
||||
if (!(horzSpan_30)) {
|
||||
posM_41.x = (xlv_TEXCOORD0.x + (tmpvar_121 * lengthSign_31));
|
||||
posM_40.x = (xlv_TEXCOORD0.x + (tmpvar_121 * lengthSign_31));
|
||||
};
|
||||
if (horzSpan_30) {
|
||||
posM_41.y = (xlv_TEXCOORD0.y + (tmpvar_121 * lengthSign_31));
|
||||
posM_40.y = (xlv_TEXCOORD0.y + (tmpvar_121 * lengthSign_31));
|
||||
};
|
||||
lowp vec4 tmpvar_122;
|
||||
tmpvar_122 = impl_low_texture2DLodEXT (_MainTex, posM_41, 0.0);
|
||||
tmpvar_122 = impl_low_texture2DLodEXT (_MainTex, posM_40, 0.0);
|
||||
highp vec4 tmpvar_123;
|
||||
tmpvar_123.xyz = tmpvar_122.xyz;
|
||||
tmpvar_123.w = rgbyM_40.w;
|
||||
tmpvar_123.w = tmpvar_41.w;
|
||||
tmpvar_2 = tmpvar_123;
|
||||
};
|
||||
gl_FragData[0] = tmpvar_2;
|
||||
|
@ -51,16 +51,14 @@ void main ()
|
||||
};
|
||||
randomDir_14 = (randomDir_14 * -(tmpvar_18));
|
||||
randomDir_14 = (randomDir_14 + (viewNorm_7 * 0.3));
|
||||
highp vec4 tmpvar_19;
|
||||
tmpvar_19 = texture (_CameraDepthNormalsTexture, (tmpvar_2 + (randomDir_14.xy * scale_5)));
|
||||
highp float tmpvar_20;
|
||||
tmpvar_20 = clamp (((depth_6 -
|
||||
highp float tmpvar_19;
|
||||
tmpvar_19 = clamp (((depth_6 -
|
||||
(randomDir_14.z * _Params.x)
|
||||
) - (
|
||||
dot (tmpvar_19.zw, vec2(1.0, 0.00392157))
|
||||
dot (texture (_CameraDepthNormalsTexture, (tmpvar_2 + (randomDir_14.xy * scale_5))).zw, vec2(1.0, 0.00392157))
|
||||
* _ProjectionParams.z)), 0.0, 1.0);
|
||||
if ((tmpvar_20 > _Params.y)) {
|
||||
occ_4 = (occ_4 + pow ((1.0 - tmpvar_20), _Params.z));
|
||||
if ((tmpvar_19 > _Params.y)) {
|
||||
occ_4 = (occ_4 + pow ((1.0 - tmpvar_19), _Params.z));
|
||||
};
|
||||
};
|
||||
occ_4 = (occ_4 / 8.0);
|
||||
|
@ -29,7 +29,7 @@ fragment xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]]
|
||||
tmpvar_9 = ((_RandomTexture.sample(_mtlsmp__RandomTexture, (float2)(_mtl_i.xlv_TEXCOORD1)).xyz * (half)2.0) - (half)1.0);
|
||||
randN_8 = tmpvar_9;
|
||||
float4 tmpvar_10;
|
||||
tmpvar_10 = float4(_CameraDepthNormalsTexture.sample(_mtlsmp__CameraDepthNormalsTexture, (float2)(_mtl_i.xlv_TEXCOORD0)));
|
||||
tmpvar_10 = _CameraDepthNormalsTexture.sample(_mtlsmp__CameraDepthNormalsTexture, (float2)(_mtl_i.xlv_TEXCOORD0));
|
||||
float3 n_11;
|
||||
float3 tmpvar_12;
|
||||
tmpvar_12 = ((tmpvar_10.xyz * float3(3.5554, 3.5554, 0.0)) + float3(-1.7777, -1.7777, 1.0));
|
||||
@ -60,16 +60,14 @@ fragment xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]]
|
||||
};
|
||||
randomDir_14 = (randomDir_14 * -(tmpvar_18));
|
||||
randomDir_14 = half3(((float3)randomDir_14 + (viewNorm_7 * 0.3)));
|
||||
float4 tmpvar_19;
|
||||
tmpvar_19 = float4(_CameraDepthNormalsTexture.sample(_mtlsmp__CameraDepthNormalsTexture, (float2)((tmpvar_2 + ((float2)randomDir_14.xy * scale_5)))));
|
||||
float tmpvar_20;
|
||||
tmpvar_20 = clamp (((depth_6 -
|
||||
float tmpvar_19;
|
||||
tmpvar_19 = clamp (((depth_6 -
|
||||
((float)randomDir_14.z * _mtl_u._Params.x)
|
||||
) - (
|
||||
dot (tmpvar_19.zw, float2(1.0, 0.00392157))
|
||||
dot (_CameraDepthNormalsTexture.sample(_mtlsmp__CameraDepthNormalsTexture, (float2)((tmpvar_2 + ((float2)randomDir_14.xy * scale_5)))).zw, float2(1.0, 0.00392157))
|
||||
* _mtl_u._ProjectionParams.z)), 0.0, 1.0);
|
||||
if ((tmpvar_20 > _mtl_u._Params.y)) {
|
||||
occ_4 = (occ_4 + pow ((1.0 - tmpvar_20), _mtl_u._Params.z));
|
||||
if ((tmpvar_19 > _mtl_u._Params.y)) {
|
||||
occ_4 = (occ_4 + pow ((1.0 - tmpvar_19), _mtl_u._Params.z));
|
||||
};
|
||||
};
|
||||
occ_4 = (occ_4 / 8.0);
|
||||
|
@ -19,23 +19,23 @@
|
||||
#include <windows.h>
|
||||
#include <gl/GL.h>
|
||||
extern "C" {
|
||||
typedef char GLcharARB; /* native character */
|
||||
typedef unsigned int GLhandleARB; /* shader object handle */
|
||||
#define GL_VERTEX_SHADER_ARB 0x8B31
|
||||
#define GL_FRAGMENT_SHADER_ARB 0x8B30
|
||||
#define GL_OBJECT_COMPILE_STATUS_ARB 0x8B81
|
||||
typedef void (WINAPI * PFNGLDELETEOBJECTARBPROC) (GLhandleARB obj);
|
||||
typedef GLhandleARB (WINAPI * PFNGLCREATESHADEROBJECTARBPROC) (GLenum shaderType);
|
||||
typedef void (WINAPI * PFNGLSHADERSOURCEARBPROC) (GLhandleARB shaderObj, GLsizei count, const GLcharARB* *string, const GLint *length);
|
||||
typedef void (WINAPI * PFNGLCOMPILESHADERARBPROC) (GLhandleARB shaderObj);
|
||||
typedef void (WINAPI * PFNGLGETINFOLOGARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog);
|
||||
typedef void (WINAPI * PFNGLGETOBJECTPARAMETERIVARBPROC) (GLhandleARB obj, GLenum pname, GLint *params);
|
||||
static PFNGLDELETEOBJECTARBPROC glDeleteObjectARB;
|
||||
static PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB;
|
||||
static PFNGLSHADERSOURCEARBPROC glShaderSourceARB;
|
||||
static PFNGLCOMPILESHADERARBPROC glCompileShaderARB;
|
||||
static PFNGLGETINFOLOGARBPROC glGetInfoLogARB;
|
||||
static PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB;
|
||||
typedef char GLchar; /* native character */
|
||||
typedef unsigned int GLuint; /* shader object handle */
|
||||
#define GL_VERTEX_SHADER 0x8B31
|
||||
#define GL_FRAGMENT_SHADER 0x8B30
|
||||
#define GL_COMPILE_STATUS 0x8B81
|
||||
typedef void (WINAPI * PFNGLDELETESHADERPROC) (GLuint shader);
|
||||
typedef GLuint (WINAPI * PFNGLCREATESHADERPROC) (GLenum type);
|
||||
typedef void (WINAPI * PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length);
|
||||
typedef void (WINAPI * PFNGLCOMPILESHADERPROC) (GLuint shader);
|
||||
typedef void (WINAPI * PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
|
||||
typedef void (WINAPI * PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint *params);
|
||||
static PFNGLDELETESHADERPROC glDeleteShader;
|
||||
static PFNGLCREATESHADERPROC glCreateShader;
|
||||
static PFNGLSHADERSOURCEPROC glShaderSource;
|
||||
static PFNGLCOMPILESHADERPROC glCompileShader;
|
||||
static PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
|
||||
static PFNGLGETSHADERIVPROC glGetShaderiv;
|
||||
}
|
||||
#endif // #ifdef _MSC_VER
|
||||
|
||||
@ -154,12 +154,12 @@ static bool InitializeOpenGL ()
|
||||
#ifdef _MSC_VER
|
||||
if (hasGLSL)
|
||||
{
|
||||
glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)wglGetProcAddress("glDeleteObjectARB");
|
||||
glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)wglGetProcAddress("glCreateShaderObjectARB");
|
||||
glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)wglGetProcAddress("glShaderSourceARB");
|
||||
glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)wglGetProcAddress("glCompileShaderARB");
|
||||
glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)wglGetProcAddress("glGetInfoLogARB");
|
||||
glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)wglGetProcAddress("glGetObjectParameterivARB");
|
||||
glDeleteShader = (PFNGLDELETESHADERPROC)wglGetProcAddress("glDeleteShader");
|
||||
glCreateShader = (PFNGLCREATESHADERPROC)wglGetProcAddress("glCreateShader");
|
||||
glShaderSource = (PFNGLSHADERSOURCEPROC)wglGetProcAddress("glShaderSource");
|
||||
glCompileShader = (PFNGLCOMPILESHADERPROC)wglGetProcAddress("glCompileShader");
|
||||
glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)wglGetProcAddress("glGetShaderInfoLog");
|
||||
glGetShaderiv = (PFNGLGETSHADERIVPROC)wglGetProcAddress("glGetShaderiv");
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -266,6 +266,8 @@ static bool CheckGLSL (bool vertex, bool gles, const std::string& testName, cons
|
||||
if (gles)
|
||||
{
|
||||
replace_string (src, "GL_EXT_shader_texture_lod", "GL_ARB_shader_texture_lod", 0);
|
||||
replace_string (src, "GL_EXT_draw_instanced", "GL_ARB_draw_instanced", 0);
|
||||
replace_string (src, "gl_InstanceIDEXT", "gl_InstanceIDARB ", 0);
|
||||
replace_string (src, "#extension GL_OES_standard_derivatives : require", "", 0);
|
||||
replace_string (src, "#extension GL_EXT_shadow_samplers : require", "", 0);
|
||||
replace_string (src, "#extension GL_EXT_frag_depth : require", "", 0);
|
||||
|
16
3rdparty/glsl-optimizer/tests/vertex/builtin-vars-in.txt
vendored
Normal file
16
3rdparty/glsl-optimizer/tests/vertex/builtin-vars-in.txt
vendored
Normal file
@ -0,0 +1,16 @@
|
||||
#extension GL_ARB_draw_instanced : require
|
||||
#extension GL_EXT_gpu_shader4 : require
|
||||
|
||||
attribute vec3 _inPos;
|
||||
attribute vec3 _inNor;
|
||||
|
||||
void main()
|
||||
{
|
||||
vec3 p;
|
||||
p = _inPos;
|
||||
p.y += float(gl_VertexID);
|
||||
p.y += float(gl_InstanceIDARB);
|
||||
p += _inNor;
|
||||
gl_Position = vec4(p,1.0);
|
||||
gl_PointSize = p.x;
|
||||
}
|
14
3rdparty/glsl-optimizer/tests/vertex/builtin-vars-inES.txt
vendored
Normal file
14
3rdparty/glsl-optimizer/tests/vertex/builtin-vars-inES.txt
vendored
Normal file
@ -0,0 +1,14 @@
|
||||
#extension GL_EXT_draw_instanced : require
|
||||
|
||||
attribute highp vec3 _inPos;
|
||||
attribute highp vec3 _inNor;
|
||||
|
||||
void main()
|
||||
{
|
||||
highp vec3 p;
|
||||
p = _inPos;
|
||||
p.y += float(gl_InstanceIDEXT);
|
||||
p += _inNor;
|
||||
gl_Position = vec4(p,1.0);
|
||||
gl_PointSize = p.x;
|
||||
}
|
23
3rdparty/glsl-optimizer/tests/vertex/builtin-vars-out.txt
vendored
Normal file
23
3rdparty/glsl-optimizer/tests/vertex/builtin-vars-out.txt
vendored
Normal file
@ -0,0 +1,23 @@
|
||||
#extension GL_ARB_draw_instanced : enable
|
||||
#extension GL_EXT_gpu_shader4 : enable
|
||||
attribute vec3 _inPos;
|
||||
attribute vec3 _inNor;
|
||||
void main ()
|
||||
{
|
||||
vec3 p_1;
|
||||
p_1.xz = _inPos.xz;
|
||||
p_1.y = (_inPos.y + float(gl_VertexID));
|
||||
p_1.y = (p_1.y + float(gl_InstanceIDARB));
|
||||
p_1 = (p_1 + _inNor);
|
||||
vec4 tmpvar_2;
|
||||
tmpvar_2.w = 1.0;
|
||||
tmpvar_2.xyz = p_1;
|
||||
gl_Position = tmpvar_2;
|
||||
gl_PointSize = p_1.x;
|
||||
}
|
||||
|
||||
|
||||
// stats: 6 alu 0 tex 0 flow
|
||||
// inputs: 2
|
||||
// #0: _inPos (high float) 3x1 [-1]
|
||||
// #1: _inNor (high float) 3x1 [-1]
|
21
3rdparty/glsl-optimizer/tests/vertex/builtin-vars-outES.txt
vendored
Normal file
21
3rdparty/glsl-optimizer/tests/vertex/builtin-vars-outES.txt
vendored
Normal file
@ -0,0 +1,21 @@
|
||||
#extension GL_EXT_draw_instanced : enable
|
||||
attribute highp vec3 _inPos;
|
||||
attribute highp vec3 _inNor;
|
||||
void main ()
|
||||
{
|
||||
highp vec3 p_1;
|
||||
p_1.xz = _inPos.xz;
|
||||
p_1.y = (_inPos.y + float(gl_InstanceIDEXT));
|
||||
p_1 = (p_1 + _inNor);
|
||||
highp vec4 tmpvar_2;
|
||||
tmpvar_2.w = 1.0;
|
||||
tmpvar_2.xyz = p_1;
|
||||
gl_Position = tmpvar_2;
|
||||
gl_PointSize = p_1.x;
|
||||
}
|
||||
|
||||
|
||||
// stats: 4 alu 0 tex 0 flow
|
||||
// inputs: 2
|
||||
// #0: _inPos (high float) 3x1 [-1]
|
||||
// #1: _inNor (high float) 3x1 [-1]
|
@ -40,7 +40,10 @@ void main ()
|
||||
Temp_int_1.xyz = floatBitsToInt((intBitsToFloat(Temp_int_0).www * intBitsToFloat(Temp_int_1).xyz));
|
||||
Temp_2.xyz = glstate_lightmodel_ambient.xyz;
|
||||
Temp_int_0.w = 0;
|
||||
for (; Temp_int_0.w < 4; Temp_int_0.w = (Temp_int_0.w + 1)) {
|
||||
while (true) {
|
||||
if ((Temp_int_0.w >= 4)) {
|
||||
break;
|
||||
};
|
||||
Temp_3.xyz = ((-(
|
||||
intBitsToFloat(Temp_int_0)
|
||||
.xyz) * unity_LightPosition[Temp_int_0.w].www) + unity_LightPosition[Temp_int_0.w].xyz);
|
||||
@ -61,6 +64,7 @@ void main ()
|
||||
Temp_2.w = max (Temp_2.w, 0.0);
|
||||
Temp_int_1.w = floatBitsToInt((intBitsToFloat(Temp_int_1).w * Temp_2.w));
|
||||
Temp_2.xyz = ((unity_LightColor[Temp_int_0.w].xyz * intBitsToFloat(Temp_int_1).www) + Temp_2.xyz);
|
||||
Temp_int_0.w = (Temp_int_0.w + 1);
|
||||
};
|
||||
COLOR0.xyz = (Temp_2.xyz * _Color.xyz);
|
||||
COLOR0.w = (_Color.w * _ReflectColor.w);
|
||||
|
@ -49,7 +49,10 @@ int4 Temp_int_1_5;
|
||||
Temp_int_1_5.xyz = as_type<int3>((as_type<float4>(Temp_int_0_4).www * as_type<float4>(Temp_int_1_5).xyz));
|
||||
Temp_2_2.xyz = _mtl_u.glstate_lightmodel_ambient.xyz;
|
||||
Temp_int_0_4.w = 0;
|
||||
for (; Temp_int_0_4.w < 4; Temp_int_0_4.w = (Temp_int_0_4.w + 1)) {
|
||||
while (true) {
|
||||
if ((Temp_int_0_4.w >= 4)) {
|
||||
break;
|
||||
};
|
||||
Temp_3_3.xyz = ((-(
|
||||
as_type<float4>(Temp_int_0_4)
|
||||
.xyz) * _mtl_u.unity_LightPosition[Temp_int_0_4.w].www) + _mtl_u.unity_LightPosition[Temp_int_0_4.w].xyz);
|
||||
@ -70,6 +73,7 @@ int4 Temp_int_1_5;
|
||||
Temp_2_2.w = max (Temp_2_2.w, 0.0);
|
||||
Temp_int_1_5.w = as_type<int>((as_type<float4>(Temp_int_1_5).w * Temp_2_2.w));
|
||||
Temp_2_2.xyz = ((_mtl_u.unity_LightColor[Temp_int_0_4.w].xyz * as_type<float4>(Temp_int_1_5).www) + Temp_2_2.xyz);
|
||||
Temp_int_0_4.w = (Temp_int_0_4.w + 1);
|
||||
};
|
||||
_mtl_o.COLOR0.xyz = (Temp_2_2.xyz * _mtl_u._Color.xyz);
|
||||
_mtl_o.COLOR0.w = (_mtl_u._Color.w * _mtl_u._ReflectColor.w);
|
||||
|
63
3rdparty/glsl-optimizer/tests/vertex/loops-forlimitbreak-inES.txt
vendored
Normal file
63
3rdparty/glsl-optimizer/tests/vertex/loops-forlimitbreak-inES.txt
vendored
Normal file
@ -0,0 +1,63 @@
|
||||
#line 1
|
||||
attribute vec4 _glesVertex;
|
||||
attribute vec3 _glesNormal;
|
||||
struct v2f {
|
||||
lowp vec4 color;
|
||||
highp vec4 pos;
|
||||
};
|
||||
struct appdata {
|
||||
highp vec3 pos;
|
||||
highp vec3 normal;
|
||||
};
|
||||
uniform mediump vec4 unity_LightColor[8];
|
||||
uniform highp vec4 unity_LightPosition[8];
|
||||
uniform highp ivec4 unity_VertexLightParams;
|
||||
mediump vec3 computeLighting(in highp int idx, in mediump vec3 dirToLight, in mediump vec3 eyeNormal, in mediump float atten)
|
||||
{
|
||||
mediump float NdotL = max( dot( eyeNormal, dirToLight), 0.0);
|
||||
mediump vec3 color = NdotL * unity_LightColor[idx].xyz;
|
||||
return color * atten;
|
||||
}
|
||||
mediump vec3 computeOneLight( in highp int idx, in mediump vec3 eyeNormal)
|
||||
{
|
||||
highp vec3 dirToLight = unity_LightPosition[idx].xyz;
|
||||
mediump float att = 1.0;
|
||||
|
||||
att *= 0.5;
|
||||
return min( computeLighting( idx, dirToLight, eyeNormal, att), vec3(1.0));
|
||||
}
|
||||
v2f vert( in appdata IN )
|
||||
{
|
||||
v2f o;
|
||||
mediump vec4 color = vec4(0.0, 0.0, 0.0, 1.1);
|
||||
|
||||
mediump vec3 eyeNormal = IN.normal;
|
||||
|
||||
mediump vec3 lcolor = vec3(0.0);
|
||||
|
||||
// loop doing up to N lights, with max cap
|
||||
highp int il = 0;
|
||||
for ( ; (float(il) < min( 8.0, float(unity_VertexLightParams.x))); (++il))
|
||||
{
|
||||
lcolor += computeOneLight(il, eyeNormal);
|
||||
}
|
||||
color.xyz = lcolor.xyz;
|
||||
|
||||
// other forms of a similar loop
|
||||
for (int j = 0; j < int(min(float(unity_VertexLightParams.y),4.0)); ++j)
|
||||
color.xyz += unity_LightColor[j].xyz;
|
||||
|
||||
o.color = color;
|
||||
o.pos = vec4(IN.pos,1.0);
|
||||
return o;
|
||||
}
|
||||
varying lowp vec4 xlv_COLOR0;
|
||||
void main() {
|
||||
v2f xl_retval;
|
||||
appdata xlt_IN;
|
||||
xlt_IN.pos = _glesVertex.xyz;
|
||||
xlt_IN.normal = _glesNormal;
|
||||
xl_retval = vert(xlt_IN);
|
||||
xlv_COLOR0 = vec4(xl_retval.color);
|
||||
gl_Position = vec4(xl_retval.pos);
|
||||
}
|
66
3rdparty/glsl-optimizer/tests/vertex/loops-forlimitbreak-inES3.txt
vendored
Normal file
66
3rdparty/glsl-optimizer/tests/vertex/loops-forlimitbreak-inES3.txt
vendored
Normal file
@ -0,0 +1,66 @@
|
||||
#version 300 es
|
||||
#line 2
|
||||
in vec4 _glesVertex;
|
||||
in vec3 _glesNormal;
|
||||
struct v2f {
|
||||
lowp vec4 color;
|
||||
highp vec4 pos;
|
||||
};
|
||||
struct appdata {
|
||||
highp vec3 pos;
|
||||
highp vec3 normal;
|
||||
};
|
||||
uniform mediump vec4 unity_LightColor[8];
|
||||
uniform highp vec4 unity_LightPosition[8];
|
||||
uniform highp ivec4 unity_VertexLightParams;
|
||||
mediump vec3 computeLighting(in highp int idx, in mediump vec3 dirToLight, in mediump vec3 eyeNormal, in mediump float atten)
|
||||
{
|
||||
mediump float NdotL = max( dot( eyeNormal, dirToLight), 0.0);
|
||||
mediump vec3 color = NdotL * unity_LightColor[idx].xyz;
|
||||
return color * atten;
|
||||
}
|
||||
mediump vec3 computeOneLight( in highp int idx, in mediump vec3 eyeNormal)
|
||||
{
|
||||
highp vec3 dirToLight = unity_LightPosition[idx].xyz;
|
||||
mediump float att = 1.0;
|
||||
|
||||
att *= 0.5;
|
||||
return min( computeLighting( idx, dirToLight, eyeNormal, att), vec3(1.0));
|
||||
}
|
||||
v2f vert( in appdata IN )
|
||||
{
|
||||
v2f o;
|
||||
mediump vec4 color = vec4(0.0, 0.0, 0.0, 1.1);
|
||||
|
||||
mediump vec3 eyeNormal = IN.normal;
|
||||
|
||||
mediump vec3 lcolor = vec3(0.0);
|
||||
|
||||
// loop doing up to N lights, with max cap
|
||||
highp int il = 0;
|
||||
for ( ; (float(il) < min( 8.0, float(unity_VertexLightParams.x))); (++il))
|
||||
{
|
||||
lcolor += computeOneLight(il, eyeNormal);
|
||||
}
|
||||
color.xyz = lcolor.xyz;
|
||||
|
||||
// other forms of a similar loop
|
||||
for (int j = 0; j < int(min(float(unity_VertexLightParams.y),4.0)); ++j)
|
||||
color.xyz += unity_LightColor[j].xyz;
|
||||
for (int j = 0; j < min(unity_VertexLightParams.y,4); ++j)
|
||||
color.xyz *= unity_LightColor[j].xyz;
|
||||
|
||||
o.color = color;
|
||||
o.pos = vec4(IN.pos,1.0);
|
||||
return o;
|
||||
}
|
||||
out lowp vec4 xlv_COLOR0;
|
||||
void main() {
|
||||
v2f xl_retval;
|
||||
appdata xlt_IN;
|
||||
xlt_IN.pos = _glesVertex.xyz;
|
||||
xlt_IN.normal = _glesNormal;
|
||||
xl_retval = vert(xlt_IN);
|
||||
xlv_COLOR0 = vec4(xl_retval.color);
|
||||
gl_Position = vec4(xl_retval.pos);
|
||||
}
|
65
3rdparty/glsl-optimizer/tests/vertex/loops-forlimitbreak-outES.txt
vendored
Normal file
65
3rdparty/glsl-optimizer/tests/vertex/loops-forlimitbreak-outES.txt
vendored
Normal file
@ -0,0 +1,65 @@
|
||||
attribute vec4 _glesVertex;
|
||||
attribute vec3 _glesNormal;
|
||||
uniform mediump vec4 unity_LightColor[8];
|
||||
uniform highp vec4 unity_LightPosition[8];
|
||||
uniform highp ivec4 unity_VertexLightParams;
|
||||
varying lowp vec4 xlv_COLOR0;
|
||||
void main ()
|
||||
{
|
||||
highp vec3 tmpvar_1;
|
||||
highp vec3 tmpvar_2;
|
||||
tmpvar_1 = _glesVertex.xyz;
|
||||
tmpvar_2 = _glesNormal;
|
||||
highp int j_3;
|
||||
highp int il_4;
|
||||
mediump vec3 lcolor_5;
|
||||
mediump vec3 eyeNormal_6;
|
||||
mediump vec4 color_7;
|
||||
lowp vec4 tmpvar_8;
|
||||
color_7 = vec4(0.0, 0.0, 0.0, 1.1);
|
||||
eyeNormal_6 = tmpvar_2;
|
||||
lcolor_5 = vec3(0.0, 0.0, 0.0);
|
||||
il_4 = 0;
|
||||
while (true) {
|
||||
highp float tmpvar_9;
|
||||
tmpvar_9 = min (8.0, float(unity_VertexLightParams.x));
|
||||
if ((float(il_4) >= tmpvar_9)) {
|
||||
break;
|
||||
};
|
||||
highp vec3 tmpvar_10;
|
||||
tmpvar_10 = unity_LightPosition[il_4].xyz;
|
||||
mediump vec3 dirToLight_11;
|
||||
dirToLight_11 = tmpvar_10;
|
||||
lcolor_5 = (lcolor_5 + min ((
|
||||
(max (dot (eyeNormal_6, dirToLight_11), 0.0) * unity_LightColor[il_4].xyz)
|
||||
* 0.5), vec3(1.0, 1.0, 1.0)));
|
||||
il_4++;
|
||||
};
|
||||
color_7.xyz = lcolor_5;
|
||||
j_3 = 0;
|
||||
while (true) {
|
||||
highp float tmpvar_12;
|
||||
tmpvar_12 = min (float(unity_VertexLightParams.y), 4.0);
|
||||
if ((j_3 >= int(tmpvar_12))) {
|
||||
break;
|
||||
};
|
||||
color_7.xyz = (color_7.xyz + unity_LightColor[j_3].xyz);
|
||||
j_3++;
|
||||
};
|
||||
tmpvar_8 = color_7;
|
||||
highp vec4 tmpvar_13;
|
||||
tmpvar_13.w = 1.0;
|
||||
tmpvar_13.xyz = tmpvar_1;
|
||||
xlv_COLOR0 = tmpvar_8;
|
||||
gl_Position = tmpvar_13;
|
||||
}
|
||||
|
||||
|
||||
// stats: 22 alu 0 tex 4 flow
|
||||
// inputs: 2
|
||||
// #0: _glesVertex (high float) 4x1 [-1]
|
||||
// #1: _glesNormal (high float) 3x1 [-1]
|
||||
// uniforms: 3 (total size: 0)
|
||||
// #0: unity_LightColor (medium float) 4x1 [8]
|
||||
// #1: unity_LightPosition (high float) 4x1 [8]
|
||||
// #2: unity_VertexLightParams (high int) 4x1 [-1]
|
77
3rdparty/glsl-optimizer/tests/vertex/loops-forlimitbreak-outES3.txt
vendored
Normal file
77
3rdparty/glsl-optimizer/tests/vertex/loops-forlimitbreak-outES3.txt
vendored
Normal file
@ -0,0 +1,77 @@
|
||||
#version 300 es
|
||||
in vec4 _glesVertex;
|
||||
in vec3 _glesNormal;
|
||||
uniform mediump vec4 unity_LightColor[8];
|
||||
uniform highp vec4 unity_LightPosition[8];
|
||||
uniform highp ivec4 unity_VertexLightParams;
|
||||
out lowp vec4 xlv_COLOR0;
|
||||
void main ()
|
||||
{
|
||||
highp vec3 tmpvar_1;
|
||||
highp vec3 tmpvar_2;
|
||||
tmpvar_1 = _glesVertex.xyz;
|
||||
tmpvar_2 = _glesNormal;
|
||||
highp int j_3;
|
||||
highp int j_4;
|
||||
highp int il_5;
|
||||
mediump vec3 lcolor_6;
|
||||
mediump vec3 eyeNormal_7;
|
||||
mediump vec4 color_8;
|
||||
lowp vec4 tmpvar_9;
|
||||
color_8 = vec4(0.0, 0.0, 0.0, 1.1);
|
||||
eyeNormal_7 = tmpvar_2;
|
||||
lcolor_6 = vec3(0.0, 0.0, 0.0);
|
||||
il_5 = 0;
|
||||
while (true) {
|
||||
highp float tmpvar_10;
|
||||
tmpvar_10 = min (8.0, float(unity_VertexLightParams.x));
|
||||
if ((float(il_5) >= tmpvar_10)) {
|
||||
break;
|
||||
};
|
||||
highp vec3 tmpvar_11;
|
||||
tmpvar_11 = unity_LightPosition[il_5].xyz;
|
||||
mediump vec3 dirToLight_12;
|
||||
dirToLight_12 = tmpvar_11;
|
||||
lcolor_6 = (lcolor_6 + min ((
|
||||
(max (dot (eyeNormal_7, dirToLight_12), 0.0) * unity_LightColor[il_5].xyz)
|
||||
* 0.5), vec3(1.0, 1.0, 1.0)));
|
||||
il_5++;
|
||||
};
|
||||
color_8.xyz = lcolor_6;
|
||||
j_4 = 0;
|
||||
while (true) {
|
||||
highp float tmpvar_13;
|
||||
tmpvar_13 = min (float(unity_VertexLightParams.y), 4.0);
|
||||
if ((j_4 >= int(tmpvar_13))) {
|
||||
break;
|
||||
};
|
||||
color_8.xyz = (color_8.xyz + unity_LightColor[j_4].xyz);
|
||||
j_4++;
|
||||
};
|
||||
j_3 = 0;
|
||||
while (true) {
|
||||
highp int tmpvar_14;
|
||||
tmpvar_14 = min (unity_VertexLightParams.y, 4);
|
||||
if ((j_3 >= tmpvar_14)) {
|
||||
break;
|
||||
};
|
||||
color_8.xyz = (color_8.xyz * unity_LightColor[j_3].xyz);
|
||||
j_3++;
|
||||
};
|
||||
tmpvar_9 = color_8;
|
||||
highp vec4 tmpvar_15;
|
||||
tmpvar_15.w = 1.0;
|
||||
tmpvar_15.xyz = tmpvar_1;
|
||||
xlv_COLOR0 = tmpvar_9;
|
||||
gl_Position = tmpvar_15;
|
||||
}
|
||||
|
||||
|
||||
// stats: 27 alu 0 tex 6 flow
|
||||
// inputs: 2
|
||||
// #0: _glesVertex (high float) 4x1 [-1]
|
||||
// #1: _glesNormal (high float) 3x1 [-1]
|
||||
// uniforms: 3 (total size: 0)
|
||||
// #0: unity_LightColor (medium float) 4x1 [8]
|
||||
// #1: unity_LightPosition (high float) 4x1 [8]
|
||||
// #2: unity_VertexLightParams (high int) 4x1 [-1]
|
85
3rdparty/glsl-optimizer/tests/vertex/loops-forlimitbreak-outES3Metal.txt
vendored
Normal file
85
3rdparty/glsl-optimizer/tests/vertex/loops-forlimitbreak-outES3Metal.txt
vendored
Normal file
@ -0,0 +1,85 @@
|
||||
#include <metal_stdlib>
|
||||
using namespace metal;
|
||||
struct xlatMtlShaderInput {
|
||||
float4 _glesVertex [[attribute(0)]];
|
||||
float3 _glesNormal [[attribute(1)]];
|
||||
};
|
||||
struct xlatMtlShaderOutput {
|
||||
float4 gl_Position [[position]];
|
||||
half4 xlv_COLOR0;
|
||||
};
|
||||
struct xlatMtlShaderUniform {
|
||||
half4 unity_LightColor[8];
|
||||
float4 unity_LightPosition[8];
|
||||
int4 unity_VertexLightParams;
|
||||
};
|
||||
vertex xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]], constant xlatMtlShaderUniform& _mtl_u [[buffer(0)]])
|
||||
{
|
||||
xlatMtlShaderOutput _mtl_o;
|
||||
float3 tmpvar_1;
|
||||
tmpvar_1 = _mtl_i._glesVertex.xyz;
|
||||
int j_2;
|
||||
int j_3;
|
||||
int il_4;
|
||||
half3 lcolor_5;
|
||||
half3 eyeNormal_6;
|
||||
half4 color_7;
|
||||
half4 tmpvar_8;
|
||||
color_7 = half4(float4(0.0, 0.0, 0.0, 1.1));
|
||||
eyeNormal_6 = half3(_mtl_i._glesNormal);
|
||||
lcolor_5 = half3(float3(0.0, 0.0, 0.0));
|
||||
il_4 = 0;
|
||||
while (true) {
|
||||
float tmpvar_9;
|
||||
tmpvar_9 = min (8.0, float(_mtl_u.unity_VertexLightParams.x));
|
||||
if ((float(il_4) >= tmpvar_9)) {
|
||||
break;
|
||||
};
|
||||
float3 tmpvar_10;
|
||||
tmpvar_10 = _mtl_u.unity_LightPosition[il_4].xyz;
|
||||
half3 dirToLight_11;
|
||||
dirToLight_11 = half3(tmpvar_10);
|
||||
lcolor_5 = (lcolor_5 + min ((
|
||||
(max (dot (eyeNormal_6, dirToLight_11), (half)0.0) * _mtl_u.unity_LightColor[il_4].xyz)
|
||||
* (half)0.5), (half3)float3(1.0, 1.0, 1.0)));
|
||||
il_4++;
|
||||
};
|
||||
color_7.xyz = lcolor_5;
|
||||
j_3 = 0;
|
||||
while (true) {
|
||||
float tmpvar_12;
|
||||
tmpvar_12 = min (float(_mtl_u.unity_VertexLightParams.y), 4.0);
|
||||
if ((j_3 >= int(tmpvar_12))) {
|
||||
break;
|
||||
};
|
||||
color_7.xyz = (color_7.xyz + _mtl_u.unity_LightColor[j_3].xyz);
|
||||
j_3++;
|
||||
};
|
||||
j_2 = 0;
|
||||
while (true) {
|
||||
int tmpvar_13;
|
||||
tmpvar_13 = min (_mtl_u.unity_VertexLightParams.y, 4);
|
||||
if ((j_2 >= tmpvar_13)) {
|
||||
break;
|
||||
};
|
||||
color_7.xyz = (color_7.xyz * _mtl_u.unity_LightColor[j_2].xyz);
|
||||
j_2++;
|
||||
};
|
||||
tmpvar_8 = color_7;
|
||||
float4 tmpvar_14;
|
||||
tmpvar_14.w = 1.0;
|
||||
tmpvar_14.xyz = tmpvar_1;
|
||||
_mtl_o.xlv_COLOR0 = tmpvar_8;
|
||||
_mtl_o.gl_Position = tmpvar_14;
|
||||
return _mtl_o;
|
||||
}
|
||||
|
||||
|
||||
// stats: 27 alu 0 tex 6 flow
|
||||
// inputs: 2
|
||||
// #0: _glesVertex (high float) 4x1 [-1] loc 0
|
||||
// #1: _glesNormal (high float) 3x1 [-1] loc 1
|
||||
// uniforms: 3 (total size: 208)
|
||||
// #0: unity_LightColor (medium float) 4x1 [8] loc 0
|
||||
// #1: unity_LightPosition (high float) 4x1 [8] loc 64
|
||||
// #2: unity_VertexLightParams (high int) 4x1 [-1] loc 192
|
@ -17,134 +17,134 @@ void main ()
|
||||
highp vec2 tmpvar_6;
|
||||
tmpvar_6.y = 1.0;
|
||||
tmpvar_6.x = float(tmpvar_5.x);
|
||||
mediump vec4 tmpvar_7;
|
||||
mediump vec2 coord_8;
|
||||
coord_8 = tmpvar_6;
|
||||
mediump vec2 coord_7;
|
||||
coord_7 = tmpvar_6;
|
||||
mediump vec4 tmpvar_8;
|
||||
tmpvar_8.zw = vec2(0.0, 0.0);
|
||||
tmpvar_8.xy = (coord_7 / _DynLampInfo_bufferSize);
|
||||
mediump vec4 tmpvar_9;
|
||||
tmpvar_9.zw = vec2(0.0, 0.0);
|
||||
tmpvar_9.xy = (coord_8 / _DynLampInfo_bufferSize);
|
||||
lowp vec4 tmpvar_10;
|
||||
tmpvar_10 = texture2DLod (_DynLampInfo, tmpvar_9.xy, 0.0);
|
||||
tmpvar_7 = tmpvar_10;
|
||||
tmpvar_10 = texture2DLod (_DynLampInfo, tmpvar_8.xy, 0.0);
|
||||
tmpvar_9 = tmpvar_10;
|
||||
highp vec2 tmpvar_11;
|
||||
tmpvar_11.y = 2.0;
|
||||
tmpvar_11.x = float(tmpvar_5.x);
|
||||
mediump vec4 tmpvar_12;
|
||||
mediump vec2 coord_13;
|
||||
coord_13 = tmpvar_11;
|
||||
mediump vec2 coord_12;
|
||||
coord_12 = tmpvar_11;
|
||||
mediump vec4 tmpvar_13;
|
||||
tmpvar_13.zw = vec2(0.0, 0.0);
|
||||
tmpvar_13.xy = (coord_12 / _DynLampInfo_bufferSize);
|
||||
mediump vec4 tmpvar_14;
|
||||
tmpvar_14.zw = vec2(0.0, 0.0);
|
||||
tmpvar_14.xy = (coord_13 / _DynLampInfo_bufferSize);
|
||||
lowp vec4 tmpvar_15;
|
||||
tmpvar_15 = texture2DLod (_DynLampInfo, tmpvar_14.xy, 0.0);
|
||||
tmpvar_12 = tmpvar_15;
|
||||
tmpvar_15 = texture2DLod (_DynLampInfo, tmpvar_13.xy, 0.0);
|
||||
tmpvar_14 = tmpvar_15;
|
||||
highp vec2 tmpvar_16;
|
||||
tmpvar_16.y = 1.0;
|
||||
tmpvar_16.x = float(tmpvar_5.y);
|
||||
mediump vec4 tmpvar_17;
|
||||
mediump vec2 coord_18;
|
||||
coord_18 = tmpvar_16;
|
||||
mediump vec2 coord_17;
|
||||
coord_17 = tmpvar_16;
|
||||
mediump vec4 tmpvar_18;
|
||||
tmpvar_18.zw = vec2(0.0, 0.0);
|
||||
tmpvar_18.xy = (coord_17 / _DynLampInfo_bufferSize);
|
||||
mediump vec4 tmpvar_19;
|
||||
tmpvar_19.zw = vec2(0.0, 0.0);
|
||||
tmpvar_19.xy = (coord_18 / _DynLampInfo_bufferSize);
|
||||
lowp vec4 tmpvar_20;
|
||||
tmpvar_20 = texture2DLod (_DynLampInfo, tmpvar_19.xy, 0.0);
|
||||
tmpvar_17 = tmpvar_20;
|
||||
tmpvar_20 = texture2DLod (_DynLampInfo, tmpvar_18.xy, 0.0);
|
||||
tmpvar_19 = tmpvar_20;
|
||||
highp vec2 tmpvar_21;
|
||||
tmpvar_21.y = 2.0;
|
||||
tmpvar_21.x = float(tmpvar_5.y);
|
||||
mediump vec4 tmpvar_22;
|
||||
mediump vec2 coord_23;
|
||||
coord_23 = tmpvar_21;
|
||||
mediump vec2 coord_22;
|
||||
coord_22 = tmpvar_21;
|
||||
mediump vec4 tmpvar_23;
|
||||
tmpvar_23.zw = vec2(0.0, 0.0);
|
||||
tmpvar_23.xy = (coord_22 / _DynLampInfo_bufferSize);
|
||||
mediump vec4 tmpvar_24;
|
||||
tmpvar_24.zw = vec2(0.0, 0.0);
|
||||
tmpvar_24.xy = (coord_23 / _DynLampInfo_bufferSize);
|
||||
lowp vec4 tmpvar_25;
|
||||
tmpvar_25 = texture2DLod (_DynLampInfo, tmpvar_24.xy, 0.0);
|
||||
tmpvar_22 = tmpvar_25;
|
||||
tmpvar_25 = texture2DLod (_DynLampInfo, tmpvar_23.xy, 0.0);
|
||||
tmpvar_24 = tmpvar_25;
|
||||
highp vec2 tmpvar_26;
|
||||
tmpvar_26.y = 1.0;
|
||||
tmpvar_26.x = float(tmpvar_5.z);
|
||||
mediump vec4 tmpvar_27;
|
||||
mediump vec2 coord_28;
|
||||
coord_28 = tmpvar_26;
|
||||
mediump vec2 coord_27;
|
||||
coord_27 = tmpvar_26;
|
||||
mediump vec4 tmpvar_28;
|
||||
tmpvar_28.zw = vec2(0.0, 0.0);
|
||||
tmpvar_28.xy = (coord_27 / _DynLampInfo_bufferSize);
|
||||
mediump vec4 tmpvar_29;
|
||||
tmpvar_29.zw = vec2(0.0, 0.0);
|
||||
tmpvar_29.xy = (coord_28 / _DynLampInfo_bufferSize);
|
||||
lowp vec4 tmpvar_30;
|
||||
tmpvar_30 = texture2DLod (_DynLampInfo, tmpvar_29.xy, 0.0);
|
||||
tmpvar_27 = tmpvar_30;
|
||||
tmpvar_30 = texture2DLod (_DynLampInfo, tmpvar_28.xy, 0.0);
|
||||
tmpvar_29 = tmpvar_30;
|
||||
highp vec2 tmpvar_31;
|
||||
tmpvar_31.y = 2.0;
|
||||
tmpvar_31.x = float(tmpvar_5.z);
|
||||
mediump vec4 tmpvar_32;
|
||||
mediump vec2 coord_33;
|
||||
coord_33 = tmpvar_31;
|
||||
mediump vec2 coord_32;
|
||||
coord_32 = tmpvar_31;
|
||||
mediump vec4 tmpvar_33;
|
||||
tmpvar_33.zw = vec2(0.0, 0.0);
|
||||
tmpvar_33.xy = (coord_32 / _DynLampInfo_bufferSize);
|
||||
mediump vec4 tmpvar_34;
|
||||
tmpvar_34.zw = vec2(0.0, 0.0);
|
||||
tmpvar_34.xy = (coord_33 / _DynLampInfo_bufferSize);
|
||||
lowp vec4 tmpvar_35;
|
||||
tmpvar_35 = texture2DLod (_DynLampInfo, tmpvar_34.xy, 0.0);
|
||||
tmpvar_32 = tmpvar_35;
|
||||
tmpvar_35 = texture2DLod (_DynLampInfo, tmpvar_33.xy, 0.0);
|
||||
tmpvar_34 = tmpvar_35;
|
||||
highp vec2 tmpvar_36;
|
||||
tmpvar_36.y = 1.0;
|
||||
tmpvar_36.x = float(tmpvar_5.w);
|
||||
mediump vec4 tmpvar_37;
|
||||
mediump vec2 coord_38;
|
||||
coord_38 = tmpvar_36;
|
||||
mediump vec2 coord_37;
|
||||
coord_37 = tmpvar_36;
|
||||
mediump vec4 tmpvar_38;
|
||||
tmpvar_38.zw = vec2(0.0, 0.0);
|
||||
tmpvar_38.xy = (coord_37 / _DynLampInfo_bufferSize);
|
||||
mediump vec4 tmpvar_39;
|
||||
tmpvar_39.zw = vec2(0.0, 0.0);
|
||||
tmpvar_39.xy = (coord_38 / _DynLampInfo_bufferSize);
|
||||
lowp vec4 tmpvar_40;
|
||||
tmpvar_40 = texture2DLod (_DynLampInfo, tmpvar_39.xy, 0.0);
|
||||
tmpvar_37 = tmpvar_40;
|
||||
tmpvar_40 = texture2DLod (_DynLampInfo, tmpvar_38.xy, 0.0);
|
||||
tmpvar_39 = tmpvar_40;
|
||||
highp vec2 tmpvar_41;
|
||||
tmpvar_41.y = 2.0;
|
||||
tmpvar_41.x = float(tmpvar_5.w);
|
||||
mediump vec4 tmpvar_42;
|
||||
mediump vec2 coord_43;
|
||||
coord_43 = tmpvar_41;
|
||||
mediump vec2 coord_42;
|
||||
coord_42 = tmpvar_41;
|
||||
mediump vec4 tmpvar_43;
|
||||
tmpvar_43.zw = vec2(0.0, 0.0);
|
||||
tmpvar_43.xy = (coord_42 / _DynLampInfo_bufferSize);
|
||||
mediump vec4 tmpvar_44;
|
||||
tmpvar_44.zw = vec2(0.0, 0.0);
|
||||
tmpvar_44.xy = (coord_43 / _DynLampInfo_bufferSize);
|
||||
lowp vec4 tmpvar_45;
|
||||
tmpvar_45 = texture2DLod (_DynLampInfo, tmpvar_44.xy, 0.0);
|
||||
tmpvar_42 = tmpvar_45;
|
||||
tmpvar_45 = texture2DLod (_DynLampInfo, tmpvar_43.xy, 0.0);
|
||||
tmpvar_44 = tmpvar_45;
|
||||
mediump vec3 hybridCol_46;
|
||||
mediump vec4 atten_47;
|
||||
highp vec3 tmpvar_48;
|
||||
tmpvar_48 = (tmpvar_7.xyz - tmpvar_2);
|
||||
tmpvar_48 = (tmpvar_9.xyz - tmpvar_2);
|
||||
highp float tmpvar_49;
|
||||
tmpvar_49 = dot (tmpvar_48, tmpvar_48);
|
||||
mediump vec4 tmpvar_50;
|
||||
tmpvar_50.yzw = atten_47.yzw;
|
||||
tmpvar_50.x = (tmpvar_49 * tmpvar_7.w);
|
||||
tmpvar_50.x = (tmpvar_49 * tmpvar_9.w);
|
||||
highp vec3 tmpvar_51;
|
||||
tmpvar_51 = (tmpvar_17.xyz - tmpvar_2);
|
||||
tmpvar_51 = (tmpvar_19.xyz - tmpvar_2);
|
||||
highp float tmpvar_52;
|
||||
tmpvar_52 = dot (tmpvar_51, tmpvar_51);
|
||||
mediump vec4 tmpvar_53;
|
||||
tmpvar_53.xzw = tmpvar_50.xzw;
|
||||
tmpvar_53.y = (tmpvar_52 * tmpvar_17.w);
|
||||
tmpvar_53.y = (tmpvar_52 * tmpvar_19.w);
|
||||
highp vec3 tmpvar_54;
|
||||
tmpvar_54 = (tmpvar_27.xyz - tmpvar_2);
|
||||
tmpvar_54 = (tmpvar_29.xyz - tmpvar_2);
|
||||
highp float tmpvar_55;
|
||||
tmpvar_55 = dot (tmpvar_54, tmpvar_54);
|
||||
mediump vec4 tmpvar_56;
|
||||
tmpvar_56.xyw = tmpvar_53.xyw;
|
||||
tmpvar_56.z = (tmpvar_55 * tmpvar_27.w);
|
||||
tmpvar_56.z = (tmpvar_55 * tmpvar_29.w);
|
||||
highp vec3 tmpvar_57;
|
||||
tmpvar_57 = (tmpvar_37.xyz - tmpvar_2);
|
||||
tmpvar_57 = (tmpvar_39.xyz - tmpvar_2);
|
||||
highp float tmpvar_58;
|
||||
tmpvar_58 = dot (tmpvar_57, tmpvar_57);
|
||||
mediump vec4 tmpvar_59;
|
||||
tmpvar_59.xyz = tmpvar_56.xyz;
|
||||
tmpvar_59.w = (tmpvar_58 * tmpvar_37.w);
|
||||
tmpvar_59.w = (tmpvar_58 * tmpvar_39.w);
|
||||
atten_47 = tmpvar_59;
|
||||
hybridCol_46 = (hybridCol_4 + (tmpvar_12.xyz * tmpvar_50.x));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_22.xyz * tmpvar_53.y));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_32.xyz * tmpvar_56.z));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_42.xyz * tmpvar_59.w));
|
||||
hybridCol_46 = (hybridCol_4 + (tmpvar_14.xyz * tmpvar_50.x));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_24.xyz * tmpvar_53.y));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_34.xyz * tmpvar_56.z));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_44.xyz * tmpvar_59.w));
|
||||
tmpvar_3 = hybridCol_46;
|
||||
tmpvar_1 = tmpvar_3;
|
||||
gl_Position = (glstate_matrix_mvp * _glesVertex);
|
||||
|
@ -18,134 +18,134 @@ void main ()
|
||||
highp vec2 tmpvar_6;
|
||||
tmpvar_6.y = 1.0;
|
||||
tmpvar_6.x = float(tmpvar_5.x);
|
||||
mediump vec4 tmpvar_7;
|
||||
mediump vec2 coord_8;
|
||||
coord_8 = tmpvar_6;
|
||||
mediump vec2 coord_7;
|
||||
coord_7 = tmpvar_6;
|
||||
mediump vec4 tmpvar_8;
|
||||
tmpvar_8.zw = vec2(0.0, 0.0);
|
||||
tmpvar_8.xy = (coord_7 / _DynLampInfo_bufferSize);
|
||||
mediump vec4 tmpvar_9;
|
||||
tmpvar_9.zw = vec2(0.0, 0.0);
|
||||
tmpvar_9.xy = (coord_8 / _DynLampInfo_bufferSize);
|
||||
lowp vec4 tmpvar_10;
|
||||
tmpvar_10 = textureLod (_DynLampInfo, tmpvar_9.xy, 0.0);
|
||||
tmpvar_7 = tmpvar_10;
|
||||
tmpvar_10 = textureLod (_DynLampInfo, tmpvar_8.xy, 0.0);
|
||||
tmpvar_9 = tmpvar_10;
|
||||
highp vec2 tmpvar_11;
|
||||
tmpvar_11.y = 2.0;
|
||||
tmpvar_11.x = float(tmpvar_5.x);
|
||||
mediump vec4 tmpvar_12;
|
||||
mediump vec2 coord_13;
|
||||
coord_13 = tmpvar_11;
|
||||
mediump vec2 coord_12;
|
||||
coord_12 = tmpvar_11;
|
||||
mediump vec4 tmpvar_13;
|
||||
tmpvar_13.zw = vec2(0.0, 0.0);
|
||||
tmpvar_13.xy = (coord_12 / _DynLampInfo_bufferSize);
|
||||
mediump vec4 tmpvar_14;
|
||||
tmpvar_14.zw = vec2(0.0, 0.0);
|
||||
tmpvar_14.xy = (coord_13 / _DynLampInfo_bufferSize);
|
||||
lowp vec4 tmpvar_15;
|
||||
tmpvar_15 = textureLod (_DynLampInfo, tmpvar_14.xy, 0.0);
|
||||
tmpvar_12 = tmpvar_15;
|
||||
tmpvar_15 = textureLod (_DynLampInfo, tmpvar_13.xy, 0.0);
|
||||
tmpvar_14 = tmpvar_15;
|
||||
highp vec2 tmpvar_16;
|
||||
tmpvar_16.y = 1.0;
|
||||
tmpvar_16.x = float(tmpvar_5.y);
|
||||
mediump vec4 tmpvar_17;
|
||||
mediump vec2 coord_18;
|
||||
coord_18 = tmpvar_16;
|
||||
mediump vec2 coord_17;
|
||||
coord_17 = tmpvar_16;
|
||||
mediump vec4 tmpvar_18;
|
||||
tmpvar_18.zw = vec2(0.0, 0.0);
|
||||
tmpvar_18.xy = (coord_17 / _DynLampInfo_bufferSize);
|
||||
mediump vec4 tmpvar_19;
|
||||
tmpvar_19.zw = vec2(0.0, 0.0);
|
||||
tmpvar_19.xy = (coord_18 / _DynLampInfo_bufferSize);
|
||||
lowp vec4 tmpvar_20;
|
||||
tmpvar_20 = textureLod (_DynLampInfo, tmpvar_19.xy, 0.0);
|
||||
tmpvar_17 = tmpvar_20;
|
||||
tmpvar_20 = textureLod (_DynLampInfo, tmpvar_18.xy, 0.0);
|
||||
tmpvar_19 = tmpvar_20;
|
||||
highp vec2 tmpvar_21;
|
||||
tmpvar_21.y = 2.0;
|
||||
tmpvar_21.x = float(tmpvar_5.y);
|
||||
mediump vec4 tmpvar_22;
|
||||
mediump vec2 coord_23;
|
||||
coord_23 = tmpvar_21;
|
||||
mediump vec2 coord_22;
|
||||
coord_22 = tmpvar_21;
|
||||
mediump vec4 tmpvar_23;
|
||||
tmpvar_23.zw = vec2(0.0, 0.0);
|
||||
tmpvar_23.xy = (coord_22 / _DynLampInfo_bufferSize);
|
||||
mediump vec4 tmpvar_24;
|
||||
tmpvar_24.zw = vec2(0.0, 0.0);
|
||||
tmpvar_24.xy = (coord_23 / _DynLampInfo_bufferSize);
|
||||
lowp vec4 tmpvar_25;
|
||||
tmpvar_25 = textureLod (_DynLampInfo, tmpvar_24.xy, 0.0);
|
||||
tmpvar_22 = tmpvar_25;
|
||||
tmpvar_25 = textureLod (_DynLampInfo, tmpvar_23.xy, 0.0);
|
||||
tmpvar_24 = tmpvar_25;
|
||||
highp vec2 tmpvar_26;
|
||||
tmpvar_26.y = 1.0;
|
||||
tmpvar_26.x = float(tmpvar_5.z);
|
||||
mediump vec4 tmpvar_27;
|
||||
mediump vec2 coord_28;
|
||||
coord_28 = tmpvar_26;
|
||||
mediump vec2 coord_27;
|
||||
coord_27 = tmpvar_26;
|
||||
mediump vec4 tmpvar_28;
|
||||
tmpvar_28.zw = vec2(0.0, 0.0);
|
||||
tmpvar_28.xy = (coord_27 / _DynLampInfo_bufferSize);
|
||||
mediump vec4 tmpvar_29;
|
||||
tmpvar_29.zw = vec2(0.0, 0.0);
|
||||
tmpvar_29.xy = (coord_28 / _DynLampInfo_bufferSize);
|
||||
lowp vec4 tmpvar_30;
|
||||
tmpvar_30 = textureLod (_DynLampInfo, tmpvar_29.xy, 0.0);
|
||||
tmpvar_27 = tmpvar_30;
|
||||
tmpvar_30 = textureLod (_DynLampInfo, tmpvar_28.xy, 0.0);
|
||||
tmpvar_29 = tmpvar_30;
|
||||
highp vec2 tmpvar_31;
|
||||
tmpvar_31.y = 2.0;
|
||||
tmpvar_31.x = float(tmpvar_5.z);
|
||||
mediump vec4 tmpvar_32;
|
||||
mediump vec2 coord_33;
|
||||
coord_33 = tmpvar_31;
|
||||
mediump vec2 coord_32;
|
||||
coord_32 = tmpvar_31;
|
||||
mediump vec4 tmpvar_33;
|
||||
tmpvar_33.zw = vec2(0.0, 0.0);
|
||||
tmpvar_33.xy = (coord_32 / _DynLampInfo_bufferSize);
|
||||
mediump vec4 tmpvar_34;
|
||||
tmpvar_34.zw = vec2(0.0, 0.0);
|
||||
tmpvar_34.xy = (coord_33 / _DynLampInfo_bufferSize);
|
||||
lowp vec4 tmpvar_35;
|
||||
tmpvar_35 = textureLod (_DynLampInfo, tmpvar_34.xy, 0.0);
|
||||
tmpvar_32 = tmpvar_35;
|
||||
tmpvar_35 = textureLod (_DynLampInfo, tmpvar_33.xy, 0.0);
|
||||
tmpvar_34 = tmpvar_35;
|
||||
highp vec2 tmpvar_36;
|
||||
tmpvar_36.y = 1.0;
|
||||
tmpvar_36.x = float(tmpvar_5.w);
|
||||
mediump vec4 tmpvar_37;
|
||||
mediump vec2 coord_38;
|
||||
coord_38 = tmpvar_36;
|
||||
mediump vec2 coord_37;
|
||||
coord_37 = tmpvar_36;
|
||||
mediump vec4 tmpvar_38;
|
||||
tmpvar_38.zw = vec2(0.0, 0.0);
|
||||
tmpvar_38.xy = (coord_37 / _DynLampInfo_bufferSize);
|
||||
mediump vec4 tmpvar_39;
|
||||
tmpvar_39.zw = vec2(0.0, 0.0);
|
||||
tmpvar_39.xy = (coord_38 / _DynLampInfo_bufferSize);
|
||||
lowp vec4 tmpvar_40;
|
||||
tmpvar_40 = textureLod (_DynLampInfo, tmpvar_39.xy, 0.0);
|
||||
tmpvar_37 = tmpvar_40;
|
||||
tmpvar_40 = textureLod (_DynLampInfo, tmpvar_38.xy, 0.0);
|
||||
tmpvar_39 = tmpvar_40;
|
||||
highp vec2 tmpvar_41;
|
||||
tmpvar_41.y = 2.0;
|
||||
tmpvar_41.x = float(tmpvar_5.w);
|
||||
mediump vec4 tmpvar_42;
|
||||
mediump vec2 coord_43;
|
||||
coord_43 = tmpvar_41;
|
||||
mediump vec2 coord_42;
|
||||
coord_42 = tmpvar_41;
|
||||
mediump vec4 tmpvar_43;
|
||||
tmpvar_43.zw = vec2(0.0, 0.0);
|
||||
tmpvar_43.xy = (coord_42 / _DynLampInfo_bufferSize);
|
||||
mediump vec4 tmpvar_44;
|
||||
tmpvar_44.zw = vec2(0.0, 0.0);
|
||||
tmpvar_44.xy = (coord_43 / _DynLampInfo_bufferSize);
|
||||
lowp vec4 tmpvar_45;
|
||||
tmpvar_45 = textureLod (_DynLampInfo, tmpvar_44.xy, 0.0);
|
||||
tmpvar_42 = tmpvar_45;
|
||||
tmpvar_45 = textureLod (_DynLampInfo, tmpvar_43.xy, 0.0);
|
||||
tmpvar_44 = tmpvar_45;
|
||||
mediump vec3 hybridCol_46;
|
||||
mediump vec4 atten_47;
|
||||
highp vec3 tmpvar_48;
|
||||
tmpvar_48 = (tmpvar_7.xyz - tmpvar_2);
|
||||
tmpvar_48 = (tmpvar_9.xyz - tmpvar_2);
|
||||
highp float tmpvar_49;
|
||||
tmpvar_49 = dot (tmpvar_48, tmpvar_48);
|
||||
mediump vec4 tmpvar_50;
|
||||
tmpvar_50.yzw = atten_47.yzw;
|
||||
tmpvar_50.x = (tmpvar_49 * tmpvar_7.w);
|
||||
tmpvar_50.x = (tmpvar_49 * tmpvar_9.w);
|
||||
highp vec3 tmpvar_51;
|
||||
tmpvar_51 = (tmpvar_17.xyz - tmpvar_2);
|
||||
tmpvar_51 = (tmpvar_19.xyz - tmpvar_2);
|
||||
highp float tmpvar_52;
|
||||
tmpvar_52 = dot (tmpvar_51, tmpvar_51);
|
||||
mediump vec4 tmpvar_53;
|
||||
tmpvar_53.xzw = tmpvar_50.xzw;
|
||||
tmpvar_53.y = (tmpvar_52 * tmpvar_17.w);
|
||||
tmpvar_53.y = (tmpvar_52 * tmpvar_19.w);
|
||||
highp vec3 tmpvar_54;
|
||||
tmpvar_54 = (tmpvar_27.xyz - tmpvar_2);
|
||||
tmpvar_54 = (tmpvar_29.xyz - tmpvar_2);
|
||||
highp float tmpvar_55;
|
||||
tmpvar_55 = dot (tmpvar_54, tmpvar_54);
|
||||
mediump vec4 tmpvar_56;
|
||||
tmpvar_56.xyw = tmpvar_53.xyw;
|
||||
tmpvar_56.z = (tmpvar_55 * tmpvar_27.w);
|
||||
tmpvar_56.z = (tmpvar_55 * tmpvar_29.w);
|
||||
highp vec3 tmpvar_57;
|
||||
tmpvar_57 = (tmpvar_37.xyz - tmpvar_2);
|
||||
tmpvar_57 = (tmpvar_39.xyz - tmpvar_2);
|
||||
highp float tmpvar_58;
|
||||
tmpvar_58 = dot (tmpvar_57, tmpvar_57);
|
||||
mediump vec4 tmpvar_59;
|
||||
tmpvar_59.xyz = tmpvar_56.xyz;
|
||||
tmpvar_59.w = (tmpvar_58 * tmpvar_37.w);
|
||||
tmpvar_59.w = (tmpvar_58 * tmpvar_39.w);
|
||||
atten_47 = tmpvar_59;
|
||||
hybridCol_46 = (hybridCol_4 + (tmpvar_12.xyz * tmpvar_50.x));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_22.xyz * tmpvar_53.y));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_32.xyz * tmpvar_56.z));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_42.xyz * tmpvar_59.w));
|
||||
hybridCol_46 = (hybridCol_4 + (tmpvar_14.xyz * tmpvar_50.x));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_24.xyz * tmpvar_53.y));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_34.xyz * tmpvar_56.z));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_44.xyz * tmpvar_59.w));
|
||||
tmpvar_3 = hybridCol_46;
|
||||
tmpvar_1 = tmpvar_3;
|
||||
gl_Position = (glstate_matrix_mvp * _glesVertex);
|
||||
|
@ -27,134 +27,134 @@ vertex xlatMtlShaderOutput xlatMtlMain (xlatMtlShaderInput _mtl_i [[stage_in]],
|
||||
float2 tmpvar_6;
|
||||
tmpvar_6.y = 1.0;
|
||||
tmpvar_6.x = float(tmpvar_5.x);
|
||||
half4 tmpvar_7;
|
||||
half2 coord_8;
|
||||
coord_8 = half2(tmpvar_6);
|
||||
half2 coord_7;
|
||||
coord_7 = half2(tmpvar_6);
|
||||
half4 tmpvar_8;
|
||||
tmpvar_8.zw = half2(float2(0.0, 0.0));
|
||||
tmpvar_8.xy = (coord_7 / _mtl_u._DynLampInfo_bufferSize);
|
||||
half4 tmpvar_9;
|
||||
tmpvar_9.zw = half2(float2(0.0, 0.0));
|
||||
tmpvar_9.xy = (coord_8 / _mtl_u._DynLampInfo_bufferSize);
|
||||
half4 tmpvar_10;
|
||||
tmpvar_10 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_9.xy), level(0.0));
|
||||
tmpvar_7 = tmpvar_10;
|
||||
tmpvar_10 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_8.xy), level(0.0));
|
||||
tmpvar_9 = tmpvar_10;
|
||||
float2 tmpvar_11;
|
||||
tmpvar_11.y = 2.0;
|
||||
tmpvar_11.x = float(tmpvar_5.x);
|
||||
half4 tmpvar_12;
|
||||
half2 coord_13;
|
||||
coord_13 = half2(tmpvar_11);
|
||||
half2 coord_12;
|
||||
coord_12 = half2(tmpvar_11);
|
||||
half4 tmpvar_13;
|
||||
tmpvar_13.zw = half2(float2(0.0, 0.0));
|
||||
tmpvar_13.xy = (coord_12 / _mtl_u._DynLampInfo_bufferSize);
|
||||
half4 tmpvar_14;
|
||||
tmpvar_14.zw = half2(float2(0.0, 0.0));
|
||||
tmpvar_14.xy = (coord_13 / _mtl_u._DynLampInfo_bufferSize);
|
||||
half4 tmpvar_15;
|
||||
tmpvar_15 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_14.xy), level(0.0));
|
||||
tmpvar_12 = tmpvar_15;
|
||||
tmpvar_15 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_13.xy), level(0.0));
|
||||
tmpvar_14 = tmpvar_15;
|
||||
float2 tmpvar_16;
|
||||
tmpvar_16.y = 1.0;
|
||||
tmpvar_16.x = float(tmpvar_5.y);
|
||||
half4 tmpvar_17;
|
||||
half2 coord_18;
|
||||
coord_18 = half2(tmpvar_16);
|
||||
half2 coord_17;
|
||||
coord_17 = half2(tmpvar_16);
|
||||
half4 tmpvar_18;
|
||||
tmpvar_18.zw = half2(float2(0.0, 0.0));
|
||||
tmpvar_18.xy = (coord_17 / _mtl_u._DynLampInfo_bufferSize);
|
||||
half4 tmpvar_19;
|
||||
tmpvar_19.zw = half2(float2(0.0, 0.0));
|
||||
tmpvar_19.xy = (coord_18 / _mtl_u._DynLampInfo_bufferSize);
|
||||
half4 tmpvar_20;
|
||||
tmpvar_20 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_19.xy), level(0.0));
|
||||
tmpvar_17 = tmpvar_20;
|
||||
tmpvar_20 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_18.xy), level(0.0));
|
||||
tmpvar_19 = tmpvar_20;
|
||||
float2 tmpvar_21;
|
||||
tmpvar_21.y = 2.0;
|
||||
tmpvar_21.x = float(tmpvar_5.y);
|
||||
half4 tmpvar_22;
|
||||
half2 coord_23;
|
||||
coord_23 = half2(tmpvar_21);
|
||||
half2 coord_22;
|
||||
coord_22 = half2(tmpvar_21);
|
||||
half4 tmpvar_23;
|
||||
tmpvar_23.zw = half2(float2(0.0, 0.0));
|
||||
tmpvar_23.xy = (coord_22 / _mtl_u._DynLampInfo_bufferSize);
|
||||
half4 tmpvar_24;
|
||||
tmpvar_24.zw = half2(float2(0.0, 0.0));
|
||||
tmpvar_24.xy = (coord_23 / _mtl_u._DynLampInfo_bufferSize);
|
||||
half4 tmpvar_25;
|
||||
tmpvar_25 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_24.xy), level(0.0));
|
||||
tmpvar_22 = tmpvar_25;
|
||||
tmpvar_25 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_23.xy), level(0.0));
|
||||
tmpvar_24 = tmpvar_25;
|
||||
float2 tmpvar_26;
|
||||
tmpvar_26.y = 1.0;
|
||||
tmpvar_26.x = float(tmpvar_5.z);
|
||||
half4 tmpvar_27;
|
||||
half2 coord_28;
|
||||
coord_28 = half2(tmpvar_26);
|
||||
half2 coord_27;
|
||||
coord_27 = half2(tmpvar_26);
|
||||
half4 tmpvar_28;
|
||||
tmpvar_28.zw = half2(float2(0.0, 0.0));
|
||||
tmpvar_28.xy = (coord_27 / _mtl_u._DynLampInfo_bufferSize);
|
||||
half4 tmpvar_29;
|
||||
tmpvar_29.zw = half2(float2(0.0, 0.0));
|
||||
tmpvar_29.xy = (coord_28 / _mtl_u._DynLampInfo_bufferSize);
|
||||
half4 tmpvar_30;
|
||||
tmpvar_30 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_29.xy), level(0.0));
|
||||
tmpvar_27 = tmpvar_30;
|
||||
tmpvar_30 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_28.xy), level(0.0));
|
||||
tmpvar_29 = tmpvar_30;
|
||||
float2 tmpvar_31;
|
||||
tmpvar_31.y = 2.0;
|
||||
tmpvar_31.x = float(tmpvar_5.z);
|
||||
half4 tmpvar_32;
|
||||
half2 coord_33;
|
||||
coord_33 = half2(tmpvar_31);
|
||||
half2 coord_32;
|
||||
coord_32 = half2(tmpvar_31);
|
||||
half4 tmpvar_33;
|
||||
tmpvar_33.zw = half2(float2(0.0, 0.0));
|
||||
tmpvar_33.xy = (coord_32 / _mtl_u._DynLampInfo_bufferSize);
|
||||
half4 tmpvar_34;
|
||||
tmpvar_34.zw = half2(float2(0.0, 0.0));
|
||||
tmpvar_34.xy = (coord_33 / _mtl_u._DynLampInfo_bufferSize);
|
||||
half4 tmpvar_35;
|
||||
tmpvar_35 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_34.xy), level(0.0));
|
||||
tmpvar_32 = tmpvar_35;
|
||||
tmpvar_35 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_33.xy), level(0.0));
|
||||
tmpvar_34 = tmpvar_35;
|
||||
float2 tmpvar_36;
|
||||
tmpvar_36.y = 1.0;
|
||||
tmpvar_36.x = float(tmpvar_5.w);
|
||||
half4 tmpvar_37;
|
||||
half2 coord_38;
|
||||
coord_38 = half2(tmpvar_36);
|
||||
half2 coord_37;
|
||||
coord_37 = half2(tmpvar_36);
|
||||
half4 tmpvar_38;
|
||||
tmpvar_38.zw = half2(float2(0.0, 0.0));
|
||||
tmpvar_38.xy = (coord_37 / _mtl_u._DynLampInfo_bufferSize);
|
||||
half4 tmpvar_39;
|
||||
tmpvar_39.zw = half2(float2(0.0, 0.0));
|
||||
tmpvar_39.xy = (coord_38 / _mtl_u._DynLampInfo_bufferSize);
|
||||
half4 tmpvar_40;
|
||||
tmpvar_40 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_39.xy), level(0.0));
|
||||
tmpvar_37 = tmpvar_40;
|
||||
tmpvar_40 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_38.xy), level(0.0));
|
||||
tmpvar_39 = tmpvar_40;
|
||||
float2 tmpvar_41;
|
||||
tmpvar_41.y = 2.0;
|
||||
tmpvar_41.x = float(tmpvar_5.w);
|
||||
half4 tmpvar_42;
|
||||
half2 coord_43;
|
||||
coord_43 = half2(tmpvar_41);
|
||||
half2 coord_42;
|
||||
coord_42 = half2(tmpvar_41);
|
||||
half4 tmpvar_43;
|
||||
tmpvar_43.zw = half2(float2(0.0, 0.0));
|
||||
tmpvar_43.xy = (coord_42 / _mtl_u._DynLampInfo_bufferSize);
|
||||
half4 tmpvar_44;
|
||||
tmpvar_44.zw = half2(float2(0.0, 0.0));
|
||||
tmpvar_44.xy = (coord_43 / _mtl_u._DynLampInfo_bufferSize);
|
||||
half4 tmpvar_45;
|
||||
tmpvar_45 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_44.xy), level(0.0));
|
||||
tmpvar_42 = tmpvar_45;
|
||||
tmpvar_45 = _DynLampInfo.sample(_mtlsmp__DynLampInfo, (float2)(tmpvar_43.xy), level(0.0));
|
||||
tmpvar_44 = tmpvar_45;
|
||||
half3 hybridCol_46;
|
||||
half4 atten_47;
|
||||
float3 tmpvar_48;
|
||||
tmpvar_48 = ((float3)tmpvar_7.xyz - tmpvar_2);
|
||||
tmpvar_48 = ((float3)tmpvar_9.xyz - tmpvar_2);
|
||||
float tmpvar_49;
|
||||
tmpvar_49 = dot (tmpvar_48, tmpvar_48);
|
||||
half4 tmpvar_50;
|
||||
tmpvar_50.yzw = atten_47.yzw;
|
||||
tmpvar_50.x = half((tmpvar_49 * (float)tmpvar_7.w));
|
||||
tmpvar_50.x = half((tmpvar_49 * (float)tmpvar_9.w));
|
||||
float3 tmpvar_51;
|
||||
tmpvar_51 = ((float3)tmpvar_17.xyz - tmpvar_2);
|
||||
tmpvar_51 = ((float3)tmpvar_19.xyz - tmpvar_2);
|
||||
float tmpvar_52;
|
||||
tmpvar_52 = dot (tmpvar_51, tmpvar_51);
|
||||
half4 tmpvar_53;
|
||||
tmpvar_53.xzw = tmpvar_50.xzw;
|
||||
tmpvar_53.y = half((tmpvar_52 * (float)tmpvar_17.w));
|
||||
tmpvar_53.y = half((tmpvar_52 * (float)tmpvar_19.w));
|
||||
float3 tmpvar_54;
|
||||
tmpvar_54 = ((float3)tmpvar_27.xyz - tmpvar_2);
|
||||
tmpvar_54 = ((float3)tmpvar_29.xyz - tmpvar_2);
|
||||
float tmpvar_55;
|
||||
tmpvar_55 = dot (tmpvar_54, tmpvar_54);
|
||||
half4 tmpvar_56;
|
||||
tmpvar_56.xyw = tmpvar_53.xyw;
|
||||
tmpvar_56.z = half((tmpvar_55 * (float)tmpvar_27.w));
|
||||
tmpvar_56.z = half((tmpvar_55 * (float)tmpvar_29.w));
|
||||
float3 tmpvar_57;
|
||||
tmpvar_57 = ((float3)tmpvar_37.xyz - tmpvar_2);
|
||||
tmpvar_57 = ((float3)tmpvar_39.xyz - tmpvar_2);
|
||||
float tmpvar_58;
|
||||
tmpvar_58 = dot (tmpvar_57, tmpvar_57);
|
||||
half4 tmpvar_59;
|
||||
tmpvar_59.xyz = tmpvar_56.xyz;
|
||||
tmpvar_59.w = half((tmpvar_58 * (float)tmpvar_37.w));
|
||||
tmpvar_59.w = half((tmpvar_58 * (float)tmpvar_39.w));
|
||||
atten_47 = tmpvar_59;
|
||||
hybridCol_46 = (hybridCol_4 + (tmpvar_12.xyz * tmpvar_50.x));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_22.xyz * tmpvar_53.y));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_32.xyz * tmpvar_56.z));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_42.xyz * tmpvar_59.w));
|
||||
hybridCol_46 = (hybridCol_4 + (tmpvar_14.xyz * tmpvar_50.x));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_24.xyz * tmpvar_53.y));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_34.xyz * tmpvar_56.z));
|
||||
hybridCol_46 = (hybridCol_46 + (tmpvar_44.xyz * tmpvar_59.w));
|
||||
tmpvar_3 = float3(hybridCol_46);
|
||||
tmpvar_1 = half3(tmpvar_3);
|
||||
_mtl_o.gl_Position = (_mtl_u.glstate_matrix_mvp * _mtl_i._glesVertex);
|
||||
|
Loading…
Reference in New Issue
Block a user