2006-05-29 08:59:36 +00:00
|
|
|
/*
|
|
|
|
* Clutter.
|
|
|
|
*
|
|
|
|
* An OpenGL based 'interactive canvas' library.
|
|
|
|
*
|
|
|
|
* Authored By Matthew Allum <mallum@openedhand.com>
|
|
|
|
*
|
|
|
|
* Copyright (C) 2006 OpenedHand
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2006-06-21 22:34:25 +00:00
|
|
|
/**
|
|
|
|
* SECTION:clutter-texture
|
|
|
|
* @short_description: An actor for displaying and manipulating images.
|
|
|
|
*
|
|
|
|
* #ClutterTexture is a base class for displaying and manipulating pixel
|
|
|
|
* buffer type data.
|
2006-09-19 19:27:16 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* The clutter_texture_set_from_rgb_data() and
|
|
|
|
* clutter_texture_set_from_file() functions are used to copy image
|
|
|
|
* data into texture memory and subsequently realize the texture.
|
2007-05-25 10:56:09 +00:00
|
|
|
*
|
2007-07-24 17:38:35 +00:00
|
|
|
* If texture reads are supported by underlying GL implementation,
|
2008-06-13 15:37:58 +00:00
|
|
|
* unrealizing frees image data from texture memory moving to main
|
2007-10-12 08:17:00 +00:00
|
|
|
* system memory. Re-realizing then performs the opposite operation.
|
2008-06-13 15:37:58 +00:00
|
|
|
* This process allows basic management of commonly limited available
|
|
|
|
* texture memory.
|
2007-12-17 15:51:30 +00:00
|
|
|
*
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
* Note: a ClutterTexture will scale its contents to fit the bounding
|
|
|
|
* box requested using clutter_actor_set_size(). To display an area of
|
|
|
|
* a texture without scaling, you should set the clip area using
|
|
|
|
* clutter_actor_set_clip().
|
2006-06-21 22:34:25 +00:00
|
|
|
*/
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
#ifdef HAVE_CONFIG_H
|
2007-04-27 21:13:06 +00:00
|
|
|
#include "config.h"
|
2007-10-12 08:17:00 +00:00
|
|
|
#endif
|
2007-04-27 21:13:06 +00:00
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
#include "clutter-texture.h"
|
|
|
|
#include "clutter-main.h"
|
|
|
|
#include "clutter-marshal.h"
|
2006-07-24 21:15:19 +00:00
|
|
|
#include "clutter-feature.h"
|
2006-06-06 20:40:40 +00:00
|
|
|
#include "clutter-util.h"
|
2006-11-21 Emmanuele Bassi <ebassi@openedhand.com>
* configure.ac: Enable debug messages also when
--enable-debug is set to "minimum".
* clutter/Makefile.am:
* clutter/clutter-debug.h: Move all debugging macros inside
this private header; make all debug macros depend on the
CLUTTER_ENABLE_DEBUG compile time define, controlled by
the --enable-debug configure switch; add G_LOG_DOMAIN define.
* clutter/clutter-main.c: Clean up the debug stuff; add
command line argument parsing using GOption; the debug
messages now are triggered like this:
CLUTTER_DEBUG=section:section:... clutter-app
or like this:
clutter-app --clutter-debug=section:section:...
where "section" is one of the sections listed in clutter-main.c,
or "all", for all sections; each section is bound to a flag,
which can be used to define a domain when adding a debug note
using the CLUTTER_NOTE() macro; the old CLUTTER_DBG() macro is
just a wrapper around that, under the CLUTTER_DEBUG_MISC domain;
CLUTTER_NOTE() is used like this:
CLUTTER_NOTE (DOMAIN, log-function);
where log function is g_printerr(), g_message(), g_warning(),
g_critical() or directly g_log() - for instance:
CLUTTER_NOTE (PANGO, g_warning ("Cache miss: %d", glyph));
will print the warning only if the "pango" flag has been
set to the CLUTTER_DEBUG envvar or passed to the --clutter-debug
command line argument.
similar to CLUTTER_SHOW_FPS, there's also the --clutter-show-fps
command line switch; also, the --display and --screen command
line switches have been added: the first overrides the DISPLAY
envvar and the second controls the X screen used by Clutter to
get the root window on the display.
* clutter/clutter-main.h:
* clutter/clutter-main.c: Add extended support for GOption
in Clutter; use clutter_init_with_args() to let Clutter
parse your own command line arguments; use instead
clutter_get_option_group() to get the GOptionGroup used by
Clutter if you want to do the parsing yourself with
g_option_context_parse(). The init sequence has been verified,
updated and moved into common functions where possible.
* clutter/pango/pangoclutter-render.c:
* clutter/*.c: Include "clutter-debug.h" where needed; use
CLUTTER_NOTE() instead of CLUTTER_DBG().
* examples/super-oh.c: Use the new clutter_init_with_args()
function, and add a --num-hands command line switch to
the SuperOH example code controlling the number of hands at
runtime.
2006-11-21 21:27:53 +00:00
|
|
|
#include "clutter-private.h"
|
2008-04-25 13:37:36 +00:00
|
|
|
#include "clutter-scriptable.h"
|
2006-11-21 Emmanuele Bassi <ebassi@openedhand.com>
* configure.ac: Enable debug messages also when
--enable-debug is set to "minimum".
* clutter/Makefile.am:
* clutter/clutter-debug.h: Move all debugging macros inside
this private header; make all debug macros depend on the
CLUTTER_ENABLE_DEBUG compile time define, controlled by
the --enable-debug configure switch; add G_LOG_DOMAIN define.
* clutter/clutter-main.c: Clean up the debug stuff; add
command line argument parsing using GOption; the debug
messages now are triggered like this:
CLUTTER_DEBUG=section:section:... clutter-app
or like this:
clutter-app --clutter-debug=section:section:...
where "section" is one of the sections listed in clutter-main.c,
or "all", for all sections; each section is bound to a flag,
which can be used to define a domain when adding a debug note
using the CLUTTER_NOTE() macro; the old CLUTTER_DBG() macro is
just a wrapper around that, under the CLUTTER_DEBUG_MISC domain;
CLUTTER_NOTE() is used like this:
CLUTTER_NOTE (DOMAIN, log-function);
where log function is g_printerr(), g_message(), g_warning(),
g_critical() or directly g_log() - for instance:
CLUTTER_NOTE (PANGO, g_warning ("Cache miss: %d", glyph));
will print the warning only if the "pango" flag has been
set to the CLUTTER_DEBUG envvar or passed to the --clutter-debug
command line argument.
similar to CLUTTER_SHOW_FPS, there's also the --clutter-show-fps
command line switch; also, the --display and --screen command
line switches have been added: the first overrides the DISPLAY
envvar and the second controls the X screen used by Clutter to
get the root window on the display.
* clutter/clutter-main.h:
* clutter/clutter-main.c: Add extended support for GOption
in Clutter; use clutter_init_with_args() to let Clutter
parse your own command line arguments; use instead
clutter_get_option_group() to get the GOptionGroup used by
Clutter if you want to do the parsing yourself with
g_option_context_parse(). The init sequence has been verified,
updated and moved into common functions where possible.
* clutter/pango/pangoclutter-render.c:
* clutter/*.c: Include "clutter-debug.h" where needed; use
CLUTTER_NOTE() instead of CLUTTER_DBG().
* examples/super-oh.c: Use the new clutter_init_with_args()
function, and add a --num-hands command line switch to
the SuperOH example code controlling the number of hands at
runtime.
2006-11-21 21:27:53 +00:00
|
|
|
#include "clutter-debug.h"
|
2007-04-27 21:13:06 +00:00
|
|
|
#include "clutter-fixed.h"
|
2008-06-07 15:08:05 +00:00
|
|
|
#include "clutter-enum-types.h"
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
#include "cogl/cogl.h"
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
static void clutter_scriptable_iface_init (ClutterScriptableIface *iface);
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
G_DEFINE_TYPE_WITH_CODE (ClutterTexture,
|
|
|
|
clutter_texture,
|
|
|
|
CLUTTER_TYPE_ACTOR,
|
|
|
|
G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_SCRIPTABLE,
|
|
|
|
clutter_scriptable_iface_init));
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2007-07-24 17:38:35 +00:00
|
|
|
#define CLUTTER_TEXTURE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), CLUTTER_TYPE_TEXTURE, ClutterTexturePrivate))
|
|
|
|
|
2006-12-03 18:34:41 +00:00
|
|
|
struct _ClutterTexturePrivate
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2007-04-27 21:13:06 +00:00
|
|
|
gint width;
|
|
|
|
gint height;
|
|
|
|
gint max_tile_waste;
|
2008-06-07 15:08:05 +00:00
|
|
|
ClutterTextureQuality filter_quality;
|
2008-04-25 13:37:36 +00:00
|
|
|
CoglHandle texture;
|
|
|
|
gboolean no_slice;
|
2008-02-01 15:29:00 +00:00
|
|
|
|
|
|
|
ClutterActor *fbo_source;
|
2008-04-25 13:37:36 +00:00
|
|
|
CoglHandle fbo_handle;
|
|
|
|
|
|
|
|
/* Non video memory copy of image data */
|
|
|
|
guint local_data_width, local_data_height;
|
|
|
|
guint local_data_rowstride;
|
|
|
|
guint local_data_has_alpha;
|
|
|
|
guchar *local_data;
|
2008-06-13 14:58:18 +00:00
|
|
|
|
2008-11-07 17:00:54 +00:00
|
|
|
guint sync_actor_size : 1;
|
|
|
|
guint repeat_x : 1;
|
|
|
|
guint repeat_y : 1;
|
2008-06-13 14:58:18 +00:00
|
|
|
guint in_dispose : 1;
|
2008-06-23 15:31:12 +00:00
|
|
|
guint keep_aspect_ratio : 1;
|
2009-01-07 17:02:43 +00:00
|
|
|
guint load_async : 1;
|
|
|
|
|
|
|
|
GThread *load_thread;
|
2009-01-12 16:54:30 +00:00
|
|
|
guint load_idle;
|
2009-01-07 17:02:43 +00:00
|
|
|
gchar *load_filename;
|
|
|
|
CoglBitmap *load_bitmap;
|
|
|
|
GError *load_error;
|
2006-05-29 08:59:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
enum
|
|
|
|
{
|
|
|
|
PROP_0,
|
2008-04-25 13:37:36 +00:00
|
|
|
PROP_NO_SLICE,
|
2006-05-29 08:59:36 +00:00
|
|
|
PROP_MAX_TILE_WASTE,
|
|
|
|
PROP_PIXEL_FORMAT, /* Texture format */
|
|
|
|
PROP_SYNC_SIZE,
|
|
|
|
PROP_REPEAT_Y,
|
2006-06-06 20:40:40 +00:00
|
|
|
PROP_REPEAT_X,
|
2008-04-25 13:37:36 +00:00
|
|
|
PROP_FILTER_QUALITY,
|
|
|
|
PROP_COGL_TEXTURE,
|
2008-06-23 15:31:12 +00:00
|
|
|
PROP_FILENAME,
|
2009-01-07 17:02:43 +00:00
|
|
|
PROP_KEEP_ASPECT_RATIO,
|
|
|
|
PROP_LOAD_ASYNC
|
2006-05-29 08:59:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
enum
|
|
|
|
{
|
2006-12-13 18:12:09 +00:00
|
|
|
SIZE_CHANGE,
|
|
|
|
PIXBUF_CHANGE,
|
2009-01-07 17:02:43 +00:00
|
|
|
LOAD_SUCCESS,
|
|
|
|
LOAD_FINISHED,
|
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
LAST_SIGNAL
|
|
|
|
};
|
|
|
|
|
|
|
|
static int texture_signals[LAST_SIGNAL] = { 0 };
|
|
|
|
|
2008-02-03 23:25:12 +00:00
|
|
|
static void
|
|
|
|
texture_fbo_free_resources (ClutterTexture *texture);
|
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
static void
|
2008-04-25 13:37:36 +00:00
|
|
|
clutter_texture_save_to_local_data (ClutterTexture *texture);
|
2006-05-29 08:59:36 +00:00
|
|
|
|
|
|
|
static void
|
2008-04-25 13:37:36 +00:00
|
|
|
clutter_texture_load_from_local_data (ClutterTexture *texture);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
GQuark
|
|
|
|
clutter_texture_error_quark (void)
|
|
|
|
{
|
|
|
|
return g_quark_from_static_string ("clutter-texture-error-quark");
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
2008-06-07 15:08:05 +00:00
|
|
|
static COGLenum
|
|
|
|
clutter_texture_quality_to_cogl_min_filter (ClutterTextureQuality buf_filter)
|
|
|
|
{
|
|
|
|
switch (buf_filter)
|
|
|
|
{
|
|
|
|
case CLUTTER_TEXTURE_QUALITY_LOW:
|
|
|
|
return CGL_NEAREST;
|
|
|
|
case CLUTTER_TEXTURE_QUALITY_MEDIUM:
|
|
|
|
return CGL_LINEAR;
|
|
|
|
case CLUTTER_TEXTURE_QUALITY_HIGH:
|
|
|
|
return CGL_LINEAR_MIPMAP_LINEAR;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static COGLenum
|
|
|
|
clutter_texture_quality_to_cogl_mag_filter (ClutterTextureQuality buf_filter)
|
|
|
|
{
|
|
|
|
switch (buf_filter)
|
|
|
|
{
|
|
|
|
case CLUTTER_TEXTURE_QUALITY_LOW:
|
|
|
|
return CGL_NEAREST;
|
|
|
|
case CLUTTER_TEXTURE_QUALITY_MEDIUM:
|
|
|
|
case CLUTTER_TEXTURE_QUALITY_HIGH:
|
|
|
|
return CGL_LINEAR;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
static void
|
2006-09-19 19:27:16 +00:00
|
|
|
texture_free_gl_resources (ClutterTexture *texture)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
|
|
|
ClutterTexturePrivate *priv;
|
|
|
|
|
|
|
|
priv = texture->priv;
|
|
|
|
|
|
|
|
CLUTTER_MARK();
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->texture != COGL_INVALID_HANDLE)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
cogl_texture_unref (priv->texture);
|
|
|
|
priv->texture = COGL_INVALID_HANDLE;
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-09-19 19:27:16 +00:00
|
|
|
static void
|
|
|
|
clutter_texture_unrealize (ClutterActor *actor)
|
|
|
|
{
|
|
|
|
ClutterTexture *texture;
|
|
|
|
ClutterTexturePrivate *priv;
|
|
|
|
|
|
|
|
texture = CLUTTER_TEXTURE(actor);
|
|
|
|
priv = texture->priv;
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->texture == COGL_INVALID_HANDLE)
|
2006-09-19 19:27:16 +00:00
|
|
|
return;
|
|
|
|
|
2007-12-28 15:34:24 +00:00
|
|
|
/* there's no need to read the pixels back when unrealizing inside
|
|
|
|
* a dispose run, and the dispose() call will release the GL
|
|
|
|
* texture data as well, so we can safely bail out now
|
|
|
|
*/
|
2008-06-13 14:58:18 +00:00
|
|
|
if ((CLUTTER_PRIVATE_FLAGS (actor) & CLUTTER_ACTOR_IN_DESTRUCTION) ||
|
|
|
|
priv->in_dispose)
|
2007-12-28 15:34:24 +00:00
|
|
|
return;
|
|
|
|
|
2006-09-19 19:27:16 +00:00
|
|
|
CLUTTER_MARK();
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->fbo_source != COGL_INVALID_HANDLE)
|
2008-02-08 10:37:38 +00:00
|
|
|
{
|
|
|
|
/* Free up our fbo handle and texture resources, realize will recreate */
|
2008-04-25 13:37:36 +00:00
|
|
|
cogl_offscreen_unref (priv->fbo_handle);
|
|
|
|
priv->fbo_handle = COGL_INVALID_HANDLE;
|
2008-02-08 10:37:38 +00:00
|
|
|
texture_free_gl_resources (texture);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-05-28 20:09:19 +00:00
|
|
|
if (clutter_feature_available (CLUTTER_FEATURE_TEXTURE_READ_PIXELS))
|
|
|
|
{
|
2007-10-12 08:17:00 +00:00
|
|
|
/* Move image data from video to main memory.
|
|
|
|
* GL/ES cant do this - it probably makes sense
|
2007-05-28 20:09:19 +00:00
|
|
|
* to move this kind of thing into a ClutterProxyTexture
|
|
|
|
* where this behaviour can be better controlled.
|
2007-06-22 15:16:40 +00:00
|
|
|
*
|
|
|
|
* Or make it controllable via a property.
|
2007-05-28 20:09:19 +00:00
|
|
|
*/
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->local_data == NULL)
|
2007-06-07 23:51:53 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
clutter_texture_save_to_local_data (texture);
|
|
|
|
CLUTTER_NOTE (TEXTURE, "moved pixels into system mem");
|
2007-06-07 23:51:53 +00:00
|
|
|
}
|
|
|
|
|
2007-05-28 20:09:19 +00:00
|
|
|
texture_free_gl_resources (texture);
|
|
|
|
}
|
2006-09-19 19:27:16 +00:00
|
|
|
|
2006-11-22 20:52:27 +00:00
|
|
|
CLUTTER_NOTE (TEXTURE, "Texture unrealized");
|
2006-09-19 19:27:16 +00:00
|
|
|
}
|
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
static void
|
2006-06-13 13:17:45 +00:00
|
|
|
clutter_texture_realize (ClutterActor *actor)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2006-09-19 19:27:16 +00:00
|
|
|
ClutterTexture *texture;
|
|
|
|
ClutterTexturePrivate *priv;
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
texture = CLUTTER_TEXTURE(actor);
|
2006-09-19 19:27:16 +00:00
|
|
|
priv = texture->priv;
|
2006-05-29 08:59:36 +00:00
|
|
|
|
|
|
|
CLUTTER_MARK();
|
|
|
|
|
2008-02-08 10:37:38 +00:00
|
|
|
if (priv->fbo_source)
|
|
|
|
{
|
|
|
|
/* Handle FBO's */
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->texture != COGL_INVALID_HANDLE)
|
|
|
|
cogl_texture_unref (priv->texture);
|
2008-02-08 10:37:38 +00:00
|
|
|
|
2009-01-12 17:12:24 +00:00
|
|
|
priv->texture =
|
|
|
|
cogl_texture_new_with_size
|
2008-06-10 10:49:21 +00:00
|
|
|
(priv->width,
|
|
|
|
priv->height,
|
|
|
|
priv->no_slice ? -1 : priv->max_tile_waste,
|
|
|
|
priv->filter_quality == CLUTTER_TEXTURE_QUALITY_HIGH,
|
|
|
|
COGL_PIXEL_FORMAT_RGBA_8888);
|
2008-02-08 10:37:38 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
cogl_texture_set_filters (priv->texture,
|
2008-06-10 10:49:21 +00:00
|
|
|
clutter_texture_quality_to_cogl_min_filter (priv->filter_quality),
|
|
|
|
clutter_texture_quality_to_cogl_mag_filter (priv->filter_quality));
|
2008-02-08 10:37:38 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
priv->fbo_handle = cogl_offscreen_new_to_texture (priv->texture);
|
2008-02-08 10:37:38 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->fbo_handle == COGL_INVALID_HANDLE)
|
2008-02-08 10:37:38 +00:00
|
|
|
{
|
|
|
|
g_warning ("%s: Offscreen texture creation failed", G_STRLOC);
|
|
|
|
CLUTTER_ACTOR_UNSET_FLAGS (actor, CLUTTER_ACTOR_REALIZED);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
clutter_actor_set_size (actor, priv->width, priv->height);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->local_data != NULL)
|
2006-09-19 19:27:16 +00:00
|
|
|
{
|
2007-10-12 08:17:00 +00:00
|
|
|
/* Move any local image data we have from unrealization
|
|
|
|
* back into video memory.
|
2006-09-19 19:27:16 +00:00
|
|
|
*/
|
2008-04-25 13:37:36 +00:00
|
|
|
clutter_texture_load_from_local_data (texture);
|
2006-09-19 19:27:16 +00:00
|
|
|
}
|
|
|
|
else
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2007-06-07 23:51:53 +00:00
|
|
|
if (clutter_feature_available (CLUTTER_FEATURE_TEXTURE_READ_PIXELS))
|
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
/* Dont allow realization with no data - note set_data
|
2007-10-12 08:17:00 +00:00
|
|
|
* will set realize flags.
|
2008-04-25 13:37:36 +00:00
|
|
|
*/
|
2007-06-07 23:51:53 +00:00
|
|
|
CLUTTER_NOTE (TEXTURE,
|
|
|
|
"Texture has no image data cannot realize");
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-07 23:51:53 +00:00
|
|
|
CLUTTER_NOTE (TEXTURE, "flags %i", actor->flags);
|
|
|
|
CLUTTER_ACTOR_UNSET_FLAGS (actor, CLUTTER_ACTOR_REALIZED);
|
|
|
|
CLUTTER_NOTE (TEXTURE, "flags %i", actor->flags);
|
|
|
|
return;
|
|
|
|
}
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:52:27 +00:00
|
|
|
CLUTTER_NOTE (TEXTURE, "Texture realized");
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
static void
|
|
|
|
clutter_texture_get_preferred_width (ClutterActor *self,
|
|
|
|
ClutterUnit for_height,
|
|
|
|
ClutterUnit *min_width_p,
|
|
|
|
ClutterUnit *natural_width_p)
|
|
|
|
{
|
|
|
|
ClutterTexture *texture = CLUTTER_TEXTURE (self);
|
|
|
|
ClutterTexturePrivate *priv = texture->priv;
|
|
|
|
|
|
|
|
/* Min request is always 0 since we can scale down or clip */
|
|
|
|
if (min_width_p)
|
|
|
|
*min_width_p = 0;
|
|
|
|
|
|
|
|
if (priv->sync_actor_size)
|
|
|
|
{
|
|
|
|
if (natural_width_p)
|
2008-06-17 14:45:33 +00:00
|
|
|
{
|
2008-06-23 15:31:12 +00:00
|
|
|
if (!priv->keep_aspect_ratio ||
|
|
|
|
for_height < 0 ||
|
|
|
|
priv->height <= 0)
|
|
|
|
{
|
|
|
|
*natural_width_p = CLUTTER_UNITS_FROM_DEVICE (priv->width);
|
|
|
|
}
|
2008-06-17 14:45:33 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Set the natural width so as to preserve the aspect ratio */
|
2008-06-23 15:31:12 +00:00
|
|
|
ClutterFixed ratio, height;
|
|
|
|
|
2008-11-18 13:52:22 +00:00
|
|
|
ratio = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (priv->width),
|
2008-10-30 16:37:55 +00:00
|
|
|
COGL_FIXED_FROM_INT (priv->height));
|
2008-06-23 15:31:12 +00:00
|
|
|
|
|
|
|
height = CLUTTER_UNITS_TO_FIXED (for_height);
|
|
|
|
|
|
|
|
*natural_width_p =
|
2008-10-30 16:37:55 +00:00
|
|
|
CLUTTER_UNITS_FROM_FIXED (COGL_FIXED_MUL (ratio, height));
|
2008-06-17 14:45:33 +00:00
|
|
|
}
|
|
|
|
}
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (natural_width_p)
|
|
|
|
*natural_width_p = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_texture_get_preferred_height (ClutterActor *self,
|
|
|
|
ClutterUnit for_width,
|
|
|
|
ClutterUnit *min_height_p,
|
|
|
|
ClutterUnit *natural_height_p)
|
|
|
|
{
|
|
|
|
ClutterTexture *texture = CLUTTER_TEXTURE (self);
|
|
|
|
ClutterTexturePrivate *priv = texture->priv;
|
|
|
|
|
|
|
|
/* Min request is always 0 since we can scale down or clip */
|
|
|
|
if (min_height_p)
|
|
|
|
*min_height_p = 0;
|
|
|
|
|
|
|
|
if (priv->sync_actor_size)
|
|
|
|
{
|
|
|
|
if (natural_height_p)
|
2008-06-17 14:45:33 +00:00
|
|
|
{
|
2008-06-23 15:31:12 +00:00
|
|
|
if (!priv->keep_aspect_ratio ||
|
|
|
|
for_width < 0 ||
|
|
|
|
priv->width <= 0)
|
|
|
|
{
|
|
|
|
*natural_height_p = CLUTTER_UNITS_FROM_DEVICE (priv->height);
|
|
|
|
}
|
2008-06-17 14:45:33 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Set the natural height so as to preserve the aspect ratio */
|
2008-06-23 15:31:12 +00:00
|
|
|
ClutterFixed ratio, width;
|
2008-12-23 16:29:29 +00:00
|
|
|
|
2008-10-30 16:37:55 +00:00
|
|
|
ratio = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (priv->height),
|
|
|
|
COGL_FIXED_FROM_INT (priv->width));
|
2008-06-23 15:31:12 +00:00
|
|
|
|
|
|
|
width = CLUTTER_UNITS_TO_FIXED (for_width);
|
2008-12-23 16:29:29 +00:00
|
|
|
|
2008-06-23 15:31:12 +00:00
|
|
|
*natural_height_p =
|
2008-10-30 16:37:55 +00:00
|
|
|
CLUTTER_UNITS_FROM_FIXED (COGL_FIXED_MUL (ratio, width));
|
2008-06-17 14:45:33 +00:00
|
|
|
}
|
|
|
|
}
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (natural_height_p)
|
|
|
|
*natural_height_p = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-04 10:44:18 +00:00
|
|
|
static void
|
|
|
|
clutter_texture_allocate (ClutterActor *self,
|
|
|
|
const ClutterActorBox *box,
|
|
|
|
gboolean origin_changed)
|
|
|
|
{
|
|
|
|
ClutterTexturePrivate *priv = CLUTTER_TEXTURE (self)->priv;
|
|
|
|
|
|
|
|
/* chain up to set actor->allocation */
|
|
|
|
CLUTTER_ACTOR_CLASS (clutter_texture_parent_class)->allocate (self, box,
|
|
|
|
origin_changed);
|
|
|
|
|
|
|
|
/* If we adopted the source fbo then allocate that at its preferred
|
|
|
|
size */
|
|
|
|
if (priv->fbo_source && clutter_actor_get_parent (priv->fbo_source) == self)
|
|
|
|
clutter_actor_allocate_preferred_size (priv->fbo_source, origin_changed);
|
|
|
|
}
|
|
|
|
|
2008-08-01 12:23:57 +00:00
|
|
|
static void
|
|
|
|
clutter_texture_set_fbo_projection (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterTexturePrivate *priv = CLUTTER_TEXTURE (self)->priv;
|
|
|
|
ClutterVertex verts[4];
|
|
|
|
ClutterFixed viewport[4];
|
2008-12-19 13:42:17 +00:00
|
|
|
ClutterUnit x_min, x_max, y_min, y_max;
|
|
|
|
ClutterFixed tx_min, tx_max, ty_min, ty_max;
|
2008-08-01 12:23:57 +00:00
|
|
|
ClutterPerspective perspective;
|
|
|
|
ClutterStage *stage;
|
|
|
|
ClutterFixed tan_angle, near_size;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Get the bounding rectangle of the source as drawn in screen
|
|
|
|
coordinates */
|
|
|
|
clutter_actor_get_abs_allocation_vertices (priv->fbo_source, verts);
|
|
|
|
|
|
|
|
x_min = x_max = verts[0].x;
|
|
|
|
y_min = y_max = verts[0].y;
|
|
|
|
|
|
|
|
for (i = 1; i < G_N_ELEMENTS (verts); ++i)
|
|
|
|
{
|
|
|
|
if (verts[i].x < x_min)
|
|
|
|
x_min = verts[i].x;
|
|
|
|
|
|
|
|
if (verts[i].x > x_max)
|
|
|
|
x_max = verts[i].x;
|
|
|
|
|
|
|
|
if (verts[i].y < y_min)
|
|
|
|
y_min = verts[i].y;
|
|
|
|
|
|
|
|
if (verts[i].y > y_max)
|
|
|
|
y_max = verts[i].y;
|
|
|
|
}
|
|
|
|
|
|
|
|
stage = CLUTTER_STAGE (clutter_actor_get_stage (self));
|
|
|
|
clutter_stage_get_perspectivex (stage, &perspective);
|
|
|
|
|
|
|
|
/* Convert the coordinates back to [-1,1] range */
|
|
|
|
cogl_get_viewport (viewport);
|
2008-12-19 13:42:17 +00:00
|
|
|
|
|
|
|
tx_min = COGL_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (x_min), viewport[2])
|
|
|
|
* 2 - COGL_FIXED_1;
|
|
|
|
tx_max = COGL_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (x_max), viewport[2])
|
|
|
|
* 2 - COGL_FIXED_1;
|
|
|
|
ty_min = COGL_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (y_min), viewport[3])
|
|
|
|
* 2 - COGL_FIXED_1;
|
|
|
|
ty_max = COGL_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (y_max), viewport[3])
|
|
|
|
* 2 - COGL_FIXED_1;
|
2008-08-01 12:23:57 +00:00
|
|
|
|
|
|
|
/* Set up a projection matrix so that the actor will be projected as
|
|
|
|
if it was drawn at its original location */
|
2008-12-19 13:42:17 +00:00
|
|
|
tan_angle = cogl_angle_tan (COGL_ANGLE_FROM_DEGX (perspective.fovy / 2));
|
2008-10-30 16:37:55 +00:00
|
|
|
near_size = COGL_FIXED_MUL (perspective.z_near, tan_angle);
|
2008-08-01 12:23:57 +00:00
|
|
|
|
2008-12-19 13:42:17 +00:00
|
|
|
cogl_frustum (COGL_FIXED_MUL (tx_min, near_size),
|
|
|
|
COGL_FIXED_MUL (tx_max, near_size),
|
|
|
|
COGL_FIXED_MUL (-ty_min, near_size),
|
|
|
|
COGL_FIXED_MUL (-ty_max, near_size),
|
|
|
|
perspective.z_near, perspective.z_far);
|
2008-08-01 12:23:57 +00:00
|
|
|
}
|
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
static void
|
2006-06-13 13:17:45 +00:00
|
|
|
clutter_texture_paint (ClutterActor *self)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2007-03-19 10:00:38 +00:00
|
|
|
ClutterTexture *texture = CLUTTER_TEXTURE (self);
|
2007-07-26 11:04:04 +00:00
|
|
|
ClutterTexturePrivate *priv = texture->priv;
|
|
|
|
gint x_1, y_1, x_2, y_2;
|
2008-10-30 16:50:07 +00:00
|
|
|
CoglColor transparent_col;
|
2008-04-25 13:37:36 +00:00
|
|
|
ClutterFixed t_w, t_h;
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2007-07-23 17:02:52 +00:00
|
|
|
if (!CLUTTER_ACTOR_IS_REALIZED (CLUTTER_ACTOR(texture)))
|
|
|
|
clutter_actor_realize (CLUTTER_ACTOR(texture));
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->fbo_handle != COGL_INVALID_HANDLE)
|
2008-02-01 15:29:00 +00:00
|
|
|
{
|
2008-02-04 11:45:12 +00:00
|
|
|
ClutterMainContext *context;
|
2008-02-08 10:37:38 +00:00
|
|
|
ClutterShader *shader = NULL;
|
2008-08-01 12:23:57 +00:00
|
|
|
ClutterActor *stage = NULL;
|
|
|
|
ClutterPerspective perspective;
|
2008-02-04 11:45:12 +00:00
|
|
|
|
|
|
|
context = clutter_context_get_default ();
|
|
|
|
|
2008-02-08 10:37:38 +00:00
|
|
|
if (context->shaders)
|
|
|
|
shader = clutter_actor_get_shader (context->shaders->data);
|
|
|
|
|
2008-02-04 11:45:12 +00:00
|
|
|
/* Temporarily turn of the shader on the top of the context's
|
|
|
|
* shader stack, to restore the GL pipeline to it's natural state.
|
|
|
|
*/
|
2008-02-08 10:37:38 +00:00
|
|
|
if (shader)
|
|
|
|
clutter_shader_set_is_enabled (shader, FALSE);
|
2008-02-04 11:45:12 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
/* Redirect drawing to the fbo */
|
|
|
|
cogl_draw_buffer (COGL_OFFSCREEN_BUFFER, priv->fbo_handle);
|
|
|
|
|
2008-08-01 12:23:57 +00:00
|
|
|
if ((stage = clutter_actor_get_stage (self)))
|
|
|
|
{
|
|
|
|
guint stage_width, stage_height;
|
|
|
|
ClutterActor *source_parent;
|
|
|
|
|
|
|
|
clutter_stage_get_perspectivex (CLUTTER_STAGE (stage), &perspective);
|
|
|
|
clutter_actor_get_size (stage, &stage_width, &stage_height);
|
|
|
|
|
|
|
|
/* Use below to set the modelview matrix as if the viewport
|
|
|
|
was still the same size as the stage */
|
|
|
|
cogl_setup_viewport (stage_width, stage_height,
|
|
|
|
perspective.fovy,
|
|
|
|
perspective.aspect,
|
|
|
|
perspective.z_near,
|
|
|
|
perspective.z_far);
|
|
|
|
/* Use a projection matrix that makes the actor appear as it
|
|
|
|
would if it was rendered at its normal screen location */
|
|
|
|
clutter_texture_set_fbo_projection (self);
|
|
|
|
/* Reset the viewport to the size of the FBO */
|
|
|
|
cogl_viewport (priv->width, priv->height);
|
|
|
|
/* Reapply the source's parent transformations */
|
|
|
|
if ((source_parent = clutter_actor_get_parent (priv->fbo_source)))
|
|
|
|
_clutter_actor_apply_modelview_transform_recursive (source_parent,
|
|
|
|
NULL);
|
|
|
|
}
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
/* cogl_paint_init is called to clear the buffers */
|
2008-10-30 16:50:07 +00:00
|
|
|
cogl_color_set_from_4ub (&transparent_col, 0, 0, 0, 0);
|
2008-04-25 13:37:36 +00:00
|
|
|
cogl_paint_init (&transparent_col);
|
2008-02-08 10:37:38 +00:00
|
|
|
|
2008-08-01 12:23:57 +00:00
|
|
|
/* Clear the clipping stack so that if the FBO actor is being
|
|
|
|
clipped then it won't affect drawing the source */
|
|
|
|
cogl_clip_stack_save ();
|
|
|
|
|
2008-02-08 10:37:38 +00:00
|
|
|
/* Render out actor scene to fbo */
|
2008-02-01 15:29:00 +00:00
|
|
|
clutter_actor_paint (priv->fbo_source);
|
2008-02-08 10:37:38 +00:00
|
|
|
|
2008-08-01 12:23:57 +00:00
|
|
|
cogl_clip_stack_restore ();
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
/* Restore drawing to the frame buffer */
|
|
|
|
cogl_draw_buffer (COGL_WINDOW_BUFFER, COGL_INVALID_HANDLE);
|
2008-02-01 15:29:00 +00:00
|
|
|
|
2008-08-01 12:23:57 +00:00
|
|
|
/* Restore the perspective matrix using cogl_perspective so that
|
|
|
|
the inverse matrix will be right */
|
2008-12-19 13:42:17 +00:00
|
|
|
cogl_perspective (perspective.fovy,
|
|
|
|
perspective.aspect,
|
|
|
|
perspective.z_near,
|
|
|
|
perspective.z_far);
|
2008-08-01 12:23:57 +00:00
|
|
|
|
2008-02-04 11:45:12 +00:00
|
|
|
/* If there is a shader on top of the shader stack, turn it back on. */
|
2008-02-08 10:37:38 +00:00
|
|
|
if (shader)
|
|
|
|
clutter_shader_set_is_enabled (shader, TRUE);
|
|
|
|
}
|
2008-02-01 15:29:00 +00:00
|
|
|
|
2008-11-07 16:31:56 +00:00
|
|
|
/* A clone may need to fire above if were a TFP/FBO but not visible.
|
|
|
|
* Ultimatly needs some reworking with maybe an extra prepare_paint
|
|
|
|
* method or some such.
|
|
|
|
*/
|
|
|
|
if (CLUTTER_PRIVATE_FLAGS(self) & CLUTTER_TEXTURE_IN_CLONE_PAINT)
|
|
|
|
return;
|
|
|
|
|
2006-11-21 Emmanuele Bassi <ebassi@openedhand.com>
* configure.ac: Enable debug messages also when
--enable-debug is set to "minimum".
* clutter/Makefile.am:
* clutter/clutter-debug.h: Move all debugging macros inside
this private header; make all debug macros depend on the
CLUTTER_ENABLE_DEBUG compile time define, controlled by
the --enable-debug configure switch; add G_LOG_DOMAIN define.
* clutter/clutter-main.c: Clean up the debug stuff; add
command line argument parsing using GOption; the debug
messages now are triggered like this:
CLUTTER_DEBUG=section:section:... clutter-app
or like this:
clutter-app --clutter-debug=section:section:...
where "section" is one of the sections listed in clutter-main.c,
or "all", for all sections; each section is bound to a flag,
which can be used to define a domain when adding a debug note
using the CLUTTER_NOTE() macro; the old CLUTTER_DBG() macro is
just a wrapper around that, under the CLUTTER_DEBUG_MISC domain;
CLUTTER_NOTE() is used like this:
CLUTTER_NOTE (DOMAIN, log-function);
where log function is g_printerr(), g_message(), g_warning(),
g_critical() or directly g_log() - for instance:
CLUTTER_NOTE (PANGO, g_warning ("Cache miss: %d", glyph));
will print the warning only if the "pango" flag has been
set to the CLUTTER_DEBUG envvar or passed to the --clutter-debug
command line argument.
similar to CLUTTER_SHOW_FPS, there's also the --clutter-show-fps
command line switch; also, the --display and --screen command
line switches have been added: the first overrides the DISPLAY
envvar and the second controls the X screen used by Clutter to
get the root window on the display.
* clutter/clutter-main.h:
* clutter/clutter-main.c: Add extended support for GOption
in Clutter; use clutter_init_with_args() to let Clutter
parse your own command line arguments; use instead
clutter_get_option_group() to get the GOptionGroup used by
Clutter if you want to do the parsing yourself with
g_option_context_parse(). The init sequence has been verified,
updated and moved into common functions where possible.
* clutter/pango/pangoclutter-render.c:
* clutter/*.c: Include "clutter-debug.h" where needed; use
CLUTTER_NOTE() instead of CLUTTER_DBG().
* examples/super-oh.c: Use the new clutter_init_with_args()
function, and add a --num-hands command line switch to
the SuperOH example code controlling the number of hands at
runtime.
2006-11-21 21:27:53 +00:00
|
|
|
CLUTTER_NOTE (PAINT,
|
2007-04-27 21:13:06 +00:00
|
|
|
"painting texture '%s'",
|
2006-11-22 20:52:27 +00:00
|
|
|
clutter_actor_get_name (self) ? clutter_actor_get_name (self)
|
2007-03-19 10:00:38 +00:00
|
|
|
: "unknown");
|
2008-10-30 16:50:07 +00:00
|
|
|
|
2008-11-12 13:57:58 +00:00
|
|
|
cogl_set_source_color4ub (255, 255, 255,
|
|
|
|
clutter_actor_get_paint_opacity (self));
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
clutter_actor_get_allocation_coords (self, &x_1, &y_1, &x_2, &y_2);
|
2007-04-27 21:13:06 +00:00
|
|
|
|
|
|
|
CLUTTER_NOTE (PAINT, "paint to x1: %i, y1: %i x2: %i, y2: %i "
|
2007-07-26 11:04:04 +00:00
|
|
|
"opacity: %i",
|
|
|
|
x_1, y_1, x_2, y_2,
|
2007-04-27 21:13:06 +00:00
|
|
|
clutter_actor_get_opacity (self));
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->repeat_x && priv->width > 0)
|
2008-10-30 16:37:55 +00:00
|
|
|
t_w = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (x_2 - x_1),
|
|
|
|
COGL_FIXED_FROM_INT (priv->width));
|
2008-04-25 13:37:36 +00:00
|
|
|
else
|
2008-10-30 16:37:55 +00:00
|
|
|
t_w = COGL_FIXED_1;
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->repeat_y && priv->height > 0)
|
2008-10-30 16:37:55 +00:00
|
|
|
t_h = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (y_2 - y_1),
|
|
|
|
COGL_FIXED_FROM_INT (priv->height));
|
2008-04-25 13:37:36 +00:00
|
|
|
else
|
2008-10-30 16:37:55 +00:00
|
|
|
t_h = COGL_FIXED_1;
|
2008-04-25 13:37:36 +00:00
|
|
|
|
|
|
|
/* Paint will have translated us */
|
|
|
|
cogl_texture_rectangle (priv->texture, 0, 0,
|
2008-12-19 13:42:17 +00:00
|
|
|
COGL_FIXED_FROM_INT (x_2 - x_1),
|
|
|
|
COGL_FIXED_FROM_INT (y_2 - y_1),
|
|
|
|
0, 0, t_w, t_h);
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
2009-01-12 16:54:30 +00:00
|
|
|
/*
|
|
|
|
* clutter_texture_async_load_cancel:
|
|
|
|
* @texture: a #ClutterTexture
|
|
|
|
*
|
|
|
|
* Cancels an asynchronous loading operation, whether done
|
|
|
|
* with threads enabled or just using the main loop
|
|
|
|
*/
|
2009-01-07 17:02:43 +00:00
|
|
|
static void
|
2009-01-12 16:54:30 +00:00
|
|
|
clutter_texture_async_load_cancel (ClutterTexture *texture)
|
2009-01-07 17:02:43 +00:00
|
|
|
{
|
|
|
|
ClutterTexturePrivate *priv = texture->priv;
|
|
|
|
|
|
|
|
if (priv->load_thread)
|
|
|
|
{
|
|
|
|
g_thread_join (priv->load_thread);
|
|
|
|
priv->load_thread = NULL;
|
|
|
|
}
|
2009-01-12 16:54:30 +00:00
|
|
|
|
|
|
|
if (priv->load_idle)
|
2009-01-07 17:02:43 +00:00
|
|
|
{
|
2009-01-12 16:54:30 +00:00
|
|
|
g_source_remove (priv->load_idle);
|
|
|
|
priv->load_idle = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (priv->load_error)
|
|
|
|
{
|
|
|
|
g_error_free (priv->load_error);
|
|
|
|
priv->load_error = NULL;
|
2009-01-07 17:02:43 +00:00
|
|
|
}
|
2009-01-12 16:54:30 +00:00
|
|
|
|
|
|
|
if (priv->load_bitmap)
|
|
|
|
{
|
|
|
|
cogl_bitmap_free (priv->load_bitmap);
|
|
|
|
priv->load_bitmap = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_free (priv->load_filename);
|
2009-01-07 17:02:43 +00:00
|
|
|
}
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
static void
|
2006-05-29 08:59:36 +00:00
|
|
|
clutter_texture_dispose (GObject *object)
|
|
|
|
{
|
2007-07-26 11:04:04 +00:00
|
|
|
ClutterTexture *texture = CLUTTER_TEXTURE (object);
|
2006-05-29 08:59:36 +00:00
|
|
|
ClutterTexturePrivate *priv;
|
|
|
|
|
2006-09-19 19:27:16 +00:00
|
|
|
priv = texture->priv;
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-06-13 14:58:18 +00:00
|
|
|
/* mark that we are in dispose, so when the parent class'
|
|
|
|
* dispose implementation will call unrealize on us we'll
|
|
|
|
* not try to copy back the resources from video memory
|
|
|
|
* to system memory
|
|
|
|
*/
|
|
|
|
if (!priv->in_dispose)
|
|
|
|
priv->in_dispose = TRUE;
|
|
|
|
|
2007-07-24 17:38:35 +00:00
|
|
|
texture_free_gl_resources (texture);
|
2008-02-03 23:25:12 +00:00
|
|
|
texture_fbo_free_resources (texture);
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->local_data != NULL)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
g_free (priv->local_data);
|
|
|
|
priv->local_data = NULL;
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
2009-01-07 17:02:43 +00:00
|
|
|
|
2009-01-12 16:54:30 +00:00
|
|
|
clutter_texture_async_load_cancel (texture);
|
2009-01-07 17:02:43 +00:00
|
|
|
|
2007-07-24 17:38:35 +00:00
|
|
|
G_OBJECT_CLASS (clutter_texture_parent_class)->dispose (object);
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2007-10-12 08:17:00 +00:00
|
|
|
clutter_texture_set_property (GObject *object,
|
2006-05-29 08:59:36 +00:00
|
|
|
guint prop_id,
|
2007-10-12 08:17:00 +00:00
|
|
|
const GValue *value,
|
2006-05-29 08:59:36 +00:00
|
|
|
GParamSpec *pspec)
|
|
|
|
{
|
|
|
|
ClutterTexture *texture;
|
|
|
|
ClutterTexturePrivate *priv;
|
|
|
|
|
|
|
|
texture = CLUTTER_TEXTURE(object);
|
|
|
|
priv = texture->priv;
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
switch (prop_id)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
|
|
|
case PROP_MAX_TILE_WASTE:
|
2008-04-25 13:37:36 +00:00
|
|
|
clutter_texture_set_max_tile_waste (texture,
|
|
|
|
g_value_get_int (value));
|
2006-05-29 08:59:36 +00:00
|
|
|
break;
|
|
|
|
case PROP_SYNC_SIZE:
|
2006-06-13 13:17:45 +00:00
|
|
|
priv->sync_actor_size = g_value_get_boolean (value);
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
clutter_actor_queue_relayout (CLUTTER_ACTOR (texture));
|
2006-05-29 08:59:36 +00:00
|
|
|
break;
|
|
|
|
case PROP_REPEAT_X:
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->repeat_x != g_value_get_boolean (value))
|
|
|
|
{
|
|
|
|
priv->repeat_x = !priv->repeat_x;
|
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (texture))
|
|
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (texture));
|
|
|
|
}
|
2006-05-29 08:59:36 +00:00
|
|
|
break;
|
|
|
|
case PROP_REPEAT_Y:
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->repeat_y != g_value_get_boolean (value))
|
|
|
|
{
|
|
|
|
priv->repeat_y = !priv->repeat_y;
|
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (texture))
|
|
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (texture));
|
|
|
|
}
|
2006-05-29 08:59:36 +00:00
|
|
|
break;
|
2006-06-06 20:40:40 +00:00
|
|
|
case PROP_FILTER_QUALITY:
|
2008-04-25 13:37:36 +00:00
|
|
|
clutter_texture_set_filter_quality (texture,
|
2008-06-07 15:08:05 +00:00
|
|
|
g_value_get_enum (value));
|
2008-04-25 13:37:36 +00:00
|
|
|
break;
|
|
|
|
case PROP_COGL_TEXTURE:
|
|
|
|
clutter_texture_set_cogl_texture
|
|
|
|
(texture, (CoglHandle) g_value_get_boxed (value));
|
|
|
|
break;
|
|
|
|
case PROP_FILENAME:
|
|
|
|
clutter_texture_set_from_file (texture,
|
|
|
|
g_value_get_string (value),
|
|
|
|
NULL);
|
|
|
|
break;
|
|
|
|
case PROP_NO_SLICE:
|
|
|
|
priv->no_slice = g_value_get_boolean (value);
|
2006-06-06 20:40:40 +00:00
|
|
|
break;
|
2008-06-23 15:31:12 +00:00
|
|
|
case PROP_KEEP_ASPECT_RATIO:
|
|
|
|
priv->keep_aspect_ratio = g_value_get_boolean (value);
|
|
|
|
break;
|
2009-01-07 17:02:43 +00:00
|
|
|
case PROP_LOAD_ASYNC:
|
|
|
|
priv->load_async = g_value_get_boolean (value);
|
|
|
|
break;
|
2006-05-29 08:59:36 +00:00
|
|
|
default:
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2007-10-12 08:17:00 +00:00
|
|
|
clutter_texture_get_property (GObject *object,
|
2006-05-29 08:59:36 +00:00
|
|
|
guint prop_id,
|
2007-10-12 08:17:00 +00:00
|
|
|
GValue *value,
|
2006-05-29 08:59:36 +00:00
|
|
|
GParamSpec *pspec)
|
|
|
|
{
|
|
|
|
ClutterTexture *texture;
|
|
|
|
ClutterTexturePrivate *priv;
|
|
|
|
|
|
|
|
texture = CLUTTER_TEXTURE(object);
|
|
|
|
priv = texture->priv;
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
switch (prop_id)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
|
|
|
case PROP_MAX_TILE_WASTE:
|
2008-04-25 13:37:36 +00:00
|
|
|
g_value_set_int (value, clutter_texture_get_max_tile_waste (texture));
|
2006-05-29 08:59:36 +00:00
|
|
|
break;
|
|
|
|
case PROP_PIXEL_FORMAT:
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->texture == COGL_INVALID_HANDLE)
|
|
|
|
g_value_set_int (value, COGL_PIXEL_FORMAT_ANY);
|
|
|
|
else
|
|
|
|
g_value_set_int (value, cogl_texture_get_format (priv->texture));
|
2006-05-29 08:59:36 +00:00
|
|
|
break;
|
|
|
|
case PROP_SYNC_SIZE:
|
2006-06-13 13:17:45 +00:00
|
|
|
g_value_set_boolean (value, priv->sync_actor_size);
|
2006-05-29 08:59:36 +00:00
|
|
|
break;
|
|
|
|
case PROP_REPEAT_X:
|
|
|
|
g_value_set_boolean (value, priv->repeat_x);
|
|
|
|
break;
|
|
|
|
case PROP_REPEAT_Y:
|
|
|
|
g_value_set_boolean (value, priv->repeat_y);
|
|
|
|
break;
|
2006-06-06 20:40:40 +00:00
|
|
|
case PROP_FILTER_QUALITY:
|
2008-06-07 15:08:05 +00:00
|
|
|
g_value_set_enum (value, clutter_texture_get_filter_quality (texture));
|
2008-04-25 13:37:36 +00:00
|
|
|
break;
|
|
|
|
case PROP_COGL_TEXTURE:
|
|
|
|
g_value_set_boxed (value, clutter_texture_get_cogl_texture (texture));
|
|
|
|
break;
|
|
|
|
case PROP_NO_SLICE:
|
|
|
|
g_value_set_boolean (value, priv->no_slice);
|
2006-06-06 20:40:40 +00:00
|
|
|
break;
|
2008-06-23 15:31:12 +00:00
|
|
|
case PROP_KEEP_ASPECT_RATIO:
|
|
|
|
g_value_set_boolean (value, priv->keep_aspect_ratio);
|
|
|
|
break;
|
2009-01-07 17:02:43 +00:00
|
|
|
case PROP_LOAD_ASYNC:
|
|
|
|
g_value_set_boolean (value, priv->load_async);
|
|
|
|
break;
|
2006-05-29 08:59:36 +00:00
|
|
|
default:
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
break;
|
2007-10-12 08:17:00 +00:00
|
|
|
}
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_texture_class_init (ClutterTextureClass *klass)
|
|
|
|
{
|
|
|
|
GObjectClass *gobject_class;
|
2006-06-13 13:17:45 +00:00
|
|
|
ClutterActorClass *actor_class;
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2007-07-24 17:38:35 +00:00
|
|
|
gobject_class = (GObjectClass*) klass;
|
|
|
|
actor_class = (ClutterActorClass*) klass;
|
|
|
|
|
|
|
|
g_type_class_add_private (klass, sizeof (ClutterTexturePrivate));
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2007-11-15 17:38:40 +00:00
|
|
|
actor_class->paint = clutter_texture_paint;
|
|
|
|
actor_class->realize = clutter_texture_realize;
|
|
|
|
actor_class->unrealize = clutter_texture_unrealize;
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
|
2008-07-04 10:44:18 +00:00
|
|
|
actor_class->get_preferred_width = clutter_texture_get_preferred_width;
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
actor_class->get_preferred_height = clutter_texture_get_preferred_height;
|
2008-07-04 10:44:18 +00:00
|
|
|
actor_class->allocate = clutter_texture_allocate;
|
2006-05-29 08:59:36 +00:00
|
|
|
|
|
|
|
gobject_class->dispose = clutter_texture_dispose;
|
|
|
|
gobject_class->set_property = clutter_texture_set_property;
|
|
|
|
gobject_class->get_property = clutter_texture_get_property;
|
|
|
|
|
|
|
|
g_object_class_install_property
|
|
|
|
(gobject_class, PROP_SYNC_SIZE,
|
|
|
|
g_param_spec_boolean ("sync-size",
|
2006-06-13 13:17:45 +00:00
|
|
|
"Sync size of actor",
|
2008-02-15 15:49:44 +00:00
|
|
|
"Auto sync size of actor to underlying pixbuf "
|
|
|
|
"dimensions",
|
2006-05-29 08:59:36 +00:00
|
|
|
TRUE,
|
2007-11-15 17:38:40 +00:00
|
|
|
CLUTTER_PARAM_READWRITE));
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
g_object_class_install_property
|
|
|
|
(gobject_class, PROP_NO_SLICE,
|
|
|
|
g_param_spec_boolean ("disable-slicing",
|
|
|
|
"Disable Slicing",
|
|
|
|
"Force the underlying texture to be singlular"
|
|
|
|
"and not made of of smaller space saving "
|
|
|
|
"inidivual textures.",
|
|
|
|
FALSE,
|
|
|
|
G_PARAM_CONSTRUCT_ONLY | CLUTTER_PARAM_READWRITE));
|
|
|
|
|
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
g_object_class_install_property
|
|
|
|
(gobject_class, PROP_REPEAT_X,
|
|
|
|
g_param_spec_boolean ("repeat-x",
|
|
|
|
"Tile underlying pixbuf in x direction",
|
2008-04-25 13:37:36 +00:00
|
|
|
"Repeat underlying pixbuf rather than scale "
|
|
|
|
"in x direction.",
|
2006-05-29 08:59:36 +00:00
|
|
|
FALSE,
|
2007-11-15 17:38:40 +00:00
|
|
|
CLUTTER_PARAM_READWRITE));
|
2006-05-29 08:59:36 +00:00
|
|
|
|
|
|
|
g_object_class_install_property
|
|
|
|
(gobject_class, PROP_REPEAT_Y,
|
|
|
|
g_param_spec_boolean ("repeat-y",
|
|
|
|
"Tile underlying pixbuf in y direction",
|
2008-04-25 13:37:36 +00:00
|
|
|
"Repeat underlying pixbuf rather than scale "
|
|
|
|
"in y direction.",
|
2006-05-29 08:59:36 +00:00
|
|
|
FALSE,
|
2007-11-15 17:38:40 +00:00
|
|
|
CLUTTER_PARAM_READWRITE));
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2006-06-06 20:40:40 +00:00
|
|
|
g_object_class_install_property
|
|
|
|
(gobject_class, PROP_FILTER_QUALITY,
|
2008-06-07 15:08:05 +00:00
|
|
|
g_param_spec_enum ("filter-quality",
|
|
|
|
"Filter Quality",
|
|
|
|
"Rendering quality used when drawing the texture.",
|
|
|
|
CLUTTER_TYPE_TEXTURE_QUALITY,
|
|
|
|
CLUTTER_TEXTURE_QUALITY_MEDIUM,
|
|
|
|
G_PARAM_CONSTRUCT | CLUTTER_PARAM_READWRITE));
|
2006-06-06 20:40:40 +00:00
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
g_object_class_install_property
|
|
|
|
(gobject_class, PROP_MAX_TILE_WASTE,
|
|
|
|
g_param_spec_int ("tile-waste",
|
2008-02-15 15:49:44 +00:00
|
|
|
"Tile dimension to waste",
|
|
|
|
"Max wastage dimension of a texture when using "
|
2008-04-25 13:37:36 +00:00
|
|
|
"sliced textures or -1 to disable slicing. "
|
|
|
|
"Bigger values use less textures, "
|
2008-02-15 15:49:44 +00:00
|
|
|
"smaller values less texture memory.",
|
2008-04-25 13:37:36 +00:00
|
|
|
-1,
|
2006-05-29 08:59:36 +00:00
|
|
|
G_MAXINT,
|
2009-01-11 00:25:27 +00:00
|
|
|
63,
|
2006-12-04 16:26:35 +00:00
|
|
|
G_PARAM_CONSTRUCT_ONLY | CLUTTER_PARAM_READWRITE));
|
2006-05-29 08:59:36 +00:00
|
|
|
|
|
|
|
g_object_class_install_property
|
|
|
|
(gobject_class, PROP_PIXEL_FORMAT,
|
|
|
|
g_param_spec_int ("pixel-format",
|
|
|
|
"Texture pixel format",
|
2008-04-25 13:37:36 +00:00
|
|
|
"CoglPixelFormat to use.",
|
2006-05-29 08:59:36 +00:00
|
|
|
0,
|
|
|
|
G_MAXINT,
|
2008-04-25 13:37:36 +00:00
|
|
|
COGL_PIXEL_FORMAT_RGBA_8888,
|
2007-05-25 10:56:09 +00:00
|
|
|
G_PARAM_READABLE));
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
g_object_class_install_property
|
|
|
|
(gobject_class, PROP_COGL_TEXTURE,
|
|
|
|
g_param_spec_boxed ("cogl-texture",
|
|
|
|
"COGL Texture",
|
|
|
|
"The underlying COGL texture handle used to draw "
|
|
|
|
"this actor",
|
|
|
|
CLUTTER_TYPE_TEXTURE_HANDLE,
|
|
|
|
G_PARAM_READWRITE));
|
|
|
|
|
|
|
|
g_object_class_install_property
|
|
|
|
(gobject_class, PROP_FILENAME,
|
|
|
|
g_param_spec_string ("filename",
|
|
|
|
"Filename",
|
|
|
|
"The full path of the file containing the texture",
|
|
|
|
NULL,
|
|
|
|
G_PARAM_WRITABLE));
|
|
|
|
|
2008-06-23 15:31:12 +00:00
|
|
|
g_object_class_install_property
|
|
|
|
(gobject_class, PROP_KEEP_ASPECT_RATIO,
|
|
|
|
g_param_spec_boolean ("keep-aspect-ratio",
|
|
|
|
"Keep Aspect Ratio",
|
|
|
|
"Keep the aspect ratio of the texture when "
|
|
|
|
"requesting the preferred width or height",
|
|
|
|
FALSE,
|
|
|
|
CLUTTER_PARAM_READWRITE));
|
|
|
|
|
2009-01-12 16:54:30 +00:00
|
|
|
/**
|
|
|
|
* ClutterTexture:load-async:
|
|
|
|
*
|
|
|
|
* Tries to load a texture from a filename by using a local thread
|
|
|
|
* to perform the read operations. Threading is only enabled if
|
|
|
|
* g_thread_init() has been called prior to clutter_init(), otherwise
|
|
|
|
* #ClutterTexture will use the main loop to load the image.
|
|
|
|
*
|
|
|
|
* The upload of the texture data on the GL pipeline is not
|
|
|
|
* asynchronous, as it must be performed from within the same
|
|
|
|
* thread that called clutter_main().
|
|
|
|
*
|
|
|
|
* Since: 1.0
|
|
|
|
*/
|
2009-01-07 17:02:43 +00:00
|
|
|
g_object_class_install_property
|
|
|
|
(gobject_class, PROP_LOAD_ASYNC,
|
|
|
|
g_param_spec_boolean ("load-async",
|
|
|
|
"Load asynchronously",
|
|
|
|
"Load files inside a thread to avoid blocking when "
|
|
|
|
"loading images.",
|
|
|
|
FALSE,
|
|
|
|
CLUTTER_PARAM_READWRITE));
|
|
|
|
|
2006-12-13 18:12:09 +00:00
|
|
|
/**
|
|
|
|
* ClutterTexture::size-change:
|
|
|
|
* @texture: the texture which received the signal
|
|
|
|
* @width: the width of the new texture
|
|
|
|
* @height: the height of the new texture
|
|
|
|
*
|
|
|
|
* The ::size-change signal is emitted each time the size of the
|
|
|
|
* pixbuf used by @texture changes. The new size is given as
|
|
|
|
* argument to the callback.
|
|
|
|
*/
|
|
|
|
texture_signals[SIZE_CHANGE] =
|
2006-05-29 08:59:36 +00:00
|
|
|
g_signal_new ("size-change",
|
|
|
|
G_TYPE_FROM_CLASS (gobject_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterTextureClass, size_change),
|
|
|
|
NULL, NULL,
|
|
|
|
clutter_marshal_VOID__INT_INT,
|
2007-10-12 08:17:00 +00:00
|
|
|
G_TYPE_NONE,
|
2006-05-29 08:59:36 +00:00
|
|
|
2, G_TYPE_INT, G_TYPE_INT);
|
2006-12-13 18:12:09 +00:00
|
|
|
/**
|
|
|
|
* ClutterTexture::pixbuf-change:
|
|
|
|
* @texture: the texture which received the signal
|
2007-10-12 08:17:00 +00:00
|
|
|
*
|
2006-12-13 18:12:09 +00:00
|
|
|
* The ::pixbuf-change signal is emitted each time the pixbuf
|
|
|
|
* used by @texture changes.
|
|
|
|
*/
|
|
|
|
texture_signals[PIXBUF_CHANGE] =
|
2006-05-29 08:59:36 +00:00
|
|
|
g_signal_new ("pixbuf-change",
|
|
|
|
G_TYPE_FROM_CLASS (gobject_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterTextureClass, pixbuf_change),
|
|
|
|
NULL, NULL,
|
|
|
|
g_cclosure_marshal_VOID__VOID,
|
2007-10-12 08:17:00 +00:00
|
|
|
G_TYPE_NONE,
|
|
|
|
0);
|
2009-01-07 17:02:43 +00:00
|
|
|
/**
|
|
|
|
* ClutterTexture::load-finished:
|
|
|
|
* @texture: the texture which received the signal
|
|
|
|
* @error: A set error, or %NULL
|
|
|
|
*
|
2009-01-12 16:54:30 +00:00
|
|
|
* The ::load-finished signal is emitted when a texture load has
|
|
|
|
* completed. If there was an error during loading, @error will
|
|
|
|
* be set, otherwise it will be %NULL
|
|
|
|
*
|
|
|
|
* Since: 1.0
|
2009-01-07 17:02:43 +00:00
|
|
|
*/
|
|
|
|
texture_signals[LOAD_FINISHED] =
|
2009-01-12 16:54:30 +00:00
|
|
|
g_signal_new (I_("load-finished"),
|
2009-01-07 17:02:43 +00:00
|
|
|
G_TYPE_FROM_CLASS (gobject_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterTextureClass, load_finished),
|
|
|
|
NULL, NULL,
|
|
|
|
g_cclosure_marshal_VOID__POINTER,
|
|
|
|
G_TYPE_NONE,
|
|
|
|
1,
|
|
|
|
G_TYPE_POINTER);
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
static ClutterScriptableIface *parent_scriptable_iface = NULL;
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_texture_set_custom_property (ClutterScriptable *scriptable,
|
|
|
|
ClutterScript *script,
|
|
|
|
const gchar *name,
|
|
|
|
const GValue *value)
|
|
|
|
{
|
|
|
|
ClutterTexture *texture = CLUTTER_TEXTURE (scriptable);
|
|
|
|
|
|
|
|
if (strcmp ("filename", name) == 0)
|
|
|
|
{
|
|
|
|
const gchar *str = g_value_get_string (value);
|
|
|
|
gchar *path;
|
|
|
|
GError *error;
|
|
|
|
|
2008-06-24 16:47:43 +00:00
|
|
|
path = clutter_script_lookup_filename (script, str);
|
|
|
|
if (G_UNLIKELY (!path))
|
|
|
|
return;
|
2008-04-25 13:37:36 +00:00
|
|
|
|
|
|
|
error = NULL;
|
|
|
|
clutter_texture_set_from_file (texture, path, &error);
|
|
|
|
if (error)
|
|
|
|
{
|
|
|
|
g_warning ("Unable to open image path at `%s': %s",
|
|
|
|
path,
|
|
|
|
error->message);
|
|
|
|
g_error_free (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
g_free (path);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* chain up */
|
|
|
|
if (parent_scriptable_iface->set_custom_property)
|
|
|
|
parent_scriptable_iface->set_custom_property (scriptable, script,
|
|
|
|
name,
|
|
|
|
value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_scriptable_iface_init (ClutterScriptableIface *iface)
|
|
|
|
{
|
|
|
|
parent_scriptable_iface = g_type_interface_peek_parent (iface);
|
|
|
|
|
|
|
|
if (!parent_scriptable_iface)
|
2008-12-23 16:29:29 +00:00
|
|
|
parent_scriptable_iface = g_type_default_interface_peek
|
2008-06-10 10:49:21 +00:00
|
|
|
(CLUTTER_TYPE_SCRIPTABLE);
|
2008-04-25 13:37:36 +00:00
|
|
|
|
|
|
|
iface->set_custom_property = clutter_texture_set_custom_property;
|
|
|
|
}
|
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
static void
|
|
|
|
clutter_texture_init (ClutterTexture *self)
|
|
|
|
{
|
|
|
|
ClutterTexturePrivate *priv;
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
self->priv = priv = CLUTTER_TEXTURE_GET_PRIVATE (self);
|
2006-06-08 21:28:05 +00:00
|
|
|
|
2009-01-11 00:25:27 +00:00
|
|
|
priv->max_tile_waste = 63;
|
2008-06-23 15:31:12 +00:00
|
|
|
priv->filter_quality = CLUTTER_TEXTURE_QUALITY_MEDIUM;
|
|
|
|
priv->repeat_x = FALSE;
|
|
|
|
priv->repeat_y = FALSE;
|
|
|
|
priv->sync_actor_size = TRUE;
|
|
|
|
priv->texture = COGL_INVALID_HANDLE;
|
|
|
|
priv->fbo_handle = COGL_INVALID_HANDLE;
|
|
|
|
priv->local_data = NULL;
|
|
|
|
priv->keep_aspect_ratio = FALSE;
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
2006-09-19 19:27:16 +00:00
|
|
|
static void
|
2008-04-25 13:37:36 +00:00
|
|
|
clutter_texture_save_to_local_data (ClutterTexture *texture)
|
2008-02-05 14:49:29 +00:00
|
|
|
{
|
|
|
|
ClutterTexturePrivate *priv;
|
2008-04-25 13:37:36 +00:00
|
|
|
int bpp;
|
|
|
|
CoglPixelFormat pixel_format;
|
2008-02-05 14:49:29 +00:00
|
|
|
|
|
|
|
priv = texture->priv;
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->local_data)
|
2008-02-12 17:17:52 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
g_free (priv->local_data);
|
|
|
|
priv->local_data = NULL;
|
2008-02-12 17:17:52 +00:00
|
|
|
}
|
2008-02-25 11:34:51 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->texture == COGL_INVALID_HANDLE)
|
|
|
|
return;
|
|
|
|
|
|
|
|
priv->local_data_width = cogl_texture_get_width (priv->texture);
|
|
|
|
priv->local_data_height = cogl_texture_get_height (priv->texture);
|
|
|
|
pixel_format = cogl_texture_get_format (priv->texture);
|
|
|
|
priv->local_data_has_alpha = pixel_format & COGL_A_BIT;
|
|
|
|
bpp = priv->local_data_has_alpha ? 4 : 3;
|
2008-06-10 10:49:21 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
/* Align to 4 bytes */
|
|
|
|
priv->local_data_rowstride = (priv->local_data_width * bpp + 3) & ~3;
|
|
|
|
|
|
|
|
/* Store the filter quality and max_tile_waste from the texture
|
|
|
|
properties so that they will be restored the data is loaded
|
|
|
|
again */
|
|
|
|
priv->max_tile_waste = clutter_texture_get_max_tile_waste (texture);
|
|
|
|
priv->filter_quality = clutter_texture_get_filter_quality (texture);
|
|
|
|
|
|
|
|
priv->local_data = g_malloc (priv->local_data_rowstride
|
|
|
|
* priv->local_data_height);
|
|
|
|
|
|
|
|
if (cogl_texture_get_data (priv->texture,
|
|
|
|
priv->local_data_has_alpha
|
|
|
|
? COGL_PIXEL_FORMAT_RGBA_8888
|
|
|
|
: COGL_PIXEL_FORMAT_RGB_888,
|
|
|
|
priv->local_data_rowstride,
|
|
|
|
priv->local_data) == 0)
|
2008-02-05 14:49:29 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
g_free (priv->local_data);
|
|
|
|
priv->local_data = NULL;
|
2008-02-05 14:49:29 +00:00
|
|
|
}
|
2008-04-25 13:37:36 +00:00
|
|
|
}
|
2008-02-05 14:49:29 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
static void
|
|
|
|
clutter_texture_load_from_local_data (ClutterTexture *texture)
|
|
|
|
{
|
|
|
|
ClutterTexturePrivate *priv;
|
2008-02-05 16:40:46 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
priv = texture->priv;
|
2008-02-05 14:49:29 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->local_data == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
clutter_texture_set_from_rgb_data (texture,
|
|
|
|
priv->local_data,
|
|
|
|
priv->local_data_has_alpha,
|
|
|
|
priv->local_data_width,
|
|
|
|
priv->local_data_height,
|
|
|
|
priv->local_data_rowstride,
|
|
|
|
priv->local_data_has_alpha ? 4: 3,
|
|
|
|
0, NULL);
|
2008-12-23 16:29:29 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
g_free (priv->local_data);
|
|
|
|
priv->local_data = NULL;
|
2008-02-05 14:49:29 +00:00
|
|
|
}
|
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
/**
|
2008-04-25 13:37:36 +00:00
|
|
|
* clutter_texture_get_cogl_texture
|
2006-06-22 09:14:35 +00:00
|
|
|
* @texture: A #ClutterTexture
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Returns a handle to the underlying COGL texture used for drawing
|
|
|
|
* the actor. No extra reference is taken so if you need to keep the
|
|
|
|
* handle then you should call cogl_texture_ref on it.
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Since: 0.8
|
2008-01-21 11:39:23 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Return value: COGL texture handle
|
2006-05-29 08:59:36 +00:00
|
|
|
**/
|
2008-04-25 13:37:36 +00:00
|
|
|
CoglHandle
|
|
|
|
clutter_texture_get_cogl_texture (ClutterTexture *texture)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_TEXTURE (texture), COGL_INVALID_HANDLE);
|
2008-02-05 14:49:29 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
return texture->priv->texture;
|
|
|
|
}
|
2006-09-19 19:27:16 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
/**
|
|
|
|
* clutter_texture_set_cogl_texture
|
|
|
|
* @texture: A #ClutterTexture
|
|
|
|
* @cogl_tex: A CoglHandle for a texture
|
|
|
|
*
|
|
|
|
* Replaces the underlying COGL texture drawn by this actor with
|
|
|
|
* @cogl_tex. A reference to the texture is taken so if the handle is
|
|
|
|
* no longer needed it should be deref'd with cogl_texture_unref.
|
|
|
|
*
|
|
|
|
* Since: 0.8
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_texture_set_cogl_texture (ClutterTexture *texture,
|
|
|
|
CoglHandle cogl_tex)
|
|
|
|
{
|
|
|
|
ClutterTexturePrivate *priv;
|
|
|
|
gboolean size_change;
|
|
|
|
guint width, height;
|
2006-09-19 19:27:16 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_TEXTURE (texture));
|
|
|
|
g_return_if_fail (cogl_is_texture (cogl_tex));
|
2008-02-05 14:49:29 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
priv = texture->priv;
|
2008-02-05 14:49:29 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
width = cogl_texture_get_width (cogl_tex);
|
|
|
|
height = cogl_texture_get_height (cogl_tex);
|
2008-02-05 14:49:29 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
/* Reference the new texture now in case it is the same one we are
|
|
|
|
already using */
|
|
|
|
cogl_texture_ref (cogl_tex);
|
2007-07-29 22:55:04 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
/* Remove FBO if exisiting */
|
|
|
|
if (priv->fbo_source)
|
|
|
|
texture_fbo_free_resources (texture);
|
|
|
|
/* Remove old texture */
|
|
|
|
texture_free_gl_resources (texture);
|
|
|
|
/* Use the new texture */
|
|
|
|
priv->texture = cogl_tex;
|
2007-07-29 22:55:04 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
size_change = width != priv->width || height != priv->height;
|
|
|
|
priv->width = width;
|
|
|
|
priv->height = height;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
CLUTTER_NOTE (TEXTURE, "set size %ix%i\n",
|
|
|
|
priv->width,
|
|
|
|
priv->height);
|
2006-09-19 19:27:16 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
CLUTTER_ACTOR_SET_FLAGS (CLUTTER_ACTOR (texture), CLUTTER_ACTOR_REALIZED);
|
2006-09-19 19:27:16 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (size_change)
|
|
|
|
{
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
g_signal_emit (texture, texture_signals[SIZE_CHANGE], 0,
|
|
|
|
priv->width,
|
|
|
|
priv->height);
|
2007-06-22 15:16:40 +00:00
|
|
|
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
clutter_actor_queue_relayout (CLUTTER_ACTOR (texture));
|
2006-09-19 19:27:16 +00:00
|
|
|
}
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
/* rename signal */
|
|
|
|
g_signal_emit (texture, texture_signals[PIXBUF_CHANGE], 0);
|
|
|
|
|
|
|
|
g_object_notify (G_OBJECT (texture), "cogl-texture");
|
2007-04-27 21:13:06 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
/* If resized actor may need resizing but paint() will do this */
|
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (texture))
|
|
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (texture));
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
static gboolean
|
|
|
|
clutter_texture_set_from_data (ClutterTexture *texture,
|
|
|
|
const guchar *data,
|
|
|
|
CoglPixelFormat source_format,
|
|
|
|
gint width,
|
|
|
|
gint height,
|
|
|
|
gint rowstride,
|
|
|
|
gint bpp,
|
|
|
|
GError **error)
|
2007-12-20 14:26:07 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
CoglHandle new_texture;
|
|
|
|
ClutterTexturePrivate *priv;
|
2007-12-20 14:26:07 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
priv = texture->priv;
|
2007-12-20 14:26:07 +00:00
|
|
|
|
2008-12-23 16:29:29 +00:00
|
|
|
if ((new_texture = cogl_texture_new_from_data
|
2008-06-07 15:08:05 +00:00
|
|
|
(width, height,
|
|
|
|
priv->no_slice ? -1 : priv->max_tile_waste,
|
|
|
|
priv->filter_quality == CLUTTER_TEXTURE_QUALITY_HIGH,
|
|
|
|
source_format,
|
|
|
|
COGL_PIXEL_FORMAT_ANY,
|
|
|
|
rowstride,
|
|
|
|
data)) == COGL_INVALID_HANDLE)
|
2007-12-20 14:26:07 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
g_set_error (error, CLUTTER_TEXTURE_ERROR,
|
|
|
|
CLUTTER_TEXTURE_ERROR_BAD_FORMAT,
|
|
|
|
"Failed to create COGL texture");
|
2007-12-20 14:26:07 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
return FALSE;
|
2007-12-20 14:26:07 +00:00
|
|
|
}
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
cogl_texture_set_filters (new_texture,
|
2008-06-07 15:08:05 +00:00
|
|
|
clutter_texture_quality_to_cogl_min_filter (priv->filter_quality),
|
|
|
|
clutter_texture_quality_to_cogl_mag_filter (priv->filter_quality));
|
2007-12-20 14:26:07 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
clutter_texture_set_cogl_texture (texture, new_texture);
|
2007-12-20 14:26:07 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
cogl_texture_unref (new_texture);
|
2007-12-20 14:26:07 +00:00
|
|
|
|
2009-01-14 15:30:10 +00:00
|
|
|
g_signal_emit (texture, texture_signals[LOAD_FINISHED], 0, error);
|
|
|
|
|
2007-12-20 14:26:07 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
/**
|
2007-05-25 10:56:09 +00:00
|
|
|
* clutter_texture_set_from_rgb_data:
|
2006-06-22 09:14:35 +00:00
|
|
|
* @texture: A #ClutterTexture
|
2008-02-15 17:11:50 +00:00
|
|
|
* @data: Image data in RGBA type colorspace.
|
2008-02-15 15:49:44 +00:00
|
|
|
* @has_alpha: Set to TRUE if image data has an alpha channel.
|
2006-09-19 19:27:16 +00:00
|
|
|
* @width: Width in pixels of image data.
|
|
|
|
* @height: Height in pixels of image data
|
|
|
|
* @rowstride: Distance in bytes between row starts.
|
2008-12-23 16:29:29 +00:00
|
|
|
* @bpp: bytes per pixel (Currently only 3 and 4 supported,
|
2008-07-01 10:11:39 +00:00
|
|
|
* depending on @has_alpha)
|
2007-05-25 10:56:09 +00:00
|
|
|
* @flags: #ClutterTextureFlags
|
2007-12-24 16:24:26 +00:00
|
|
|
* @error: return location for a #GError, or %NULL.
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2006-09-19 19:27:16 +00:00
|
|
|
* Sets #ClutterTexture image data.
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2007-12-24 16:24:26 +00:00
|
|
|
* Note: This function is likely to change in future versions.
|
2007-05-25 10:56:09 +00:00
|
|
|
*
|
2007-12-24 16:24:26 +00:00
|
|
|
* Return value: %TRUE on success, %FALSE on failure.
|
|
|
|
*
|
|
|
|
* Since: 0.4.
|
2006-05-29 08:59:36 +00:00
|
|
|
**/
|
2007-10-12 08:17:00 +00:00
|
|
|
gboolean
|
2007-05-25 10:56:09 +00:00
|
|
|
clutter_texture_set_from_rgb_data (ClutterTexture *texture,
|
|
|
|
const guchar *data,
|
|
|
|
gboolean has_alpha,
|
|
|
|
gint width,
|
|
|
|
gint height,
|
|
|
|
gint rowstride,
|
|
|
|
gint bpp,
|
|
|
|
ClutterTextureFlags flags,
|
2007-06-06 14:27:52 +00:00
|
|
|
GError **error)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
|
|
|
ClutterTexturePrivate *priv;
|
2008-04-25 13:37:36 +00:00
|
|
|
CoglPixelFormat source_format;
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_TEXTURE (texture), FALSE);
|
2007-05-25 10:56:09 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
priv = texture->priv;
|
2007-05-25 10:56:09 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
/* Convert the flags to a CoglPixelFormat */
|
|
|
|
if (has_alpha)
|
2006-07-24 21:15:19 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
if (bpp != 4)
|
2006-07-24 21:15:19 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
g_set_error (error, CLUTTER_TEXTURE_ERROR,
|
|
|
|
CLUTTER_TEXTURE_ERROR_BAD_FORMAT,
|
|
|
|
"Unsupported BPP");
|
|
|
|
return FALSE;
|
2006-07-24 21:15:19 +00:00
|
|
|
}
|
2008-04-25 13:37:36 +00:00
|
|
|
source_format = COGL_PIXEL_FORMAT_RGBA_8888;
|
2006-09-19 19:27:16 +00:00
|
|
|
}
|
2008-04-25 13:37:36 +00:00
|
|
|
else
|
2006-09-19 19:27:16 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
if (bpp != 3)
|
|
|
|
{
|
|
|
|
g_set_error (error, CLUTTER_TEXTURE_ERROR,
|
|
|
|
CLUTTER_TEXTURE_ERROR_BAD_FORMAT,
|
|
|
|
"Unsupported BPP");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
source_format = COGL_PIXEL_FORMAT_RGB_888;
|
2006-09-19 19:27:16 +00:00
|
|
|
}
|
2008-04-25 13:37:36 +00:00
|
|
|
if ((flags & CLUTTER_TEXTURE_RGB_FLAG_BGR))
|
|
|
|
source_format |= COGL_BGR_BIT;
|
|
|
|
if ((flags & CLUTTER_TEXTURE_RGB_FLAG_PREMULT))
|
|
|
|
source_format |= COGL_PREMULT_BIT;
|
|
|
|
|
|
|
|
return clutter_texture_set_from_data (texture, data,
|
|
|
|
source_format,
|
|
|
|
width, height,
|
|
|
|
rowstride, bpp,
|
|
|
|
error);
|
2007-05-25 10:56:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_texture_set_from_yuv_data:
|
|
|
|
* @texture: A #ClutterTexture
|
2008-02-15 15:18:02 +00:00
|
|
|
* @data: Image data in YUV type colorspace.
|
2007-05-25 10:56:09 +00:00
|
|
|
* @width: Width in pixels of image data.
|
|
|
|
* @height: Height in pixels of image data
|
|
|
|
* @flags: #ClutterTextureFlags
|
2007-07-24 17:38:35 +00:00
|
|
|
* @error: Return location for a #GError, or %NULL.
|
2007-05-25 10:56:09 +00:00
|
|
|
*
|
2007-07-24 17:38:35 +00:00
|
|
|
* Sets a #ClutterTexture from YUV image data. If an error occurred,
|
|
|
|
* %FALSE is returned and @error is set.
|
2007-05-25 10:56:09 +00:00
|
|
|
*
|
2007-07-24 17:38:35 +00:00
|
|
|
* This function is likely to change in future versions.
|
2007-05-25 10:56:09 +00:00
|
|
|
*
|
2007-07-24 17:38:35 +00:00
|
|
|
* Return value: %TRUE if the texture was successfully updated
|
|
|
|
*
|
2008-12-05 14:08:06 +00:00
|
|
|
* Since: 0.4
|
2009-01-12 16:54:30 +00:00
|
|
|
*/
|
2007-10-12 08:17:00 +00:00
|
|
|
gboolean
|
2009-01-12 16:54:30 +00:00
|
|
|
clutter_texture_set_from_yuv_data (ClutterTexture *texture,
|
|
|
|
const guchar *data,
|
|
|
|
gint width,
|
|
|
|
gint height,
|
|
|
|
ClutterTextureFlags flags,
|
|
|
|
GError **error)
|
2007-05-25 10:56:09 +00:00
|
|
|
{
|
2007-06-07 23:51:53 +00:00
|
|
|
ClutterTexturePrivate *priv;
|
2007-05-25 10:56:09 +00:00
|
|
|
|
2007-07-24 17:38:35 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_TEXTURE (texture), FALSE);
|
|
|
|
|
|
|
|
if (!clutter_feature_available (CLUTTER_FEATURE_TEXTURE_YUV))
|
|
|
|
{
|
|
|
|
g_set_error (error, CLUTTER_TEXTURE_ERROR,
|
|
|
|
CLUTTER_TEXTURE_ERROR_NO_YUV,
|
|
|
|
"YUV textures are not supported");
|
|
|
|
return FALSE;
|
|
|
|
}
|
2007-05-25 10:56:09 +00:00
|
|
|
|
|
|
|
priv = texture->priv;
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
/* Convert the flags to a CoglPixelFormat */
|
|
|
|
if ((flags & CLUTTER_TEXTURE_YUV_FLAG_YUV2))
|
2007-05-25 10:56:09 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
g_set_error (error, CLUTTER_TEXTURE_ERROR,
|
|
|
|
CLUTTER_TEXTURE_ERROR_BAD_FORMAT,
|
|
|
|
"YUV2 not supported");
|
|
|
|
return FALSE;
|
2007-05-25 10:56:09 +00:00
|
|
|
}
|
2007-06-07 23:51:53 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
return clutter_texture_set_from_data (texture, data,
|
|
|
|
COGL_PIXEL_FORMAT_YUV,
|
|
|
|
width, height,
|
|
|
|
width * 3, 3,
|
|
|
|
error);
|
2006-09-19 19:27:16 +00:00
|
|
|
}
|
|
|
|
|
2009-01-12 16:54:30 +00:00
|
|
|
/*
|
|
|
|
* clutter_texture_async_load_complete:
|
|
|
|
* @self: a #ClutterTexture
|
|
|
|
* @error: load error
|
|
|
|
*
|
|
|
|
* If @error is %NULL, loads the #CoglBitmap into a #CoglTexture.
|
|
|
|
*
|
|
|
|
* This function emits the ::load-finished signal on @self.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
clutter_texture_async_load_complete (ClutterTexture *self,
|
|
|
|
const GError *error)
|
2009-01-07 17:02:43 +00:00
|
|
|
{
|
|
|
|
ClutterTexturePrivate *priv = self->priv;
|
2009-01-12 16:54:30 +00:00
|
|
|
CoglHandle handle;
|
|
|
|
gboolean enable_mipmap = FALSE;
|
|
|
|
gint waste = -1;
|
|
|
|
|
|
|
|
if (error == NULL)
|
2009-01-07 17:02:43 +00:00
|
|
|
{
|
2009-01-12 16:54:30 +00:00
|
|
|
if (priv->no_slice)
|
|
|
|
waste = priv->max_tile_waste;
|
|
|
|
|
|
|
|
if (priv->filter_quality == CLUTTER_TEXTURE_QUALITY_HIGH)
|
|
|
|
enable_mipmap = TRUE;
|
|
|
|
|
2009-01-07 17:02:43 +00:00
|
|
|
handle = cogl_texture_new_from_bitmap (priv->load_bitmap,
|
2009-01-12 16:54:30 +00:00
|
|
|
waste, enable_mipmap,
|
|
|
|
COGL_PIXEL_FORMAT_ANY);
|
2009-01-07 17:02:43 +00:00
|
|
|
clutter_texture_set_cogl_texture (self, handle);
|
|
|
|
cogl_texture_unref (handle);
|
|
|
|
|
|
|
|
cogl_bitmap_free (priv->load_bitmap);
|
|
|
|
priv->load_bitmap = NULL;
|
|
|
|
}
|
2009-01-12 16:54:30 +00:00
|
|
|
|
|
|
|
g_signal_emit (self, texture_signals[LOAD_FINISHED], 0, error);
|
2009-01-12 17:09:47 +00:00
|
|
|
|
|
|
|
clutter_actor_queue_relayout (CLUTTER_ACTOR (self));
|
2009-01-12 16:54:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
clutter_texture_thread_cb (gpointer data)
|
|
|
|
{
|
|
|
|
ClutterTexture *self = data;
|
|
|
|
ClutterTexturePrivate *priv = self->priv;
|
|
|
|
|
|
|
|
priv->load_idle = 0;
|
|
|
|
|
|
|
|
if (priv->load_thread)
|
|
|
|
{
|
|
|
|
g_thread_join (priv->load_thread);
|
|
|
|
priv->load_thread = NULL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
clutter_texture_async_load_complete (self, priv->load_error);
|
|
|
|
|
2009-01-07 17:02:43 +00:00
|
|
|
if (priv->load_error)
|
|
|
|
{
|
|
|
|
g_error_free (priv->load_error);
|
|
|
|
priv->load_error = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static gpointer
|
2009-01-12 16:54:30 +00:00
|
|
|
clutter_texture_thread_func (gpointer data)
|
2009-01-07 17:02:43 +00:00
|
|
|
{
|
2009-01-12 16:54:30 +00:00
|
|
|
ClutterTexture *self = data;
|
2009-01-07 17:02:43 +00:00
|
|
|
ClutterTexturePrivate *priv = self->priv;
|
2009-01-12 16:54:30 +00:00
|
|
|
|
2009-01-07 17:02:43 +00:00
|
|
|
/* Try loading with imaging backend */
|
|
|
|
priv->load_bitmap = cogl_bitmap_new_from_file (priv->load_filename,
|
|
|
|
&priv->load_error);
|
|
|
|
g_free (priv->load_filename);
|
|
|
|
priv->load_filename = NULL;
|
2009-01-12 16:54:30 +00:00
|
|
|
|
|
|
|
/* make sure we load the image in the main thread, where we
|
|
|
|
* hold the main Clutter lock
|
|
|
|
*/
|
|
|
|
priv->load_idle =
|
|
|
|
clutter_threads_add_idle (clutter_texture_thread_cb, self);
|
|
|
|
|
2009-01-07 17:02:43 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-01-12 16:54:30 +00:00
|
|
|
static gboolean
|
|
|
|
clutter_texture_idle_func (gpointer data)
|
|
|
|
{
|
|
|
|
ClutterTexture *self = data;
|
|
|
|
ClutterTexturePrivate *priv = self->priv;
|
|
|
|
GError *internal_error;
|
|
|
|
|
|
|
|
internal_error = NULL;
|
|
|
|
priv->load_bitmap = cogl_bitmap_new_from_file (priv->load_filename,
|
|
|
|
&internal_error);
|
|
|
|
|
|
|
|
clutter_texture_async_load_complete (self, internal_error);
|
|
|
|
|
|
|
|
g_free (priv->load_filename);
|
|
|
|
priv->load_filename = NULL;
|
|
|
|
|
|
|
|
if (internal_error)
|
|
|
|
g_error_free (internal_error);
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* clutter_texture_async_load:
|
|
|
|
* @self: a #ClutterTexture
|
|
|
|
* @error: return location for a #GError
|
|
|
|
*
|
|
|
|
* Starts an asynchronous load of the file name stored inside
|
|
|
|
* the load_filename private member.
|
|
|
|
*
|
|
|
|
* If threading is enabled we use a GThread to perform the actual
|
|
|
|
* I/O; if threading is not enabled, we use an idle GSource.
|
|
|
|
*
|
|
|
|
* The I/O is the only bit done in a thread -- uploading the
|
|
|
|
* texture data to the GL pipeline must be done from within the
|
|
|
|
* same thread that called clutter_main(). Threaded upload should
|
|
|
|
* be part of the GL implementation.
|
|
|
|
*
|
|
|
|
* This function will block until we get a size from the file
|
|
|
|
* so that we can effectively get the size the texture actor after
|
|
|
|
* clutter_texture_set_from_file().
|
|
|
|
*
|
|
|
|
* Return value: %TRUE if the asynchronous loading was successfully
|
|
|
|
* initiated, %FALSE otherwise
|
|
|
|
*/
|
|
|
|
static gboolean
|
|
|
|
clutter_texture_async_load (ClutterTexture *self,
|
|
|
|
GError **error)
|
|
|
|
{
|
|
|
|
ClutterTexturePrivate *priv = self->priv;
|
|
|
|
gint width, height;
|
|
|
|
gboolean res;
|
|
|
|
|
|
|
|
g_assert (priv->load_filename != NULL);
|
|
|
|
|
|
|
|
/* ask the file for a size; if we cannot get the size then
|
|
|
|
* there's no point in even continuing the asynchronous
|
|
|
|
* loading, so we just stop there
|
|
|
|
*/
|
|
|
|
res = cogl_bitmap_get_size_from_file (priv->load_filename,
|
|
|
|
&width,
|
|
|
|
&height);
|
|
|
|
if (!res)
|
|
|
|
{
|
|
|
|
g_set_error (error, CLUTTER_TEXTURE_ERROR,
|
|
|
|
CLUTTER_TEXTURE_ERROR_BAD_FORMAT,
|
|
|
|
"Failed to create COGL texture");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
else
|
2009-01-12 17:09:47 +00:00
|
|
|
{
|
|
|
|
priv->width = width;
|
|
|
|
priv->height = height;
|
|
|
|
}
|
2009-01-12 16:54:30 +00:00
|
|
|
|
|
|
|
if (g_thread_supported ())
|
|
|
|
{
|
|
|
|
priv->load_thread =
|
|
|
|
g_thread_create ((GThreadFunc) clutter_texture_thread_func,
|
|
|
|
self, TRUE,
|
|
|
|
error);
|
|
|
|
|
|
|
|
return priv->load_thread != NULL? TRUE : FALSE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
priv->load_idle =
|
|
|
|
clutter_threads_add_idle (clutter_texture_idle_func, self);
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-09-19 19:27:16 +00:00
|
|
|
/**
|
2008-04-25 13:37:36 +00:00
|
|
|
* clutter_texture_set_from_file:
|
2006-09-19 19:27:16 +00:00
|
|
|
* @texture: A #ClutterTexture
|
2008-04-25 13:37:36 +00:00
|
|
|
* @filename: The filename of the image in GLib file name encoding
|
2007-07-24 17:38:35 +00:00
|
|
|
* @error: Return location for a #GError, or %NULL
|
2006-09-19 19:27:16 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Sets the #ClutterTexture image data from an image file. In case of
|
2007-07-24 17:38:35 +00:00
|
|
|
* failure, %FALSE is returned and @error is set.
|
2006-09-19 19:27:16 +00:00
|
|
|
*
|
2009-01-12 17:09:47 +00:00
|
|
|
* If #ClutterTexture:load-async is set to %TRUE, this function
|
|
|
|
* will return as soon as possible, and the actual image loading
|
|
|
|
* from disk will be performed asynchronously. #ClutterTexture::load-finished
|
|
|
|
* will be emitted when the image has been loaded or if an error
|
|
|
|
* occurred.
|
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Return value: %TRUE if the image was successfully loaded and set
|
2007-07-24 17:38:35 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Since: 0.8
|
2007-07-24 17:38:35 +00:00
|
|
|
*/
|
2007-05-25 10:56:09 +00:00
|
|
|
gboolean
|
2008-04-25 13:37:36 +00:00
|
|
|
clutter_texture_set_from_file (ClutterTexture *texture,
|
|
|
|
const gchar *filename,
|
|
|
|
GError **error)
|
2006-09-19 19:27:16 +00:00
|
|
|
{
|
2009-01-12 16:54:30 +00:00
|
|
|
ClutterTexturePrivate *priv;
|
|
|
|
CoglHandle new_texture = COGL_INVALID_HANDLE;
|
|
|
|
GError *internal_error = NULL;
|
|
|
|
gboolean enable_mipmap = FALSE;
|
|
|
|
gint max_waste = -1;
|
2007-05-25 10:56:09 +00:00
|
|
|
|
2008-03-18 17:56:50 +00:00
|
|
|
priv = texture->priv;
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2009-01-07 17:02:43 +00:00
|
|
|
if (priv->load_async)
|
|
|
|
{
|
2009-01-12 16:54:30 +00:00
|
|
|
clutter_texture_async_load_cancel (texture);
|
|
|
|
|
2009-01-07 17:02:43 +00:00
|
|
|
priv->load_filename = g_strdup (filename);
|
2009-01-12 16:54:30 +00:00
|
|
|
|
|
|
|
return clutter_texture_async_load (texture, error);
|
2009-01-07 17:02:43 +00:00
|
|
|
}
|
|
|
|
|
2009-01-12 16:54:30 +00:00
|
|
|
if (priv->no_slice)
|
|
|
|
max_waste = priv->max_tile_waste;
|
|
|
|
|
|
|
|
if (priv->filter_quality == CLUTTER_TEXTURE_QUALITY_HIGH)
|
|
|
|
enable_mipmap = TRUE;
|
|
|
|
|
|
|
|
new_texture = cogl_texture_new_from_file (filename,
|
|
|
|
max_waste, enable_mipmap,
|
|
|
|
COGL_PIXEL_FORMAT_ANY,
|
|
|
|
&internal_error);
|
|
|
|
if (new_texture == COGL_INVALID_HANDLE)
|
2008-04-25 13:37:36 +00:00
|
|
|
{
|
|
|
|
/* If COGL didn't give an error then make one up */
|
2009-01-12 16:54:30 +00:00
|
|
|
if (internal_error == NULL)
|
2008-04-25 13:37:36 +00:00
|
|
|
{
|
|
|
|
g_set_error (error, CLUTTER_TEXTURE_ERROR,
|
|
|
|
CLUTTER_TEXTURE_ERROR_BAD_FORMAT,
|
|
|
|
"Failed to create COGL texture");
|
|
|
|
}
|
2009-01-12 16:54:30 +00:00
|
|
|
else
|
|
|
|
g_propagate_error (error, internal_error);
|
|
|
|
|
|
|
|
g_signal_emit (texture, texture_signals[LOAD_FINISHED], 0, error);
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
2008-03-18 17:56:50 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
cogl_texture_set_filters (new_texture,
|
2008-06-07 15:08:05 +00:00
|
|
|
clutter_texture_quality_to_cogl_min_filter (priv->filter_quality),
|
|
|
|
clutter_texture_quality_to_cogl_mag_filter (priv->filter_quality));
|
2006-06-20 20:29:45 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
clutter_texture_set_cogl_texture (texture, new_texture);
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
cogl_texture_unref (new_texture);
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2009-01-12 16:54:30 +00:00
|
|
|
g_signal_emit (texture, texture_signals[LOAD_FINISHED], 0, error);
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
return TRUE;
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-06-12 11:43:25 +00:00
|
|
|
* clutter_texture_set_filter_quality:
|
|
|
|
* @texture: a #ClutterTexture
|
|
|
|
* @filter_quality: new filter quality value
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2008-06-10 11:18:19 +00:00
|
|
|
* Sets the filter quality when scaling a texture. The quality is an
|
|
|
|
* enumeration currently the following values are supported:
|
2008-06-12 11:43:25 +00:00
|
|
|
* %CLUTTER_TEXTURE_QUALITY_LOW which is fast but only uses nearest neighbour
|
|
|
|
* interpolation. %CLUTTER_TEXTURE_QUALITY_MEDIUM which is computationally a
|
|
|
|
* bit more expensive (bilinear interpolation), and
|
|
|
|
* %CLUTTER_TEXTURE_QUALITY_HIGH which uses extra texture memory resources to
|
|
|
|
* improve scaled down rendering as well (by using mipmaps). The default value
|
|
|
|
* is %CLUTTER_TEXTURE_QUALITY_MEDIUM.
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Since: 0.8
|
|
|
|
*/
|
2006-05-29 08:59:36 +00:00
|
|
|
void
|
2008-06-07 15:08:05 +00:00
|
|
|
clutter_texture_set_filter_quality (ClutterTexture *texture,
|
|
|
|
ClutterTextureQuality filter_quality)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
|
|
|
ClutterTexturePrivate *priv;
|
2008-06-07 15:08:05 +00:00
|
|
|
ClutterTextureQuality old_quality;
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2007-07-26 11:04:04 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_TEXTURE (texture));
|
|
|
|
|
2006-05-29 08:59:36 +00:00
|
|
|
priv = texture->priv;
|
2007-07-26 11:04:04 +00:00
|
|
|
|
2008-06-07 15:08:05 +00:00
|
|
|
old_quality = clutter_texture_get_filter_quality (texture);
|
2008-10-31 16:59:51 +00:00
|
|
|
|
2008-06-07 15:08:05 +00:00
|
|
|
if (filter_quality != old_quality)
|
2008-04-25 13:37:36 +00:00
|
|
|
{
|
|
|
|
priv->filter_quality = filter_quality;
|
|
|
|
|
2008-10-31 16:59:51 +00:00
|
|
|
/* Is this actually needed - causes problems with TFP mipmaps */
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->texture != COGL_INVALID_HANDLE)
|
|
|
|
cogl_texture_set_filters (priv->texture,
|
2008-06-07 15:08:05 +00:00
|
|
|
clutter_texture_quality_to_cogl_min_filter (priv->filter_quality),
|
|
|
|
clutter_texture_quality_to_cogl_mag_filter (priv->filter_quality));
|
2008-06-12 11:43:25 +00:00
|
|
|
|
2008-06-07 15:08:05 +00:00
|
|
|
if ((old_quality == CLUTTER_TEXTURE_QUALITY_HIGH ||
|
|
|
|
filter_quality == CLUTTER_TEXTURE_QUALITY_HIGH) &&
|
|
|
|
CLUTTER_ACTOR_IS_REALIZED (texture))
|
|
|
|
{
|
2008-11-07 16:50:23 +00:00
|
|
|
gboolean was_visible;
|
|
|
|
|
|
|
|
was_visible = CLUTTER_ACTOR_IS_VISIBLE (CLUTTER_ACTOR (texture));
|
|
|
|
|
|
|
|
clutter_actor_unrealize (CLUTTER_ACTOR (texture));
|
|
|
|
clutter_actor_realize (CLUTTER_ACTOR (texture));
|
|
|
|
|
|
|
|
if (was_visible)
|
|
|
|
clutter_actor_show (CLUTTER_ACTOR (texture));
|
2008-06-07 15:08:05 +00:00
|
|
|
}
|
2008-10-31 16:59:51 +00:00
|
|
|
|
2008-06-10 10:49:21 +00:00
|
|
|
g_object_notify (G_OBJECT (texture), "filter-quality");
|
2008-04-25 13:37:36 +00:00
|
|
|
|
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (texture))
|
|
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (texture));
|
|
|
|
}
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-04-25 13:37:36 +00:00
|
|
|
* clutter_texture_get_filter_quality
|
2006-06-22 09:14:35 +00:00
|
|
|
* @texture: A #ClutterTexture
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Gets the filter quality used when scaling a texture.
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Return value: The filter quality value.
|
|
|
|
*
|
|
|
|
* Since: 0.8
|
|
|
|
*/
|
2008-06-07 15:08:05 +00:00
|
|
|
ClutterTextureQuality
|
2008-04-25 13:37:36 +00:00
|
|
|
clutter_texture_get_filter_quality (ClutterTexture *texture)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
ClutterTexturePrivate *priv;
|
2008-03-18 17:56:50 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_TEXTURE (texture), 0);
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
priv = texture->priv;
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-10-31 16:59:51 +00:00
|
|
|
return priv->filter_quality;
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-04-25 13:37:36 +00:00
|
|
|
* clutter_texture_set_max_tile_waste
|
2006-06-22 09:14:35 +00:00
|
|
|
* @texture: A #ClutterTexture
|
2008-04-25 13:37:36 +00:00
|
|
|
* @max_tile_waste: Maximum amount of waste in pixels or -1
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Sets the maximum number of pixels in either axis that can be wasted
|
|
|
|
* for an individual texture slice. If -1 is specified then the
|
|
|
|
* texture is forced not to be sliced and the texture creation will
|
|
|
|
* fail if the hardware can't create a texture large enough.
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* The value is only used when first creating a texture so changing it
|
|
|
|
* after the texture data has been set has no effect.
|
|
|
|
*
|
|
|
|
* Since: 0.8
|
|
|
|
*/
|
2006-05-29 08:59:36 +00:00
|
|
|
void
|
2008-04-25 13:37:36 +00:00
|
|
|
clutter_texture_set_max_tile_waste (ClutterTexture *texture,
|
|
|
|
gint max_tile_waste)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2008-03-18 17:56:50 +00:00
|
|
|
ClutterTexturePrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_TEXTURE (texture));
|
|
|
|
|
|
|
|
priv = texture->priv;
|
2006-05-29 08:59:36 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
/* There's no point in changing the max_tile_waste if the texture
|
|
|
|
has already been created because it will be overridden with the
|
|
|
|
value from the texture handle */
|
|
|
|
if (priv->texture == COGL_INVALID_HANDLE)
|
|
|
|
priv->max_tile_waste = max_tile_waste;
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-04-25 13:37:36 +00:00
|
|
|
* clutter_texture_get_max_tile_waste
|
2006-06-22 09:14:35 +00:00
|
|
|
* @texture: A #ClutterTexture
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Gets the maximum waste that will be used when creating a texture or
|
|
|
|
* -1 if slicing is disabled.
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Return value: The maximum waste or -1 if the texture waste is
|
|
|
|
* unlimited.
|
|
|
|
*
|
|
|
|
* Since: 0.8
|
|
|
|
*/
|
|
|
|
gint
|
|
|
|
clutter_texture_get_max_tile_waste (ClutterTexture *texture)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2007-03-19 10:00:38 +00:00
|
|
|
ClutterTexturePrivate *priv;
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_TEXTURE (texture), 0);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-03-19 10:00:38 +00:00
|
|
|
priv = texture->priv;
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->texture == COGL_INVALID_HANDLE)
|
|
|
|
return texture->priv->max_tile_waste;
|
|
|
|
else
|
|
|
|
/* If we have a valid texture handle then use the value from that
|
|
|
|
instead */
|
|
|
|
return cogl_texture_get_max_waste (texture->priv->texture);
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-04-25 13:37:36 +00:00
|
|
|
* clutter_texture_new_from_file:
|
|
|
|
* @filename: The name of an image file to load.
|
|
|
|
* @error: Return locatoin for an error.
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Creates a new ClutterTexture actor to display the image contained a
|
|
|
|
* file. If the image failed to load then NULL is returned and @error
|
|
|
|
* is set.
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Return value: A newly created #ClutterTexture object or NULL on
|
|
|
|
* error.
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Since: 0.8
|
2006-05-29 08:59:36 +00:00
|
|
|
**/
|
2008-04-25 13:37:36 +00:00
|
|
|
ClutterActor*
|
|
|
|
clutter_texture_new_from_file (const gchar *filename,
|
|
|
|
GError **error)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
ClutterActor *texture = clutter_texture_new ();
|
2007-03-19 10:00:38 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (!clutter_texture_set_from_file (CLUTTER_TEXTURE (texture),
|
|
|
|
filename, error))
|
|
|
|
{
|
|
|
|
g_object_ref_sink (texture);
|
|
|
|
g_object_unref (texture);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return texture;
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-04-25 13:37:36 +00:00
|
|
|
* clutter_texture_new:
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Creates a new empty #ClutterTexture object.
|
2006-05-29 08:59:36 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Return value: A newly created #ClutterTexture object.
|
2006-05-29 08:59:36 +00:00
|
|
|
**/
|
2008-04-25 13:37:36 +00:00
|
|
|
ClutterActor *
|
|
|
|
clutter_texture_new (void)
|
2006-05-29 08:59:36 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
return g_object_new (CLUTTER_TYPE_TEXTURE, NULL);
|
2006-05-29 08:59:36 +00:00
|
|
|
}
|
2007-12-20 14:26:07 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
/**
|
|
|
|
* clutter_texture_get_base_size:
|
|
|
|
* @texture: A #ClutterTexture
|
|
|
|
* @width: Pointer to gint to be populated with width value if non NULL.
|
|
|
|
* @height: Pointer to gint to be populated with height value if non NULL.
|
2008-02-12 13:41:44 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
* Gets the size in pixels of the untransformed underlying texture pixbuf data.
|
2008-02-12 13:41:44 +00:00
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
**/
|
|
|
|
void /* FIXME: rename to get_image_size */
|
|
|
|
clutter_texture_get_base_size (ClutterTexture *texture,
|
|
|
|
gint *width,
|
|
|
|
gint *height)
|
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_TEXTURE (texture));
|
2007-12-20 14:26:07 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
/* Attempt to realize, mainly for subclasses ( such as labels )
|
|
|
|
* which may not create pixbuf data and thus base size until
|
|
|
|
* realization happens.
|
|
|
|
*/
|
|
|
|
if (!CLUTTER_ACTOR_IS_REALIZED (texture))
|
|
|
|
clutter_actor_realize (CLUTTER_ACTOR (texture));
|
2007-12-20 14:26:07 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (width)
|
|
|
|
*width = texture->priv->width;
|
2007-12-20 14:26:07 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (height)
|
|
|
|
*height = texture->priv->height;
|
2007-12-20 14:26:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_texture_set_area_from_rgb_data:
|
|
|
|
* @texture: A #ClutterTexture
|
|
|
|
* @data: Image data in RGB type colorspace.
|
2008-02-15 15:49:44 +00:00
|
|
|
* @has_alpha: Set to TRUE if image data has an alpha channel.
|
2007-12-20 14:26:07 +00:00
|
|
|
* @x: X coordinate of upper left corner of region to update.
|
|
|
|
* @y: Y coordinate of upper left corner of region to update.
|
|
|
|
* @width: Width in pixels of region to update.
|
|
|
|
* @height: Height in pixels of region to update.
|
2008-02-07 12:55:51 +00:00
|
|
|
* @rowstride: Distance in bytes between row starts on source buffer.
|
2008-12-23 16:29:29 +00:00
|
|
|
* @bpp: bytes per pixel (Currently only 3 and 4 supported,
|
2008-07-01 10:11:39 +00:00
|
|
|
* depending on @has_alpha)
|
2007-12-20 14:26:07 +00:00
|
|
|
* @flags: #ClutterTextureFlags
|
2007-12-24 16:24:26 +00:00
|
|
|
* @error: return location for a #GError, or %NULL
|
2007-12-20 14:26:07 +00:00
|
|
|
*
|
2008-02-15 15:49:44 +00:00
|
|
|
* Updates a sub-region of the pixel data in a #ClutterTexture.
|
2007-12-20 14:26:07 +00:00
|
|
|
*
|
2007-12-24 16:24:26 +00:00
|
|
|
* Return value: %TRUE on success, %FALSE on failure.
|
2007-12-20 14:26:07 +00:00
|
|
|
*
|
2008-12-05 14:08:06 +00:00
|
|
|
* Since: 0.6
|
2007-12-24 16:24:26 +00:00
|
|
|
*/
|
2007-12-20 14:26:07 +00:00
|
|
|
gboolean
|
|
|
|
clutter_texture_set_area_from_rgb_data (ClutterTexture *texture,
|
|
|
|
const guchar *data,
|
|
|
|
gboolean has_alpha,
|
|
|
|
gint x,
|
|
|
|
gint y,
|
|
|
|
gint width,
|
|
|
|
gint height,
|
|
|
|
gint rowstride,
|
|
|
|
gint bpp,
|
|
|
|
ClutterTextureFlags flags,
|
|
|
|
GError **error)
|
|
|
|
{
|
|
|
|
ClutterTexturePrivate *priv;
|
2008-04-25 13:37:36 +00:00
|
|
|
CoglPixelFormat source_format;
|
2007-12-20 14:26:07 +00:00
|
|
|
|
|
|
|
priv = texture->priv;
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (has_alpha)
|
2007-12-20 14:26:07 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
if (bpp != 4)
|
|
|
|
{
|
|
|
|
g_set_error (error, CLUTTER_TEXTURE_ERROR,
|
|
|
|
CLUTTER_TEXTURE_ERROR_BAD_FORMAT,
|
|
|
|
"Unsupported BPP");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
source_format = COGL_PIXEL_FORMAT_RGBA_8888;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (bpp != 3)
|
|
|
|
{
|
|
|
|
g_set_error (error, CLUTTER_TEXTURE_ERROR,
|
|
|
|
CLUTTER_TEXTURE_ERROR_BAD_FORMAT,
|
|
|
|
"Unsupported BPP");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
source_format = COGL_PIXEL_FORMAT_RGB_888;
|
2007-12-20 14:26:07 +00:00
|
|
|
}
|
2008-04-25 13:37:36 +00:00
|
|
|
if ((flags & CLUTTER_TEXTURE_RGB_FLAG_BGR))
|
|
|
|
source_format |= COGL_BGR_BIT;
|
|
|
|
if ((flags & CLUTTER_TEXTURE_RGB_FLAG_PREMULT))
|
|
|
|
source_format |= COGL_PREMULT_BIT;
|
2007-12-20 14:26:07 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
clutter_actor_realize (CLUTTER_ACTOR (texture));
|
2007-12-20 14:26:07 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->texture == COGL_INVALID_HANDLE)
|
|
|
|
{
|
|
|
|
g_set_error (error, CLUTTER_TEXTURE_ERROR,
|
|
|
|
CLUTTER_TEXTURE_ERROR_BAD_FORMAT,
|
|
|
|
"Failed to realize actor");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!cogl_texture_set_region (priv->texture,
|
|
|
|
0, 0,
|
|
|
|
x, y, width, height,
|
|
|
|
width, height,
|
|
|
|
source_format,
|
|
|
|
rowstride,
|
|
|
|
data))
|
|
|
|
{
|
|
|
|
g_set_error (error, CLUTTER_TEXTURE_ERROR,
|
|
|
|
CLUTTER_TEXTURE_ERROR_BAD_FORMAT,
|
|
|
|
"Failed to upload COGL texture data");
|
|
|
|
return FALSE;
|
|
|
|
}
|
2007-12-20 14:26:07 +00:00
|
|
|
|
|
|
|
/* rename signal */
|
|
|
|
g_signal_emit (texture, texture_signals[PIXBUF_CHANGE], 0);
|
|
|
|
|
2008-03-19 15:05:16 +00:00
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (texture))
|
|
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (texture));
|
2007-12-20 14:26:07 +00:00
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
2008-02-01 15:29:00 +00:00
|
|
|
|
2008-02-06 14:39:04 +00:00
|
|
|
static void
|
|
|
|
on_fbo_source_size_change (GObject *object,
|
|
|
|
GParamSpec *param_spec,
|
|
|
|
ClutterTexture *texture)
|
|
|
|
{
|
|
|
|
ClutterTexturePrivate *priv = texture->priv;
|
|
|
|
guint w, h;
|
|
|
|
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
clutter_actor_get_transformed_size (priv->fbo_source, &w, &h);
|
2008-02-12 13:41:44 +00:00
|
|
|
|
2008-02-06 14:39:04 +00:00
|
|
|
if (w != priv->width || h != priv->height)
|
|
|
|
{
|
2008-02-08 10:37:38 +00:00
|
|
|
/* tear down the FBO */
|
2008-04-25 13:37:36 +00:00
|
|
|
cogl_offscreen_unref (priv->fbo_handle);
|
2008-02-06 14:39:04 +00:00
|
|
|
|
|
|
|
texture_free_gl_resources (texture);
|
|
|
|
|
|
|
|
priv->width = w;
|
|
|
|
priv->height = h;
|
|
|
|
|
2008-08-01 12:23:57 +00:00
|
|
|
priv->texture = cogl_texture_new_with_size (MAX (priv->width, 1),
|
|
|
|
MAX (priv->height, 1),
|
2008-06-06 13:44:22 +00:00
|
|
|
-1,
|
2008-06-07 15:08:05 +00:00
|
|
|
priv->filter_quality == CLUTTER_TEXTURE_QUALITY_HIGH,
|
2008-04-25 13:37:36 +00:00
|
|
|
COGL_PIXEL_FORMAT_RGBA_8888);
|
2008-02-06 14:39:04 +00:00
|
|
|
|
2008-08-01 12:23:57 +00:00
|
|
|
cogl_texture_set_filters (priv->texture,
|
2008-06-07 15:08:05 +00:00
|
|
|
clutter_texture_quality_to_cogl_min_filter (priv->filter_quality),
|
|
|
|
clutter_texture_quality_to_cogl_mag_filter (priv->filter_quality));
|
2008-02-06 14:39:04 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
priv->fbo_handle = cogl_offscreen_new_to_texture (priv->texture);
|
2008-02-12 13:41:44 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->fbo_handle == COGL_INVALID_HANDLE)
|
|
|
|
{
|
|
|
|
g_warning ("%s: Offscreen texture creation failed", G_STRLOC);
|
|
|
|
CLUTTER_ACTOR_UNSET_FLAGS (CLUTTER_ACTOR (texture),
|
|
|
|
CLUTTER_ACTOR_REALIZED);
|
|
|
|
return;
|
|
|
|
}
|
2008-02-06 14:39:04 +00:00
|
|
|
|
2009-01-12 17:12:24 +00:00
|
|
|
clutter_actor_set_size (CLUTTER_ACTOR (texture), w, h);
|
2008-02-06 14:39:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
on_fbo_parent_change (ClutterActor *actor,
|
|
|
|
ClutterActor *old_parent,
|
|
|
|
ClutterTexture *texture)
|
|
|
|
{
|
|
|
|
ClutterActor *parent = CLUTTER_ACTOR(texture);
|
|
|
|
|
|
|
|
while ((parent = clutter_actor_get_parent (parent)) != NULL)
|
|
|
|
if (parent == actor)
|
2008-02-08 10:37:38 +00:00
|
|
|
{
|
|
|
|
g_warning ("Offscreen texture is ancestor of source!");
|
|
|
|
/* Desperate but will avoid infinite loops */
|
|
|
|
clutter_actor_unparent (actor);
|
|
|
|
}
|
2008-02-06 14:39:04 +00:00
|
|
|
}
|
|
|
|
|
2008-02-01 15:29:00 +00:00
|
|
|
/**
|
|
|
|
* clutter_texture_new_from_actor:
|
2008-02-12 13:41:44 +00:00
|
|
|
* @actor: A source #ClutterActor
|
2008-02-01 15:29:00 +00:00
|
|
|
*
|
2008-02-12 13:41:44 +00:00
|
|
|
* Creates a new #ClutterTexture object with its source a prexisting
|
2008-02-08 10:37:38 +00:00
|
|
|
* actor (and associated children). The textures content will contain
|
2008-02-12 13:41:44 +00:00
|
|
|
* 'live' redirected output of the actors scene.
|
2008-02-01 15:29:00 +00:00
|
|
|
*
|
|
|
|
* Note this function is intented as a utility call for uniformly applying
|
2008-02-15 15:18:02 +00:00
|
|
|
* shaders to groups and other potential visual effects. It requires that
|
2008-12-23 16:29:29 +00:00
|
|
|
* the %CLUTTER_FEATURE_OFFSCREEN feature is supported by the current backend
|
2008-06-06 13:44:22 +00:00
|
|
|
* and the target system.
|
2008-02-08 10:37:38 +00:00
|
|
|
*
|
|
|
|
* Some tips on usage:
|
|
|
|
*
|
|
|
|
* <itemizedlist>
|
|
|
|
* <listitem>
|
2008-02-12 13:41:44 +00:00
|
|
|
* <para>The source actor must be made visible (i.e by calling
|
2008-07-04 10:44:18 +00:00
|
|
|
* #clutter_actor_show).</para>
|
|
|
|
* </listitem>
|
|
|
|
* <listitem>
|
|
|
|
* <para>The source actor must have a parent in order for it to be
|
|
|
|
* allocated a size from the layouting mechanism. If the source
|
|
|
|
* actor does not have a parent when this function is called then
|
|
|
|
* the ClutterTexture will adopt it and allocate it at its
|
|
|
|
* preferred size. Using this you can clone an actor that is
|
|
|
|
* otherwise not displayed. Because of this feature if you do
|
|
|
|
* intend to display the source actor then you must make sure that
|
|
|
|
* the actor is parented before calling
|
|
|
|
* clutter_texture_new_from_actor() or that you unparent it before
|
|
|
|
* adding it to a container.</para>
|
2008-08-01 12:23:57 +00:00
|
|
|
* </listitem>
|
|
|
|
* <listitem>
|
|
|
|
* <para>When getting the image for the clone texture, Clutter
|
|
|
|
* will attempt to render the source actor exactly as it would
|
|
|
|
* appear if it was rendered on screen. The source actor's parent
|
|
|
|
* transformations are taken into account. Therefore if your
|
|
|
|
* source actor is rotated along the X or Y axes so that it has
|
|
|
|
* some depth, the texture will appear differently depending on
|
|
|
|
* the on-screen location of the source actor. While painting the
|
|
|
|
* source actor, Clutter will set up a temporary asymmetric
|
|
|
|
* perspective matrix as the projection matrix so that the source
|
|
|
|
* actor will be projected as if a small section of the screen was
|
|
|
|
* being viewed. Before version 0.8.2, an orthogonal identity
|
|
|
|
* projection was used which meant that the source actor would be
|
|
|
|
* clipped if any part of it was not on the zero Z-plane.</para>
|
2008-02-08 13:52:11 +00:00
|
|
|
* </listitem>
|
2008-02-08 10:37:38 +00:00
|
|
|
* <listitem>
|
|
|
|
* <para>Avoid reparenting the source with the created texture.</para>
|
|
|
|
* </listitem>
|
|
|
|
* <listitem>
|
2008-02-12 13:41:44 +00:00
|
|
|
* <para>A group can be padded with a transparent rectangle as to
|
2008-02-08 10:37:38 +00:00
|
|
|
* provide a border to contents for shader output (blurring text
|
|
|
|
* for example).</para>
|
|
|
|
* </listitem>
|
|
|
|
* <listitem>
|
2008-02-12 13:41:44 +00:00
|
|
|
* <para>The texture will automatically resize to contain a further
|
2008-02-15 15:18:02 +00:00
|
|
|
* transformed source. However, this involves overhead and can be
|
2008-02-08 10:37:38 +00:00
|
|
|
* avoided by placing the source actor in a bounding group
|
|
|
|
* sized large enough to contain any child tranformations.</para>
|
|
|
|
* </listitem>
|
|
|
|
* <listitem>
|
2008-03-18 17:56:50 +00:00
|
|
|
* <para>Uploading pixel data to the texture (e.g by using
|
2008-04-25 13:37:36 +00:00
|
|
|
* clutter_actor_set_from_file()) will destroy the offscreen texture data
|
2008-02-15 15:18:02 +00:00
|
|
|
* and end redirection.</para>
|
2008-02-08 10:37:38 +00:00
|
|
|
* </listitem>
|
|
|
|
* <listitem>
|
2008-04-25 13:37:36 +00:00
|
|
|
* <para>cogl_texture_get_data() with the handle returned by
|
|
|
|
* clutter_texture_get_cogl_texture() can be used to read the
|
|
|
|
* offscreen texture pixels into a pixbuf.</para>
|
2008-02-08 10:37:38 +00:00
|
|
|
* </listitem>
|
|
|
|
* </itemizedlist>
|
2008-02-01 15:29:00 +00:00
|
|
|
*
|
2008-02-15 15:18:02 +00:00
|
|
|
* Return value: A newly created #ClutterTexture object, or %NULL on failure.
|
2008-02-08 13:52:11 +00:00
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
2008-02-01 15:29:00 +00:00
|
|
|
ClutterActor *
|
|
|
|
clutter_texture_new_from_actor (ClutterActor *actor)
|
|
|
|
{
|
|
|
|
ClutterTexture *texture;
|
|
|
|
ClutterTexturePrivate *priv;
|
|
|
|
guint w, h;
|
|
|
|
|
2008-02-03 01:53:10 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), NULL);
|
|
|
|
|
2008-02-01 15:29:00 +00:00
|
|
|
if (clutter_feature_available (CLUTTER_FEATURE_OFFSCREEN) == FALSE)
|
|
|
|
return NULL;
|
|
|
|
|
2008-02-03 01:53:10 +00:00
|
|
|
if (!CLUTTER_ACTOR_IS_REALIZED (actor))
|
|
|
|
{
|
|
|
|
clutter_actor_realize (actor);
|
2008-02-01 15:29:00 +00:00
|
|
|
|
2008-02-03 01:53:10 +00:00
|
|
|
if (!CLUTTER_ACTOR_IS_REALIZED (actor))
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-06-10 Emmanuele Bassi <ebassi@openedhand.com>
Bug #815 - Split up request, allocation, and paint box
* clutter/clutter-actor.[ch]: Rework the size allocation,
request and paint area. Now ::request_coords() is called
::allocate(), and ::query_coords() has been split into
::get_preferred_width() and ::get_preferred_height(). See
the documentation and the layout test on how to implement
a container and layout manager with the new API. (#915,
based on a patch by Havoc Pennington, Lucas Rocha and Johan
Bilien)
* clutter/clutter-clone-texture.c: Port CloneTexture to
the new size negotiation API; it just means forwarding
the requests to the parent texture.
* clutter/clutter-deprecated.h: Add deprecated and replaced
API.
* clutter/clutter-entry.c: Port Entry to the new size
negotiation API.
* clutter/clutter-group.c: Port Group to the new size
negotiation API; the semantics of the Group actor do not
change.
* clutter/clutter-label.c: Port Label to the new size
negotiation API, and vastly simplify the code.
* clutter/clutter-main.[ch]: Add API for executing a
relayout when needed.
* clutter/clutter-private.h: Add new Stage private API.
* clutter/clutter-rectangle.c: Update the get_abs_opacity()
call to get_paint_opacity().
* clutter/clutter-stage.c:
(clutter_stage_get_preferred_width),
(clutter_stage_get_preferred_height),
(clutter_stage_allocate),
(clutter_stage_class_init): Port Stage to the new size
negotiation API.
* clutter/clutter-texture.c: Port Texture to the new size
negotiation API.
* clutter/clutter-types.h: Add ClutterRequestMode enumeration.
* clutter/x11/clutter-stage-x11.c: Port the X11 stage
implementation to the new size negotiation API.
* tests/Makefile.am: Add the layout manager test case.
* tests/test-opacity.c: Update.
* tests/test-project.c: Update.
* tests/test-layout.c: Test case for a layout manager implemented
using the new size negotiation API; the layout manager handles
both transformed and untransformed children.
2008-06-10 17:07:52 +00:00
|
|
|
clutter_actor_get_transformed_size (actor, &w, &h);
|
2008-02-01 15:29:00 +00:00
|
|
|
|
2008-02-03 01:53:10 +00:00
|
|
|
if (w == 0 || h == 0)
|
|
|
|
return NULL;
|
2008-02-01 15:29:00 +00:00
|
|
|
|
2008-02-08 10:37:38 +00:00
|
|
|
/* Hopefully now were good.. */
|
2008-12-23 16:29:29 +00:00
|
|
|
texture = g_object_new (CLUTTER_TYPE_TEXTURE,
|
2008-06-06 13:44:22 +00:00
|
|
|
"disable-slicing", TRUE,
|
|
|
|
NULL);
|
2008-02-01 15:29:00 +00:00
|
|
|
|
2008-02-03 01:53:10 +00:00
|
|
|
priv = texture->priv;
|
2008-02-01 15:29:00 +00:00
|
|
|
|
2008-07-04 10:44:18 +00:00
|
|
|
priv->fbo_source = g_object_ref_sink (actor);
|
|
|
|
|
|
|
|
/* If the actor doesn't have a parent then claim it so that it will
|
|
|
|
get a size allocation during layout */
|
|
|
|
if (clutter_actor_get_parent (actor) == NULL)
|
|
|
|
clutter_actor_set_parent (actor, CLUTTER_ACTOR (texture));
|
2008-02-01 15:29:00 +00:00
|
|
|
|
2008-02-06 14:39:04 +00:00
|
|
|
/* Connect up any signals which could change our underlying size */
|
|
|
|
g_signal_connect (actor,
|
|
|
|
"notify::width",
|
|
|
|
G_CALLBACK(on_fbo_source_size_change),
|
|
|
|
texture);
|
|
|
|
g_signal_connect (actor,
|
|
|
|
"notify::height",
|
|
|
|
G_CALLBACK(on_fbo_source_size_change),
|
|
|
|
texture);
|
|
|
|
g_signal_connect (actor,
|
|
|
|
"notify::scale-x",
|
|
|
|
G_CALLBACK(on_fbo_source_size_change),
|
|
|
|
texture);
|
|
|
|
g_signal_connect (actor,
|
|
|
|
"notify::scale-y",
|
|
|
|
G_CALLBACK(on_fbo_source_size_change),
|
|
|
|
texture);
|
|
|
|
g_signal_connect (actor,
|
|
|
|
"notify::rotation-angle-x",
|
|
|
|
G_CALLBACK(on_fbo_source_size_change),
|
|
|
|
texture);
|
|
|
|
g_signal_connect (actor,
|
|
|
|
"notify::rotation-angle-y",
|
|
|
|
G_CALLBACK(on_fbo_source_size_change),
|
|
|
|
texture);
|
|
|
|
g_signal_connect (actor,
|
|
|
|
"notify::rotation-angle-z",
|
|
|
|
G_CALLBACK(on_fbo_source_size_change),
|
|
|
|
texture);
|
|
|
|
|
|
|
|
/* And a warning if the source becomes a child of the texture */
|
|
|
|
g_signal_connect (actor,
|
|
|
|
"parent-set",
|
|
|
|
G_CALLBACK(on_fbo_parent_change),
|
|
|
|
texture);
|
|
|
|
|
2008-02-03 01:53:10 +00:00
|
|
|
priv->width = w;
|
|
|
|
priv->height = h;
|
2008-02-01 15:29:00 +00:00
|
|
|
|
2009-01-12 17:12:24 +00:00
|
|
|
clutter_actor_set_size (CLUTTER_ACTOR (texture), priv->width, priv->height);
|
2008-02-01 15:29:00 +00:00
|
|
|
|
2009-01-12 17:12:24 +00:00
|
|
|
return CLUTTER_ACTOR (texture);
|
2008-02-01 15:29:00 +00:00
|
|
|
}
|
2008-02-03 23:25:12 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
texture_fbo_free_resources (ClutterTexture *texture)
|
|
|
|
{
|
|
|
|
ClutterTexturePrivate *priv;
|
|
|
|
|
|
|
|
priv = texture->priv;
|
|
|
|
|
|
|
|
CLUTTER_MARK();
|
|
|
|
|
|
|
|
if (priv->fbo_source != NULL)
|
|
|
|
{
|
2008-07-04 10:44:18 +00:00
|
|
|
/* If we parented the texture then unparent it again so that it
|
|
|
|
will lose the reference */
|
|
|
|
if (clutter_actor_get_parent (priv->fbo_source)
|
|
|
|
== CLUTTER_ACTOR (texture))
|
|
|
|
clutter_actor_unparent (priv->fbo_source);
|
|
|
|
|
2008-02-12 13:41:44 +00:00
|
|
|
g_signal_handlers_disconnect_by_func
|
|
|
|
(priv->fbo_source,
|
|
|
|
G_CALLBACK(on_fbo_parent_change),
|
2008-02-08 10:37:38 +00:00
|
|
|
texture);
|
2008-02-12 13:41:44 +00:00
|
|
|
|
|
|
|
g_signal_handlers_disconnect_by_func
|
|
|
|
(priv->fbo_source,
|
|
|
|
G_CALLBACK(on_fbo_source_size_change),
|
2008-02-08 10:37:38 +00:00
|
|
|
texture);
|
|
|
|
|
2008-02-03 23:25:12 +00:00
|
|
|
g_object_unref (priv->fbo_source);
|
2008-02-08 10:37:38 +00:00
|
|
|
|
2008-02-03 23:25:12 +00:00
|
|
|
priv->fbo_source = NULL;
|
|
|
|
}
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (priv->fbo_handle != COGL_INVALID_HANDLE)
|
2008-02-03 23:25:12 +00:00
|
|
|
{
|
2008-04-25 13:37:36 +00:00
|
|
|
cogl_offscreen_unref (priv->fbo_handle);
|
|
|
|
priv->fbo_handle = COGL_INVALID_HANDLE;
|
2008-02-03 23:25:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
GType
|
|
|
|
clutter_texture_handle_get_type (void)
|
|
|
|
{
|
|
|
|
static GType our_type = 0;
|
|
|
|
|
|
|
|
if (G_UNLIKELY (!our_type))
|
|
|
|
{
|
|
|
|
our_type =
|
|
|
|
g_boxed_type_register_static (I_("ClutterTextureHandle"),
|
|
|
|
(GBoxedCopyFunc) cogl_texture_ref,
|
|
|
|
(GBoxedFreeFunc) cogl_texture_unref);
|
|
|
|
}
|
|
|
|
|
|
|
|
return our_type;
|
|
|
|
}
|