Edit

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

Branch :

  • Show log

    Commit

  • Author : Olli Etuaho
    Date : 2017-01-02 17:34:40
    Hash : d68924e5
    Message : Use GetOperatorString when writing GLSL unary built-in calls GetOperatorString is now used when writing GLSL for built-in calls that fall under TIntermUnary. Component-wise not TOperator enum is renamed for consistency. This also cleans up some unnecessary creation of string objects when writing built-in functions. BUG=angleproject:1682 TEST=angle_unittests, angle_end2end_tests, WebGL conformance tests Change-Id: I89b2ef222bf5af479d4977417f320789b58ace85 Reviewed-on: https://chromium-review.googlesource.com/424552 Commit-Queue: Olli Etuaho <oetuaho@nvidia.com> Reviewed-by: Jamie Madill <jmadill@chromium.org>

  • 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"

namespace sh
{

//
// 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:
    BuiltInFunctionEmulator();

    void MarkBuiltInFunctionsForEmulation(TIntermNode *root);

    void Cleanup();

    // "name" gets written as "webgl_name_emu".
    static void WriteEmulatedFunctionName(TInfoSinkBase &out, const char *name);

    bool IsOutputEmpty() const;

    // Output function emulation definition. This should be before any other shader source.
    void OutputEmulatedFunctions(TInfoSinkBase &out) const;

    class FunctionId
    {
      public:
        FunctionId();
        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);

        FunctionId(const FunctionId &) = default;
        FunctionId &operator=(const FunctionId &) = default;

        bool operator==(const FunctionId &other) const;
        bool operator<(const FunctionId &other) const;

        FunctionId getCopy() const;

      private:
        TOperator mOp;

        // The memory that these TType objects use is freed by PoolAllocator. The
        // BuiltInFunctionEmulator's lifetime can extend until after the memory pool is freed, but
        // that's not an issue since this class never destructs these objects.
        const TType *mParam1;
        const TType *mParam2;
        const TType *mParam3;
    };

    // Add functions that need to be emulated.
    FunctionId addEmulatedFunction(TOperator op,
                                   const TType *param,
                                   const char *emulatedFunctionDefinition);
    FunctionId addEmulatedFunction(TOperator op,
                                   const TType *param1,
                                   const TType *param2,
                                   const char *emulatedFunctionDefinition);
    FunctionId addEmulatedFunction(TOperator op,
                                   const TType *param1,
                                   const TType *param2,
                                   const TType *param3,
                                   const char *emulatedFunctionDefinition);

    FunctionId addEmulatedFunctionWithDependency(FunctionId dependency,
                                                 TOperator op,
                                                 const TType *param1,
                                                 const TType *param2,
                                                 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);

    bool SetFunctionCalled(const FunctionId &functionId);

    // Map from function id to emulated function definition
    std::map<FunctionId, std::string> mEmulatedFunctions;

    // Map from dependent functions to their dependencies. This structure allows each function to
    // have at most one dependency.
    std::map<FunctionId, FunctionId> mFunctionDependencies;

    // Called function ids
    std::vector<FunctionId> mFunctions;
};

}  // namespace sh

#endif  // COMPILER_TRANSLATOR_BUILTINFUNCTIONEMULATOR_H_