mutter/cogl/cogl-sub-texture.c
Neil Roberts 63c984f193 cogl-sub-texture: Fix the height of sub textures
The code which is used to get the texture height was accidentally
using the width due to a cut-and-paste fail.
2009-12-03 14:46:20 +00:00

700 lines
22 KiB
C

/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2009 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*
* Authors:
* Neil Roberts <neil@linux.intel.com>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "cogl.h"
#include "cogl-internal.h"
#include "cogl-util.h"
#include "cogl-texture-private.h"
#include "cogl-sub-texture-private.h"
#include "cogl-context.h"
#include "cogl-handle.h"
#include "cogl-texture-driver.h"
#include <string.h>
#include <math.h>
static void _cogl_sub_texture_free (CoglSubTexture *sub_tex);
COGL_HANDLE_DEFINE (SubTexture, sub_texture);
static const CoglTextureVtable cogl_sub_texture_vtable;
/* Maps from the texture coordinates of this texture to the texture
coordinates of the full texture */
static void
_cogl_sub_texture_map_coordinate_pair (CoglSubTexture *sub_tex,
gfloat *tx, gfloat *ty)
{
*tx = *tx * (sub_tex->tx2 - sub_tex->tx1) + sub_tex->tx1;
*ty = *ty * (sub_tex->ty2 - sub_tex->ty1) + sub_tex->ty1;
}
static void
_cogl_sub_texture_map_coordinate_set (CoglSubTexture *sub_tex,
gfloat *tx1, gfloat *ty1,
gfloat *tx2, gfloat *ty2)
{
_cogl_sub_texture_map_coordinate_pair (sub_tex, tx1, ty1);
_cogl_sub_texture_map_coordinate_pair (sub_tex, tx2, ty2);
}
/* Maps from the texture coordinates of the full texture to the
texture coordinates of the sub texture */
static void
_cogl_sub_texture_unmap_coordinate_pair (CoglSubTexture *sub_tex,
gfloat *coords)
{
if (sub_tex->tx1 == sub_tex->tx2)
coords[0] = sub_tex->tx1;
else
coords[0] = (coords[0] - sub_tex->tx1) / (sub_tex->tx2 - sub_tex->tx1);
if (sub_tex->ty1 == sub_tex->ty2)
coords[0] = sub_tex->ty1;
else
coords[1] = (coords[1] - sub_tex->ty1) / (sub_tex->ty2 - sub_tex->ty1);
}
static void
_cogl_sub_texture_unmap_coordinate_set (CoglSubTexture *sub_tex,
gfloat *coords)
{
_cogl_sub_texture_unmap_coordinate_pair (sub_tex, coords);
_cogl_sub_texture_unmap_coordinate_pair (sub_tex, coords + 2);
}
static gboolean
_cogl_sub_texture_same_int_part (float t1, float t2)
{
float int_part1, int_part2;
float frac_part1, frac_part2;
frac_part1 = modff (t1, &int_part1);
frac_part2 = modff (t2, &int_part2);
return (int_part1 == int_part2 ||
((frac_part1 == 0.0f || frac_part2 == 0.0f) &&
ABS (int_part1 - int_part2) == 1.0f));
}
typedef struct _CoglSubTextureForeachData
{
CoglSubTexture *sub_tex;
CoglTextureSliceCallback callback;
void *user_data;
} CoglSubTextureForeachData;
static void
_cogl_sub_texture_foreach_cb (CoglHandle handle,
GLuint gl_handle,
GLenum gl_target,
const float *slice_coords,
const float *full_virtual_coords,
void *user_data)
{
CoglSubTextureForeachData *data = user_data;
float virtual_coords[4];
memcpy (virtual_coords, full_virtual_coords, sizeof (virtual_coords));
/* Convert the virtual coords from the full-texture space to the sub
texture space */
_cogl_sub_texture_unmap_coordinate_set (data->sub_tex, virtual_coords);
data->callback (handle, gl_handle, gl_target,
slice_coords, virtual_coords,
data->user_data);
}
static void
_cogl_sub_texture_manual_repeat_cb (const float *coords,
void *user_data)
{
CoglSubTextureForeachData *data = user_data;
float mapped_coords[4];
memcpy (mapped_coords, coords, sizeof (mapped_coords));
_cogl_sub_texture_map_coordinate_set (data->sub_tex,
&mapped_coords[0],
&mapped_coords[1],
&mapped_coords[2],
&mapped_coords[3]);
_cogl_texture_foreach_sub_texture_in_region (data->sub_tex->full_texture,
mapped_coords[0],
mapped_coords[1],
mapped_coords[2],
mapped_coords[3],
_cogl_sub_texture_foreach_cb,
user_data);
}
static void
_cogl_sub_texture_foreach_sub_texture_in_region (
CoglTexture *tex,
float virtual_tx_1,
float virtual_ty_1,
float virtual_tx_2,
float virtual_ty_2,
CoglTextureSliceCallback callback,
void *user_data)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
CoglSubTextureForeachData data;
data.sub_tex = sub_tex;
data.callback = callback;
data.user_data = user_data;
/* If there is no repeating or the sub texture coordinates are a
multiple of the whole texture then we can just directly map the
texture coordinates */
if (sub_tex->tex_coords_are_a_multiple ||
(_cogl_sub_texture_same_int_part (virtual_tx_1, virtual_tx_2) &&
_cogl_sub_texture_same_int_part (virtual_ty_1, virtual_ty_2)))
{
_cogl_sub_texture_map_coordinate_set (sub_tex,
&virtual_tx_1,
&virtual_ty_1,
&virtual_tx_2,
&virtual_ty_2);
_cogl_texture_foreach_sub_texture_in_region
(sub_tex->full_texture,
virtual_tx_1, virtual_ty_1,
virtual_tx_2, virtual_ty_2,
_cogl_sub_texture_foreach_cb, &data);
}
else
_cogl_texture_iterate_manual_repeats (_cogl_sub_texture_manual_repeat_cb,
virtual_tx_1, virtual_ty_1,
virtual_tx_2, virtual_ty_2,
&data);
}
static void
_cogl_sub_texture_set_wrap_mode_parameter (CoglTexture *tex,
GLenum wrap_mode)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
_cogl_texture_set_wrap_mode_parameter (sub_tex->full_texture, wrap_mode);
}
static void
_cogl_sub_texture_free (CoglSubTexture *sub_tex)
{
cogl_handle_unref (sub_tex->full_texture);
g_free (sub_tex);
}
CoglHandle
_cogl_sub_texture_new (CoglHandle full_texture,
gfloat tx1, gfloat ty1,
gfloat tx2, gfloat ty2)
{
CoglSubTexture *sub_tex;
CoglTexture *tex;
gfloat integer_part;
sub_tex = g_new (CoglSubTexture, 1);
tex = COGL_TEXTURE (sub_tex);
tex->vtable = &cogl_sub_texture_vtable;
sub_tex->full_texture = cogl_handle_ref (full_texture);
sub_tex->tx1 = tx1;
sub_tex->ty1 = ty1;
sub_tex->tx2 = tx2;
sub_tex->ty2 = ty2;
/* Track whether the texture coords are a multiple of one because in
that case we can use hardware repeating */
sub_tex->tex_coords_are_a_multiple
= (modff (tx1, &integer_part) == 0.0f &&
modff (ty1, &integer_part) == 0.0f &&
modff (tx2, &integer_part) == 0.0f &&
modff (ty2, &integer_part) == 0.0f);
return _cogl_sub_texture_handle_new (sub_tex);
}
static gint
_cogl_sub_texture_get_max_waste (CoglTexture *tex)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
return cogl_texture_get_max_waste (sub_tex->full_texture);
}
static gboolean
_cogl_sub_texture_is_sliced (CoglTexture *tex)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
return cogl_texture_is_sliced (sub_tex->full_texture);
}
static gboolean
_cogl_sub_texture_can_hardware_repeat (CoglTexture *tex)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
/* We can hardware repeat if the full texture can hardware repeat
and the coordinates for the subregion are all a multiple of the
full size of the texture (ie, they have no fractional part) */
return (sub_tex->tex_coords_are_a_multiple &&
_cogl_texture_can_hardware_repeat (sub_tex->full_texture));
}
static void
_cogl_sub_texture_transform_coords_to_gl (CoglTexture *tex,
float *s,
float *t)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
_cogl_sub_texture_map_coordinate_pair (sub_tex, s, t);
_cogl_texture_transform_coords_to_gl (sub_tex->full_texture, s, t);
}
static gboolean
_cogl_sub_texture_get_gl_texture (CoglTexture *tex,
GLuint *out_gl_handle,
GLenum *out_gl_target)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
return cogl_texture_get_gl_texture (sub_tex->full_texture,
out_gl_handle,
out_gl_target);
}
static void
_cogl_sub_texture_set_filters (CoglTexture *tex,
GLenum min_filter,
GLenum mag_filter)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
_cogl_texture_set_filters (sub_tex->full_texture, min_filter, mag_filter);
}
static void
_cogl_sub_texture_ensure_mipmaps (CoglTexture *tex)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
_cogl_texture_ensure_mipmaps (sub_tex->full_texture);
}
static void
_cogl_sub_texture_get_next_chunk (int pos, int end,
int tex_size,
int *chunk_start, int *chunk_end)
{
/* pos and end may be negative or greater than the size of the
texture. We want to calculate the next largest range we can copy
in one chunk */
if (pos < 0)
/* The behaviour of % for negative numbers is implementation
dependant in C89 so we have to do this */
*chunk_start = (tex_size - pos) % tex_size;
else
*chunk_start = pos % tex_size;
/* If the region is larger than the remaining size of the texture
then we need to crop it */
if (end - pos > tex_size - *chunk_start)
end = pos + tex_size - *chunk_start;
if (end < 0)
*chunk_end = (tex_size - end) % tex_size;
else
*chunk_end = end % tex_size;
if (*chunk_end == 0)
*chunk_end = tex_size;
}
static void
_cogl_sub_texture_get_x_pixel_pos (CoglSubTexture *sub_tex,
gint *px1, gint *px2)
{
gint full_width = cogl_texture_get_width (sub_tex->full_texture);
*px1 = full_width * sub_tex->tx1;
*px2 = full_width * sub_tex->tx2;
if (*px1 > *px2)
{
gint temp = *px1;
*px1 = *px2;
*px2 = temp;
}
}
static void
_cogl_sub_texture_get_y_pixel_pos (CoglSubTexture *sub_tex,
gint *py1, gint *py2)
{
gint full_height = cogl_texture_get_height (sub_tex->full_texture);
*py1 = full_height * sub_tex->ty1;
*py2 = full_height * sub_tex->ty2;
if (*py1 > *py2)
{
gint temp = *py1;
*py1 = *py2;
*py2 = temp;
}
}
static gboolean
_cogl_sub_texture_set_region (CoglTexture *tex,
int src_x,
int src_y,
int dst_x,
int dst_y,
unsigned int dst_width,
unsigned int dst_height,
int width,
int height,
CoglPixelFormat format,
unsigned int rowstride,
const guint8 *data)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
gint full_tex_width, full_tex_height;
gint bpp;
gint px1, py1, px2, py2;
gint it_x, it_y;
gint src_x1, src_y1, src_x2, src_y2;
CoglBitmap source_bmp;
CoglBitmap temp_bmp;
gboolean source_bmp_owner = FALSE;
CoglPixelFormat closest_format;
GLenum closest_gl_format;
GLenum closest_gl_type;
gboolean success;
CoglPixelFormat tex_format;
/* Check for valid format */
if (format == COGL_PIXEL_FORMAT_ANY)
return FALSE;
/* Shortcut out early if the image is empty */
if (width == 0 || height == 0)
return TRUE;
/* FIXME: If the sub texture coordinates are swapped around then we
should flip the bitmap */
_cogl_sub_texture_get_x_pixel_pos (sub_tex, &px1, &px2);
_cogl_sub_texture_get_y_pixel_pos (sub_tex, &py1, &py2);
full_tex_width = cogl_texture_get_width (sub_tex->full_texture);
full_tex_height = cogl_texture_get_height (sub_tex->full_texture);
/* Init source bitmap */
source_bmp.width = width;
source_bmp.height = height;
source_bmp.format = format;
source_bmp.data = (guchar*) data;
/* Rowstride from texture width if none specified */
bpp = _cogl_get_format_bpp (format);
source_bmp.rowstride = (rowstride == 0) ? width * bpp : rowstride;
/* Find closest format to internal that's supported by GL */
tex_format = cogl_texture_get_format (sub_tex->full_texture);
closest_format = _cogl_pixel_format_to_gl (tex_format,
NULL, /* don't need */
&closest_gl_format,
&closest_gl_type);
/* If no direct match, convert */
if (closest_format != format)
{
/* Convert to required format */
success = _cogl_bitmap_convert_and_premult (&source_bmp,
&temp_bmp,
closest_format);
/* Swap bitmaps if succeeded */
if (!success) return FALSE;
source_bmp = temp_bmp;
source_bmp_owner = TRUE;
}
for (it_y = py1; it_y < py2; it_y += src_y2 - src_y1)
{
_cogl_sub_texture_get_next_chunk (it_y, py2, full_tex_width,
&src_y1, &src_y2);
for (it_x = px1; it_x < px2; it_x += src_x2 - src_x1)
{
gint virt_x_1, virt_y_1, virt_width, virt_height;
gint copy_dst_x, copy_dst_y, copy_dst_width, copy_dst_height;
_cogl_sub_texture_get_next_chunk (it_x, px2, full_tex_height,
&src_x1, &src_x2);
/* Offset of the chunk from the left edge in the virtual sub
texture coordinates */
virt_x_1 = it_x - px1;
/* Pixel width covered by this chunk */
virt_width = src_x2 - src_x1;
/* Offset of the chunk from the top edge in the virtual sub
texture coordinates */
virt_y_1 = it_y - py1;
/* Pixel height covered by this chunk */
virt_height = src_y2 - src_y1;
/* Check if this chunk intersects with the update region */
if (dst_x + dst_width <= virt_x_1 ||
dst_x >= virt_x_1 + virt_width ||
dst_y + dst_height <= it_y - py1 ||
dst_y >= virt_y_1 + virt_height)
continue;
/* Calculate the intersection in virtual coordinates */
copy_dst_width = dst_width;
if (dst_x < virt_x_1)
{
copy_dst_width -= virt_x_1 - dst_x;
copy_dst_x = virt_x_1;
}
else
copy_dst_x = dst_x;
if (copy_dst_width + copy_dst_x > virt_x_1 + virt_width)
copy_dst_width = virt_x_1 + virt_width - copy_dst_x;
copy_dst_height = dst_height;
if (dst_y < virt_y_1)
{
copy_dst_height -= virt_y_1 - dst_y;
copy_dst_y = virt_y_1;
}
else
copy_dst_y = dst_y;
if (copy_dst_height + copy_dst_y > virt_y_1 + virt_height)
copy_dst_height = virt_y_1 + virt_height - copy_dst_y;
/* Update the region in the full texture */
cogl_texture_set_region (sub_tex->full_texture,
src_x + copy_dst_x - dst_x,
src_y + copy_dst_y - dst_y,
src_x1 + copy_dst_x - virt_x_1,
src_y1 + copy_dst_y - virt_y_1,
copy_dst_width,
copy_dst_height,
width,
height,
format,
rowstride,
data);
}
}
/* Free data if owner */
if (source_bmp_owner)
g_free (source_bmp.data);
return TRUE;
}
static void
_cogl_sub_texture_copy_region (guchar *dst,
const guchar *src,
gint dst_x, gint dst_y,
gint src_x, gint src_y,
gint width, gint height,
gint dst_rowstride,
gint src_rowstride,
gint bpp)
{
int y;
dst += dst_x * bpp + dst_y * dst_rowstride;
src += src_x * bpp + src_y * src_rowstride;
for (y = 0; y < height; y++)
{
memcpy (dst, src, bpp * width);
dst += dst_rowstride;
src += src_rowstride;
}
}
static int
_cogl_sub_texture_get_data (CoglTexture *tex,
CoglPixelFormat format,
unsigned int rowstride,
guint8 *data)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
unsigned int full_rowstride;
guint8 *full_data;
int byte_size, full_size;
gint bpp;
gint px1, py1, px2, py2;
gint full_tex_width, full_tex_height;
/* FIXME: This gets the full data from the full texture and then
copies a subregion of that. It would be better if there was a
texture_get_sub_data virtual and it can just munge the texture
coordinates */
/* Default to internal format if none specified */
if (format == COGL_PIXEL_FORMAT_ANY)
format = cogl_texture_get_format (sub_tex->full_texture);
_cogl_sub_texture_get_x_pixel_pos (sub_tex, &px1, &px2);
_cogl_sub_texture_get_y_pixel_pos (sub_tex, &py1, &py2);
full_tex_width = cogl_texture_get_width (sub_tex->full_texture);
full_tex_height = cogl_texture_get_height (sub_tex->full_texture);
/* Rowstride from texture width if none specified */
bpp = _cogl_get_format_bpp (format);
if (rowstride == 0)
rowstride = px2 - px1;
/* Return byte size if only that requested */
byte_size = (py2 - py1) * rowstride;
if (data == NULL)
return byte_size;
full_rowstride = _cogl_get_format_bpp (format) * full_tex_width;
full_data = g_malloc (full_rowstride * full_tex_height);
full_size = cogl_texture_get_data (sub_tex->full_texture, format,
full_rowstride, full_data);
if (full_size)
{
int dst_x, dst_y;
int src_x1, src_y1;
int src_x2, src_y2;
for (dst_y = py1; dst_y < py2; dst_y += src_y2 - src_y1)
{
_cogl_sub_texture_get_next_chunk (dst_y, py2, full_tex_width,
&src_y1, &src_y2);
for (dst_x = px1; dst_x < px2; dst_x += src_x2 - src_x1)
{
_cogl_sub_texture_get_next_chunk (dst_x, px2, full_tex_height,
&src_x1, &src_x2);
_cogl_sub_texture_copy_region (data, full_data,
dst_x - px1, dst_y - py1,
src_x1, src_y1,
src_x2 - src_x1,
src_y2 - src_y1,
rowstride,
full_rowstride,
bpp);
}
}
}
else
byte_size = 0;
g_free (full_data);
return byte_size;
}
static CoglPixelFormat
_cogl_sub_texture_get_format (CoglTexture *tex)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
return cogl_texture_get_format (sub_tex->full_texture);
}
static GLenum
_cogl_sub_texture_get_gl_format (CoglTexture *tex)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
return _cogl_texture_get_gl_format (sub_tex->full_texture);
}
static gint
_cogl_sub_texture_get_width (CoglTexture *tex)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
gint px1, px2;
_cogl_sub_texture_get_x_pixel_pos (sub_tex, &px1, &px2);
return px2 - px1;
}
static gint
_cogl_sub_texture_get_height (CoglTexture *tex)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
gint py1, py2;
_cogl_sub_texture_get_y_pixel_pos (sub_tex, &py1, &py2);
return py2 - py1;
}
static const CoglTextureVtable
cogl_sub_texture_vtable =
{
_cogl_sub_texture_set_region,
_cogl_sub_texture_get_data,
_cogl_sub_texture_foreach_sub_texture_in_region,
_cogl_sub_texture_get_max_waste,
_cogl_sub_texture_is_sliced,
_cogl_sub_texture_can_hardware_repeat,
_cogl_sub_texture_transform_coords_to_gl,
_cogl_sub_texture_get_gl_texture,
_cogl_sub_texture_set_filters,
_cogl_sub_texture_ensure_mipmaps,
_cogl_sub_texture_set_wrap_mode_parameter,
_cogl_sub_texture_get_format,
_cogl_sub_texture_get_gl_format,
_cogl_sub_texture_get_width,
_cogl_sub_texture_get_height
};