X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Ftexcompress.c;h=992818cc00165b2a69355afc445c80e3fb14d7b5;hb=8e3696137f2cb7b4f5a3824f26186ecbb06f9282;hp=42bd1eee5ca061145a863722102b27a7fed06926;hpb=b189d1635d89cd7d900e8f9a5eed88d7dc0b46cb;p=mesa.git diff --git a/src/mesa/main/texcompress.c b/src/mesa/main/texcompress.c index 42bd1eee5ca..992818cc001 100644 --- a/src/mesa/main/texcompress.c +++ b/src/mesa/main/texcompress.c @@ -1,6 +1,5 @@ /* * Mesa 3-D graphics library - * Version: 6.5.1 * * Copyright (C) 1999-2006 Brian Paul All Rights Reserved. * Copyright (c) 2008 VMware, Inc. @@ -18,9 +17,10 @@ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN - * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. */ @@ -31,12 +31,17 @@ #include "glheader.h" -#include "imports.h" -#include "colormac.h" + +#include "context.h" #include "formats.h" -#include "mfeatures.h" #include "mtypes.h" +#include "context.h" #include "texcompress.h" +#include "texcompress_fxt1.h" +#include "texcompress_rgtc.h" +#include "texcompress_s3tc.h" +#include "texcompress_etc.h" +#include "texcompress_bptc.h" /** @@ -72,28 +77,42 @@ _mesa_gl_compressed_format_base_format(GLenum format) { switch (format) { case GL_COMPRESSED_RED: + case GL_COMPRESSED_R11_EAC: case GL_COMPRESSED_RED_RGTC1: + case GL_COMPRESSED_SIGNED_R11_EAC: case GL_COMPRESSED_SIGNED_RED_RGTC1: return GL_RED; case GL_COMPRESSED_RG: + case GL_COMPRESSED_RG11_EAC: case GL_COMPRESSED_RG_RGTC2: + case GL_COMPRESSED_SIGNED_RG11_EAC: case GL_COMPRESSED_SIGNED_RG_RGTC2: return GL_RG; case GL_COMPRESSED_RGB: case GL_COMPRESSED_SRGB: + case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB: + case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB: case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: case GL_COMPRESSED_RGB_FXT1_3DFX: case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: + case GL_ETC1_RGB8_OES: + case GL_COMPRESSED_RGB8_ETC2: + case GL_COMPRESSED_SRGB8_ETC2: + case GL_RGB_S3TC: + case GL_RGB4_S3TC: + case GL_PALETTE4_RGB8_OES: + case GL_PALETTE4_R5_G6_B5_OES: + case GL_PALETTE8_RGB8_OES: + case GL_PALETTE8_R5_G6_B5_OES: + case GL_ATC_RGB_AMD: return GL_RGB; case GL_COMPRESSED_RGBA: case GL_COMPRESSED_SRGB_ALPHA: case GL_COMPRESSED_RGBA_BPTC_UNORM_ARB: case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB: - case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB: - case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB: case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: @@ -101,6 +120,20 @@ _mesa_gl_compressed_format_base_format(GLenum format) case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: + case GL_COMPRESSED_RGBA8_ETC2_EAC: + case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: + case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: + case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: + case GL_RGBA_S3TC: + case GL_RGBA4_S3TC: + case GL_PALETTE4_RGBA8_OES: + case GL_PALETTE8_RGB5_A1_OES: + case GL_PALETTE4_RGBA4_OES: + case GL_PALETTE4_RGB5_A1_OES: + case GL_PALETTE8_RGBA8_OES: + case GL_PALETTE8_RGBA4_OES: + case GL_ATC_RGBA_EXPLICIT_ALPHA_AMD: + case GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD: return GL_RGBA; case GL_COMPRESSED_ALPHA: @@ -219,6 +252,12 @@ _mesa_gl_compressed_format_base_format(GLenum format) * GL_EXT_texture_compression_latc. At the very least, Catalyst 11.6 does not * expose the 3dc formats through this mechanism. * + * The spec for GL_ARB_texture_compression_bptc doesn't mention whether it + * should be included in GL_COMPRESSED_TEXTURE_FORMATS. However as it takes a + * very long time to compress the textures in this format it's probably not + * very useful as a general format where the GL will have to compress it on + * the fly. + * * \param ctx the GL context * \param formats the resulting format list (may be NULL). * @@ -227,42 +266,88 @@ _mesa_gl_compressed_format_base_format(GLenum format) GLuint _mesa_get_compressed_formats(struct gl_context *ctx, GLint *formats) { + GLint discard_formats[100]; GLuint n = 0; - if (ctx->Extensions.TDFX_texture_compression_FXT1) { - if (formats) { - formats[n++] = GL_COMPRESSED_RGB_FXT1_3DFX; - formats[n++] = GL_COMPRESSED_RGBA_FXT1_3DFX; - } - else { - n += 2; - } + + if (!formats) { + formats = discard_formats; + } + + if (_mesa_is_desktop_gl(ctx) && + ctx->Extensions.TDFX_texture_compression_FXT1) { + formats[n++] = GL_COMPRESSED_RGB_FXT1_3DFX; + formats[n++] = GL_COMPRESSED_RGBA_FXT1_3DFX; } if (ctx->Extensions.EXT_texture_compression_s3tc) { - if (formats) { - formats[n++] = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; - formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; - formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; - } - else { - n += 3; + formats[n++] = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; + formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; + formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; + + /* The ES and desktop GL specs diverge here. + * + * In desktop OpenGL, the driver can perform online compression of + * uncompressed texture data. GL_NUM_COMPRESSED_TEXTURE_FORMATS and + * GL_COMPRESSED_TEXTURE_FORMATS give the application a list of + * formats that it could ask the driver to compress with some + * expectation of quality. The GL_ARB_texture_compression spec + * calls this "suitable for general-purpose usage." As noted + * above, this means GL_COMPRESSED_RGBA_S3TC_DXT1_EXT is not + * included in the list. + * + * In OpenGL ES, the driver never performs compression. + * GL_NUM_COMPRESSED_TEXTURE_FORMATS and + * GL_COMPRESSED_TEXTURE_FORMATS give the application a list of + * formats that the driver can receive from the application. It + * is the *complete* list of formats. The + * GL_EXT_texture_compression_s3tc spec says: + * + * "New State for OpenGL ES 2.0.25 and 3.0.2 Specifications + * + * The queries for NUM_COMPRESSED_TEXTURE_FORMATS and + * COMPRESSED_TEXTURE_FORMATS include + * COMPRESSED_RGB_S3TC_DXT1_EXT, + * COMPRESSED_RGBA_S3TC_DXT1_EXT, + * COMPRESSED_RGBA_S3TC_DXT3_EXT, and + * COMPRESSED_RGBA_S3TC_DXT5_EXT." + * + * Note that the addition is only to the OpenGL ES specification! + */ + if (_mesa_is_gles(ctx)) { + formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; } } - if (ctx->Extensions.S3_s3tc) { - if (formats) { - formats[n++] = GL_RGB_S3TC; - formats[n++] = GL_RGB4_S3TC; - formats[n++] = GL_RGBA_S3TC; - formats[n++] = GL_RGBA4_S3TC; - } - else { - n += 4; - } + + /* The GL_OES_compressed_ETC1_RGB8_texture spec says: + * + * "New State + * + * The queries for NUM_COMPRESSED_TEXTURE_FORMATS and + * COMPRESSED_TEXTURE_FORMATS include ETC1_RGB8_OES." + */ + if (_mesa_is_gles(ctx) + && ctx->Extensions.OES_compressed_ETC1_RGB8_texture) { + formats[n++] = GL_ETC1_RGB8_OES; + } + + /* Required by EXT_texture_compression_bptc in GLES. */ + if (_mesa_has_EXT_texture_compression_bptc(ctx)) { + formats[n++] = GL_COMPRESSED_RGBA_BPTC_UNORM; + formats[n++] = GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM; + formats[n++] = GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT; + formats[n++] = GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT; + } + + /* Required by EXT_texture_compression_rgtc in GLES. */ + if (_mesa_is_gles3(ctx) && + _mesa_has_EXT_texture_compression_rgtc(ctx)) { + formats[n++] = GL_COMPRESSED_RED_RGTC1_EXT; + formats[n++] = GL_COMPRESSED_SIGNED_RED_RGTC1_EXT; + formats[n++] = GL_COMPRESSED_RED_GREEN_RGTC2_EXT; + formats[n++] = GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT; } - return n; -#if FEATURE_ES1 || FEATURE_ES2 - if (formats) { + if (ctx->API == API_OPENGLES) { formats[n++] = GL_PALETTE4_RGB8_OES; formats[n++] = GL_PALETTE4_RGBA8_OES; formats[n++] = GL_PALETTE4_R5_G6_B5_OES; @@ -274,17 +359,129 @@ _mesa_get_compressed_formats(struct gl_context *ctx, GLint *formats) formats[n++] = GL_PALETTE8_RGBA4_OES; formats[n++] = GL_PALETTE8_RGB5_A1_OES; } - else { - n += 10; + + if (_mesa_is_gles3(ctx) || ctx->Extensions.ARB_ES3_compatibility) { + formats[n++] = GL_COMPRESSED_RGB8_ETC2; + formats[n++] = GL_COMPRESSED_RGBA8_ETC2_EAC; + formats[n++] = GL_COMPRESSED_R11_EAC; + formats[n++] = GL_COMPRESSED_RG11_EAC; + formats[n++] = GL_COMPRESSED_SIGNED_R11_EAC; + formats[n++] = GL_COMPRESSED_SIGNED_RG11_EAC; + formats[n++] = GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2; + } + + if (_mesa_is_gles3(ctx)) { + formats[n++] = GL_COMPRESSED_SRGB8_ETC2; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC; + formats[n++] = GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2; + } + + /* The KHR_texture_compression_astc_hdr spec says: + * + * "Interactions with OpenGL 4.2 + * + * OpenGL 4.2 supports the feature that compressed textures can be + * compressed online, by passing the compressed texture format enum + * as the internal format when uploading a texture using TexImage1D, + * TexImage2D or TexImage3D (see Section 3.9.3, Texture Image + * Specification, subsection Encoding of Special Internal Formats). + * + * Due to the complexity of the ASTC compression algorithm, it is + * not usually suitable for online use, and therefore ASTC support + * will be limited to pre-compressed textures only. Where on-device + * compression is required, a domain-specific limited compressor + * will typically be used, and this is therefore not suitable for + * implementation in the driver. + * + * In particular, the ASTC format specifiers will not be added to + * Table 3.14, and thus will not be accepted by the TexImage*D + * functions, and will not be returned by the (already deprecated) + * COMPRESSED_TEXTURE_FORMATS query." + * + * The ES and the desktop specs diverge here. In OpenGL ES, the + * COMPRESSED_TEXTURE_FORMATS query returns the set of supported specific + * compressed formats. + */ + if (ctx->API == API_OPENGLES2 && + ctx->Extensions.KHR_texture_compression_astc_ldr) { + formats[n++] = GL_COMPRESSED_RGBA_ASTC_4x4_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_5x4_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_5x5_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_6x5_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_6x6_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_8x5_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_8x6_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_8x8_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_10x5_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_10x6_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_10x8_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_10x10_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_12x10_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_12x12_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR; + } + + if (_mesa_is_gles3(ctx) && + ctx->Extensions.OES_texture_compression_astc) { + formats[n++] = GL_COMPRESSED_RGBA_ASTC_3x3x3_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_4x3x3_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_4x4x3_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_4x4x4_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_5x4x4_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_5x5x4_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_5x5x5_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_6x5x5_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_6x6x5_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_6x6x6_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES; } -#endif + + /* The GL_AMD_compressed_ATC_texture spec says: + * + * "New State + * + * The queries for NUM_COMPRESSED_TEXTURE_FORMATS and + * COMPRESSED_TEXTURE_FORMATS include ATC_RGB_AMD, + * ATC_RGBA_EXPLICIT_ALPHA_AMD, and ATC_RGBA_INTERPOLATED_ALPHA_AMD." + */ + if (_mesa_has_AMD_compressed_ATC_texture(ctx)) { + formats[n++] = GL_ATC_RGB_AMD; + formats[n++] = GL_ATC_RGBA_EXPLICIT_ALPHA_AMD; + formats[n++] = GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD; + } + + assert(n <= ARRAY_SIZE(discard_formats)); + + return n; } /** - * Convert a compressed MESA_FORMAT_x to a GLenum. + * Convert GLenum to a compressed MESA_FORMAT_x. */ -gl_format +mesa_format _mesa_glenum_to_compressed_format(GLenum format) { switch (format) { @@ -295,15 +492,15 @@ _mesa_glenum_to_compressed_format(GLenum format) case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: case GL_RGB_S3TC: + case GL_RGB4_S3TC: return MESA_FORMAT_RGB_DXT1; case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: - case GL_RGB4_S3TC: return MESA_FORMAT_RGBA_DXT1; case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: case GL_RGBA_S3TC: + case GL_RGBA4_S3TC: return MESA_FORMAT_RGBA_DXT3; case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: - case GL_RGBA4_S3TC: return MESA_FORMAT_RGBA_DXT5; case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: @@ -316,23 +513,159 @@ _mesa_glenum_to_compressed_format(GLenum format) return MESA_FORMAT_SRGBA_DXT5; case GL_COMPRESSED_RED_RGTC1: - return MESA_FORMAT_RED_RGTC1; + return MESA_FORMAT_R_RGTC1_UNORM; case GL_COMPRESSED_SIGNED_RED_RGTC1: - return MESA_FORMAT_SIGNED_RED_RGTC1; + return MESA_FORMAT_R_RGTC1_SNORM; case GL_COMPRESSED_RG_RGTC2: - return MESA_FORMAT_RG_RGTC2; + return MESA_FORMAT_RG_RGTC2_UNORM; case GL_COMPRESSED_SIGNED_RG_RGTC2: - return MESA_FORMAT_SIGNED_RG_RGTC2; + return MESA_FORMAT_RG_RGTC2_SNORM; case GL_COMPRESSED_LUMINANCE_LATC1_EXT: - return MESA_FORMAT_L_LATC1; + return MESA_FORMAT_L_LATC1_UNORM; case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT: - return MESA_FORMAT_SIGNED_L_LATC1; + return MESA_FORMAT_L_LATC1_SNORM; case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT: case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI: - return MESA_FORMAT_LA_LATC2; + return MESA_FORMAT_LA_LATC2_UNORM; case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT: - return MESA_FORMAT_SIGNED_LA_LATC2; + return MESA_FORMAT_LA_LATC2_SNORM; + + case GL_ETC1_RGB8_OES: + return MESA_FORMAT_ETC1_RGB8; + case GL_COMPRESSED_RGB8_ETC2: + return MESA_FORMAT_ETC2_RGB8; + case GL_COMPRESSED_SRGB8_ETC2: + return MESA_FORMAT_ETC2_SRGB8; + case GL_COMPRESSED_RGBA8_ETC2_EAC: + return MESA_FORMAT_ETC2_RGBA8_EAC; + case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: + return MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC; + case GL_COMPRESSED_R11_EAC: + return MESA_FORMAT_ETC2_R11_EAC; + case GL_COMPRESSED_RG11_EAC: + return MESA_FORMAT_ETC2_RG11_EAC; + case GL_COMPRESSED_SIGNED_R11_EAC: + return MESA_FORMAT_ETC2_SIGNED_R11_EAC; + case GL_COMPRESSED_SIGNED_RG11_EAC: + return MESA_FORMAT_ETC2_SIGNED_RG11_EAC; + case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: + return MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1; + case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: + return MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1; + + case GL_COMPRESSED_RGBA_BPTC_UNORM: + return MESA_FORMAT_BPTC_RGBA_UNORM; + case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM: + return MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM; + case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT: + return MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT; + case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT: + return MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT; + + case GL_COMPRESSED_RGBA_ASTC_4x4_KHR: + return MESA_FORMAT_RGBA_ASTC_4x4; + case GL_COMPRESSED_RGBA_ASTC_5x4_KHR: + return MESA_FORMAT_RGBA_ASTC_5x4; + case GL_COMPRESSED_RGBA_ASTC_5x5_KHR: + return MESA_FORMAT_RGBA_ASTC_5x5; + case GL_COMPRESSED_RGBA_ASTC_6x5_KHR: + return MESA_FORMAT_RGBA_ASTC_6x5; + case GL_COMPRESSED_RGBA_ASTC_6x6_KHR: + return MESA_FORMAT_RGBA_ASTC_6x6; + case GL_COMPRESSED_RGBA_ASTC_8x5_KHR: + return MESA_FORMAT_RGBA_ASTC_8x5; + case GL_COMPRESSED_RGBA_ASTC_8x6_KHR: + return MESA_FORMAT_RGBA_ASTC_8x6; + case GL_COMPRESSED_RGBA_ASTC_8x8_KHR: + return MESA_FORMAT_RGBA_ASTC_8x8; + case GL_COMPRESSED_RGBA_ASTC_10x5_KHR: + return MESA_FORMAT_RGBA_ASTC_10x5; + case GL_COMPRESSED_RGBA_ASTC_10x6_KHR: + return MESA_FORMAT_RGBA_ASTC_10x6; + case GL_COMPRESSED_RGBA_ASTC_10x8_KHR: + return MESA_FORMAT_RGBA_ASTC_10x8; + case GL_COMPRESSED_RGBA_ASTC_10x10_KHR: + return MESA_FORMAT_RGBA_ASTC_10x10; + case GL_COMPRESSED_RGBA_ASTC_12x10_KHR: + return MESA_FORMAT_RGBA_ASTC_12x10; + case GL_COMPRESSED_RGBA_ASTC_12x12_KHR: + return MESA_FORMAT_RGBA_ASTC_12x12; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x4; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x5; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x5; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x6; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x8; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x5; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x6; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x8; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x10; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x10; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x12; + case GL_COMPRESSED_RGBA_ASTC_3x3x3_OES: + return MESA_FORMAT_RGBA_ASTC_3x3x3; + case GL_COMPRESSED_RGBA_ASTC_4x3x3_OES: + return MESA_FORMAT_RGBA_ASTC_4x3x3; + case GL_COMPRESSED_RGBA_ASTC_4x4x3_OES: + return MESA_FORMAT_RGBA_ASTC_4x4x3; + case GL_COMPRESSED_RGBA_ASTC_4x4x4_OES: + return MESA_FORMAT_RGBA_ASTC_4x4x4; + case GL_COMPRESSED_RGBA_ASTC_5x4x4_OES: + return MESA_FORMAT_RGBA_ASTC_5x4x4; + case GL_COMPRESSED_RGBA_ASTC_5x5x4_OES: + return MESA_FORMAT_RGBA_ASTC_5x5x4; + case GL_COMPRESSED_RGBA_ASTC_5x5x5_OES: + return MESA_FORMAT_RGBA_ASTC_5x5x5; + case GL_COMPRESSED_RGBA_ASTC_6x5x5_OES: + return MESA_FORMAT_RGBA_ASTC_6x5x5; + case GL_COMPRESSED_RGBA_ASTC_6x6x5_OES: + return MESA_FORMAT_RGBA_ASTC_6x6x5; + case GL_COMPRESSED_RGBA_ASTC_6x6x6_OES: + return MESA_FORMAT_RGBA_ASTC_6x6x6; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_3x3x3; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x3x3; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4x3; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4x4; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x4x4; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5x4; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5x5; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x5x5; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6x5; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6x6; + + case GL_ATC_RGB_AMD: + return MESA_FORMAT_ATC_RGB; + case GL_ATC_RGBA_EXPLICIT_ALPHA_AMD: + return MESA_FORMAT_ATC_RGBA_EXPLICIT; + case GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD: + return MESA_FORMAT_ATC_RGBA_INTERPOLATED; default: return MESA_FORMAT_NONE; @@ -351,16 +684,14 @@ _mesa_glenum_to_compressed_format(GLenum format) * internal format unchanged. */ GLenum -_mesa_compressed_format_to_glenum(struct gl_context *ctx, GLuint mesaFormat) +_mesa_compressed_format_to_glenum(struct gl_context *ctx, + mesa_format mesaFormat) { switch (mesaFormat) { -#if FEATURE_texture_fxt1 case MESA_FORMAT_RGB_FXT1: return GL_COMPRESSED_RGB_FXT1_3DFX; case MESA_FORMAT_RGBA_FXT1: return GL_COMPRESSED_RGBA_FXT1_3DFX; -#endif -#if FEATURE_texture_s3tc case MESA_FORMAT_RGB_DXT1: return GL_COMPRESSED_RGB_S3TC_DXT1_EXT; case MESA_FORMAT_RGBA_DXT1: @@ -369,7 +700,6 @@ _mesa_compressed_format_to_glenum(struct gl_context *ctx, GLuint mesaFormat) return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; case MESA_FORMAT_RGBA_DXT5: return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; -#if FEATURE_EXT_texture_sRGB case MESA_FORMAT_SRGB_DXT1: return GL_COMPRESSED_SRGB_S3TC_DXT1_EXT; case MESA_FORMAT_SRGBA_DXT1: @@ -378,27 +708,161 @@ _mesa_compressed_format_to_glenum(struct gl_context *ctx, GLuint mesaFormat) return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT; case MESA_FORMAT_SRGBA_DXT5: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT; -#endif -#endif - - case MESA_FORMAT_RED_RGTC1: + case MESA_FORMAT_R_RGTC1_UNORM: return GL_COMPRESSED_RED_RGTC1; - case MESA_FORMAT_SIGNED_RED_RGTC1: + case MESA_FORMAT_R_RGTC1_SNORM: return GL_COMPRESSED_SIGNED_RED_RGTC1; - case MESA_FORMAT_RG_RGTC2: + case MESA_FORMAT_RG_RGTC2_UNORM: return GL_COMPRESSED_RG_RGTC2; - case MESA_FORMAT_SIGNED_RG_RGTC2: + case MESA_FORMAT_RG_RGTC2_SNORM: return GL_COMPRESSED_SIGNED_RG_RGTC2; - case MESA_FORMAT_L_LATC1: + case MESA_FORMAT_L_LATC1_UNORM: return GL_COMPRESSED_LUMINANCE_LATC1_EXT; - case MESA_FORMAT_SIGNED_L_LATC1: + case MESA_FORMAT_L_LATC1_SNORM: return GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT; - case MESA_FORMAT_LA_LATC2: + case MESA_FORMAT_LA_LATC2_UNORM: return GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT; - case MESA_FORMAT_SIGNED_LA_LATC2: + case MESA_FORMAT_LA_LATC2_SNORM: return GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT; + case MESA_FORMAT_ETC1_RGB8: + return GL_ETC1_RGB8_OES; + case MESA_FORMAT_ETC2_RGB8: + return GL_COMPRESSED_RGB8_ETC2; + case MESA_FORMAT_ETC2_SRGB8: + return GL_COMPRESSED_SRGB8_ETC2; + case MESA_FORMAT_ETC2_RGBA8_EAC: + return GL_COMPRESSED_RGBA8_ETC2_EAC; + case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC: + return GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC; + case MESA_FORMAT_ETC2_R11_EAC: + return GL_COMPRESSED_R11_EAC; + case MESA_FORMAT_ETC2_RG11_EAC: + return GL_COMPRESSED_RG11_EAC; + case MESA_FORMAT_ETC2_SIGNED_R11_EAC: + return GL_COMPRESSED_SIGNED_R11_EAC; + case MESA_FORMAT_ETC2_SIGNED_RG11_EAC: + return GL_COMPRESSED_SIGNED_RG11_EAC; + case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1: + return GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2; + case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1: + return GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2; + + case MESA_FORMAT_BPTC_RGBA_UNORM: + return GL_COMPRESSED_RGBA_BPTC_UNORM; + case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM: + return GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM; + case MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT: + return GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT; + case MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT: + return GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT; + + case MESA_FORMAT_RGBA_ASTC_4x4: + return GL_COMPRESSED_RGBA_ASTC_4x4_KHR; + case MESA_FORMAT_RGBA_ASTC_5x4: + return GL_COMPRESSED_RGBA_ASTC_5x4_KHR; + case MESA_FORMAT_RGBA_ASTC_5x5: + return GL_COMPRESSED_RGBA_ASTC_5x5_KHR; + case MESA_FORMAT_RGBA_ASTC_6x5: + return GL_COMPRESSED_RGBA_ASTC_6x5_KHR; + case MESA_FORMAT_RGBA_ASTC_6x6: + return GL_COMPRESSED_RGBA_ASTC_6x6_KHR; + case MESA_FORMAT_RGBA_ASTC_8x5: + return GL_COMPRESSED_RGBA_ASTC_8x5_KHR; + case MESA_FORMAT_RGBA_ASTC_8x6: + return GL_COMPRESSED_RGBA_ASTC_8x6_KHR; + case MESA_FORMAT_RGBA_ASTC_8x8: + return GL_COMPRESSED_RGBA_ASTC_8x8_KHR; + case MESA_FORMAT_RGBA_ASTC_10x5: + return GL_COMPRESSED_RGBA_ASTC_10x5_KHR; + case MESA_FORMAT_RGBA_ASTC_10x6: + return GL_COMPRESSED_RGBA_ASTC_10x6_KHR; + case MESA_FORMAT_RGBA_ASTC_10x8: + return GL_COMPRESSED_RGBA_ASTC_10x8_KHR; + case MESA_FORMAT_RGBA_ASTC_10x10: + return GL_COMPRESSED_RGBA_ASTC_10x10_KHR; + case MESA_FORMAT_RGBA_ASTC_12x10: + return GL_COMPRESSED_RGBA_ASTC_12x10_KHR; + case MESA_FORMAT_RGBA_ASTC_12x12: + return GL_COMPRESSED_RGBA_ASTC_12x12_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x4: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x6: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x8: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x6: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x8: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x10: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x10: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x12: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR; + + case MESA_FORMAT_RGBA_ASTC_3x3x3: + return GL_COMPRESSED_RGBA_ASTC_3x3x3_OES; + case MESA_FORMAT_RGBA_ASTC_4x3x3: + return GL_COMPRESSED_RGBA_ASTC_4x3x3_OES; + case MESA_FORMAT_RGBA_ASTC_4x4x3: + return GL_COMPRESSED_RGBA_ASTC_4x4x3_OES; + case MESA_FORMAT_RGBA_ASTC_4x4x4: + return GL_COMPRESSED_RGBA_ASTC_4x4x4_OES; + case MESA_FORMAT_RGBA_ASTC_5x4x4: + return GL_COMPRESSED_RGBA_ASTC_5x4x4_OES; + case MESA_FORMAT_RGBA_ASTC_5x5x4: + return GL_COMPRESSED_RGBA_ASTC_5x5x4_OES; + case MESA_FORMAT_RGBA_ASTC_5x5x5: + return GL_COMPRESSED_RGBA_ASTC_5x5x5_OES; + case MESA_FORMAT_RGBA_ASTC_6x5x5: + return GL_COMPRESSED_RGBA_ASTC_6x5x5_OES; + case MESA_FORMAT_RGBA_ASTC_6x6x5: + return GL_COMPRESSED_RGBA_ASTC_6x6x5_OES; + case MESA_FORMAT_RGBA_ASTC_6x6x6: + return GL_COMPRESSED_RGBA_ASTC_6x6x6_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_3x3x3: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x3x3: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4x3: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4x4: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x4x4: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5x4: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x5x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6x6: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES; + + case MESA_FORMAT_ATC_RGB: + return GL_ATC_RGB_AMD; + case MESA_FORMAT_ATC_RGBA_EXPLICIT: + return GL_ATC_RGBA_EXPLICIT_ALPHA_AMD; + case MESA_FORMAT_ATC_RGBA_INTERPOLATED: + return GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD; + default: _mesa_problem(ctx, "Unexpected mesa texture format in" " _mesa_compressed_format_to_glenum()"); @@ -419,7 +883,7 @@ _mesa_compressed_format_to_glenum(struct gl_context *ctx, GLuint mesaFormat) */ GLubyte * _mesa_compressed_image_address(GLint col, GLint row, GLint img, - gl_format mesaFormat, + mesa_format mesaFormat, GLsizei width, const GLubyte *image) { /* XXX only 2D images implemented, not 3D */ @@ -429,11 +893,71 @@ _mesa_compressed_image_address(GLint col, GLint row, GLint img, _mesa_get_format_block_size(mesaFormat, &bw, &bh); - ASSERT(col % bw == 0); - ASSERT(row % bh == 0); + assert(col % bw == 0); + assert(row % bh == 0); offset = ((width + bw - 1) / bw) * (row / bh) + col / bw; offset *= blockSize; return (GLubyte *) image + offset; } + + +/** + * Return a texel-fetch function for the given format, or NULL if + * invalid format. + */ +compressed_fetch_func +_mesa_get_compressed_fetch_func(mesa_format format) +{ + switch (_mesa_get_format_layout(format)) { + case MESA_FORMAT_LAYOUT_S3TC: + return _mesa_get_dxt_fetch_func(format); + case MESA_FORMAT_LAYOUT_FXT1: + return _mesa_get_fxt_fetch_func(format); + case MESA_FORMAT_LAYOUT_RGTC: + case MESA_FORMAT_LAYOUT_LATC: + return _mesa_get_compressed_rgtc_func(format); + case MESA_FORMAT_LAYOUT_ETC1: + return _mesa_get_etc_fetch_func(format); + case MESA_FORMAT_LAYOUT_BPTC: + return _mesa_get_bptc_fetch_func(format); + default: + return NULL; + } +} + + +/** + * Decompress a compressed texture image, returning a GL_RGBA/GL_FLOAT image. + * \param srcRowStride stride in bytes between rows of blocks in the + * compressed source image. + */ +void +_mesa_decompress_image(mesa_format format, GLuint width, GLuint height, + const GLubyte *src, GLint srcRowStride, + GLfloat *dest) +{ + compressed_fetch_func fetch; + GLuint i, j; + GLuint bytes, bw, bh; + GLint stride; + + bytes = _mesa_get_format_bytes(format); + _mesa_get_format_block_size(format, &bw, &bh); + + fetch = _mesa_get_compressed_fetch_func(format); + if (!fetch) { + _mesa_problem(NULL, "Unexpected format in _mesa_decompress_image()"); + return; + } + + stride = srcRowStride * bh / bytes; + + for (j = 0; j < height; j++) { + for (i = 0; i < width; i++) { + fetch(src, stride, i, j, dest); + dest += 4; + } + } +}