kc3-lang/angle/src/libANGLE/renderer/d3d/d3d11/Blit11Helper_autogen.inc

• Show log

  Commit

• Hash : 37752956
  Author :
  Date : 2021-02-11T16:12:48
  

  Generators: Use fixed year in license headers.
  
  Remove dynamic year generation from generator scripts, as required by
  the Chromium C++ style guide.
  The dynamic year values were replaced by the current year at the time
  the file was created according to git log. The code to dynamically
  generate the year was removed.
  This patch also refreshes generated files and hashes.
  
  Bug: angleproject:5516
  Change-Id: I735028bccb5c83217e92c380538f1abf0a906b2c
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2690950
  Commit-Queue: Lubosz Sarnecki <lubosz.sarnecki@collabora.com>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/renderer/d3d/d3d11/Blit11Helper_autogen.inc

• // GENERATED FILE - DO NOT EDIT.
  // Generated by gen_blit11helper.py.
  //
  // Copyright 2018 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.
  //
  // Blit11Helper_autogen.inc:
  //   Defines and retrieves blitshaders for the D3D11 backend.
  
  namespace
  {
  // Include inline shaders in the anonymous namespace to make sure no symbols are exported
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2d11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2d11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2d11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrougha2d11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlum2d11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha2d11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2dui11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2di11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2dui11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2di11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2dui11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2di11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2dui11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2di11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgba_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgba_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgba_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgb_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgb_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgb_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d_4444_11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_4444_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_4444_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2d_565_11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_565_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_565_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d_5551_11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_5551_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_5551_2d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3d11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3d11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg3d11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr3d11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlum3d11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha3d11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3dui11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3di11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3dui11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3di11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg3dui11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg3di11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr3dui11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr3di11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgba_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgba_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgba_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgb_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgb_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgb_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgba_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgba_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgba_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgb_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgb_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgb_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3d_4444_11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_4444_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_4444_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3d_565_11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_565_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_565_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3d_5551_11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_5551_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_5551_3d_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darray11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darray11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2darray11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2darray11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlum2darray11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha2darray11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darrayui11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darrayi11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darrayui11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darrayi11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2darrayui11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2darrayi11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2darrayui11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2darrayi11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgba_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgba_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgba_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgb_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgb_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgb_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgba_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgba_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgba_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgb_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgb_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgb_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darray_4444_11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_4444_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_4444_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darray_565_11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_565_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_565_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darray_5551_11ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_5551_2darray_ps.h"
  #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_5551_2darray_ps.h"
  } // namespace
  
  enum Blit11::BlitShaderOperation : unsigned int
  {
      RGBAF,
      BGRAF,
      RGBF,
      RGF,
      RF,
      ALPHA,
      LUMA,
      LUMAALPHA,
      RGBAUI,
      RGBAI,
      RGBUI,
      RGBI,
      RGUI,
      RGI,
      RUI,
      RI,
      RGBAF_PREMULTIPLY,
      RGBAF_UNMULTIPLY,
      RGBF_PREMULTIPLY,
      RGBF_UNMULTIPLY,
      RGBAF_TOUI,
      RGBAF_TOUI_PREMULTIPLY,
      RGBAF_TOUI_UNMULTIPLY,
      RGBF_TOUI,
      RGBF_TOUI_PREMULTIPLY,
      RGBF_TOUI_UNMULTIPLY,
      RGBAF_TOI,
      RGBAF_TOI_PREMULTIPLY,
      RGBAF_TOI_UNMULTIPLY,
      RGBF_TOI,
      RGBF_TOI_PREMULTIPLY,
      RGBF_TOI_UNMULTIPLY,
      LUMAF_PREMULTIPLY,
      LUMAF_UNMULTIPLY,
      LUMAALPHAF_PREMULTIPLY,
      LUMAALPHAF_UNMULTIPLY,
      RGBAF_4444,
      RGBAF_4444_PREMULTIPLY,
      RGBAF_4444_UNMULTIPLY,
      RGBF_565,
      RGBF_565_PREMULTIPLY,
      RGBF_565_UNMULTIPLY,
      RGBAF_5551,
      RGBAF_5551_PREMULTIPLY,
      RGBAF_5551_UNMULTIPLY,
      OPERATION_INVALID
  };
  
  enum Blit11::BlitShaderType : unsigned int
  {
      BLITSHADER_2D_RGBAF,
      BLITSHADER_2D_BGRAF,
      BLITSHADER_2D_RGBF,
      BLITSHADER_2D_RGF,
      BLITSHADER_2D_RF,
      BLITSHADER_2D_ALPHA,
      BLITSHADER_2D_LUMA,
      BLITSHADER_2D_LUMAALPHA,
      BLITSHADER_2D_RGBAUI,
      BLITSHADER_2D_RGBAI,
      BLITSHADER_2D_RGBUI,
      BLITSHADER_2D_RGBI,
      BLITSHADER_2D_RGUI,
      BLITSHADER_2D_RGI,
      BLITSHADER_2D_RUI,
      BLITSHADER_2D_RI,
      BLITSHADER_2D_RGBAF_PREMULTIPLY,
      BLITSHADER_2D_RGBAF_UNMULTIPLY,
      BLITSHADER_2D_RGBF_PREMULTIPLY,
      BLITSHADER_2D_RGBF_UNMULTIPLY,
      BLITSHADER_2D_RGBAF_TOUI,
      BLITSHADER_2D_RGBAF_TOUI_PREMULTIPLY,
      BLITSHADER_2D_RGBAF_TOUI_UNMULTIPLY,
      BLITSHADER_2D_RGBF_TOUI,
      BLITSHADER_2D_RGBF_TOUI_PREMULTIPLY,
      BLITSHADER_2D_RGBF_TOUI_UNMULTIPLY,
      BLITSHADER_2D_LUMAF_PREMULTIPLY,
      BLITSHADER_2D_LUMAF_UNMULTIPLY,
      BLITSHADER_2D_LUMAALPHAF_PREMULTIPLY,
      BLITSHADER_2D_LUMAALPHAF_UNMULTIPLY,
      BLITSHADER_2D_RGBAF_4444,
      BLITSHADER_2D_RGBAF_4444_PREMULTIPLY,
      BLITSHADER_2D_RGBAF_4444_UNMULTIPLY,
      BLITSHADER_2D_RGBF_565,
      BLITSHADER_2D_RGBF_565_PREMULTIPLY,
      BLITSHADER_2D_RGBF_565_UNMULTIPLY,
      BLITSHADER_2D_RGBAF_5551,
      BLITSHADER_2D_RGBAF_5551_PREMULTIPLY,
      BLITSHADER_2D_RGBAF_5551_UNMULTIPLY,
      BLITSHADER_3D_RGBAF,
      BLITSHADER_3D_BGRAF,
      BLITSHADER_3D_RGBF,
      BLITSHADER_3D_RGF,
      BLITSHADER_3D_RF,
      BLITSHADER_3D_ALPHA,
      BLITSHADER_3D_LUMA,
      BLITSHADER_3D_LUMAALPHA,
      BLITSHADER_3D_RGBAUI,
      BLITSHADER_3D_RGBAI,
      BLITSHADER_3D_RGBUI,
      BLITSHADER_3D_RGBI,
      BLITSHADER_3D_RGUI,
      BLITSHADER_3D_RGI,
      BLITSHADER_3D_RUI,
      BLITSHADER_3D_RI,
      BLITSHADER_3D_RGBAF_PREMULTIPLY,
      BLITSHADER_3D_RGBAF_UNMULTIPLY,
      BLITSHADER_3D_RGBF_PREMULTIPLY,
      BLITSHADER_3D_RGBF_UNMULTIPLY,
      BLITSHADER_3D_RGBAF_TOUI,
      BLITSHADER_3D_RGBAF_TOUI_PREMULTIPLY,
      BLITSHADER_3D_RGBAF_TOUI_UNMULTIPLY,
      BLITSHADER_3D_RGBF_TOUI,
      BLITSHADER_3D_RGBF_TOUI_PREMULTIPLY,
      BLITSHADER_3D_RGBF_TOUI_UNMULTIPLY,
      BLITSHADER_3D_RGBAF_TOI,
      BLITSHADER_3D_RGBAF_TOI_PREMULTIPLY,
      BLITSHADER_3D_RGBAF_TOI_UNMULTIPLY,
      BLITSHADER_3D_RGBF_TOI,
      BLITSHADER_3D_RGBF_TOI_PREMULTIPLY,
      BLITSHADER_3D_RGBF_TOI_UNMULTIPLY,
      BLITSHADER_3D_LUMAF_PREMULTIPLY,
      BLITSHADER_3D_LUMAF_UNMULTIPLY,
      BLITSHADER_3D_LUMAALPHAF_PREMULTIPLY,
      BLITSHADER_3D_LUMAALPHAF_UNMULTIPLY,
      BLITSHADER_3D_RGBAF_4444,
      BLITSHADER_3D_RGBAF_4444_PREMULTIPLY,
      BLITSHADER_3D_RGBAF_4444_UNMULTIPLY,
      BLITSHADER_3D_RGBF_565,
      BLITSHADER_3D_RGBF_565_PREMULTIPLY,
      BLITSHADER_3D_RGBF_565_UNMULTIPLY,
      BLITSHADER_3D_RGBAF_5551,
      BLITSHADER_3D_RGBAF_5551_PREMULTIPLY,
      BLITSHADER_3D_RGBAF_5551_UNMULTIPLY,
      BLITSHADER_2DARRAY_RGBAF,
      BLITSHADER_2DARRAY_BGRAF,
      BLITSHADER_2DARRAY_RGBF,
      BLITSHADER_2DARRAY_RGF,
      BLITSHADER_2DARRAY_RF,
      BLITSHADER_2DARRAY_ALPHA,
      BLITSHADER_2DARRAY_LUMA,
      BLITSHADER_2DARRAY_LUMAALPHA,
      BLITSHADER_2DARRAY_RGBAUI,
      BLITSHADER_2DARRAY_RGBAI,
      BLITSHADER_2DARRAY_RGBUI,
      BLITSHADER_2DARRAY_RGBI,
      BLITSHADER_2DARRAY_RGUI,
      BLITSHADER_2DARRAY_RGI,
      BLITSHADER_2DARRAY_RUI,
      BLITSHADER_2DARRAY_RI,
      BLITSHADER_2DARRAY_RGBAF_PREMULTIPLY,
      BLITSHADER_2DARRAY_RGBAF_UNMULTIPLY,
      BLITSHADER_2DARRAY_RGBF_PREMULTIPLY,
      BLITSHADER_2DARRAY_RGBF_UNMULTIPLY,
      BLITSHADER_2DARRAY_RGBAF_TOUI,
      BLITSHADER_2DARRAY_RGBAF_TOUI_PREMULTIPLY,
      BLITSHADER_2DARRAY_RGBAF_TOUI_UNMULTIPLY,
      BLITSHADER_2DARRAY_RGBF_TOUI,
      BLITSHADER_2DARRAY_RGBF_TOUI_PREMULTIPLY,
      BLITSHADER_2DARRAY_RGBF_TOUI_UNMULTIPLY,
      BLITSHADER_2DARRAY_RGBAF_TOI,
      BLITSHADER_2DARRAY_RGBAF_TOI_PREMULTIPLY,
      BLITSHADER_2DARRAY_RGBAF_TOI_UNMULTIPLY,
      BLITSHADER_2DARRAY_RGBF_TOI,
      BLITSHADER_2DARRAY_RGBF_TOI_PREMULTIPLY,
      BLITSHADER_2DARRAY_RGBF_TOI_UNMULTIPLY,
      BLITSHADER_2DARRAY_LUMAF_PREMULTIPLY,
      BLITSHADER_2DARRAY_LUMAF_UNMULTIPLY,
      BLITSHADER_2DARRAY_LUMAALPHAF_PREMULTIPLY,
      BLITSHADER_2DARRAY_LUMAALPHAF_UNMULTIPLY,
      BLITSHADER_2DARRAY_RGBAF_4444,
      BLITSHADER_2DARRAY_RGBAF_4444_PREMULTIPLY,
      BLITSHADER_2DARRAY_RGBAF_4444_UNMULTIPLY,
      BLITSHADER_2DARRAY_RGBF_565,
      BLITSHADER_2DARRAY_RGBF_565_PREMULTIPLY,
      BLITSHADER_2DARRAY_RGBF_565_UNMULTIPLY,
      BLITSHADER_2DARRAY_RGBAF_5551,
      BLITSHADER_2DARRAY_RGBAF_5551_PREMULTIPLY,
      BLITSHADER_2DARRAY_RGBAF_5551_UNMULTIPLY,
      BLITSHADER_INVALID
  };
  
  Blit11::BlitShaderType Blit11::getBlitShaderType(BlitShaderOperation operation, ShaderDimension dimension)
  {
      switch(operation)
      {
          case RGBAF:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBAF;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBAF;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBAF;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case BGRAF:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_BGRAF;
                  case SHADER_3D:
                      return BLITSHADER_3D_BGRAF;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_BGRAF;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBF:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBF;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBF;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBF;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGF:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGF;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGF;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGF;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RF:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RF;
                  case SHADER_3D:
                      return BLITSHADER_3D_RF;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RF;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case ALPHA:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_ALPHA;
                  case SHADER_3D:
                      return BLITSHADER_3D_ALPHA;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_ALPHA;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case LUMA:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_LUMA;
                  case SHADER_3D:
                      return BLITSHADER_3D_LUMA;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_LUMA;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case LUMAALPHA:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_LUMAALPHA;
                  case SHADER_3D:
                      return BLITSHADER_3D_LUMAALPHA;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_LUMAALPHA;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBAUI:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBAUI;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBAUI;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBAUI;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBAI:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBAI;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBAI;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBAI;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBUI:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBUI;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBUI;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBUI;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBI:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBI;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBI;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBI;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGUI:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGUI;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGUI;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGUI;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGI:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGI;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGI;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGI;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RUI:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RUI;
                  case SHADER_3D:
                      return BLITSHADER_3D_RUI;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RUI;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RI:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RI;
                  case SHADER_3D:
                      return BLITSHADER_3D_RI;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RI;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBAF_PREMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBAF_PREMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBAF_PREMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBAF_PREMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBAF_UNMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBAF_UNMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBAF_UNMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBAF_UNMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBF_PREMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBF_PREMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBF_PREMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBF_PREMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBF_UNMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBF_UNMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBF_UNMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBF_UNMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBAF_TOUI:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBAF_TOUI;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBAF_TOUI;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBAF_TOUI;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBAF_TOUI_PREMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBAF_TOUI_PREMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBAF_TOUI_PREMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBAF_TOUI_PREMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBAF_TOUI_UNMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBAF_TOUI_UNMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBAF_TOUI_UNMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBAF_TOUI_UNMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBF_TOUI:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBF_TOUI;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBF_TOUI;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBF_TOUI;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBF_TOUI_PREMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBF_TOUI_PREMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBF_TOUI_PREMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBF_TOUI_PREMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBF_TOUI_UNMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBF_TOUI_UNMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBF_TOUI_UNMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBF_TOUI_UNMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBAF_TOI:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_INVALID;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBAF_TOI;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBAF_TOI;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBAF_TOI_PREMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_INVALID;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBAF_TOI_PREMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBAF_TOI_PREMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBAF_TOI_UNMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_INVALID;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBAF_TOI_UNMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBAF_TOI_UNMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBF_TOI:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_INVALID;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBF_TOI;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBF_TOI;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBF_TOI_PREMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_INVALID;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBF_TOI_PREMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBF_TOI_PREMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBF_TOI_UNMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_INVALID;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBF_TOI_UNMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBF_TOI_UNMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case LUMAF_PREMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_LUMAF_PREMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_LUMAF_PREMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_LUMAF_PREMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case LUMAF_UNMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_LUMAF_UNMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_LUMAF_UNMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_LUMAF_UNMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case LUMAALPHAF_PREMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_LUMAALPHAF_PREMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_LUMAALPHAF_PREMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_LUMAALPHAF_PREMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case LUMAALPHAF_UNMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_LUMAALPHAF_UNMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_LUMAALPHAF_UNMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_LUMAALPHAF_UNMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBAF_4444:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBAF_4444;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBAF_4444;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBAF_4444;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBAF_4444_PREMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBAF_4444_PREMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBAF_4444_PREMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBAF_4444_PREMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBAF_4444_UNMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBAF_4444_UNMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBAF_4444_UNMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBAF_4444_UNMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBF_565:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBF_565;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBF_565;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBF_565;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBF_565_PREMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBF_565_PREMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBF_565_PREMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBF_565_PREMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBF_565_UNMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBF_565_UNMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBF_565_UNMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBF_565_UNMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBAF_5551:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBAF_5551;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBAF_5551;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBAF_5551;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBAF_5551_PREMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBAF_5551_PREMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBAF_5551_PREMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBAF_5551_PREMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          case RGBAF_5551_UNMULTIPLY:
              switch (dimension)
              {
                  case SHADER_2D:
                      return BLITSHADER_2D_RGBAF_5551_UNMULTIPLY;
                  case SHADER_3D:
                      return BLITSHADER_3D_RGBAF_5551_UNMULTIPLY;
                  case SHADER_2DARRAY:
                      return BLITSHADER_2DARRAY_RGBAF_5551_UNMULTIPLY;
                  default:
                      UNREACHABLE();
                      return BLITSHADER_INVALID;
              }
          default:
              UNREACHABLE();
              return BLITSHADER_INVALID;
      }
  }
  
  angle::Result Blit11::mapBlitShader(const gl::Context *context,
                                      BlitShaderType blitShaderType)
  {
      switch(blitShaderType)
      {
          case BLITSHADER_2D_RGBAF:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughRGBA2D),
                                           "Blit11 2D PassthroughRGBA2D pixel shader"));
              break;
          case BLITSHADER_2D_BGRAF:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughRGBA2D),
                                           "Blit11 2D PassthroughRGBA2D pixel shader"));
              break;
          case BLITSHADER_2D_RGBF:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughRGB2D),
                                           "Blit11 2D PassthroughRGB2D pixel shader"));
              break;
          case BLITSHADER_2D_RGF:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughRG2D),
                                           "Blit11 2D PassthroughRG2D pixel shader"));
              break;
          case BLITSHADER_2D_RF:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughR2D),
                                           "Blit11 2D PassthroughR2D pixel shader"));
              break;
          case BLITSHADER_2D_ALPHA:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughA2D),
                                           "Blit11 2D PassthroughA2D pixel shader"));
              break;
          case BLITSHADER_2D_LUMA:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughLum2D),
                                           "Blit11 2D PassthroughLum2D pixel shader"));
              break;
          case BLITSHADER_2D_LUMAALPHA:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughLumAlpha2D),
                                           "Blit11 2D PassthroughLumAlpha2D pixel shader"));
              break;
          case BLITSHADER_2D_RGBAUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughRGBA2DUI),
                                           "Blit11 2D PassthroughRGBA2DUI pixel shader"));
              break;
          case BLITSHADER_2D_RGBAI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughRGBA2DI),
                                           "Blit11 2D PassthroughRGBA2DI pixel shader"));
              break;
          case BLITSHADER_2D_RGBUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughRGB2DUI),
                                           "Blit11 2D PassthroughRGB2DUI pixel shader"));
              break;
          case BLITSHADER_2D_RGBI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughRGB2DI),
                                           "Blit11 2D PassthroughRGB2DI pixel shader"));
              break;
          case BLITSHADER_2D_RGUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughRG2DUI),
                                           "Blit11 2D PassthroughRG2DUI pixel shader"));
              break;
          case BLITSHADER_2D_RGI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughRG2DI),
                                           "Blit11 2D PassthroughRG2DI pixel shader"));
              break;
          case BLITSHADER_2D_RUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughR2DUI),
                                           "Blit11 2D PassthroughR2DUI pixel shader"));
              break;
          case BLITSHADER_2D_RI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughR2DI),
                                           "Blit11 2D PassthroughR2DI pixel shader"));
              break;
          case BLITSHADER_2D_RGBAF_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoF_PM_RGBA_2D),
                                           "Blit11 2D FtoF PM RGBA 2D pixel shader"));
              break;
          case BLITSHADER_2D_RGBAF_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoF_UM_RGBA_2D),
                                           "Blit11 2D FtoF UM RGBA 2D pixel shader"));
              break;
          case BLITSHADER_2D_RGBF_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoF_PM_RGB_2D),
                                           "Blit11 2D FtoF PM RGB 2D pixel shader"));
              break;
          case BLITSHADER_2D_RGBF_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoF_UM_RGB_2D),
                                           "Blit11 2D FtoF UM RGB 2D pixel shader"));
              break;
          case BLITSHADER_2D_RGBAF_TOUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoU_PT_RGBA_2D),
                                           "Blit11 2D FtoU PT RGBA 2D pixel shader"));
              break;
          case BLITSHADER_2D_RGBAF_TOUI_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoU_PM_RGBA_2D),
                                           "Blit11 2D FtoU PM RGBA 2D pixel shader"));
              break;
          case BLITSHADER_2D_RGBAF_TOUI_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoU_UM_RGBA_2D),
                                           "Blit11 2D FtoU UM RGBA 2D pixel shader"));
              break;
          case BLITSHADER_2D_RGBF_TOUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoU_PT_RGB_2D),
                                           "Blit11 2D FtoU PT RGB 2D pixel shader"));
              break;
          case BLITSHADER_2D_RGBF_TOUI_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoU_PM_RGB_2D),
                                           "Blit11 2D FtoU PM RGB 2D pixel shader"));
              break;
          case BLITSHADER_2D_RGBF_TOUI_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoU_UM_RGB_2D),
                                           "Blit11 2D FtoU UM RGB 2D pixel shader"));
              break;
          case BLITSHADER_2D_LUMAF_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoF_PM_LUMA_2D),
                                           "Blit11 2D FtoF PM LUMA 2D pixel shader"));
              break;
          case BLITSHADER_2D_LUMAF_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoF_UM_LUMA_2D),
                                           "Blit11 2D FtoF UM LUMA 2D pixel shader"));
              break;
          case BLITSHADER_2D_LUMAALPHAF_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoF_PM_LUMAALPHA_2D),
                                           "Blit11 2D FtoF PM LUMAALPHA 2D pixel shader"));
              break;
          case BLITSHADER_2D_LUMAALPHAF_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoF_UM_LUMAALPHA_2D),
                                           "Blit11 2D FtoF UM LUMAALPHA 2D pixel shader"));
              break;
          case BLITSHADER_2D_RGBAF_4444:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughRGBA2D_4444),
                                           "Blit11 2D PassthroughRGBA2D 4444 pixel shader"));
              break;
          case BLITSHADER_2D_RGBAF_4444_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoF_PM_RGBA_4444_2D),
                                           "Blit11 2D FtoF PM RGBA 4444 2D pixel shader"));
              break;
          case BLITSHADER_2D_RGBAF_4444_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoF_UM_RGBA_4444_2D),
                                           "Blit11 2D FtoF UM RGBA 4444 2D pixel shader"));
              break;
          case BLITSHADER_2D_RGBF_565:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughRGB2D_565),
                                           "Blit11 2D PassthroughRGB2D 565 pixel shader"));
              break;
          case BLITSHADER_2D_RGBF_565_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoF_PM_RGB_565_2D),
                                           "Blit11 2D FtoF PM RGB 565 2D pixel shader"));
              break;
          case BLITSHADER_2D_RGBF_565_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoF_UM_RGB_565_2D),
                                           "Blit11 2D FtoF UM RGB 565 2D pixel shader"));
              break;
          case BLITSHADER_2D_RGBAF_5551:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_PassthroughRGBA2D_5551),
                                           "Blit11 2D PassthroughRGBA2D 5551 pixel shader"));
              break;
          case BLITSHADER_2D_RGBAF_5551_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoF_PM_RGBA_5551_2D),
                                           "Blit11 2D FtoF PM RGBA 5551 2D pixel shader"));
              break;
          case BLITSHADER_2D_RGBAF_5551_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D,
                                           ShaderData(g_PS_FtoF_UM_RGBA_5551_2D),
                                           "Blit11 2D FtoF UM RGBA 5551 2D pixel shader"));
              break;
          case BLITSHADER_3D_RGBAF:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughRGBA3D),
                                           "Blit11 3D PassthroughRGBA3D pixel shader"));
              break;
          case BLITSHADER_3D_BGRAF:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughRGBA3D),
                                           "Blit11 3D PassthroughRGBA3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBF:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughRGB3D),
                                           "Blit11 3D PassthroughRGB3D pixel shader"));
              break;
          case BLITSHADER_3D_RGF:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughRG3D),
                                           "Blit11 3D PassthroughRG3D pixel shader"));
              break;
          case BLITSHADER_3D_RF:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughR3D),
                                           "Blit11 3D PassthroughR3D pixel shader"));
              break;
          case BLITSHADER_3D_ALPHA:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughRGBA3D),
                                           "Blit11 3D PassthroughRGBA3D pixel shader"));
              break;
          case BLITSHADER_3D_LUMA:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughLum3D),
                                           "Blit11 3D PassthroughLum3D pixel shader"));
              break;
          case BLITSHADER_3D_LUMAALPHA:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughLumAlpha3D),
                                           "Blit11 3D PassthroughLumAlpha3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBAUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughRGBA3DUI),
                                           "Blit11 3D PassthroughRGBA3DUI pixel shader"));
              break;
          case BLITSHADER_3D_RGBAI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughRGBA3DI),
                                           "Blit11 3D PassthroughRGBA3DI pixel shader"));
              break;
          case BLITSHADER_3D_RGBUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughRGB3DUI),
                                           "Blit11 3D PassthroughRGB3DUI pixel shader"));
              break;
          case BLITSHADER_3D_RGBI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughRGB3DI),
                                           "Blit11 3D PassthroughRGB3DI pixel shader"));
              break;
          case BLITSHADER_3D_RGUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughRG3DUI),
                                           "Blit11 3D PassthroughRG3DUI pixel shader"));
              break;
          case BLITSHADER_3D_RGI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughRG3DI),
                                           "Blit11 3D PassthroughRG3DI pixel shader"));
              break;
          case BLITSHADER_3D_RUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughR3DUI),
                                           "Blit11 3D PassthroughR3DUI pixel shader"));
              break;
          case BLITSHADER_3D_RI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughR3DI),
                                           "Blit11 3D PassthroughR3DI pixel shader"));
              break;
          case BLITSHADER_3D_RGBAF_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoF_PM_RGBA_3D),
                                           "Blit11 3D FtoF PM RGBA 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBAF_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoF_UM_RGBA_3D),
                                           "Blit11 3D FtoF UM RGBA 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBF_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoF_PM_RGB_3D),
                                           "Blit11 3D FtoF PM RGB 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBF_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoF_UM_RGB_3D),
                                           "Blit11 3D FtoF UM RGB 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBAF_TOUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoU_PT_RGBA_3D),
                                           "Blit11 3D FtoU PT RGBA 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBAF_TOUI_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoU_PM_RGBA_3D),
                                           "Blit11 3D FtoU PM RGBA 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBAF_TOUI_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoU_UM_RGBA_3D),
                                           "Blit11 3D FtoU UM RGBA 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBF_TOUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoU_PT_RGB_3D),
                                           "Blit11 3D FtoU PT RGB 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBF_TOUI_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoU_PM_RGB_3D),
                                           "Blit11 3D FtoU PM RGB 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBF_TOUI_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoU_UM_RGB_3D),
                                           "Blit11 3D FtoU UM RGB 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBAF_TOI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoI_PT_RGBA_3D),
                                           "Blit11 3D FtoI PT RGBA 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBAF_TOI_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoI_PM_RGBA_3D),
                                           "Blit11 3D FtoI PM RGBA 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBAF_TOI_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoI_UM_RGBA_3D),
                                           "Blit11 3D FtoI UM RGBA 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBF_TOI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoI_PT_RGB_3D),
                                           "Blit11 3D FtoI PT RGB 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBF_TOI_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoI_PM_RGB_3D),
                                           "Blit11 3D FtoI PM RGB 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBF_TOI_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoI_UM_RGB_3D),
                                           "Blit11 3D FtoI UM RGB 3D pixel shader"));
              break;
          case BLITSHADER_3D_LUMAF_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoF_PM_LUMA_3D),
                                           "Blit11 3D FtoF PM LUMA 3D pixel shader"));
              break;
          case BLITSHADER_3D_LUMAF_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoF_UM_LUMA_3D),
                                           "Blit11 3D FtoF UM LUMA 3D pixel shader"));
              break;
          case BLITSHADER_3D_LUMAALPHAF_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoF_PM_LUMAALPHA_3D),
                                           "Blit11 3D FtoF PM LUMAALPHA 3D pixel shader"));
              break;
          case BLITSHADER_3D_LUMAALPHAF_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoF_UM_LUMAALPHA_3D),
                                           "Blit11 3D FtoF UM LUMAALPHA 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBAF_4444:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughRGBA3D_4444),
                                           "Blit11 3D PassthroughRGBA3D 4444 pixel shader"));
              break;
          case BLITSHADER_3D_RGBAF_4444_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoF_PM_RGBA_4444_3D),
                                           "Blit11 3D FtoF PM RGBA 4444 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBAF_4444_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoF_UM_RGBA_4444_3D),
                                           "Blit11 3D FtoF UM RGBA 4444 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBF_565:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughRGB3D_565),
                                           "Blit11 3D PassthroughRGB3D 565 pixel shader"));
              break;
          case BLITSHADER_3D_RGBF_565_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoF_PM_RGB_565_3D),
                                           "Blit11 3D FtoF PM RGB 565 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBF_565_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoF_UM_RGB_565_3D),
                                           "Blit11 3D FtoF UM RGB 565 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBAF_5551:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_PassthroughRGBA3D_5551),
                                           "Blit11 3D PassthroughRGBA3D 5551 pixel shader"));
              break;
          case BLITSHADER_3D_RGBAF_5551_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoF_PM_RGBA_5551_3D),
                                           "Blit11 3D FtoF PM RGBA 5551 3D pixel shader"));
              break;
          case BLITSHADER_3D_RGBAF_5551_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D,
                                           ShaderData(g_PS_FtoF_UM_RGBA_5551_3D),
                                           "Blit11 3D FtoF UM RGBA 5551 3D pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBAF:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughRGBA2DArray),
                                           "Blit11 2DArray PassthroughRGBA2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_BGRAF:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughRGBA2DArray),
                                           "Blit11 2DArray PassthroughRGBA2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBF:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughRGB2DArray),
                                           "Blit11 2DArray PassthroughRGB2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGF:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughRG2DArray),
                                           "Blit11 2DArray PassthroughRG2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RF:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughR2DArray),
                                           "Blit11 2DArray PassthroughR2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_ALPHA:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughRGBA2DArray),
                                           "Blit11 2DArray PassthroughRGBA2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_LUMA:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughLum2DArray),
                                           "Blit11 2DArray PassthroughLum2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_LUMAALPHA:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughLumAlpha2DArray),
                                           "Blit11 2DArray PassthroughLumAlpha2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBAUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughRGBA2DArrayUI),
                                           "Blit11 2DArray PassthroughRGBA2DArrayUI pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBAI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughRGBA2DArrayI),
                                           "Blit11 2DArray PassthroughRGBA2DArrayI pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughRGB2DArrayUI),
                                           "Blit11 2DArray PassthroughRGB2DArrayUI pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughRGB2DArrayI),
                                           "Blit11 2DArray PassthroughRGB2DArrayI pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughRG2DArrayUI),
                                           "Blit11 2DArray PassthroughRG2DArrayUI pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughRG2DArrayI),
                                           "Blit11 2DArray PassthroughRG2DArrayI pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughR2DArrayUI),
                                           "Blit11 2DArray PassthroughR2DArrayUI pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughR2DArrayI),
                                           "Blit11 2DArray PassthroughR2DArrayI pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBAF_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoF_PM_RGBA_2DArray),
                                           "Blit11 2DArray FtoF PM RGBA 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBAF_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoF_UM_RGBA_2DArray),
                                           "Blit11 2DArray FtoF UM RGBA 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBF_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoF_PM_RGB_2DArray),
                                           "Blit11 2DArray FtoF PM RGB 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBF_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoF_UM_RGB_2DArray),
                                           "Blit11 2DArray FtoF UM RGB 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBAF_TOUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoU_PT_RGBA_2DArray),
                                           "Blit11 2DArray FtoU PT RGBA 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBAF_TOUI_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoU_PM_RGBA_2DArray),
                                           "Blit11 2DArray FtoU PM RGBA 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBAF_TOUI_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoU_UM_RGBA_2DArray),
                                           "Blit11 2DArray FtoU UM RGBA 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBF_TOUI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoU_PT_RGB_2DArray),
                                           "Blit11 2DArray FtoU PT RGB 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBF_TOUI_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoU_PM_RGB_2DArray),
                                           "Blit11 2DArray FtoU PM RGB 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBF_TOUI_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoU_UM_RGB_2DArray),
                                           "Blit11 2DArray FtoU UM RGB 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBAF_TOI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoI_PT_RGBA_2DArray),
                                           "Blit11 2DArray FtoI PT RGBA 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBAF_TOI_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoI_PM_RGBA_2DArray),
                                           "Blit11 2DArray FtoI PM RGBA 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBAF_TOI_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoI_UM_RGBA_2DArray),
                                           "Blit11 2DArray FtoI UM RGBA 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBF_TOI:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoI_PT_RGB_2DArray),
                                           "Blit11 2DArray FtoI PT RGB 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBF_TOI_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoI_PM_RGB_2DArray),
                                           "Blit11 2DArray FtoI PM RGB 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBF_TOI_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoI_UM_RGB_2DArray),
                                           "Blit11 2DArray FtoI UM RGB 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_LUMAF_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoF_PM_LUMA_2DArray),
                                           "Blit11 2DArray FtoF PM LUMA 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_LUMAF_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoF_UM_LUMA_2DArray),
                                           "Blit11 2DArray FtoF UM LUMA 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_LUMAALPHAF_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoF_PM_LUMAALPHA_2DArray),
                                           "Blit11 2DArray FtoF PM LUMAALPHA 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_LUMAALPHAF_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoF_UM_LUMAALPHA_2DArray),
                                           "Blit11 2DArray FtoF UM LUMAALPHA 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBAF_4444:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughRGBA2DArray_4444),
                                           "Blit11 2DArray PassthroughRGBA2DArray 4444 pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBAF_4444_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoF_PM_RGBA_4444_2DArray),
                                           "Blit11 2DArray FtoF PM RGBA 4444 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBAF_4444_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoF_UM_RGBA_4444_2DArray),
                                           "Blit11 2DArray FtoF UM RGBA 4444 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBF_565:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughRGB2DArray_565),
                                           "Blit11 2DArray PassthroughRGB2DArray 565 pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBF_565_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoF_PM_RGB_565_2DArray),
                                           "Blit11 2DArray FtoF PM RGB 565 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBF_565_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoF_UM_RGB_565_2DArray),
                                           "Blit11 2DArray FtoF UM RGB 565 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBAF_5551:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_PassthroughRGBA2DArray_5551),
                                           "Blit11 2DArray PassthroughRGBA2DArray 5551 pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBAF_5551_PREMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoF_PM_RGBA_5551_2DArray),
                                           "Blit11 2DArray FtoF PM RGBA 5551 2DArray pixel shader"));
              break;
          case BLITSHADER_2DARRAY_RGBAF_5551_UNMULTIPLY:
              ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY,
                                           ShaderData(g_PS_FtoF_UM_RGBA_5551_2DArray),
                                           "Blit11 2DArray FtoF UM RGBA 5551 2DArray pixel shader"));
              break;
          default:
              ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context));
      }
  
      return angle::Result::Continue;
  }
  
  

Download