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

• Show log

  Commit

• Hash : 80a5a6c6
  Author :
  Date : 2015-01-12T15:35:27
  

  Clean up BuiltInFunctionEmulator public interface
  
  This removes all language-specific bits from BuiltInFunctionEmulator
  parent class, and makes the public interface of BuiltInFunctionEmulator
  minimal.
  
  Writing comments around emulated function definitions is removed from
  OutputHLSL, they are not necessary as the emulated function definitions
  are just another part of the shader header.
  
  Change-Id: I9abf57d86f4e37b0674d7dfafe653298f205dd27
  Reviewed-on: https://chromium-review.googlesource.com/240230
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Nicolas Capens <capn@chromium.org>
  Reviewed-by: Olli Etuaho <oetuaho@nvidia.com>
  Tested-by: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• src/compiler/translator/BuiltInFunctionEmulator.h

• //
  // Copyright (c) 2011 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.
  //
  
  #ifndef COMPILER_TRANSLATOR_BUILTINFUNCTIONEMULATOR_H_
  #define COMPILER_TRANSLATOR_BUILTINFUNCTIONEMULATOR_H_
  
  #include "compiler/translator/InfoSink.h"
  #include "compiler/translator/IntermNode.h"
  
  //
  // This class decides which built-in functions need to be replaced with the
  // emulated ones.
  // It can be used to work around driver bugs or implement functions that are
  // not natively implemented on a specific platform.
  //
  class BuiltInFunctionEmulator
  {
    public:
      void MarkBuiltInFunctionsForEmulation(TIntermNode* root);
  
      void Cleanup();
  
      // "name(" becomes "webgl_name_emu(".
      static TString GetEmulatedFunctionName(const TString& name);
  
    protected:
      BuiltInFunctionEmulator();
  
      bool IsOutputEmpty() const;
  
      // Output function emulation definition. This should be before any other
      // shader source.
      void OutputEmulatedFunctions(TInfoSinkBase& out) const;
  
      // Add functions that need to be emulated.
      void AddEmulatedFunction(TOperator op, const TType& param, const char* emulatedFunctionDefinition);
      void AddEmulatedFunction(TOperator op, const TType& param1, const TType& param2, const char* emulatedFunctionDefinition);
      void AddEmulatedFunction(TOperator op, const TType& param1, const TType& param2, const TType& param3, const char* emulatedFunctionDefinition);
  
    private:
      class BuiltInFunctionEmulationMarker;
  
      // Records that a function is called by the shader and might need to be
      // emulated. If the function is not in mEmulatedFunctions, this becomes a
      // no-op. Returns true if the function call needs to be replaced with an
      // emulated one.
      bool SetFunctionCalled(TOperator op, const TType& param);
      bool SetFunctionCalled(
          TOperator op, const TType& param1, const TType& param2);
      bool SetFunctionCalled(
          TOperator op, const TType& param1, const TType& param2, const TType& param3);
  
      class FunctionId {
        public:
          FunctionId(TOperator op, const TType& param);
          FunctionId(TOperator op, const TType& param1, const TType& param2);
          FunctionId(TOperator op, const TType& param1, const TType& param2, const TType& param3);
  
          bool operator==(const FunctionId& other) const;
          bool operator<(const FunctionId& other) const;
        private:
          TOperator mOp;
          TType mParam1;
          TType mParam2;
          TType mParam3;
      };
  
      bool SetFunctionCalled(const FunctionId& functionId);
  
      // Map from function id to emulated function definition
      std::map<FunctionId, std::string> mEmulatedFunctions;
  
      // Called function ids
      std::vector<FunctionId> mFunctions;
  };
  
  #endif  // COMPILER_TRANSLATOR_BUILTINFUNCTIONEMULATOR_H_
  

Download