static void
paint (TestState *state)
{
CoglColor bg;
int i;
cogl_set_source_color4ub (255, 255, 255, 255);
/* We push the third framebuffer first so that later we can switch
back to it by popping to test that that works */
cogl_push_framebuffer (state->fbo[2]);
cogl_push_framebuffer (state->fbo[0]);
cogl_rectangle (-1.0, -1.0, 1.0, 1.0);
cogl_pop_framebuffer ();
cogl_push_framebuffer (state->fbo[1]);
cogl_rectangle (-1.0, -1.0, 1.0, 1.0);
cogl_pop_framebuffer ();
/* We should now be back on the third framebuffer */
cogl_rectangle (-1.0, -1.0, 1.0, 1.0);
cogl_pop_framebuffer ();
cogl_color_init_from_4ub (&bg, 128, 128, 128, 255);
cogl_clear (&bg, COGL_BUFFER_BIT_COLOR | COGL_BUFFER_BIT_DEPTH);
/* Render all of the textures to the screen */
for (i = 0; i < NUM_FBOS; i++)
{
cogl_set_source_texture (state->tex[i]);
cogl_rectangle (2.0f / NUM_FBOS * i - 1.0f, -1.0f,
2.0f / NUM_FBOS * (i + 1) - 1.0f, 1.0f);
}
/* Verify all of the fbos drew the right color */
for (i = 0; i < NUM_FBOS; i++)
{
guint8 expected_colors[NUM_FBOS][4] =
{ { 0xff, 0x00, 0x00, 0xff },
{ 0x00, 0xff, 0x00, 0xff },
{ 0x00, 0x00, 0xff, 0xff } };
test_utils_check_pixel_rgb (state->width * (i + 0.5f) / NUM_FBOS,
state->height / 2,
expected_colors[i][0],
expected_colors[i][1],
expected_colors[i][2]);
}
}
void
test_just_vertex_shader (void)
{
TestState state;
cogl_framebuffer_orthographic (test_fb,
0, 0,
cogl_framebuffer_get_width (test_fb),
cogl_framebuffer_get_height (test_fb),
-1,
100);
/* XXX: we have to push/pop a framebuffer since this test currently
* uses the legacy cogl_rectangle() api. */
cogl_push_framebuffer (test_fb);
paint_legacy (&state);
validate_result (test_fb);
paint (&state);
validate_result (test_fb);
cogl_pop_framebuffer ();
if (cogl_test_verbose ())
g_print ("OK\n");
}
static gboolean
_cogl_blit_copy_tex_sub_image_begin (CoglBlitData *data)
{
CoglHandle fbo;
_COGL_GET_CONTEXT (ctx, FALSE);
/* This will only work if the target texture is a CoglTexture2D */
if (!cogl_is_texture_2d (data->dst_tex))
return FALSE;
fbo = _cogl_offscreen_new_to_texture_full
(data->src_tex, COGL_OFFSCREEN_DISABLE_DEPTH_AND_STENCIL, 0 /* level */);
if (fbo == COGL_INVALID_HANDLE)
return FALSE;
if (!cogl_framebuffer_allocate (fbo, NULL))
{
cogl_handle_unref (fbo);
return FALSE;
}
cogl_push_framebuffer (fbo);
cogl_handle_unref (fbo);
return TRUE;
}
CoglHandle
_st_create_shadow_material_from_actor (StShadow *shadow_spec,
ClutterActor *actor)
{
CoglHandle shadow_material = COGL_INVALID_HANDLE;
if (CLUTTER_IS_TEXTURE (actor))
{
CoglHandle texture;
texture = clutter_texture_get_cogl_texture (CLUTTER_TEXTURE (actor));
shadow_material = _st_create_shadow_material (shadow_spec, texture);
}
else
{
CoglHandle buffer, offscreen;
ClutterActorBox box;
CoglColor clear_color;
float width, height;
clutter_actor_get_allocation_box (actor, &box);
clutter_actor_box_get_size (&box, &width, &height);
if (width == 0 || height == 0)
return COGL_INVALID_HANDLE;
buffer = st_cogl_texture_new_with_size_wrapper (width, height,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_ANY);
if (buffer == COGL_INVALID_HANDLE)
return COGL_INVALID_HANDLE;
offscreen = cogl_offscreen_new_to_texture (buffer);
if (offscreen == COGL_INVALID_HANDLE)
{
cogl_handle_unref (buffer);
return COGL_INVALID_HANDLE;
}
cogl_color_set_from_4ub (&clear_color, 0, 0, 0, 0);
cogl_push_framebuffer (offscreen);
cogl_clear (&clear_color, COGL_BUFFER_BIT_COLOR);
cogl_translate (-box.x1, -box.y1, 0);
cogl_ortho (0, width, height, 0, 0, 1.0);
clutter_actor_paint (actor);
cogl_pop_framebuffer ();
cogl_handle_unref (offscreen);
shadow_material = _st_create_shadow_material (shadow_spec, buffer);
cogl_handle_unref (buffer);
}
return shadow_material;
}
static void
st_background_effect_paint_target (ClutterOffscreenEffect *effect)
{
StBackgroundEffect *self = ST_BACKGROUND_EFFECT (effect);
if ((self->bg_texture != NULL) && (self->opacity == 0xff))
{
cogl_push_source (self->pipeline2);
cogl_rectangle (0.0f, 0.0f, (self->fg_width_i), (self->fg_height_i));
cogl_pop_source ();
CoglOffscreen *vertical_FBO;
vertical_FBO = cogl_offscreen_new_to_texture (self->bg_sub_texture);
cogl_push_framebuffer ((CoglFramebuffer*)vertical_FBO);
cogl_push_source (self->pipeline0);
cogl_rectangle (-1.0f, 1.0f, 1.0f, -1.0f);
cogl_pop_source ();
cogl_pop_framebuffer ();
cogl_handle_unref (vertical_FBO);
cogl_pipeline_set_layer_texture (self->pipeline1, 0, self->bg_sub_texture);
cogl_push_source (self->pipeline1);
cogl_rectangle (4.0f, 4.0f, (self->bg_width_i) + 4.0f,
(self->bg_height_i) + 4.0f);
cogl_pop_source ();
}
cogl_pipeline_set_color4ub (self->pipeline3,
0x00,
0x00,
0x00,
0x80);
cogl_push_source (self->pipeline3);
cogl_rectangle (0.0f, 0.0f, (self->fg_width_i), (self->fg_height_i));
cogl_pop_source ();
clutter_actor_queue_redraw (self->actor);
cogl_pipeline_set_color4ub (self->pipeline4,
self->opacity,
self->opacity,
self->opacity,
self->opacity);
cogl_push_source (self->pipeline4);
cogl_rectangle (0.0f, 0.0f, (self->fg_width_i), (self->fg_height_i));
cogl_pop_source ();
clutter_actor_queue_redraw (self->actor);
}
static void
cogland_compositor_create_output (CoglandCompositor *compositor,
int x,
int y,
int width_mm,
int height_mm)
{
CoglandOutput *output = g_slice_new0 (CoglandOutput);
CoglFramebuffer *fb;
GError *error = NULL;
CoglandMode *mode;
output->x = x;
output->y = y;
output->width_mm = width_mm;
output->height_mm = height_mm;
output->wayland_output.interface = &wl_output_interface;
wl_display_add_global (compositor->wayland_display,
&wl_output_interface,
output,
bind_output);
output->onscreen = cogl_onscreen_new (compositor->cogl_context,
width_mm, height_mm);
/* Eventually there will be an implicit allocate on first use so this
* will become optional... */
fb = COGL_FRAMEBUFFER (output->onscreen);
if (!cogl_framebuffer_allocate (fb, &error))
g_error ("Failed to allocate framebuffer: %s\n", error->message);
cogl_onscreen_show (output->onscreen);
#if 0
cogl_framebuffer_set_viewport (fb, x, y, width, height);
#else
cogl_push_framebuffer (fb);
cogl_set_viewport (-x, -y,
compositor->virtual_width,
compositor->virtual_height);
cogl_pop_framebuffer ();
#endif
mode = g_slice_new0 (CoglandMode);
mode->flags = 0;
mode->width = width_mm;
mode->height = height_mm;
mode->refresh = 60;
output->modes = g_list_prepend (output->modes, mode);
compositor->outputs = g_list_prepend (compositor->outputs, output);
}
static gboolean
paint_cb (void *user_data)
{
CoglandCompositor *compositor = user_data;
GList *l;
for (l = compositor->outputs; l; l = l->next)
{
CoglandOutput *output = l->data;
CoglFramebuffer *fb = COGL_FRAMEBUFFER (output->onscreen);
GList *l2;
cogl_push_framebuffer (fb);
cogl_framebuffer_clear4f (fb, COGL_BUFFER_BIT_COLOR, 0, 0, 0, 1);
cogl_framebuffer_draw_primitive (fb, compositor->triangle_pipeline,
compositor->triangle);
for (l2 = compositor->surfaces; l2; l2 = l2->next)
{
CoglandSurface *surface = l2->data;
if (surface->buffer)
{
CoglTexture2D *texture = surface->buffer->texture;
cogl_set_source_texture (COGL_TEXTURE (texture));
cogl_rectangle (-1, 1, 1, -1);
}
}
cogl_framebuffer_swap_buffers (fb);
cogl_pop_framebuffer ();
}
while (!g_queue_is_empty (&compositor->frame_callbacks))
{
CoglandFrameCallback *callback =
g_queue_peek_head (&compositor->frame_callbacks);
wl_resource_post_event (&callback->resource,
WL_CALLBACK_DONE, get_time ());
wl_resource_destroy (&callback->resource, 0);
}
return TRUE;
}
static CoglHandle
data_to_cogl_handle (const guchar *data,
gboolean has_alpha,
int width,
int height,
int rowstride,
gboolean add_padding)
{
CoglHandle texture, offscreen;
CoglColor clear_color;
guint size;
size = MAX (width, height);
if (!add_padding || width == height)
return cogl_texture_new_from_data (width,
height,
COGL_TEXTURE_NONE,
has_alpha ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888,
COGL_PIXEL_FORMAT_ANY,
rowstride,
data);
texture = cogl_texture_new_with_size (size, size,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_ANY);
offscreen = cogl_offscreen_new_to_texture (texture);
cogl_color_set_from_4ub (&clear_color, 0, 0, 0, 0);
cogl_push_framebuffer (offscreen);
cogl_clear (&clear_color, COGL_BUFFER_BIT_COLOR);
cogl_pop_framebuffer ();
cogl_handle_unref (offscreen);
cogl_texture_set_region (texture,
0, 0,
(size - width) / 2, (size - height) / 2,
width, height,
width, height,
has_alpha ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888,
rowstride,
data);
return texture;
}
static CoglHandle
pixbuf_to_cogl_handle (GdkPixbuf *pixbuf,
gboolean add_padding)
{
CoglHandle texture, offscreen;
CoglColor clear_color;
int width, height;
guint size;
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
size = MAX (width, height);
if (!add_padding || width == height)
return cogl_texture_new_from_data (width,
height,
COGL_TEXTURE_NONE,
gdk_pixbuf_get_has_alpha (pixbuf) ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888,
COGL_PIXEL_FORMAT_ANY,
gdk_pixbuf_get_rowstride (pixbuf),
gdk_pixbuf_get_pixels (pixbuf));
texture = cogl_texture_new_with_size (size, size,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_ANY);
offscreen = cogl_offscreen_new_to_texture (texture);
cogl_color_set_from_4ub (&clear_color, 0, 0, 0, 0);
cogl_push_framebuffer (offscreen);
cogl_clear (&clear_color, COGL_BUFFER_BIT_COLOR);
cogl_pop_framebuffer ();
cogl_handle_unref (offscreen);
cogl_texture_set_region (texture,
0, 0,
(size - width) / 2, (size - height) / 2,
width, height,
width, height,
gdk_pixbuf_get_has_alpha (pixbuf) ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888,
gdk_pixbuf_get_rowstride (pixbuf),
gdk_pixbuf_get_pixels (pixbuf));
return texture;
}
static void
paint (TestState *state)
{
float stage_viewport[4];
CoglMatrix stage_projection;
CoglMatrix stage_modelview;
paint_test_backface_culling (state);
/*
* Now repeat the test but rendered to an offscreen
* framebuffer. Note that by default the conformance tests are
* always run to an offscreen buffer but we might as well have this
* check anyway in case it is being run with COGL_TEST_ONSCREEN=1
*/
cogl_get_viewport (stage_viewport);
cogl_get_projection_matrix (&stage_projection);
cogl_get_modelview_matrix (&stage_modelview);
cogl_push_framebuffer (state->offscreen);
cogl_set_viewport (stage_viewport[0],
stage_viewport[1],
stage_viewport[2],
stage_viewport[3]);
cogl_set_projection_matrix (&stage_projection);
cogl_set_modelview_matrix (&stage_modelview);
paint_test_backface_culling (state);
cogl_pop_framebuffer ();
/* Incase we want feedback of what was drawn offscreen we draw it
* to the stage... */
cogl_set_source_texture (state->offscreen_tex);
cogl_rectangle (0, TEXTURE_RENDER_SIZE * 16,
stage_viewport[2],
stage_viewport[3] + TEXTURE_RENDER_SIZE * 16);
validate_result (0);
validate_result (16);
}
static gboolean
paint_cb (void *user_data)
{
CoglandCompositor *compositor = user_data;
GList *l;
for (l = compositor->outputs; l; l = l->next)
{
CoglandOutput *output = l->data;
CoglFramebuffer *fb = COGL_FRAMEBUFFER (output->onscreen);
GList *l2;
cogl_push_framebuffer (fb);
#if 0
cogl_framebuffer_clear (fb, COGL_BUFFER_BIT_COLOR);
#else
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
#endif
cogl_primitive_draw (compositor->triangle);
for (l2 = compositor->surfaces; l2; l2 = l2->next)
{
CoglandSurface *surface = l2->data;
if (surface->buffer)
{
CoglTexture2D *texture = surface->buffer->texture;
cogl_set_source_texture (texture);
cogl_rectangle (-1, 1, 1, -1);
}
wl_display_post_frame (compositor->wayland_display,
&surface->wayland_surface, get_time ());
}
cogl_framebuffer_swap_buffers (fb);
cogl_pop_framebuffer ();
}
return TRUE;
}
static int test_init (TestData* data)
{
CoglOnscreen *onscreen;
GError *error = NULL;
CoglVertexP2C4 triangle_vertices[] = {
{0, 0.7, 0xff, 0x00, 0x00, 0x80},
{-0.7, -0.7, 0x00, 0xff, 0x00, 0xff},
{0.7, -0.7, 0x00, 0x00, 0xff, 0xff}
};
cogl_android_set_native_window (data->app->window);
data->context = cogl_context_new (NULL, &error);
if (!data->context)
{
g_critical ("Failed to create context: %s\n", error->message);
return 1;
}
onscreen = cogl_onscreen_new (data->context, 320, 420);
/* Eventually there will be an implicit allocate on first use so this
* will become optional... */
data->fb = COGL_FRAMEBUFFER (onscreen);
if (!cogl_framebuffer_allocate (data->fb, &error))
{
if (error)
g_critical ("Failed to allocate framebuffer: %s\n", error->message);
else
g_critical ("Failed to allocate framebuffer");
return 1;
}
cogl_onscreen_show (onscreen);
cogl_push_framebuffer (data->fb);
data->triangle = cogl_primitive_new_p2c4 (COGL_VERTICES_MODE_TRIANGLES,
3, triangle_vertices);
return 0;
}
void
test_cogl_color_mask (TestUtilsGTestFixture *fixture,
void *data)
{
TestUtilsSharedState *shared_state = data;
TestState state;
CoglColor bg;
int i;
state.width = cogl_framebuffer_get_width (shared_state->fb);
state.height = cogl_framebuffer_get_height (shared_state->fb);
cogl_color_init_from_4ub (&bg, 0, 0, 0, 255);
for (i = 0; i < NUM_FBOS; i++)
{
state.tex[i] = cogl_texture_new_with_size (128, 128,
COGL_TEXTURE_NO_ATLAS,
COGL_PIXEL_FORMAT_RGB_888);
state.fbo[i] = cogl_offscreen_new_to_texture (state.tex[i]);
/* Clear the texture color bits */
cogl_push_framebuffer (state.fbo[i]);
cogl_clear (&bg, COGL_BUFFER_BIT_COLOR);
cogl_pop_framebuffer ();
cogl_framebuffer_set_color_mask (state.fbo[i],
i == 0 ? COGL_COLOR_MASK_RED :
i == 1 ? COGL_COLOR_MASK_GREEN :
COGL_COLOR_MASK_BLUE);
}
paint (&state);
if (g_test_verbose ())
g_print ("OK\n");
}
static gboolean
get_texture_bits_via_offscreen (CoglHandle texture_handle,
int x,
int y,
int width,
int height,
guint8 *dst_bits,
unsigned int dst_rowstride,
CoglPixelFormat dst_format)
{
CoglFramebuffer *framebuffer;
_COGL_GET_CONTEXT (ctx, FALSE);
if (!cogl_features_available (COGL_FEATURE_OFFSCREEN))
return FALSE;
framebuffer = _cogl_offscreen_new_to_texture_full
(texture_handle,
COGL_OFFSCREEN_DISABLE_DEPTH_AND_STENCIL,
0);
if (framebuffer == NULL)
return FALSE;
cogl_push_framebuffer (framebuffer);
_cogl_read_pixels_with_rowstride (x, y, width, height,
COGL_READ_PIXELS_COLOR_BUFFER,
dst_format, dst_bits, dst_rowstride);
cogl_pop_framebuffer ();
cogl_object_unref (framebuffer);
return TRUE;
}
CoglPipeline *
_st_create_shadow_pipeline_from_actor (StShadow *shadow_spec,
ClutterActor *actor)
{
CoglPipeline *shadow_pipeline = NULL;
if (CLUTTER_IS_TEXTURE (actor))
{
CoglTexture *texture;
texture = clutter_texture_get_cogl_texture (CLUTTER_TEXTURE (actor));
shadow_pipeline = _st_create_shadow_pipeline (shadow_spec, texture);
}
else
{
CoglTexture *buffer;
CoglOffscreen *offscreen;
CoglFramebuffer *fb;
ClutterActorBox box;
CoglColor clear_color;
float width, height;
CoglError *catch_error = NULL;
clutter_actor_get_allocation_box (actor, &box);
clutter_actor_box_get_size (&box, &width, &height);
if (width == 0 || height == 0)
return NULL;
buffer = cogl_texture_new_with_size (width,
height,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_ANY);
if (buffer == NULL)
return NULL;
offscreen = cogl_offscreen_new_with_texture (buffer);
fb = COGL_FRAMEBUFFER (offscreen);
if (!cogl_framebuffer_allocate (fb, &catch_error))
{
cogl_error_free (catch_error);
cogl_object_unref (buffer);
return NULL;
}
cogl_color_init_from_4ub (&clear_color, 0, 0, 0, 0);
/* XXX: There's no way to render a ClutterActor to an offscreen
* as it uses the implicit API. */
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
cogl_push_framebuffer (fb);
G_GNUC_END_IGNORE_DEPRECATIONS;
cogl_framebuffer_clear (fb, COGL_BUFFER_BIT_COLOR, &clear_color);
cogl_framebuffer_translate (fb, -box.x1, -box.y1, 0);
cogl_framebuffer_orthographic (fb, 0, 0, width, height, 0, 1.0);
clutter_actor_set_opacity_override (actor, 255);
clutter_actor_paint (actor);
clutter_actor_set_opacity_override (actor, -1);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
cogl_pop_framebuffer ();
G_GNUC_END_IGNORE_DEPRECATIONS;
cogl_object_unref (fb);
shadow_pipeline = _st_create_shadow_pipeline (shadow_spec, buffer);
cogl_object_unref (buffer);
}
return shadow_pipeline;
}
static gboolean
setup_framebuffers (StThemeNodeTransition *transition,
const ClutterActorBox *allocation)
{
StThemeNodeTransitionPrivate *priv = transition->priv;
CoglColor clear_color = { 0, 0, 0, 0 };
guint width, height;
/* template material to avoid unnecessary shader compilation */
static CoglHandle material_template = COGL_INVALID_HANDLE;
width = priv->offscreen_box.x2 - priv->offscreen_box.x1;
height = priv->offscreen_box.y2 - priv->offscreen_box.y1;
g_return_val_if_fail (width > 0, FALSE);
g_return_val_if_fail (height > 0, FALSE);
if (priv->old_texture)
cogl_handle_unref (priv->old_texture);
priv->old_texture = cogl_texture_new_with_size (width, height,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_ANY);
if (priv->new_texture)
cogl_handle_unref (priv->new_texture);
priv->new_texture = cogl_texture_new_with_size (width, height,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_ANY);
g_return_val_if_fail (priv->old_texture != COGL_INVALID_HANDLE, FALSE);
g_return_val_if_fail (priv->new_texture != COGL_INVALID_HANDLE, FALSE);
if (priv->old_offscreen)
cogl_handle_unref (priv->old_offscreen);
priv->old_offscreen = cogl_offscreen_new_to_texture (priv->old_texture);
if (priv->new_offscreen)
cogl_handle_unref (priv->new_offscreen);
priv->new_offscreen = cogl_offscreen_new_to_texture (priv->new_texture);
g_return_val_if_fail (priv->old_offscreen != COGL_INVALID_HANDLE, FALSE);
g_return_val_if_fail (priv->new_offscreen != COGL_INVALID_HANDLE, FALSE);
if (priv->material == NULL)
{
if (G_UNLIKELY (material_template == COGL_INVALID_HANDLE))
{
material_template = cogl_material_new ();
cogl_material_set_layer_combine (material_template, 0,
"RGBA = REPLACE (TEXTURE)",
NULL);
cogl_material_set_layer_combine (material_template, 1,
"RGBA = INTERPOLATE (PREVIOUS, "
"TEXTURE, "
"CONSTANT[A])",
NULL);
cogl_material_set_layer_combine (material_template, 2,
"RGBA = MODULATE (PREVIOUS, "
"PRIMARY)",
NULL);
}
priv->material = cogl_material_copy (material_template);
}
cogl_material_set_layer (priv->material, 0, priv->new_texture);
cogl_material_set_layer (priv->material, 1, priv->old_texture);
cogl_push_framebuffer (priv->old_offscreen);
cogl_clear (&clear_color, COGL_BUFFER_BIT_COLOR);
cogl_ortho (priv->offscreen_box.x1, priv->offscreen_box.x2,
priv->offscreen_box.y2, priv->offscreen_box.y1,
0.0, 1.0);
st_theme_node_paint (priv->old_theme_node, allocation, 255);
cogl_pop_framebuffer ();
cogl_push_framebuffer (priv->new_offscreen);
cogl_clear (&clear_color, COGL_BUFFER_BIT_COLOR);
cogl_ortho (priv->offscreen_box.x1, priv->offscreen_box.x2,
priv->offscreen_box.y2, priv->offscreen_box.y1,
0.0, 1.0);
st_theme_node_paint (priv->new_theme_node, allocation, 255);
cogl_pop_framebuffer ();
return TRUE;
}
static CoglHandle
data_to_cogl_handle (const guchar *data,
gboolean has_alpha,
int width,
int height,
int rowstride,
gboolean add_padding)
{
CoglHandle texture, offscreen;
CoglColor clear_color;
guint size;
GError *error;
size = MAX (width, height);
if (!add_padding || width == height)
return cogl_texture_new_from_data (width,
height,
COGL_TEXTURE_NONE,
has_alpha ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888,
COGL_PIXEL_FORMAT_ANY,
rowstride,
data);
texture = cogl_texture_new_with_size (size, size,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_ANY);
offscreen = cogl_offscreen_new_with_texture (texture);
error = NULL;
if (!cogl_framebuffer_allocate (offscreen, &error))
{
g_warning ("Failed to allocate FBO (sized %d): %s", size, error->message);
cogl_object_unref (texture);
cogl_object_unref (offscreen);
g_clear_error (&error);
return cogl_texture_new_from_data (width,
height,
COGL_TEXTURE_NONE,
has_alpha ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888,
COGL_PIXEL_FORMAT_ANY,
rowstride,
data);
}
cogl_color_set_from_4ub (&clear_color, 0, 0, 0, 0);
cogl_push_framebuffer (offscreen);
cogl_clear (&clear_color, COGL_BUFFER_BIT_COLOR);
cogl_pop_framebuffer ();
cogl_handle_unref (offscreen);
cogl_texture_set_region (texture,
0, 0,
(size - width) / 2, (size - height) / 2,
width, height,
width, height,
has_alpha ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888,
rowstride,
data);
return texture;
}
static CoglBool
draw_rectangle (TestState *state,
int x,
int y,
TestDepthState *rect_state,
CoglBool legacy_mode)
{
uint8_t Cr = MASK_RED (rect_state->color);
uint8_t Cg = MASK_GREEN (rect_state->color);
uint8_t Cb = MASK_BLUE (rect_state->color);
uint8_t Ca = MASK_ALPHA (rect_state->color);
CoglPipeline *pipeline;
CoglDepthState depth_state;
cogl_depth_state_init (&depth_state);
cogl_depth_state_set_test_enabled (&depth_state, rect_state->test_enable);
cogl_depth_state_set_test_function (&depth_state, rect_state->test_function);
cogl_depth_state_set_write_enabled (&depth_state, rect_state->write_enable);
cogl_depth_state_set_range (&depth_state,
rect_state->range_near,
rect_state->range_far);
pipeline = cogl_pipeline_new (test_ctx);
if (!cogl_pipeline_set_depth_state (pipeline, &depth_state, NULL))
{
cogl_object_unref (pipeline);
return FALSE;
}
if (!legacy_mode)
{
cogl_pipeline_set_color4ub (pipeline, Cr, Cg, Cb, Ca);
cogl_framebuffer_set_depth_write_enabled (test_fb,
rect_state->fb_write_enable);
cogl_framebuffer_push_matrix (test_fb);
cogl_framebuffer_translate (test_fb, 0, 0, rect_state->depth);
cogl_framebuffer_draw_rectangle (test_fb,
pipeline,
x * QUAD_WIDTH,
y * QUAD_WIDTH,
x * QUAD_WIDTH + QUAD_WIDTH,
y * QUAD_WIDTH + QUAD_WIDTH);
cogl_framebuffer_pop_matrix (test_fb);
}
else
{
cogl_push_framebuffer (test_fb);
cogl_push_matrix ();
cogl_set_source_color4ub (Cr, Cg, Cb, Ca);
cogl_translate (0, 0, rect_state->depth);
cogl_rectangle (x * QUAD_WIDTH,
y * QUAD_WIDTH,
x * QUAD_WIDTH + QUAD_WIDTH,
y * QUAD_WIDTH + QUAD_WIDTH);
cogl_pop_matrix ();
cogl_pop_framebuffer ();
}
cogl_object_unref (pipeline);
return TRUE;
}
static void
on_paint (ClutterActor *actor, void *state)
{
float saved_viewport[4];
CoglMatrix saved_projection;
CoglMatrix projection;
CoglMatrix modelview;
guchar *data;
CoglHandle tex;
CoglHandle offscreen;
CoglColor black;
float x0;
float y0;
float width;
float height;
/* for clearing the offscreen framebuffer to black... */
cogl_color_init_from_4ub (&black, 0x00, 0x00, 0x00, 0xff);
cogl_get_viewport (saved_viewport);
cogl_get_projection_matrix (&saved_projection);
cogl_push_matrix ();
cogl_matrix_init_identity (&projection);
cogl_matrix_init_identity (&modelview);
cogl_set_projection_matrix (&projection);
cogl_set_modelview_matrix (&modelview);
/* - Create a 100x200 viewport (i.e. smaller than the onscreen framebuffer)
* and position it a (20, 10) inside the framebuffer.
* - Fill the whole viewport with a purple rectangle
* - Verify that the framebuffer is black with a 100x200 purple rectangle at
* (20, 10)
*/
cogl_set_viewport (20, /* x */
10, /* y */
100, /* width */
200); /* height */
/* clear everything... */
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
/* fill the viewport with purple.. */
cogl_set_source_color4ub (0xff, 0x00, 0xff, 0xff);
cogl_rectangle (-1, 1, 1, -1);
assert_rectangle_color_and_black_border (20, 10, 100, 200,
0xff, 0x00, 0xff);
/* - Create a viewport twice the size of the onscreen framebuffer with
* a negative offset positioning it at (-20, -10) relative to the
* buffer itself.
* - Draw a 100x200 green rectangle at (40, 20) within the viewport (which
* is (20, 10) within the framebuffer)
* - Verify that the framebuffer is black with a 100x200 green rectangle at
* (20, 10)
*/
cogl_set_viewport (-20, /* x */
-10, /* y */
FRAMEBUFFER_WIDTH * 2, /* width */
FRAMEBUFFER_HEIGHT * 2); /* height */
/* clear everything... */
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
/* draw a 100x200 green rectangle offset into the viewport such that its
* top left corner should be found at (20, 10) in the offscreen buffer */
/* (offset 40 pixels right from the left of the viewport) */
x0 = -1.0f + (1.0f / FRAMEBUFFER_WIDTH) * 40.f;
/* (offset 20 pixels down from the top of the viewport) */
y0 = 1.0f - (1.0f / FRAMEBUFFER_HEIGHT) * 20.0f;
width = (1.0f / FRAMEBUFFER_WIDTH) * 100;
height = (1.0f / FRAMEBUFFER_HEIGHT) * 200;
cogl_set_source_color4ub (0x00, 0xff, 0x00, 0xff);
cogl_rectangle (x0, y0, x0 + width, y0 - height);
assert_rectangle_color_and_black_border (20, 10, 100, 200,
0x00, 0xff, 0x00);
/* - Create a 200x400 viewport and position it a (20, 10) inside the draw
* buffer.
* - Push a 100x200 window space clip rectangle at (20, 10)
* - Fill the whole viewport with a blue rectangle
* - Verify that the framebuffer is black with a 100x200 blue rectangle at
* (20, 10)
*/
cogl_set_viewport (20, /* x */
10, /* y */
200, /* width */
400); /* height */
/* clear everything... */
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
cogl_clip_push_window_rectangle (20, 10, 100, 200);
/* fill the viewport with blue.. */
cogl_set_source_color4ub (0x00, 0x00, 0xff, 0xff);
cogl_rectangle (-1, 1, 1, -1);
cogl_clip_pop ();
assert_rectangle_color_and_black_border (20, 10, 100, 200,
0x00, 0x00, 0xff);
/* - Create a 200x400 viewport and position it a (20, 10) inside the draw
* buffer.
* - Push a 100x200 model space clip rectangle at (20, 10) in the viewport
* (i.e. (40, 20) inside the framebuffer)
* - Fill the whole viewport with a green rectangle
* - Verify that the framebuffer is black with a 100x200 green rectangle at
* (40, 20)
*/
cogl_set_viewport (20, /* x */
10, /* y */
200, /* width */
400); /* height */
/* clear everything... */
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
/* figure out where to position our clip rectangle in model space
* coordinates... */
/* (offset 40 pixels right from the left of the viewport) */
x0 = -1.0f + (2.0f / 200) * 20.f;
/* (offset 20 pixels down from the top of the viewport) */
y0 = 1.0f - (2.0f / 400) * 10.0f;
width = (2.0f / 200) * 100;
height = (2.0f / 400) * 200;
/* add the clip rectangle... */
cogl_push_matrix ();
cogl_translate (x0 + (width/2.0), y0 - (height/2.0), 0);
/* XXX: Rotate just enough to stop Cogl from converting our model space
* rectangle into a window space rectangle.. */
cogl_rotate (0.1, 0, 0, 1);
cogl_clip_push_rectangle (-(width/2.0), -(height/2.0),
width/2.0, height/2.0);
cogl_pop_matrix ();
/* fill the viewport with green.. */
cogl_set_source_color4ub (0x00, 0xff, 0x00, 0xff);
cogl_rectangle (-1, 1, 1, -1);
cogl_clip_pop ();
assert_rectangle_color_and_black_border (40, 20, 100, 200,
0x00, 0xff, 0x00);
/* Set the viewport to something specific so we can verify that it gets
* restored after we are done testing with an offscreen framebuffer... */
cogl_set_viewport (20, 10, 100, 200);
/*
* Next test offscreen drawing...
*/
data = g_malloc (FRAMEBUFFER_WIDTH * 4 * FRAMEBUFFER_HEIGHT);
tex = cogl_texture_new_from_data (FRAMEBUFFER_WIDTH, FRAMEBUFFER_HEIGHT,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_RGBA_8888, /* data fmt */
COGL_PIXEL_FORMAT_ANY, /* internal fmt */
FRAMEBUFFER_WIDTH * 4, /* rowstride */
data);
g_free (data);
offscreen = cogl_offscreen_new_to_texture (tex);
cogl_push_framebuffer (offscreen);
/* - Create a 100x200 viewport (i.e. smaller than the offscreen framebuffer)
* and position it a (20, 10) inside the framebuffer.
* - Fill the whole viewport with a blue rectangle
* - Verify that the framebuffer is black with a 100x200 blue rectangle at
* (20, 10)
*/
cogl_set_viewport (20, /* x */
10, /* y */
100, /* width */
200); /* height */
/* clear everything... */
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
/* fill the viewport with blue.. */
cogl_set_source_color4ub (0x00, 0x00, 0xff, 0xff);
cogl_rectangle (-1, 1, 1, -1);
assert_rectangle_color_and_black_border (20, 10, 100, 200,
0x00, 0x00, 0xff);
/* - Create a viewport twice the size of the offscreen framebuffer with
* a negative offset positioning it at (-20, -10) relative to the
* buffer itself.
* - Draw a 100x200 red rectangle at (40, 20) within the viewport (which
* is (20, 10) within the framebuffer)
* - Verify that the framebuffer is black with a 100x200 red rectangle at
* (20, 10)
*/
cogl_set_viewport (-20, /* x */
-10, /* y */
FRAMEBUFFER_WIDTH * 2, /* width */
FRAMEBUFFER_HEIGHT * 2); /* height */
/* clear everything... */
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
/* draw a 100x200 red rectangle offset into the viewport such that its
* top left corner should be found at (20, 10) in the offscreen buffer */
/* (offset 40 pixels right from the left of the viewport) */
x0 = -1.0f + (1.0f / FRAMEBUFFER_WIDTH) * 40.f;
/* (offset 20 pixels down from the top of the viewport) */
y0 = 1.0f - (1.0f / FRAMEBUFFER_HEIGHT) * 20.0f;
width = (1.0f / FRAMEBUFFER_WIDTH) * 100;
height = (1.0f / FRAMEBUFFER_HEIGHT) * 200;
cogl_set_source_color4ub (0xff, 0x00, 0x00, 0xff);
cogl_rectangle (x0, y0, x0 + width, y0 - height);
assert_rectangle_color_and_black_border (20, 10, 100, 200,
0xff, 0x00, 0x00);
/* - Create a 200x400 viewport and position it a (20, 10) inside the draw
* buffer.
* - Push a 100x200 window space clip rectangle at (20, 10)
* - Fill the whole viewport with a blue rectangle
* - Verify that the framebuffer is black with a 100x200 blue rectangle at
* (20, 10)
*/
cogl_set_viewport (20, /* x */
10, /* y */
200, /* width */
400); /* height */
/* clear everything... */
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
cogl_clip_push_window_rectangle (20, 10, 100, 200);
/* fill the viewport with blue.. */
cogl_set_source_color4ub (0x00, 0x00, 0xff, 0xff);
cogl_rectangle (-1, 1, 1, -1);
cogl_clip_pop ();
assert_rectangle_color_and_black_border (20, 10, 100, 200,
0x00, 0x00, 0xff);
/* - Create a 200x400 viewport and position it a (20, 10) inside the draw
* buffer.
* - Push a 100x200 model space clip rectangle at (20, 10) in the viewport
* (i.e. (40, 20) inside the framebuffer)
* - Fill the whole viewport with a green rectangle
* - Verify that the framebuffer is black with a 100x200 green rectangle at
* (40, 20)
*/
cogl_set_viewport (20, /* x */
10, /* y */
200, /* width */
400); /* height */
/* clear everything... */
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
/* figure out where to position our clip rectangle in model space
* coordinates... */
/* (offset 40 pixels right from the left of the viewport) */
x0 = -1.0f + (2.0f / 200) * 20.f;
/* (offset 20 pixels down from the top of the viewport) */
y0 = 1.0f - (2.0f / 400) * 10.0f;
width = (2.0f / 200) * 100;
height = (2.0f / 400) * 200;
/* add the clip rectangle... */
cogl_push_matrix ();
cogl_translate (x0 + (width/2.0), y0 - (height/2.0), 0);
/* XXX: Rotate just enough to stop Cogl from converting our model space
* rectangle into a window space rectangle.. */
cogl_rotate (0.1, 0, 0, 1);
cogl_clip_push_rectangle (-(width/2.0), -(height/2.0),
width/2, height/2);
cogl_pop_matrix ();
/* fill the viewport with green.. */
cogl_set_source_color4ub (0x00, 0xff, 0x00, 0xff);
cogl_rectangle (-1, 1, 1, -1);
cogl_clip_pop ();
assert_rectangle_color_and_black_border (40, 20, 100, 200,
0x00, 0xff, 0x00);
/* Set the viewport to something obscure to verify that it gets
* replace when we switch back to the onscreen framebuffer... */
cogl_set_viewport (0, 0, 10, 10);
cogl_pop_framebuffer ();
cogl_handle_unref (offscreen);
/*
* Verify that the previous onscreen framebuffer's viewport was restored
* by drawing a white rectangle across the whole viewport. This should
* draw a 100x200 rectangle at (20,10) relative to the onscreen draw
* buffer...
*/
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
cogl_set_source_color4ub (0xff, 0xff, 0xff, 0xff);
cogl_rectangle (-1, 1, 1, -1);
assert_rectangle_color_and_black_border (20, 10, 100, 200,
0xff, 0xff, 0xff);
/* Uncomment to display the last contents of the offscreen framebuffer */
#if 1
cogl_matrix_init_identity (&projection);
cogl_matrix_init_identity (&modelview);
cogl_set_viewport (0, 0, FRAMEBUFFER_WIDTH, FRAMEBUFFER_HEIGHT);
cogl_set_projection_matrix (&projection);
cogl_set_modelview_matrix (&modelview);
cogl_set_source_texture (tex);
cogl_rectangle (-1, 1, 1, -1);
#endif
cogl_handle_unref (tex);
/* Finally restore the stage's original state... */
cogl_pop_matrix ();
cogl_set_projection_matrix (&saved_projection);
cogl_set_viewport (saved_viewport[0], saved_viewport[1],
saved_viewport[2], saved_viewport[3]);
/* Comment this out if you want visual feedback of what this test
* paints.
*/
clutter_main_quit ();
}
static gboolean
_cogl_blit_texture_render_begin (CoglBlitData *data)
{
CoglHandle fbo;
CoglPipeline *pipeline;
unsigned int dst_width, dst_height;
_COGL_GET_CONTEXT (ctx, FALSE);
fbo = _cogl_offscreen_new_to_texture_full
(data->dst_tex, COGL_OFFSCREEN_DISABLE_DEPTH_AND_STENCIL, 0 /* level */);
if (fbo == COGL_INVALID_HANDLE)
return FALSE;
if (!cogl_framebuffer_allocate (fbo, NULL))
{
cogl_handle_unref (fbo);
return FALSE;
}
cogl_push_framebuffer (fbo);
cogl_handle_unref (fbo);
dst_width = cogl_texture_get_width (data->dst_tex);
dst_height = cogl_texture_get_height (data->dst_tex);
/* Set up an orthographic projection so we can use pixel
coordinates to render to the texture */
cogl_ortho (0, /* left */
dst_width, /* right */
dst_height, /* bottom */
0, /* top */
-1, /* near */
1 /* far */);
/* We cache a pipeline used for migrating on to the context so
that it doesn't have to continuously regenerate a shader
program */
if (ctx->blit_texture_pipeline == NULL)
{
ctx->blit_texture_pipeline = cogl_pipeline_new ();
cogl_pipeline_set_layer_filters (ctx->blit_texture_pipeline, 0,
COGL_PIPELINE_FILTER_NEAREST,
COGL_PIPELINE_FILTER_NEAREST);
/* Disable blending by just directly taking the contents of the
source texture */
cogl_pipeline_set_blend (ctx->blit_texture_pipeline,
"RGBA = ADD(SRC_COLOR, 0)",
NULL);
}
pipeline = ctx->blit_texture_pipeline;
cogl_pipeline_set_layer_texture (pipeline, 0, data->src_tex);
_cogl_push_source (pipeline, FALSE);
return TRUE;
}
