kc3-lang/angle/src/libANGLE/params.h

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Jamie Madill
  Date : 2017-05-04 11:38:30
  Hash : ee769dd2
  Message : GLES2: Auto-generate entry points file. BUG=angleproject:1309 Change-Id: I7817444c3ea56f932fe769a860f4a70b29262019 Reviewed-on: https://chromium-review.googlesource.com/483427 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Geoff Lang <geofflang@chromium.org> Commit-Queue: Jamie Madill <jmadill@chromium.org>

• src/libANGLE/params.h

• //
  // Copyright 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.
  //
  // params:
  //   Parameter wrapper structs for OpenGL ES. These helpers cache re-used values
  //   in entry point routines.
  
  #ifndef LIBANGLE_PARAMS_H_
  #define LIBANGLE_PARAMS_H_
  
  #include "angle_gl.h"
  #include "common/Optional.h"
  #include "common/angleutils.h"
  #include "common/mathutil.h"
  #include "libANGLE/entry_points_enum_autogen.h"
  
  namespace gl
  {
  class Context;
  
  template <EntryPoint EP>
  struct EntryPointParam;
  
  template <EntryPoint EP>
  using EntryPointParamType = typename EntryPointParam<EP>::Type;
  
  class ParamTypeInfo
  {
    public:
      constexpr ParamTypeInfo(const char *selfClass, const ParamTypeInfo *parentType)
          : mSelfClass(selfClass), mParentTypeInfo(parentType)
      {
      }
  
      constexpr bool hasDynamicType(const ParamTypeInfo &typeInfo) const
      {
          return mSelfClass == typeInfo.mSelfClass ||
                 (mParentTypeInfo && mParentTypeInfo->hasDynamicType(typeInfo));
      }
  
      constexpr bool isValid() const { return mSelfClass != nullptr; }
  
    private:
      const char *mSelfClass;
      const ParamTypeInfo *mParentTypeInfo;
  };
  
  #define ANGLE_PARAM_TYPE_INFO(NAME, BASENAME) \
      static constexpr ParamTypeInfo TypeInfo = {#NAME, &BASENAME::TypeInfo}
  
  class ParamsBase : angle::NonCopyable
  {
    public:
      ParamsBase(Context *context, ...);
  
      template <EntryPoint EP, typename... ArgsT>
      static void Factory(EntryPointParamType<EP> *objBuffer, ArgsT... args);
  
      static constexpr ParamTypeInfo TypeInfo = {nullptr, nullptr};
  };
  
  // static
  template <EntryPoint EP, typename... ArgsT>
  void ParamsBase::Factory(EntryPointParamType<EP> *objBuffer, ArgsT... args)
  {
      new (objBuffer) EntryPointParamType<EP>(args...);
  }
  
  class HasIndexRange : public ParamsBase
  {
    public:
      HasIndexRange(Context *context, GLsizei count, GLenum type, const void *indices);
  
      template <EntryPoint EP, typename... ArgsT>
      static void Factory(HasIndexRange *objBuffer, ArgsT... args);
  
      const Optional<IndexRange> &getIndexRange() const;
  
      ANGLE_PARAM_TYPE_INFO(HasIndexRange, ParamsBase);
  
    private:
      Context *mContext;
      GLsizei mCount;
      GLenum mType;
      const GLvoid *mIndices;
      mutable Optional<IndexRange> mIndexRange;
  };
  
  // Entry point funcs essentially re-map different entry point parameter arrays into
  // the format the parameter type class expects. For example, for HasIndexRange, for the
  // various indexed draw calls, they drop parameters that aren't useful and re-arrange
  // the rest.
  #define ANGLE_ENTRY_POINT_FUNC(NAME, CLASS, ...)    \
      \
  template<> struct EntryPointParam<EntryPoint::NAME> \
      {                                               \
          using Type = CLASS;                         \
      };                                              \
      \
  template<> inline void CLASS::Factory<EntryPoint::NAME>(__VA_ARGS__)
  
  ANGLE_ENTRY_POINT_FUNC(DrawElements,
                         HasIndexRange,
                         HasIndexRange *objBuffer,
                         Context *context,
                         GLenum /*mode*/,
                         GLsizei count,
                         GLenum type,
                         const void *indices)
  {
      return ParamsBase::Factory<EntryPoint::DrawElements>(objBuffer, context, count, type, indices);
  }
  
  ANGLE_ENTRY_POINT_FUNC(DrawElementsInstanced,
                         HasIndexRange,
                         HasIndexRange *objBuffer,
                         Context *context,
                         GLenum /*mode*/,
                         GLsizei count,
                         GLenum type,
                         const void *indices,
                         GLsizei /*instanceCount*/)
  {
      return ParamsBase::Factory<EntryPoint::DrawElementsInstanced>(objBuffer, context, count, type,
                                                                    indices);
  }
  
  ANGLE_ENTRY_POINT_FUNC(DrawElementsInstancedANGLE,
                         HasIndexRange,
                         HasIndexRange *objBuffer,
                         Context *context,
                         GLenum /*mode*/,
                         GLsizei count,
                         GLenum type,
                         const void *indices,
                         GLsizei /*instanceCount*/)
  {
      return ParamsBase::Factory<EntryPoint::DrawElementsInstancedANGLE>(objBuffer, context, count,
                                                                         type, indices);
  }
  
  ANGLE_ENTRY_POINT_FUNC(DrawRangeElements,
                         HasIndexRange,
                         HasIndexRange *objBuffer,
                         Context *context,
                         GLenum /*mode*/,
                         GLuint /*start*/,
                         GLuint /*end*/,
                         GLsizei count,
                         GLenum type,
                         const void *indices)
  {
      return ParamsBase::Factory<EntryPoint::DrawRangeElements>(objBuffer, context, count, type,
                                                                indices);
  }
  
  #undef ANGLE_ENTRY_POINT_FUNC
  
  template <EntryPoint EP>
  struct EntryPointParam
  {
      using Type = ParamsBase;
  };
  
  }  // namespace gl
  
  #endif  // LIBANGLE_PARAMS_H_