kc3-lang/angle/src/compiler/translator/VectorizeVectorScalarArithmetic.h

• Show log

  Commit

• Hash : 661fc487
  Author :
  Date : 2017-10-16T12:17:05
  

  Work around NVIDIA GLSL vector-scalar op bug
  
  This adds a new AST transform VectorizeVectorScalarArithmetic. The AST
  transform works around incorrect handling of certain types of GLSL
  arithmetic operations by NVIDIA's GL driver. It works around only the
  most common cases where the bug reproduces, since detecting all the
  cases would take more sophisticated analysis of the code than what
  is currently easily implementable in ANGLE.
  
  When a float add operator has both vector and scalar operands, the AST
  transform turns the scalar operand into a vector operand. Example:
  
  vec4 f;
  f += 1.0;
  
  gets turned into:
  
  vec4 f;
  f += vec4(1.0);
  
  When a vector constructor contains a binary scalar float
  multiplication or division operation as its only argument, the AST
  transform turns both operands of the binary operation into vector
  operands. Example:
  
  float f, g;
  vec4(f * g);
  
  gets turned into:
  
  float f, g;
  vec4(vec4(f) * vec4(g));
  
  Another example with compound assignment:
  
  float f, g;
  vec4(f *= g);
  
  gets turned into:
  
  float f, g;
  vec4 s0 = vec4(f);
  (s0 *= g, f = s0.x), s0;
  
  This latter transformation only works in case the compound assignment
  left hand expression doesn't have side effects.
  
  BUG=chromium:772651
  TEST=angle_end2end_tests
  
  Change-Id: I84ec04287793c56a94845a725785439565debdaf
  Reviewed-on: https://chromium-review.googlesource.com/721321
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  

Download

• src/compiler/translator/VectorizeVectorScalarArithmetic.h

• // Copyright (c) 2017 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // VectorizeVectorScalarArithmetic.h: Turn some arithmetic operations that operate on a float
  // vector-scalar pair into vector-vector operations. This is done recursively. Some scalar binary
  // operations inside vector constructors are also turned into vector operations.
  //
  // This is targeted to work around a bug in NVIDIA OpenGL drivers that was reproducible on NVIDIA
  // driver version 387.92. It works around the most common occurrences of the bug.
  
  #ifndef COMPILER_TRANSLATOR_VECTORIZEVECTORSCALARARITHMETIC_H_
  #define COMPILER_TRANSLATOR_VECTORIZEVECTORSCALARARITHMETIC_H_
  
  namespace sh
  {
  
  class TIntermBlock;
  class TSymbolTable;
  
  void VectorizeVectorScalarArithmetic(TIntermBlock *root, TSymbolTable *symbolTable);
  
  }  // namespace sh
  
  #endif  // COMPILER_TRANSLATOR_VECTORIZEVECTORSCALARARITHMETIC_H_

Download