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;

Source code

Revision control

Copy as Markdown

Other Tools