chromium/third_party/angle/src/image_util/imageformats.cpp

//
// Copyright 2016 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.
//

// imageformats.cpp: Defines image format types with functions for mip generation
// and copying.

#include "image_util/imageformats.h"

#include "common/mathutil.h"

namespace angle
{

void L8::readColor(gl::ColorF *dst, const L8 *src)
{ … }

void L8::writeColor(L8 *dst, const gl::ColorF *src)
{ … }

void L8::average(L8 *dst, const L8 *src1, const L8 *src2)
{ … }

void R8::readColor(gl::ColorUI *dst, const R8 *src)
{ … }

void R8::readColor(gl::ColorF *dst, const R8 *src)
{ … }

void R8::writeColor(R8 *dst, const gl::ColorUI *src)
{ … }

void R8::writeColor(R8 *dst, const gl::ColorF *src)
{ … }

void R8::average(R8 *dst, const R8 *src1, const R8 *src2)
{ … }

void A8::readColor(gl::ColorF *dst, const A8 *src)
{ … }

void A8::writeColor(A8 *dst, const gl::ColorF *src)
{ … }

void A8::average(A8 *dst, const A8 *src1, const A8 *src2)
{ … }

void L8A8::readColor(gl::ColorF *dst, const L8A8 *src)
{ … }

void L8A8::writeColor(L8A8 *dst, const gl::ColorF *src)
{ … }

void L8A8::average(L8A8 *dst, const L8A8 *src1, const L8A8 *src2)
{ … }

void A8L8::readColor(gl::ColorF *dst, const A8L8 *src)
{ … }

void A8L8::writeColor(A8L8 *dst, const gl::ColorF *src)
{ … }

void A8L8::average(A8L8 *dst, const A8L8 *src1, const A8L8 *src2)
{ … }

void R8G8::readColor(gl::ColorUI *dst, const R8G8 *src)
{ … }

void R8G8::readColor(gl::ColorF *dst, const R8G8 *src)
{ … }

void R8G8::writeColor(R8G8 *dst, const gl::ColorUI *src)
{ … }

void R8G8::writeColor(R8G8 *dst, const gl::ColorF *src)
{ … }

void R8G8::average(R8G8 *dst, const R8G8 *src1, const R8G8 *src2)
{ … }

void R8G8B8::readColor(gl::ColorUI *dst, const R8G8B8 *src)
{ … }

void R8G8B8::readColor(gl::ColorF *dst, const R8G8B8 *src)
{ … }

void R8G8B8::writeColor(R8G8B8 *dst, const gl::ColorUI *src)
{ … }

void R8G8B8::writeColor(R8G8B8 *dst, const gl::ColorF *src)
{ … }

void R8G8B8::average(R8G8B8 *dst, const R8G8B8 *src1, const R8G8B8 *src2)
{ … }

void B8G8R8::readColor(gl::ColorUI *dst, const B8G8R8 *src)
{ … }

void B8G8R8::readColor(gl::ColorF *dst, const B8G8R8 *src)
{ … }

void B8G8R8::writeColor(B8G8R8 *dst, const gl::ColorUI *src)
{ … }

void B8G8R8::writeColor(B8G8R8 *dst, const gl::ColorF *src)
{ … }

void B8G8R8::average(B8G8R8 *dst, const B8G8R8 *src1, const B8G8R8 *src2)
{ … }

void R5G6B5::readColor(gl::ColorF *dst, const R5G6B5 *src)
{ … }

void R5G6B5::writeColor(R5G6B5 *dst, const gl::ColorF *src)
{ … }

void R5G6B5::average(R5G6B5 *dst, const R5G6B5 *src1, const R5G6B5 *src2)
{ … }

void B5G6R5::readColor(gl::ColorF *dst, const B5G6R5 *src)
{ … }

void B5G6R5::writeColor(B5G6R5 *dst, const gl::ColorF *src)
{ … }

void B5G6R5::average(B5G6R5 *dst, const B5G6R5 *src1, const B5G6R5 *src2)
{ … }

void A8R8G8B8::readColor(gl::ColorUI *dst, const A8R8G8B8 *src)
{ … }

void A8R8G8B8::readColor(gl::ColorF *dst, const A8R8G8B8 *src)
{ … }

void A8R8G8B8::writeColor(A8R8G8B8 *dst, const gl::ColorUI *src)
{ … }

void A8R8G8B8::writeColor(A8R8G8B8 *dst, const gl::ColorF *src)
{ … }

void A8R8G8B8::average(A8R8G8B8 *dst, const A8R8G8B8 *src1, const A8R8G8B8 *src2)
{ … }

void R8G8B8A8::readColor(gl::ColorUI *dst, const R8G8B8A8 *src)
{ … }

void R8G8B8A8::readColor(gl::ColorF *dst, const R8G8B8A8 *src)
{ … }

void R8G8B8A8::writeColor(R8G8B8A8 *dst, const gl::ColorUI *src)
{ … }

void R8G8B8A8::writeColor(R8G8B8A8 *dst, const gl::ColorF *src)
{ … }

void R8G8B8A8::average(R8G8B8A8 *dst, const R8G8B8A8 *src1, const R8G8B8A8 *src2)
{ … }

void R8G8B8A8SRGB::readColor(gl::ColorF *dst, const R8G8B8A8SRGB *src)
{ … }

void R8G8B8A8SRGB::writeColor(R8G8B8A8SRGB *dst, const gl::ColorF *src)
{ … }

void R8G8B8A8SRGB::average(R8G8B8A8SRGB *dst, const R8G8B8A8SRGB *src1, const R8G8B8A8SRGB *src2)
{ … }

void B8G8R8A8::readColor(gl::ColorUI *dst, const B8G8R8A8 *src)
{ … }

void B8G8R8A8::readColor(gl::ColorF *dst, const B8G8R8A8 *src)
{ … }

void B8G8R8A8::writeColor(B8G8R8A8 *dst, const gl::ColorUI *src)
{ … }

void B8G8R8A8::writeColor(B8G8R8A8 *dst, const gl::ColorF *src)
{ … }

void B8G8R8A8::average(B8G8R8A8 *dst, const B8G8R8A8 *src1, const B8G8R8A8 *src2)
{ … }

void B8G8R8X8::readColor(gl::ColorUI *dst, const B8G8R8X8 *src)
{ … }

void B8G8R8X8::readColor(gl::ColorF *dst, const B8G8R8X8 *src)
{ … }

void B8G8R8X8::writeColor(B8G8R8X8 *dst, const gl::ColorUI *src)
{ … }

void B8G8R8X8::writeColor(B8G8R8X8 *dst, const gl::ColorF *src)
{ … }

void B8G8R8X8::average(B8G8R8X8 *dst, const B8G8R8X8 *src1, const B8G8R8X8 *src2)
{ … }

void R8G8B8X8::readColor(gl::ColorUI *dst, const R8G8B8X8 *src)
{ … }

void R8G8B8X8::readColor(gl::ColorF *dst, const R8G8B8X8 *src)
{ … }

void R8G8B8X8::writeColor(R8G8B8X8 *dst, const gl::ColorUI *src)
{ … }

void R8G8B8X8::writeColor(R8G8B8X8 *dst, const gl::ColorF *src)
{ … }

void R8G8B8X8::average(R8G8B8X8 *dst, const R8G8B8X8 *src1, const R8G8B8X8 *src2)
{ … }

void A1R5G5B5::readColor(gl::ColorF *dst, const A1R5G5B5 *src)
{ … }

void A1R5G5B5::writeColor(A1R5G5B5 *dst, const gl::ColorF *src)
{ … }

void A1R5G5B5::average(A1R5G5B5 *dst, const A1R5G5B5 *src1, const A1R5G5B5 *src2)
{ … }

void R5G5B5A1::readColor(gl::ColorF *dst, const R5G5B5A1 *src)
{ … }

void R5G5B5A1::writeColor(R5G5B5A1 *dst, const gl::ColorF *src)
{ … }

void R5G5B5A1::average(R5G5B5A1 *dst, const R5G5B5A1 *src1, const R5G5B5A1 *src2)
{ … }

void R4G4B4A4::readColor(gl::ColorF *dst, const R4G4B4A4 *src)
{ … }

void R4G4B4A4::writeColor(R4G4B4A4 *dst, const gl::ColorF *src)
{ … }

void R4G4B4A4::average(R4G4B4A4 *dst, const R4G4B4A4 *src1, const R4G4B4A4 *src2)
{ … }

void A4R4G4B4::readColor(gl::ColorF *dst, const A4R4G4B4 *src)
{ … }

void A4R4G4B4::writeColor(A4R4G4B4 *dst, const gl::ColorF *src)
{ … }

void A4R4G4B4::average(A4R4G4B4 *dst, const A4R4G4B4 *src1, const A4R4G4B4 *src2)
{ … }

void R16::readColor(gl::ColorUI *dst, const R16 *src)
{ … }

void R16::readColor(gl::ColorF *dst, const R16 *src)
{ … }

void R16::writeColor(R16 *dst, const gl::ColorUI *src)
{ … }

void R16::writeColor(R16 *dst, const gl::ColorF *src)
{ … }

void R16::average(R16 *dst, const R16 *src1, const R16 *src2)
{ … }

void R16G16::readColor(gl::ColorUI *dst, const R16G16 *src)
{ … }

void R16G16::readColor(gl::ColorF *dst, const R16G16 *src)
{ … }

void R16G16::writeColor(R16G16 *dst, const gl::ColorUI *src)
{ … }

void R16G16::writeColor(R16G16 *dst, const gl::ColorF *src)
{ … }

void R16G16::average(R16G16 *dst, const R16G16 *src1, const R16G16 *src2)
{ … }

void R16G16B16::readColor(gl::ColorUI *dst, const R16G16B16 *src)
{ … }

void R16G16B16::readColor(gl::ColorF *dst, const R16G16B16 *src)
{ … }

void R16G16B16::writeColor(R16G16B16 *dst, const gl::ColorUI *src)
{ … }

void R16G16B16::writeColor(R16G16B16 *dst, const gl::ColorF *src)
{ … }

void R16G16B16::average(R16G16B16 *dst, const R16G16B16 *src1, const R16G16B16 *src2)
{ … }

void R16G16B16A16::readColor(gl::ColorUI *dst, const R16G16B16A16 *src)
{ … }

void R16G16B16A16::readColor(gl::ColorF *dst, const R16G16B16A16 *src)
{ … }

void R16G16B16A16::writeColor(R16G16B16A16 *dst, const gl::ColorUI *src)
{ … }

void R16G16B16A16::writeColor(R16G16B16A16 *dst, const gl::ColorF *src)
{ … }

void R16G16B16A16::average(R16G16B16A16 *dst, const R16G16B16A16 *src1, const R16G16B16A16 *src2)
{ … }

void R32::readColor(gl::ColorUI *dst, const R32 *src)
{ … }

void R32::readColor(gl::ColorF *dst, const R32 *src)
{ … }

void R32::writeColor(R32 *dst, const gl::ColorUI *src)
{ … }

void R32::writeColor(R32 *dst, const gl::ColorF *src)
{ … }

void R32::average(R32 *dst, const R32 *src1, const R32 *src2)
{ … }

void R32G32::readColor(gl::ColorUI *dst, const R32G32 *src)
{ … }

void R32G32::readColor(gl::ColorF *dst, const R32G32 *src)
{ … }

void R32G32::writeColor(R32G32 *dst, const gl::ColorUI *src)
{ … }

void R32G32::writeColor(R32G32 *dst, const gl::ColorF *src)
{ … }

void R32G32::average(R32G32 *dst, const R32G32 *src1, const R32G32 *src2)
{ … }

void R32G32B32::readColor(gl::ColorUI *dst, const R32G32B32 *src)
{ … }

void R32G32B32::readColor(gl::ColorF *dst, const R32G32B32 *src)
{ … }

void R32G32B32::writeColor(R32G32B32 *dst, const gl::ColorUI *src)
{ … }

void R32G32B32::writeColor(R32G32B32 *dst, const gl::ColorF *src)
{ … }

void R32G32B32::average(R32G32B32 *dst, const R32G32B32 *src1, const R32G32B32 *src2)
{ … }

void R32G32B32A32::readColor(gl::ColorUI *dst, const R32G32B32A32 *src)
{ … }

void R32G32B32A32::readColor(gl::ColorF *dst, const R32G32B32A32 *src)
{ … }

void R32G32B32A32::writeColor(R32G32B32A32 *dst, const gl::ColorUI *src)
{ … }

void R32G32B32A32::writeColor(R32G32B32A32 *dst, const gl::ColorF *src)
{ … }

void R32G32B32A32::average(R32G32B32A32 *dst, const R32G32B32A32 *src1, const R32G32B32A32 *src2)
{ … }

void R8S::readColor(gl::ColorI *dst, const R8S *src)
{ … }

void R8S::readColor(gl::ColorF *dst, const R8S *src)
{ … }

void R8S::writeColor(R8S *dst, const gl::ColorI *src)
{ … }

void R8S::writeColor(R8S *dst, const gl::ColorF *src)
{ … }

void R8S::average(R8S *dst, const R8S *src1, const R8S *src2)
{ … }

void R8G8S::readColor(gl::ColorI *dst, const R8G8S *src)
{ … }

void R8G8S::readColor(gl::ColorF *dst, const R8G8S *src)
{ … }

void R8G8S::writeColor(R8G8S *dst, const gl::ColorI *src)
{ … }

void R8G8S::writeColor(R8G8S *dst, const gl::ColorF *src)
{ … }

void R8G8S::average(R8G8S *dst, const R8G8S *src1, const R8G8S *src2)
{ … }

void R8G8B8S::readColor(gl::ColorI *dst, const R8G8B8S *src)
{ … }

void R8G8B8S::readColor(gl::ColorF *dst, const R8G8B8S *src)
{ … }

void R8G8B8S::writeColor(R8G8B8S *dst, const gl::ColorI *src)
{ … }

void R8G8B8S::writeColor(R8G8B8S *dst, const gl::ColorF *src)
{ … }

void R8G8B8S::average(R8G8B8S *dst, const R8G8B8S *src1, const R8G8B8S *src2)
{ … }

void R8G8B8A8S::readColor(gl::ColorI *dst, const R8G8B8A8S *src)
{ … }

void R8G8B8A8S::readColor(gl::ColorF *dst, const R8G8B8A8S *src)
{ … }

void R8G8B8A8S::writeColor(R8G8B8A8S *dst, const gl::ColorI *src)
{ … }

void R8G8B8A8S::writeColor(R8G8B8A8S *dst, const gl::ColorF *src)
{ … }

void R8G8B8A8S::average(R8G8B8A8S *dst, const R8G8B8A8S *src1, const R8G8B8A8S *src2)
{ … }

void R16S::readColor(gl::ColorI *dst, const R16S *src)
{ … }

void R16S::readColor(gl::ColorF *dst, const R16S *src)
{ … }

void R16S::writeColor(R16S *dst, const gl::ColorI *src)
{ … }

void R16S::writeColor(R16S *dst, const gl::ColorF *src)
{ … }

void R16S::average(R16S *dst, const R16S *src1, const R16S *src2)
{ … }

void R16G16S::readColor(gl::ColorI *dst, const R16G16S *src)
{ … }

void R16G16S::readColor(gl::ColorF *dst, const R16G16S *src)
{ … }

void R16G16S::writeColor(R16G16S *dst, const gl::ColorI *src)
{ … }

void R16G16S::writeColor(R16G16S *dst, const gl::ColorF *src)
{ … }

void R16G16S::average(R16G16S *dst, const R16G16S *src1, const R16G16S *src2)
{ … }

void R16G16B16S::readColor(gl::ColorI *dst, const R16G16B16S *src)
{ … }

void R16G16B16S::readColor(gl::ColorF *dst, const R16G16B16S *src)
{ … }

void R16G16B16S::writeColor(R16G16B16S *dst, const gl::ColorI *src)
{ … }

void R16G16B16S::writeColor(R16G16B16S *dst, const gl::ColorF *src)
{ … }

void R16G16B16S::average(R16G16B16S *dst, const R16G16B16S *src1, const R16G16B16S *src2)
{ … }

void R16G16B16A16S::readColor(gl::ColorI *dst, const R16G16B16A16S *src)
{ … }

void R16G16B16A16S::readColor(gl::ColorF *dst, const R16G16B16A16S *src)
{ … }

void R16G16B16A16S::writeColor(R16G16B16A16S *dst, const gl::ColorI *src)
{ … }

void R16G16B16A16S::writeColor(R16G16B16A16S *dst, const gl::ColorF *src)
{ … }

void R16G16B16A16S::average(R16G16B16A16S *dst,
                            const R16G16B16A16S *src1,
                            const R16G16B16A16S *src2)
{ … }

void R32S::readColor(gl::ColorI *dst, const R32S *src)
{ … }

void R32S::readColor(gl::ColorF *dst, const R32S *src)
{ … }

void R32S::writeColor(R32S *dst, const gl::ColorI *src)
{ … }

void R32S::writeColor(R32S *dst, const gl::ColorF *src)
{ … }

void R32S::average(R32S *dst, const R32S *src1, const R32S *src2)
{ … }

void R32G32S::readColor(gl::ColorI *dst, const R32G32S *src)
{ … }

void R32G32S::readColor(gl::ColorF *dst, const R32G32S *src)
{ … }

void R32G32S::writeColor(R32G32S *dst, const gl::ColorI *src)
{ … }

void R32G32S::writeColor(R32G32S *dst, const gl::ColorF *src)
{ … }

void R32G32S::average(R32G32S *dst, const R32G32S *src1, const R32G32S *src2)
{ … }

void R32G32B32S::readColor(gl::ColorI *dst, const R32G32B32S *src)
{ … }

void R32G32B32S::readColor(gl::ColorF *dst, const R32G32B32S *src)
{ … }

void R32G32B32S::writeColor(R32G32B32S *dst, const gl::ColorI *src)
{ … }

void R32G32B32S::writeColor(R32G32B32S *dst, const gl::ColorF *src)
{ … }

void R32G32B32S::average(R32G32B32S *dst, const R32G32B32S *src1, const R32G32B32S *src2)
{ … }

void R32G32B32A32S::readColor(gl::ColorI *dst, const R32G32B32A32S *src)
{ … }

void R32G32B32A32S::readColor(gl::ColorF *dst, const R32G32B32A32S *src)
{ … }

void R32G32B32A32S::writeColor(R32G32B32A32S *dst, const gl::ColorI *src)
{ … }

void R32G32B32A32S::writeColor(R32G32B32A32S *dst, const gl::ColorF *src)
{ … }

void R32G32B32A32S::average(R32G32B32A32S *dst,
                            const R32G32B32A32S *src1,
                            const R32G32B32A32S *src2)
{ … }

void A16B16G16R16F::readColor(gl::ColorF *dst, const A16B16G16R16F *src)
{ … }

void A16B16G16R16F::writeColor(A16B16G16R16F *dst, const gl::ColorF *src)
{ … }

void A16B16G16R16F::average(A16B16G16R16F *dst,
                            const A16B16G16R16F *src1,
                            const A16B16G16R16F *src2)
{ … }

void R16G16B16A16F::readColor(gl::ColorF *dst, const R16G16B16A16F *src)
{ … }

void R16G16B16A16F::writeColor(R16G16B16A16F *dst, const gl::ColorF *src)
{ … }

void R16G16B16A16F::average(R16G16B16A16F *dst,
                            const R16G16B16A16F *src1,
                            const R16G16B16A16F *src2)
{ … }

void R16F::readColor(gl::ColorF *dst, const R16F *src)
{ … }

void R16F::writeColor(R16F *dst, const gl::ColorF *src)
{ … }

void R16F::average(R16F *dst, const R16F *src1, const R16F *src2)
{ … }

void A16F::readColor(gl::ColorF *dst, const A16F *src)
{ … }

void A16F::writeColor(A16F *dst, const gl::ColorF *src)
{ … }

void A16F::average(A16F *dst, const A16F *src1, const A16F *src2)
{ … }

void L16F::readColor(gl::ColorF *dst, const L16F *src)
{ … }

void L16F::writeColor(L16F *dst, const gl::ColorF *src)
{ … }

void L16F::average(L16F *dst, const L16F *src1, const L16F *src2)
{ … }

void L16A16F::readColor(gl::ColorF *dst, const L16A16F *src)
{ … }

void L16A16F::writeColor(L16A16F *dst, const gl::ColorF *src)
{ … }

void L16A16F::average(L16A16F *dst, const L16A16F *src1, const L16A16F *src2)
{ … }

void R16G16F::readColor(gl::ColorF *dst, const R16G16F *src)
{ … }

void R16G16F::writeColor(R16G16F *dst, const gl::ColorF *src)
{ … }

void R16G16F::average(R16G16F *dst, const R16G16F *src1, const R16G16F *src2)
{ … }

void R16G16B16F::readColor(gl::ColorF *dst, const R16G16B16F *src)
{ … }

void R16G16B16F::writeColor(R16G16B16F *dst, const gl::ColorF *src)
{ … }

void R16G16B16F::average(R16G16B16F *dst, const R16G16B16F *src1, const R16G16B16F *src2)
{ … }

void A32B32G32R32F::readColor(gl::ColorF *dst, const A32B32G32R32F *src)
{ … }

void A32B32G32R32F::writeColor(A32B32G32R32F *dst, const gl::ColorF *src)
{ … }

void A32B32G32R32F::average(A32B32G32R32F *dst,
                            const A32B32G32R32F *src1,
                            const A32B32G32R32F *src2)
{ … }

void R32G32B32A32F::readColor(gl::ColorF *dst, const R32G32B32A32F *src)
{ … }

void R32G32B32A32F::writeColor(R32G32B32A32F *dst, const gl::ColorF *src)
{ … }

void R32G32B32A32F::average(R32G32B32A32F *dst,
                            const R32G32B32A32F *src1,
                            const R32G32B32A32F *src2)
{ … }

void R32F::readColor(gl::ColorF *dst, const R32F *src)
{ … }

void R32F::writeColor(R32F *dst, const gl::ColorF *src)
{ … }

void R32F::average(R32F *dst, const R32F *src1, const R32F *src2)
{ … }

void A32F::readColor(gl::ColorF *dst, const A32F *src)
{ … }

void A32F::writeColor(A32F *dst, const gl::ColorF *src)
{ … }

void A32F::average(A32F *dst, const A32F *src1, const A32F *src2)
{ … }

void L32F::readColor(gl::ColorF *dst, const L32F *src)
{ … }

void L32F::writeColor(L32F *dst, const gl::ColorF *src)
{ … }

void L32F::average(L32F *dst, const L32F *src1, const L32F *src2)
{ … }

void L32A32F::readColor(gl::ColorF *dst, const L32A32F *src)
{ … }

void L32A32F::writeColor(L32A32F *dst, const gl::ColorF *src)
{ … }

void L32A32F::average(L32A32F *dst, const L32A32F *src1, const L32A32F *src2)
{ … }

void R32G32F::readColor(gl::ColorF *dst, const R32G32F *src)
{ … }

void R32G32F::writeColor(R32G32F *dst, const gl::ColorF *src)
{ … }

void R32G32F::average(R32G32F *dst, const R32G32F *src1, const R32G32F *src2)
{ … }

void R32G32B32F::readColor(gl::ColorF *dst, const R32G32B32F *src)
{ … }

void R32G32B32F::writeColor(R32G32B32F *dst, const gl::ColorF *src)
{ … }

void R32G32B32F::average(R32G32B32F *dst, const R32G32B32F *src1, const R32G32B32F *src2)
{ … }

void R10G10B10A2::readColor(gl::ColorUI *dst, const R10G10B10A2 *src)
{ … }

void R10G10B10A2::readColor(gl::ColorF *dst, const R10G10B10A2 *src)
{ … }

void R10G10B10A2::writeColor(R10G10B10A2 *dst, const gl::ColorUI *src)
{ … }

void R10G10B10A2::writeColor(R10G10B10A2 *dst, const gl::ColorF *src)
{ … }

void R10G10B10A2::average(R10G10B10A2 *dst, const R10G10B10A2 *src1, const R10G10B10A2 *src2)
{ … }

void R10G10B10A2S::readColor(gl::ColorI *dst, const R10G10B10A2S *src)
{ … }

void R10G10B10A2S::readColor(gl::ColorF *dst, const R10G10B10A2S *src)
{ … }

void R10G10B10A2S::writeColor(R10G10B10A2S *dst, const gl::ColorI *src)
{ … }

void R10G10B10A2S::writeColor(R10G10B10A2S *dst, const gl::ColorF *src)
{ … }

void R10G10B10A2S::average(R10G10B10A2S *dst, const R10G10B10A2S *src1, const R10G10B10A2S *src2)
{ … }

void R10G10B10X2::readColor(gl::ColorUI *dst, const R10G10B10X2 *src)
{ … }

void R10G10B10X2::readColor(gl::ColorF *dst, const R10G10B10X2 *src)
{ … }

void R10G10B10X2::writeColor(R10G10B10X2 *dst, const gl::ColorUI *src)
{ … }

void R10G10B10X2::writeColor(R10G10B10X2 *dst, const gl::ColorF *src)
{ … }

void R10G10B10X2::average(R10G10B10X2 *dst, const R10G10B10X2 *src1, const R10G10B10X2 *src2)
{ … }

void B10G10R10A2::readColor(gl::ColorUI *dst, const B10G10R10A2 *src)
{ … }

void B10G10R10A2::readColor(gl::ColorF *dst, const B10G10R10A2 *src)
{ … }

void B10G10R10A2::writeColor(B10G10R10A2 *dst, const gl::ColorUI *src)
{ … }

void B10G10R10A2::writeColor(B10G10R10A2 *dst, const gl::ColorF *src)
{ … }

void B10G10R10A2::average(B10G10R10A2 *dst, const B10G10R10A2 *src1, const B10G10R10A2 *src2)
{ … }

void R9G9B9E5::readColor(gl::ColorF *dst, const R9G9B9E5 *src)
{ … }

void R9G9B9E5::writeColor(R9G9B9E5 *dst, const gl::ColorF *src)
{ … }

void R9G9B9E5::average(R9G9B9E5 *dst, const R9G9B9E5 *src1, const R9G9B9E5 *src2)
{ … }

void R11G11B10F::readColor(gl::ColorF *dst, const R11G11B10F *src)
{ … }

void R11G11B10F::writeColor(R11G11B10F *dst, const gl::ColorF *src)
{ … }

void R11G11B10F::average(R11G11B10F *dst, const R11G11B10F *src1, const R11G11B10F *src2)
{ … }

void D24S8::ReadDepthStencil(DepthStencil *dst, const D24S8 *src)
{ … }

void D24S8::WriteDepthStencil(D24S8 *dst, const DepthStencil *src)
{ … }

void S8::ReadDepthStencil(DepthStencil *dst, const S8 *src)
{ … }

void S8::WriteDepthStencil(S8 *dst, const DepthStencil *src)
{ … }

void D16::ReadDepthStencil(DepthStencil *dst, const D16 *src)
{ … }

void D16::WriteDepthStencil(D16 *dst, const DepthStencil *src)
{ … }

void D24X8::ReadDepthStencil(DepthStencil *dst, const D24X8 *src)
{ … }

void D24X8::WriteDepthStencil(D24X8 *dst, const DepthStencil *src)
{ … }

void D32F::ReadDepthStencil(DepthStencil *dst, const D32F *src)
{ … }

void D32F::WriteDepthStencil(D32F *dst, const DepthStencil *src)
{ … }

void D32::ReadDepthStencil(DepthStencil *dst, const D32 *src)
{ … }

void D32::WriteDepthStencil(D32 *dst, const DepthStencil *src)
{ … }

void D32FS8X24::ReadDepthStencil(DepthStencil *dst, const D32FS8X24 *src)
{ … }

void D32FS8X24::WriteDepthStencil(D32FS8X24 *dst, const DepthStencil *src)
{ … }
}  // namespace angle