isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-21 23:50:41 -05:00
Code Issues Packages Projects Releases Wiki Activity

cogl: Remove unused cogl_texture_new_from_foreign

Browse Source 
https://gitlab.gnome.org/GNOME/mutter/merge_requests/546
This commit is contained in:
Adam Jackson 2019-03-08 10:17:32 -05:00
parent fc09fa50a5
commit fb40e2eefb
6 changed files with 1 additions and 395 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
clutter/tests/interactive/meson.build
View File

@ -31,7 +31,6 @@ clutter_tests_interactive_test_sources = [
'test-fbo.c', 'test-fbo.c',
'test-cogl-tex-tile.c', 'test-cogl-tex-tile.c',
'test-cogl-tex-convert.c', 'test-cogl-tex-convert.c',
'test-cogl-tex-foreign.c',
'test-cogl-offscreen.c', 'test-cogl-offscreen.c',
'test-cogl-tex-polygon.c', 'test-cogl-tex-polygon.c',
'test-cogl-multitexture.c', 'test-cogl-multitexture.c',

276
clutter/tests/interactive/test-cogl-tex-foreign.c
View File

@ -1,276 +0,0 @@
#include <glib.h>
#include <gmodule.h>
#include <stdlib.h>
#include <clutter/clutter.h>
#include <cogl/cogl.h>
#ifndef GL_UNPACK_ALIGNMENT
#define GL_UNPACK_ALIGNMENT 0x0CF5
#endif
#ifndef GL_TEXTURE_BINDING_2D
#define GL_TEXTURE_BINDING_2D 0x8069
#endif
#ifndef GL_TEXTURE_2D
#define GL_TEXTURE_2D 0x0DE1
#endif
#ifndef GL_RGB
#define GL_RGB 0x1907
#endif
#ifndef GL_UNSIGNED_BYTE
#define GL_UNSIGNED_BYTE 0x1401
#endif
#ifndef GL_TEXTURE_MAG_FILTER
#define GL_TEXTURE_MAG_FILTER 0x2800
#endif
#ifndef GL_LINEAR
#define GL_LINEAR 0x1208
#endif
#ifndef GL_TEXTURE_MIN_FILTER
#define GL_TEXTURE_MIN_FILTER 0x2801
#endif
/* Coglbox declaration
*--------------------------------------------------*/
G_BEGIN_DECLS
#define TEST_TYPE_COGLBOX test_coglbox_get_type()
#define TEST_COGLBOX(obj) \
(G_TYPE_CHECK_INSTANCE_CAST ((obj), \
TEST_TYPE_COGLBOX, TestCoglboxClass))
#define TEST_COGLBOX_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST ((klass), \
TEST_TYPE_COGLBOX, TestCoglboxClass))
#define TEST_IS_COGLBOX(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
TEST_TYPE_COGLBOX))
#define TEST_IS_COGLBOX_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE ((klass), \
TEST_TYPE_COGLBOX))
#define TEST_COGLBOX_GET_CLASS(obj) \
(G_TYPE_INSTANCE_GET_CLASS ((obj), \
TEST_TYPE_COGLBOX, TestCoglboxClass))
typedef struct _TestCoglbox TestCoglbox;
typedef struct _TestCoglboxClass TestCoglboxClass;
typedef struct _TestCoglboxPrivate TestCoglboxPrivate;
const char *
test_cogl_tex_foreign_describe (void);
struct _TestCoglbox
{
ClutterActor parent;
/*< private >*/
TestCoglboxPrivate *priv;
};
struct _TestCoglboxClass
{
ClutterActorClass parent_class;
/* padding for future expansion */
void (*_test_coglbox1) (void);
void (*_test_coglbox2) (void);
void (*_test_coglbox3) (void);
void (*_test_coglbox4) (void);
};
static GType test_coglbox_get_type (void) G_GNUC_CONST;
G_END_DECLS
/* Coglbox private declaration
*--------------------------------------------------*/
struct _TestCoglboxPrivate
{
guint gl_handle;
CoglHandle cogl_handle;
void
(* glGetIntegerv) (guint pname, int *params);
void
(* glPixelStorei) (guint pname, int param);
void
(* glTexParameteri) (guint target, guint pname, int param);
void
(* glTexImage2D) (guint target, int level,
int internalFormat,
int width, int height,
int border, guint format, guint type,
const void *pixels);
void
(* glGenTextures) (int n, guint *textures);
void
(* glDeleteTextures) (int n, const guint *textures);
void
(* glBindTexture) (guint target, guint texture);
};
G_DEFINE_TYPE_WITH_PRIVATE (TestCoglbox, test_coglbox, CLUTTER_TYPE_ACTOR);
#define TEST_COGLBOX_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), TEST_TYPE_COGLBOX, TestCoglboxPrivate))
int
test_cogl_tex_foreign_main (int argc, char *argv[]);
/* Coglbox implementation
*--------------------------------------------------*/
static void
test_coglbox_paint(ClutterActor *self)
{
TestCoglboxPrivate *priv = TEST_COGLBOX_GET_PRIVATE (self);
gfloat texcoords[4] = { 0.3f, 0.3f, 0.7f, 0.7f };
cogl_set_source_color4ub (0x66, 0x66, 0xdd, 0xff);
cogl_rectangle (0,0,400,400);
cogl_push_matrix ();
cogl_translate (100,100,0);
cogl_set_source_texture (priv->cogl_handle);
cogl_rectangle_with_texture_coords (0, 0, 200, 200,
texcoords[0], texcoords[1],
texcoords[2], texcoords[3]);
cogl_pop_matrix();
}
static void
test_coglbox_finalize (GObject *object)
{
G_OBJECT_CLASS (test_coglbox_parent_class)->finalize (object);
}
static void
test_coglbox_dispose (GObject *object)
{
TestCoglboxPrivate *priv;
priv = TEST_COGLBOX_GET_PRIVATE (object);
cogl_handle_unref (priv->cogl_handle);
priv->glDeleteTextures (1, &priv->gl_handle);
G_OBJECT_CLASS (test_coglbox_parent_class)->dispose (object);
}
static void
test_coglbox_init (TestCoglbox *self)
{
TestCoglboxPrivate *priv;
guchar data[12];
int prev_unpack_alignment;
int prev_2d_texture_binding;
self->priv = priv = TEST_COGLBOX_GET_PRIVATE(self);
/* Prepare a 2x2 pixels texture */
data[0] = 255; data[1] = 0; data[2] = 0;
data[3] = 0; data[4] = 255; data[5] = 0;
data[6] = 0; data[7] = 0; data[8] = 255;
data[9] = 0; data[10] = 0; data[11] = 0;
priv->glGetIntegerv = (void *) cogl_get_proc_address ("glGetIntegerv");
priv->glPixelStorei = (void *) cogl_get_proc_address ("glPixelStorei");
priv->glTexParameteri = (void *) cogl_get_proc_address ("glTexParameteri");
priv->glTexImage2D = (void *) cogl_get_proc_address ("glTexImage2D");
priv->glGenTextures = (void *) cogl_get_proc_address ("glGenTextures");
priv->glDeleteTextures = (void *) cogl_get_proc_address ("glDeleteTextures");
priv->glBindTexture = (void *) cogl_get_proc_address ("glBindTexture");
/* We are about to use OpenGL directly to create a TEXTURE_2D
* texture so we need to save the state that we modify so we can
* restore it afterwards and be sure not to interfere with any state
* caching that Cogl may do internally.
*/
priv->glGetIntegerv (GL_UNPACK_ALIGNMENT, &prev_unpack_alignment);
priv->glGetIntegerv (GL_TEXTURE_BINDING_2D, &prev_2d_texture_binding);
priv->glGenTextures (1, &priv->gl_handle);
priv->glBindTexture (GL_TEXTURE_2D, priv->gl_handle);
priv->glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
priv->glTexImage2D (GL_TEXTURE_2D, 0, GL_RGB,
2, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
/* Now restore the original GL state as Cogl had left it */
priv->glPixelStorei (GL_UNPACK_ALIGNMENT, prev_unpack_alignment);
priv->glBindTexture (GL_TEXTURE_2D, prev_2d_texture_binding);
priv->glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
priv->glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
/* Create texture from foreign */
priv->cogl_handle =
cogl_texture_new_from_foreign (priv->gl_handle,
GL_TEXTURE_2D,
2, 2, 0, 0,
COGL_PIXEL_FORMAT_RGB_888);
if (priv->cogl_handle == COGL_INVALID_HANDLE)
{
printf ("Failed creating texture from foreign!\n");
return;
}
}
static void
test_coglbox_class_init (TestCoglboxClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
gobject_class->finalize = test_coglbox_finalize;
gobject_class->dispose = test_coglbox_dispose;
actor_class->paint = test_coglbox_paint;
}
static ClutterActor*
test_coglbox_new (void)
{
return g_object_new (TEST_TYPE_COGLBOX, NULL);
}
G_MODULE_EXPORT int
test_cogl_tex_foreign_main (int argc, char *argv[])
{
ClutterActor *stage;
ClutterActor *coglbox;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
/* Stage */
stage = clutter_stage_new ();
clutter_actor_set_size (stage, 400, 400);
clutter_stage_set_title (CLUTTER_STAGE (stage), "Cogl Foreign Textures");
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
/* Cogl Box */
coglbox = test_coglbox_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (stage), coglbox);
clutter_actor_show_all (stage);
clutter_main ();
return 0;
}
G_MODULE_EXPORT const char *
test_cogl_tex_foreign_describe (void)
{
return "Foreign textures support in Cogl.";
}

4
cogl/cogl/cogl-texture-2d-sliced.c
View File

@ -931,9 +931,7 @@ _cogl_texture_2d_sliced_new_from_foreign (CoglContext *ctx,
* in GLES, hence such a function prototype. * in GLES, hence such a function prototype.
*/ */
/* This should only be called when the texture target is 2D. If a /* This should only be called when the texture target is 2D. */
rectangle texture is used then _cogl_texture_new_from_foreign
will create a cogl_texture_rectangle instead */
_COGL_RETURN_VAL_IF_FAIL (gl_target == GL_TEXTURE_2D, NULL); _COGL_RETURN_VAL_IF_FAIL (gl_target == GL_TEXTURE_2D, NULL);
/* Assert it is a valid GL texture object */ /* Assert it is a valid GL texture object */

1
cogl/cogl/cogl.symbols
View File

@ -908,7 +908,6 @@ cogl_texture_is_sliced
cogl_texture_new_from_bitmap cogl_texture_new_from_bitmap
cogl_texture_new_from_data cogl_texture_new_from_data
cogl_texture_new_from_file cogl_texture_new_from_file
cogl_texture_new_from_foreign
cogl_texture_new_from_sub_texture cogl_texture_new_from_sub_texture
cogl_texture_new_with_size cogl_texture_new_with_size
#ifdef COGL_HAS_X11 #ifdef COGL_HAS_X11

76
cogl/cogl/deprecated/cogl-auto-texture.c
View File

@ -314,82 +314,6 @@ cogl_texture_new_from_file (const char *filename,
return texture; return texture;
} }
CoglTexture *
cogl_texture_new_from_foreign (GLuint gl_handle,
GLenum gl_target,
GLuint width,
GLuint height,
GLuint x_pot_waste,
GLuint y_pot_waste,
CoglPixelFormat format)
{
_COGL_GET_CONTEXT (ctx, NULL);
#ifdef HAVE_COGL_GL
if (gl_target == GL_TEXTURE_RECTANGLE_ARB)
{
CoglTextureRectangle *texture_rectangle;
CoglSubTexture *sub_texture;
if (x_pot_waste != 0 || y_pot_waste != 0)
{
/* It shouldn't be necessary to have waste in this case since
* the texture isn't limited to power of two sizes. */
g_warning ("You can't create a foreign GL_TEXTURE_RECTANGLE cogl "
"texture with waste\n");
return NULL;
}
texture_rectangle = cogl_texture_rectangle_new_from_foreign (ctx,
gl_handle,
width,
height,
format);
_cogl_texture_set_internal_format (COGL_TEXTURE (texture_rectangle),
format);
/* CoglTextureRectangle textures work with non-normalized
* coordinates, but the semantics for this function that people
* depend on are that all returned texture works with normalized
* coordinates so we wrap with a CoglSubTexture... */
sub_texture = cogl_sub_texture_new (ctx,
COGL_TEXTURE (texture_rectangle),
0, 0, width, height);
return COGL_TEXTURE (sub_texture);
}
#endif
if (x_pot_waste != 0 || y_pot_waste != 0)
{
CoglTexture *tex =
COGL_TEXTURE (_cogl_texture_2d_sliced_new_from_foreign (ctx,
gl_handle,
gl_target,
width,
height,
x_pot_waste,
y_pot_waste,
format));
_cogl_texture_set_internal_format (tex, format);
cogl_texture_allocate (tex, NULL);
return tex;
}
else
{
CoglTexture *tex =
COGL_TEXTURE (cogl_texture_2d_gl_new_from_foreign (ctx,
gl_handle,
width,
height,
format));
_cogl_texture_set_internal_format (tex, format);
cogl_texture_allocate (tex, NULL);
return tex;
}
}
CoglTexture * CoglTexture *
cogl_texture_new_from_sub_texture (CoglTexture *full_texture, cogl_texture_new_from_sub_texture (CoglTexture *full_texture,
int sub_x, int sub_x,

38
cogl/cogl/deprecated/cogl-auto-texture.h
View File

@ -125,44 +125,6 @@ cogl_texture_new_from_data (int width,
int rowstride, int rowstride,
const uint8_t *data); const uint8_t *data);
/**
* cogl_texture_new_from_foreign:
* @gl_handle: opengl handle of foreign texture.
* @gl_target: opengl target type of foreign texture
* @width: width of foreign texture
* @height: height of foreign texture.
* @x_pot_waste: horizontal waste on the right hand edge of the texture.
* @y_pot_waste: vertical waste on the bottom edge of the texture.
* @format: format of the foreign texture.
*
* Creates a #CoglTexture based on an existing OpenGL texture; the
* width, height and format are passed along since it is not always
* possible to query these from OpenGL.
*
* The waste arguments allow you to create a Cogl texture that maps to
* a region smaller than the real OpenGL texture. For instance if your
* hardware only supports power-of-two textures you may load a
* non-power-of-two image into a larger power-of-two texture and use
* the waste arguments to tell Cogl which region should be mapped to
* the texture coordinate range [0:1].
*
* Return value: (transfer full): A newly created #CoglTexture or
* %NULL on failure
*
* Since: 0.8
* Deprecated: 1.18: Use specific constructors such as
* cogl_texture_2d_new_from_foreign()
*/
COGL_DEPRECATED_FOR (cogl_texture_2d_new_from_foreign)
CoglTexture *
cogl_texture_new_from_foreign (unsigned int gl_handle,
unsigned int gl_target,
unsigned int width,
unsigned int height,
unsigned int x_pot_waste,
unsigned int y_pot_waste,
CoglPixelFormat format);
/** /**
* cogl_texture_new_from_bitmap: * cogl_texture_new_from_bitmap:
* @bitmap: A #CoglBitmap pointer * @bitmap: A #CoglBitmap pointer