Debian Codegraph @

clutter/deprecated/clutter-actor-deprecated.c

raw
1 #ifdef HAVE_CONFIG_H
2 #include "config.h"
3 #endif
4
5 #include <glib-object.h>
6
7 #define CLUTTER_DISABLE_DEPRECATION_WARNINGS
8 #include "deprecated/clutter-actor.h"
9
10 #include "clutter-actor-private.h"
11 #include "clutter-private.h"
12 #include "clutter-shader.h"
13
14 typedef struct _ShaderData ShaderData;
15
16 struct _ShaderData
17 {
18 ClutterShader *shader;
19
20 /* back pointer to the actor */
21 ClutterActor *actor;
22
23 /* list of values that should be set on the shader
24 * before each paint cycle
25 */
26 GHashTable *value_hash;
27 };
28
29 static void
30 shader_value_free (gpointer data)
31 {
32 GValue *var = data;
33 g_value_unset (var);
34 g_slice_free (GValue, var);
35 }
36
37 static void
38 destroy_shader_data (gpointer data)
39 {
40 ShaderData *shader_data = data;
41
42 if (shader_data == NULL)
43 return;
44
45 if (shader_data->shader != NULL)
46 {
47 g_object_unref (shader_data->shader);
48 shader_data->shader = NULL;
49 }
50
51 if (shader_data->value_hash != NULL)
52 {
53 g_hash_table_destroy (shader_data->value_hash);
54 shader_data->value_hash = NULL;
55 }
56
57 g_slice_free (ShaderData, shader_data);
58 }
59
60 /**
61 * clutter_actor_get_shader:
62 * @self: a #ClutterActor
63 *
64 * Queries the currently set #ClutterShader on @self.
65 *
66 * Return value: (transfer none): The currently set #ClutterShader
67 * or %NULL if no shader is set.
68 *
69 * Since: 0.6
70 *
71 * Deprecated: 1.8: Use clutter_actor_get_effect() instead.
72 */
73 ClutterShader *
74 clutter_actor_get_shader (ClutterActor *self)
75 {
76 ShaderData *shader_data;
77
78 g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
79
80 shader_data = g_object_get_data (G_OBJECT (self), "-clutter-actor-shader-data");
81 if (shader_data != NULL)
82 return shader_data->shader;
83
84 return NULL;
85 }
86
87 /**
88 * clutter_actor_set_shader:
89 * @self: a #ClutterActor
90 * @shader: (allow-none): a #ClutterShader or %NULL to unset the shader.
91 *
92 * Sets the #ClutterShader to be used when rendering @self.
93 *
94 * If @shader is %NULL this function will unset any currently set shader
95 * for the actor.
96 *
97 * Any #ClutterEffect applied to @self will take the precedence
98 * over the #ClutterShader set using this function.
99 *
100 * Return value: %TRUE if the shader was successfully applied
101 * or removed
102 *
103 * Since: 0.6
104 *
105 * Deprecated: 1.8: Use #ClutterShaderEffect and
106 * clutter_actor_add_effect() instead.
107 */
108 gboolean
109 clutter_actor_set_shader (ClutterActor *self,
110 ClutterShader *shader)
111 {
112 ShaderData *shader_data;
113
114 g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
115 g_return_val_if_fail (shader == NULL || CLUTTER_IS_SHADER (shader), FALSE);
116
117 if (shader != NULL)
118 g_object_ref (shader);
119 else
120 {
121 /* if shader passed in is NULL we destroy the shader */
122 g_object_set_data (G_OBJECT (self), "-clutter-actor-shader-data", NULL);
123 return TRUE;
124 }
125
126 shader_data = g_object_get_data (G_OBJECT (self), "-clutter-actor-shader-data");
127 if (shader_data == NULL)
128 {
129 shader_data = g_slice_new (ShaderData);
130 shader_data->actor = self;
131 shader_data->shader = NULL;
132 shader_data->value_hash =
133 g_hash_table_new_full (g_str_hash, g_str_equal,
134 g_free,
135 shader_value_free);
136
137 g_object_set_data_full (G_OBJECT (self), "-clutter-actor-shader-data",
138 shader_data,
139 destroy_shader_data);
140 }
141
142 if (shader_data->shader != NULL)
143 g_object_unref (shader_data->shader);
144
145 shader_data->shader = shader;
146
147 clutter_actor_queue_redraw (self);
148
149 return TRUE;
150 }
151
152 static void
153 set_each_param (gpointer key,
154 gpointer value,
155 gpointer user_data)
156 {
157 ClutterShader *shader = user_data;
158 const gchar *uniform = key;
159 GValue *var = value;
160
161 clutter_shader_set_uniform (shader, uniform, var);
162 }
163
164 void
165 _clutter_actor_shader_pre_paint (ClutterActor *actor,
166 gboolean repeat)
167 {
168 ShaderData *shader_data;
169 ClutterShader *shader;
170
171 shader_data = g_object_get_data (G_OBJECT (actor), "-clutter-actor-shader-data");
172 if (shader_data == NULL)
173 return;
174
175 shader = shader_data->shader;
176 if (shader != NULL)
177 {
178 clutter_shader_set_is_enabled (shader, TRUE);
179
180 g_hash_table_foreach (shader_data->value_hash, set_each_param, shader);
181
182 if (!repeat)
183 _clutter_context_push_shader_stack (actor);
184 }
185 }
186
187 void
188 _clutter_actor_shader_post_paint (ClutterActor *actor)
189 {
190 ShaderData *shader_data;
191 ClutterShader *shader;
192
193 shader_data = g_object_get_data (G_OBJECT (actor), "-clutter-actor-shader-data");
194 if (G_LIKELY (shader_data == NULL))
195 return;
196
197 shader = shader_data->shader;
198 if (shader != NULL)
199 {
200 ClutterActor *head;
201
202 clutter_shader_set_is_enabled (shader, FALSE);
203
204 /* remove the actor from the shaders stack; if there is another
205 * actor inside it, then call pre-paint again to set its shader
206 * but this time with the second argument being TRUE, indicating
207 * that we are re-applying an existing shader and thus should it
208 * not be prepended to the stack
209 */
210 head = _clutter_context_pop_shader_stack (actor);
211 if (head != NULL)
212 _clutter_actor_shader_pre_paint (head, TRUE);
213 }
214 }
215
216 static inline void
217 clutter_actor_set_shader_param_internal (ClutterActor *self,
218 const gchar *param,
219 const GValue *value)
220 {
221 ShaderData *shader_data;
222 GValue *var;
223
224 shader_data = g_object_get_data (G_OBJECT (self), "-clutter-actor-shader-data");
225 if (shader_data == NULL)
226 return;
227
228 var = g_slice_new0 (GValue);
229 g_value_init (var, G_VALUE_TYPE (value));
230 g_value_copy (value, var);
231 g_hash_table_insert (shader_data->value_hash, g_strdup (param), var);
232
233 clutter_actor_queue_redraw (self);
234 }
235
236 /**
237 * clutter_actor_set_shader_param:
238 * @self: a #ClutterActor
239 * @param: the name of the parameter
240 * @value: the value of the parameter
241 *
242 * Sets the value for a named parameter of the shader applied
243 * to @actor.
244 *
245 * Since: 1.0
246 *
247 * Deprecated: 1.8: Use clutter_shader_effect_set_uniform_value() instead
248 */
249 void
250 clutter_actor_set_shader_param (ClutterActor *self,
251 const gchar *param,
252 const GValue *value)
253 {
254 g_return_if_fail (CLUTTER_IS_ACTOR (self));
255 g_return_if_fail (param != NULL);
256 g_return_if_fail (CLUTTER_VALUE_HOLDS_SHADER_FLOAT (value) ||
257 CLUTTER_VALUE_HOLDS_SHADER_INT (value) ||
258 CLUTTER_VALUE_HOLDS_SHADER_MATRIX (value) ||
259 G_VALUE_HOLDS_FLOAT (value) ||
260 G_VALUE_HOLDS_INT (value));
261
262 clutter_actor_set_shader_param_internal (self, param, value);
263 }
264
265 /**
266 * clutter_actor_set_shader_param_float:
267 * @self: a #ClutterActor
268 * @param: the name of the parameter
269 * @value: the value of the parameter
270 *
271 * Sets the value for a named float parameter of the shader applied
272 * to @actor.
273 *
274 * Since: 0.8
275 *
276 * Deprecated: 1.8: Use clutter_shader_effect_set_uniform() instead
277 */
278 void
279 clutter_actor_set_shader_param_float (ClutterActor *self,
280 const gchar *param,
281 gfloat value)
282 {
283 GValue var = { 0, };
284
285 g_value_init (&var, G_TYPE_FLOAT);
286 g_value_set_float (&var, value);
287
288 clutter_actor_set_shader_param_internal (self, param, &var);
289
290 g_value_unset (&var);
291 }
292
293 /**
294 * clutter_actor_set_shader_param_int:
295 * @self: a #ClutterActor
296 * @param: the name of the parameter
297 * @value: the value of the parameter
298 *
299 * Sets the value for a named int parameter of the shader applied to
300 * @actor.
301 *
302 * Since: 0.8
303 *
304 * Deprecated: 1.8: Use clutter_shader_effect_set_uniform() instead
305 */
306 void
307 clutter_actor_set_shader_param_int (ClutterActor *self,
308 const gchar *param,
309 gint value)
310 {
311 GValue var = { 0, };
312
313 g_value_init (&var, G_TYPE_INT);
314 g_value_set_int (&var, value);
315
316 clutter_actor_set_shader_param_internal (self, param, &var);
317
318 g_value_unset (&var);
319 }
320
321 /**
322 * clutter_actor_set_geometry:
323 * @self: A #ClutterActor
324 * @geometry: A #ClutterGeometry
325 *
326 * Sets the actor's fixed position and forces its minimum and natural
327 * size, in pixels. This means the untransformed actor will have the
328 * given geometry. This is the same as calling clutter_actor_set_position()
329 * and clutter_actor_set_size().
330 *
331 * Deprecated: 1.10: Use clutter_actor_set_position() and
332 * clutter_actor_set_size() instead.
333 */
334 void
335 clutter_actor_set_geometry (ClutterActor *self,
336 const ClutterGeometry *geometry)
337 {
338 g_object_freeze_notify (G_OBJECT (self));
339
340 clutter_actor_set_position (self, geometry->x, geometry->y);
341 clutter_actor_set_size (self, geometry->width, geometry->height);
342
343 g_object_thaw_notify (G_OBJECT (self));
344 }
345
346 /**
347 * clutter_actor_get_geometry:
348 * @self: A #ClutterActor
349 * @geometry: (out caller-allocates): A location to store actors #ClutterGeometry
350 *
351 * Gets the size and position of an actor relative to its parent
352 * actor. This is the same as calling clutter_actor_get_position() and
353 * clutter_actor_get_size(). It tries to "do what you mean" and get the
354 * requested size and position if the actor's allocation is invalid.
355 *
356 * Deprecated: 1.10: Use clutter_actor_get_position() and
357 * clutter_actor_get_size(), or clutter_actor_get_allocation_geometry()
358 * instead.
359 */
360 void
361 clutter_actor_get_geometry (ClutterActor *self,
362 ClutterGeometry *geometry)
363 {
364 gfloat x, y, width, height;
365
366 g_return_if_fail (CLUTTER_IS_ACTOR (self));
367 g_return_if_fail (geometry != NULL);
368
369 clutter_actor_get_position (self, &x, &y);
370 clutter_actor_get_size (self, &width, &height);
371
372 geometry->x = (int) x;
373 geometry->y = (int) y;
374 geometry->width = (int) width;
375 geometry->height = (int) height;
376 }
377
378 /**
379 * clutter_actor_get_allocation_geometry:
380 * @self: A #ClutterActor
381 * @geom: (out): allocation geometry in pixels
382 *
383 * Gets the layout box an actor has been assigned. The allocation can
384 * only be assumed valid inside a paint() method; anywhere else, it
385 * may be out-of-date.
386 *
387 * An allocation does not incorporate the actor's scale or anchor point;
388 * those transformations do not affect layout, only rendering.
389 *
390 * The returned rectangle is in pixels.
391 *
392 * Since: 0.8
393 *
394 * Deprecated: 1.12: Use clutter_actor_get_allocation_box() instead.
395 */
396 void
397 clutter_actor_get_allocation_geometry (ClutterActor *self,
398 ClutterGeometry *geom)
399 {
400 ClutterActorBox box;
401
402 g_return_if_fail (CLUTTER_IS_ACTOR (self));
403 g_return_if_fail (geom != NULL);
404
405 clutter_actor_get_allocation_box (self, &box);
406
407 geom->x = CLUTTER_NEARBYINT (clutter_actor_box_get_x (&box));
408 geom->y = CLUTTER_NEARBYINT (clutter_actor_box_get_y (&box));
409 geom->width = CLUTTER_NEARBYINT (clutter_actor_box_get_width (&box));
410 geom->height = CLUTTER_NEARBYINT (clutter_actor_box_get_height (&box));
411 }