347 lines
9.7 KiB
C
347 lines
9.7 KiB
C
/*
|
|
* (C) Copyright IBM Corporation 2004
|
|
* All Rights Reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* on the rights to use, copy, modify, merge, publish, distribute, sub
|
|
* license, and/or sell copies of the Software, and to permit persons to whom
|
|
* the Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the next
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
* Software.
|
|
*
|
|
* 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 NON-INFRINGEMENT. IN NO EVENT SHALL
|
|
* THE COPYRIGHT HOLDERS AND/OR THEIR SUPPLIERS 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.
|
|
*/
|
|
|
|
/**
|
|
* \file glx_texture_compression.c
|
|
* Contains the routines required to implement GLX protocol for
|
|
* ARB_texture_compression and related extensions.
|
|
*
|
|
* \sa http://oss.sgi.com/projects/ogl-sample/registry/ARB/texture_compression.txt
|
|
*
|
|
* \author Ian Romanick <idr@us.ibm.com>
|
|
*/
|
|
|
|
#include "packrender.h"
|
|
#include "packsingle.h"
|
|
|
|
#include <assert.h>
|
|
|
|
|
|
void
|
|
__indirect_glGetCompressedTexImage( GLenum target, GLint level,
|
|
GLvoid * img )
|
|
{
|
|
__GLX_SINGLE_DECLARE_VARIABLES();
|
|
xGLXGetTexImageReply reply;
|
|
size_t image_bytes;
|
|
|
|
__GLX_SINGLE_LOAD_VARIABLES();
|
|
__GLX_SINGLE_BEGIN( X_GLsop_GetCompressedTexImage, 8 );
|
|
__GLX_SINGLE_PUT_LONG( 0, target );
|
|
__GLX_SINGLE_PUT_LONG( 4, level );
|
|
__GLX_SINGLE_READ_XREPLY();
|
|
|
|
image_bytes = reply.width;
|
|
assert( image_bytes <= ((4 * reply.length) - 0) );
|
|
assert( image_bytes >= ((4 * reply.length) - 3) );
|
|
|
|
if ( image_bytes != 0 ) {
|
|
_XRead( dpy, (char *) img, image_bytes );
|
|
if ( image_bytes < (4 * reply.length) ) {
|
|
_XEatData( dpy, (4 * reply.length) - image_bytes );
|
|
}
|
|
}
|
|
|
|
__GLX_SINGLE_END();
|
|
}
|
|
|
|
|
|
/**
|
|
* Internal function used for \c glCompressedTexImage1D and
|
|
* \c glCompressedTexImage2D.
|
|
*/
|
|
static void
|
|
CompressedTexImage1D2D( GLenum target, GLint level,
|
|
GLenum internal_format,
|
|
GLsizei width, GLsizei height,
|
|
GLint border, GLsizei image_size,
|
|
const GLvoid *data, CARD32 rop )
|
|
{
|
|
__GLX_DECLARE_VARIABLES();
|
|
|
|
__GLX_LOAD_VARIABLES();
|
|
if ( gc->currentDpy == NULL ) {
|
|
return;
|
|
}
|
|
|
|
if ( (target == GL_PROXY_TEXTURE_1D)
|
|
|| (target == GL_PROXY_TEXTURE_2D)
|
|
|| (target == GL_PROXY_TEXTURE_CUBE_MAP) ) {
|
|
compsize = 0;
|
|
}
|
|
else {
|
|
compsize = image_size;
|
|
}
|
|
|
|
cmdlen = __GLX_PAD( __GLX_COMPRESSED_TEXIMAGE_CMD_HDR_SIZE
|
|
+ compsize );
|
|
if ( cmdlen <= gc->maxSmallRenderCommandSize ) {
|
|
__GLX_BEGIN_VARIABLE( rop, cmdlen );
|
|
__GLX_PUT_LONG( 4, target );
|
|
__GLX_PUT_LONG( 8, level );
|
|
__GLX_PUT_LONG( 12, internal_format );
|
|
__GLX_PUT_LONG( 16, width );
|
|
__GLX_PUT_LONG( 20, height );
|
|
__GLX_PUT_LONG( 24, border );
|
|
__GLX_PUT_LONG( 28, image_size );
|
|
if ( compsize != 0 ) {
|
|
__GLX_PUT_CHAR_ARRAY( __GLX_COMPRESSED_TEXIMAGE_CMD_HDR_SIZE,
|
|
data, image_size );
|
|
}
|
|
__GLX_END( cmdlen );
|
|
}
|
|
else {
|
|
assert( compsize != 0 );
|
|
|
|
__GLX_BEGIN_VARIABLE_LARGE( rop, cmdlen + 4 );
|
|
__GLX_PUT_LONG( 8, target );
|
|
__GLX_PUT_LONG( 12, level );
|
|
__GLX_PUT_LONG( 16, internal_format );
|
|
__GLX_PUT_LONG( 20, width );
|
|
__GLX_PUT_LONG( 24, height );
|
|
__GLX_PUT_LONG( 28, border );
|
|
__GLX_PUT_LONG( 32, image_size );
|
|
__glXSendLargeCommand( gc, gc->pc,
|
|
__GLX_COMPRESSED_TEXIMAGE_CMD_HDR_SIZE + 4,
|
|
data, image_size );
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Internal function used for \c glCompressedTexSubImage1D and
|
|
* \c glCompressedTexSubImage2D.
|
|
*/
|
|
static void
|
|
CompressedTexSubImage1D2D( GLenum target, GLint level,
|
|
GLsizei xoffset, GLsizei yoffset,
|
|
GLsizei width, GLsizei height,
|
|
GLenum format, GLsizei image_size,
|
|
const GLvoid *data, CARD32 rop )
|
|
{
|
|
__GLX_DECLARE_VARIABLES();
|
|
|
|
__GLX_LOAD_VARIABLES();
|
|
if ( gc->currentDpy == NULL ) {
|
|
return;
|
|
}
|
|
|
|
if ( target == GL_PROXY_TEXTURE_3D ) {
|
|
compsize = 0;
|
|
}
|
|
else {
|
|
compsize = image_size;
|
|
}
|
|
|
|
cmdlen = __GLX_PAD( __GLX_COMPRESSED_TEXSUBIMAGE_CMD_HDR_SIZE
|
|
+ compsize );
|
|
if ( cmdlen <= gc->maxSmallRenderCommandSize ) {
|
|
__GLX_BEGIN_VARIABLE( rop, cmdlen );
|
|
__GLX_PUT_LONG( 4, target );
|
|
__GLX_PUT_LONG( 8, level );
|
|
__GLX_PUT_LONG( 12, xoffset );
|
|
__GLX_PUT_LONG( 16, yoffset );
|
|
__GLX_PUT_LONG( 20, width );
|
|
__GLX_PUT_LONG( 24, height );
|
|
__GLX_PUT_LONG( 28, format );
|
|
__GLX_PUT_LONG( 32, image_size );
|
|
if ( compsize != 0 ) {
|
|
__GLX_PUT_CHAR_ARRAY( __GLX_COMPRESSED_TEXSUBIMAGE_CMD_HDR_SIZE,
|
|
data, image_size );
|
|
}
|
|
__GLX_END( cmdlen );
|
|
}
|
|
else {
|
|
assert( compsize != 0 );
|
|
|
|
__GLX_BEGIN_VARIABLE_LARGE( rop, cmdlen + 4 );
|
|
__GLX_PUT_LONG( 8, target );
|
|
__GLX_PUT_LONG( 12, level );
|
|
__GLX_PUT_LONG( 16, xoffset );
|
|
__GLX_PUT_LONG( 20, yoffset );
|
|
__GLX_PUT_LONG( 24, width );
|
|
__GLX_PUT_LONG( 28, height );
|
|
__GLX_PUT_LONG( 32, format );
|
|
__GLX_PUT_LONG( 36, image_size );
|
|
__glXSendLargeCommand( gc, gc->pc,
|
|
__GLX_COMPRESSED_TEXSUBIMAGE_CMD_HDR_SIZE + 4,
|
|
data, image_size );
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
__indirect_glCompressedTexImage1D( GLenum target, GLint level,
|
|
GLenum internal_format, GLsizei width,
|
|
GLint border, GLsizei image_size,
|
|
const GLvoid *data )
|
|
{
|
|
CompressedTexImage1D2D( target, level, internal_format, width, 0,
|
|
border, image_size, data,
|
|
X_GLrop_CompressedTexImage1D );
|
|
}
|
|
|
|
|
|
void
|
|
__indirect_glCompressedTexImage2D( GLenum target, GLint level,
|
|
GLenum internal_format,
|
|
GLsizei width, GLsizei height,
|
|
GLint border, GLsizei image_size,
|
|
const GLvoid *data )
|
|
{
|
|
CompressedTexImage1D2D( target, level, internal_format, width, height,
|
|
border, image_size, data,
|
|
X_GLrop_CompressedTexImage2D );
|
|
}
|
|
|
|
|
|
void
|
|
__indirect_glCompressedTexImage3D( GLenum target, GLint level,
|
|
GLenum internal_format,
|
|
GLsizei width, GLsizei height, GLsizei depth,
|
|
GLint border, GLsizei image_size,
|
|
const GLvoid *data )
|
|
{
|
|
__GLX_DECLARE_VARIABLES();
|
|
|
|
__GLX_LOAD_VARIABLES();
|
|
if ( gc->currentDpy == NULL ) {
|
|
return;
|
|
}
|
|
|
|
cmdlen = __GLX_PAD( __GLX_COMPRESSED_TEXIMAGE_3D_CMD_HDR_SIZE
|
|
+ image_size );
|
|
if ( cmdlen <= gc->maxSmallRenderCommandSize ) {
|
|
__GLX_BEGIN_VARIABLE( X_GLrop_CompressedTexImage3D, cmdlen );
|
|
__GLX_PUT_LONG( 4, target );
|
|
__GLX_PUT_LONG( 8, level );
|
|
__GLX_PUT_LONG( 12, internal_format );
|
|
__GLX_PUT_LONG( 16, width );
|
|
__GLX_PUT_LONG( 20, height );
|
|
__GLX_PUT_LONG( 24, depth );
|
|
__GLX_PUT_LONG( 28, border );
|
|
__GLX_PUT_LONG( 32, image_size );
|
|
if ( image_size != 0 ) {
|
|
__GLX_PUT_CHAR_ARRAY( __GLX_COMPRESSED_TEXIMAGE_3D_CMD_HDR_SIZE,
|
|
data, image_size );
|
|
}
|
|
__GLX_END( cmdlen );
|
|
}
|
|
else {
|
|
__GLX_BEGIN_VARIABLE_LARGE( X_GLrop_CompressedTexImage3D,
|
|
cmdlen + 4 );
|
|
__GLX_PUT_LONG( 8, target );
|
|
__GLX_PUT_LONG( 12, level );
|
|
__GLX_PUT_LONG( 16, internal_format );
|
|
__GLX_PUT_LONG( 20, width );
|
|
__GLX_PUT_LONG( 24, height );
|
|
__GLX_PUT_LONG( 28, depth );
|
|
__GLX_PUT_LONG( 32, border );
|
|
__GLX_PUT_LONG( 36, image_size );
|
|
__glXSendLargeCommand( gc, gc->pc,
|
|
__GLX_COMPRESSED_TEXIMAGE_3D_CMD_HDR_SIZE + 4,
|
|
data, image_size );
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
__indirect_glCompressedTexSubImage1D( GLenum target, GLint level,
|
|
GLint xoffset,
|
|
GLsizei width,
|
|
GLenum format, GLsizei image_size,
|
|
const GLvoid *data )
|
|
{
|
|
CompressedTexSubImage1D2D( target, level, xoffset, 0, width, 0,
|
|
format, image_size, data,
|
|
X_GLrop_CompressedTexSubImage1D );
|
|
}
|
|
|
|
|
|
void
|
|
__indirect_glCompressedTexSubImage2D( GLenum target, GLint level,
|
|
GLint xoffset, GLint yoffset,
|
|
GLsizei width, GLsizei height,
|
|
GLenum format, GLsizei image_size,
|
|
const GLvoid *data )
|
|
{
|
|
CompressedTexSubImage1D2D( target, level, xoffset, yoffset, width, height,
|
|
format, image_size, data,
|
|
X_GLrop_CompressedTexSubImage2D );
|
|
}
|
|
|
|
|
|
void
|
|
__indirect_glCompressedTexSubImage3D( GLenum target, GLint level,
|
|
GLint xoffset, GLint yoffset, GLint zoffset,
|
|
GLsizei width, GLsizei height, GLsizei depth,
|
|
GLenum format, GLsizei image_size,
|
|
const GLvoid *data )
|
|
{
|
|
__GLX_DECLARE_VARIABLES();
|
|
|
|
__GLX_LOAD_VARIABLES();
|
|
if ( gc->currentDpy == NULL ) {
|
|
return;
|
|
}
|
|
|
|
cmdlen = __GLX_PAD( __GLX_COMPRESSED_TEXSUBIMAGE_3D_CMD_HDR_SIZE
|
|
+ image_size );
|
|
if ( cmdlen <= gc->maxSmallRenderCommandSize ) {
|
|
__GLX_BEGIN_VARIABLE( X_GLrop_CompressedTexSubImage3D, cmdlen );
|
|
__GLX_PUT_LONG( 4, target );
|
|
__GLX_PUT_LONG( 8, level );
|
|
__GLX_PUT_LONG( 12, xoffset );
|
|
__GLX_PUT_LONG( 16, yoffset );
|
|
__GLX_PUT_LONG( 20, zoffset );
|
|
__GLX_PUT_LONG( 24, width );
|
|
__GLX_PUT_LONG( 28, height );
|
|
__GLX_PUT_LONG( 32, depth );
|
|
__GLX_PUT_LONG( 36, format );
|
|
__GLX_PUT_LONG( 40, image_size );
|
|
if ( image_size != 0 ) {
|
|
__GLX_PUT_CHAR_ARRAY( __GLX_COMPRESSED_TEXSUBIMAGE_3D_CMD_HDR_SIZE,
|
|
data, image_size );
|
|
}
|
|
__GLX_END( cmdlen );
|
|
}
|
|
else {
|
|
__GLX_BEGIN_VARIABLE_LARGE( X_GLrop_CompressedTexSubImage3D,
|
|
cmdlen + 4 );
|
|
__GLX_PUT_LONG( 8, target );
|
|
__GLX_PUT_LONG( 12, level );
|
|
__GLX_PUT_LONG( 16, xoffset );
|
|
__GLX_PUT_LONG( 20, yoffset );
|
|
__GLX_PUT_LONG( 24, zoffset );
|
|
__GLX_PUT_LONG( 28, width );
|
|
__GLX_PUT_LONG( 32, height );
|
|
__GLX_PUT_LONG( 36, depth );
|
|
__GLX_PUT_LONG( 40, format );
|
|
__GLX_PUT_LONG( 44, image_size );
|
|
__glXSendLargeCommand( gc, gc->pc,
|
|
__GLX_COMPRESSED_TEXSUBIMAGE_3D_CMD_HDR_SIZE + 4,
|
|
data, image_size );
|
|
}
|
|
}
|