mutter/cogl/cogl-driver.h
Robert Bragg 6f480c7530 texture: remove _cogl_texture_prepare_for_upload
This removes the gl centric _cogl_texture_prepare_for_upload api from
cogl-texture.c and instead adds a _cogl_bitmap_convert_for_upload() api
which everything now uses instead. GL specific code that needed the gl
internal/format/type enums returned by _cogl_texture_prepare_for_upload
now use ->pixel_format_to_gl directly.

Since there was a special case optimization in
cogl_texture_new_from_file that aimed to avoid copying the temporary
bitmap that's created for the given file and allow conversions to
happen in-place the new _cogl_bitmap_convert_for_upload() api supports
converting in place depending on a 'can_convert_in_place' argument.

This ability to convert bitmaps in-place has been integrated across the
different components as appropriate.

In updating cogl-texture-2d-sliced.c this was able to remove a number of
other GL specific parts to how spans are setup.

Reviewed-by: Neil Roberts <neil@linux.intel.com>

(cherry picked from commit e190dd23c655da34b9c5c263a9f6006dcc0413b0)

Conflicts:
	cogl/cogl-auto-texture.c
	cogl/cogl.symbols
2013-07-29 16:31:44 +01:00

287 lines
10 KiB
C

/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2012 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
*/
#ifndef __COGL_DRIVER_H
#define __COGL_DRIVER_H
#include "cogl-context.h"
#include "cogl-offscreen.h"
#include "cogl-framebuffer-private.h"
#include "cogl-attribute-private.h"
typedef struct _CoglDriverVtable CoglDriverVtable;
struct _CoglDriverVtable
{
/* TODO: factor this out since this is OpenGL specific and
* so can be ignored by non-OpenGL drivers. */
CoglBool
(* pixel_format_from_gl_internal) (CoglContext *context,
GLenum gl_int_format,
CoglPixelFormat *out_format);
/* TODO: factor this out since this is OpenGL specific and
* so can be ignored by non-OpenGL drivers. */
CoglPixelFormat
(* pixel_format_to_gl) (CoglContext *context,
CoglPixelFormat format,
GLenum *out_glintformat,
GLenum *out_glformat,
GLenum *out_gltype);
CoglBool
(* update_features) (CoglContext *context,
CoglError **error);
CoglBool
(* offscreen_allocate) (CoglOffscreen *offscreen,
CoglError **error);
void
(* offscreen_free) (CoglOffscreen *offscreen);
void
(* framebuffer_flush_state) (CoglFramebuffer *draw_buffer,
CoglFramebuffer *read_buffer,
CoglFramebufferState state);
void
(* framebuffer_clear) (CoglFramebuffer *framebuffer,
unsigned long buffers,
float red,
float green,
float blue,
float alpha);
void
(* framebuffer_query_bits) (CoglFramebuffer *framebuffer,
CoglFramebufferBits *bits);
void
(* framebuffer_finish) (CoglFramebuffer *framebuffer);
void
(* framebuffer_discard_buffers) (CoglFramebuffer *framebuffer,
unsigned long buffers);
void
(* framebuffer_draw_attributes) (CoglFramebuffer *framebuffer,
CoglPipeline *pipeline,
CoglVerticesMode mode,
int first_vertex,
int n_vertices,
CoglAttribute **attributes,
int n_attributes,
CoglDrawFlags flags);
void
(* framebuffer_draw_indexed_attributes) (CoglFramebuffer *framebuffer,
CoglPipeline *pipeline,
CoglVerticesMode mode,
int first_vertex,
int n_vertices,
CoglIndices *indices,
CoglAttribute **attributes,
int n_attributes,
CoglDrawFlags flags);
CoglBool
(* framebuffer_read_pixels_into_bitmap) (CoglFramebuffer *framebuffer,
int x,
int y,
CoglReadPixelsFlags source,
CoglBitmap *bitmap,
CoglError **error);
/* Destroys any driver specific resources associated with the given
* 2D texture. */
void
(* texture_2d_free) (CoglTexture2D *tex_2d);
/* Returns TRUE if the driver can support creating a 2D texture with
* the given geometry and specified internal format.
*/
CoglBool
(* texture_2d_can_create) (CoglContext *ctx,
int width,
int height,
CoglPixelFormat internal_format);
/* Initializes driver private state before allocating any specific
* storage for a 2D texture, where base texture and texture 2D
* members will already be initialized before passing control to
* the driver.
*/
void
(* texture_2d_init) (CoglTexture2D *tex_2d);
/* Allocates (uninitialized) storage for the given texture according
* to the configured size and format of the texture */
CoglBool
(* texture_2d_allocate) (CoglTexture *tex,
CoglError **error);
/* Instantiates a new CoglTexture2D object with storage initialized
* with the contents of the given bitmap, using the specified
* internal format.
*/
CoglTexture2D *
(* texture_2d_new_from_bitmap) (CoglBitmap *bmp,
CoglPixelFormat internal_format,
CoglBool can_convert_in_place,
CoglError **error);
#if defined (COGL_HAS_EGL_SUPPORT) && defined (EGL_KHR_image_base)
/* Instantiates a new CoglTexture2D object with storage initialized
* with the contents of the given EGL image.
*
* This is optional for drivers to support
*/
CoglTexture2D *
(* egl_texture_2d_new_from_image) (CoglContext *ctx,
int width,
int height,
CoglPixelFormat format,
EGLImageKHR image,
CoglError **error);
#endif
/* Initialize the specified region of storage of the given texture
* with the contents of the specified framebuffer region
*/
void
(* texture_2d_copy_from_framebuffer) (CoglTexture2D *tex_2d,
int src_x,
int src_y,
int width,
int height,
CoglFramebuffer *src_fb,
int dst_x,
int dst_y,
int level);
/* If the given texture has a corresponding OpenGL texture handle
* then return that.
*
* This is optional
*/
unsigned int
(* texture_2d_get_gl_handle) (CoglTexture2D *tex_2d);
/* Update all mipmap levels > 0 */
void
(* texture_2d_generate_mipmap) (CoglTexture2D *tex_2d);
/* Initialize the specified region of storage of the given texture
* with the contents of the specified bitmap region
*
* Since this may need to create the underlying storage first
* it may throw a NO_MEMORY error.
*/
CoglBool
(* texture_2d_copy_from_bitmap) (CoglTexture2D *tex_2d,
int src_x,
int src_y,
int width,
int height,
CoglBitmap *bitmap,
int dst_x,
int dst_y,
int level,
CoglError **error);
/* Reads back the full contents of the given texture and write it to
* @data in the given @format and with the given @rowstride.
*
* This is optional
*/
void
(* texture_2d_get_data) (CoglTexture2D *tex_2d,
CoglPixelFormat format,
int rowstride,
uint8_t *data);
/* Prepares for drawing by flushing the journal, framebuffer state,
* pipeline state and attribute state.
*/
void
(* flush_attributes_state) (CoglFramebuffer *framebuffer,
CoglPipeline *pipeline,
CoglFlushLayerState *layer_state,
CoglDrawFlags flags,
CoglAttribute **attributes,
int n_attributes);
/* Flushes the clip stack to the GPU using a combination of the
* stencil buffer, scissor and clip plane state.
*/
void
(* clip_stack_flush) (CoglClipStack *stack, CoglFramebuffer *framebuffer);
/* Enables the driver to create some meta data to represent a buffer
* but with no corresponding storage allocated yet.
*/
void
(* buffer_create) (CoglBuffer *buffer);
void
(* buffer_destroy) (CoglBuffer *buffer);
/* Maps a buffer into the CPU */
void *
(* buffer_map_range) (CoglBuffer *buffer,
size_t offset,
size_t size,
CoglBufferAccess access,
CoglBufferMapHint hints,
CoglError **error);
/* Unmaps a buffer */
void
(* buffer_unmap) (CoglBuffer *buffer);
/* Uploads data to the buffer without needing to map it necessarily
*/
CoglBool
(* buffer_set_data) (CoglBuffer *buffer,
unsigned int offset,
const void *data,
unsigned int size,
CoglError **error);
};
#define COGL_DRIVER_ERROR (_cogl_driver_error_quark ())
typedef enum { /*< prefix=COGL_DRIVER_ERROR >*/
COGL_DRIVER_ERROR_UNKNOWN_VERSION,
COGL_DRIVER_ERROR_INVALID_VERSION,
COGL_DRIVER_ERROR_NO_SUITABLE_DRIVER_FOUND,
COGL_DRIVER_ERROR_FAILED_TO_LOAD_LIBRARY
} CoglDriverError;
uint32_t
_cogl_driver_error_quark (void);
#endif /* __COGL_DRIVER_H */