summaryrefslogtreecommitdiff
path: root/cogl/cogl-internal.h
Commit message (Collapse)AuthorAgeFilesLines
* cogl-program: Move the code for CoglBoxedValue to its own fileNeil Roberts2011-11-161-23/+0
| | | | | | | | | The code for manipulating CoglBoxedValues is now separated from cogl-program.c into its own file. That way when we add support for setting uniform values on a CoglPipeline the code for storing the values can be shared. Reviewed-by: Robert Bragg <robert@linux.intel.com>
* make COGL_FEATURE_VBOS a private featureRobert Bragg2011-11-011-1/+2
| | | | | | | | | | | | Cogl provides a consistent public interface regardless of whether the underlying GL driver supports VBOs so it doesn't make much sense to have this feature as part of the public api. We can't break the api by removing the enum but at least we no longer ever set the feature flag. We now have a replacement private feature flag COGL_PRIVATE_FEATURE_VBOS which cogl now checks for internally. Reviewed-by: Neil Roberts <neil@linux.intel.com>
* make COGL_FEATURE_PBOS a private featureRobert Bragg2011-11-011-1/+2
| | | | | | | | | | | | Cogl provides a consistent public interface regardless of whether the underlying GL driver supports PBOs so it doesn't make much sense to have this feature as part of the public api. We can't break the api by removing the enum but at least we no longer ever set the feature flag. We now have a replacement private feature flag COGL_PRIVATE_FEATURE_PBOS which cogl now checks for internally. Reviewed-by: Neil Roberts <neil@linux.intel.com>
* make COGL_FEATURE_FOUR_CLIP_PLANES a private featureRobert Bragg2011-11-011-1/+2
| | | | | | | | | | | | | Cogl doesn't currently expose public api for clip planes so it doesn't make much sense to have this feature as part of the public api. We can't break the api by removing the enum but at least we no longer ever set the feature flag. We now have a replacement private feature flag COGL_PRIVATE_FEATURE_FOUR_CLIP_PLANES which cogl now checks for internally. Reviewed-by: Neil Roberts <neil@linux.intel.com>
* make COGL_FEATURE_OFFSCREEN_BLIT a private featureRobert Bragg2011-11-011-1/+2
| | | | | | | | | | | | | Cogl doesn't expose public api for blitting between framebuffers so it doesn't make much sense to have this feature as part of the public api currently. We can't break the api by removing the enum but at least we no longer ever set the feature flag. We now have a replacement private feature flag COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT which cogl now checks for internally. Reviewed-by: Neil Roberts <neil@linux.intel.com>
* make COGL_FEATURE_STENCIL_BUFFER privateRobert Bragg2011-11-011-1/+2
| | | | | | | | | | | | | | Although we have to leave the COGL_FEATURE_STENCIL_BUFFER enum as part of the public api we no longer ever set this feature flag. Cogl doesn't currently expose the concept of a stencil buffer in the public api (we only indirectly expose it via the clip stack api) so it doesn't make much sense to have a stencil buffer feature flag. We now have a COGL_PRIVATE_FEATURE_STENCIL_BUFFER flag instead which we can check when we need to use the buffer for clipping. Reviewed-by: Neil Roberts <neil@linux.intel.com>
* pipeline: Split more code out from cogl-pipeline.cRobert Bragg2011-09-211-0/+8
| | | | | | | | | | | | | This splits out the core CoglPipelineLayer support code from cogl-pipeline.c into cogl-pipeline-layer.c; it splits out the debugging code for dumping a pipeline to a .dot file into cogl-pipeline-debug.c and it splits the CoglPipelineNode support which is shared between CoglPipeline and CoglPipelineLayer into cogl-node.c. Note: cogl-pipeline-layer.c only contains the layer code directly relating to CoglPipelineLayer objects; it does not contain any _cogl_pipeline API relating to how CoglPipeline tracks and manipulates layers.
* Make backface culling be part of the legacy stateNeil Roberts2011-09-191-10/+0
| | | | | | | | | | | | | | | | | | | | This adds an internal function to set the backface culling state on a pipeline. This includes properties to set the culling mode (front, back or both) and also to set which face is considered the front (COGL_WINDING_CLOCKWISE or COGL_WINDING_COUNTER_CLOCKWISE). The actual front face flushed to GL depends on whether we are rendering to an offscreen buffer or not. This means that when changing between on- and off- screen framebuffers it now checks whether the last flushed pipeline has backface culling enabled and forces a reflush of the cull face state if so. The backface culling is now set on a pipeline as part of the legacy state. This is important because some code in Cogl assumes it can flush a temporary pipeline to revert to a known state, but previously this wouldn't disable backface culling so things such as flushing the clip stack could get confused. Reviewed-by: Robert Bragg <robert@linux.intel.com>
* Use MESA_pack_invert to avoid read_pixels flipRobert Bragg2011-07-131-0/+1
| | | | | | | | | | cogl_read_pixels returns image data in a top-down memory order, but because OpenGL normally returns pixel data in a bottom-up order we have to flip the data before returning it to the user. If the OpenGL driver supports the GL_MESA_pack_invert extension though we can ask the driver to return the data in a top-down order in the first place. Signed-off-by: Neil Roberts <neil@linux.intel.com>
* Dynamically load the GL or GLES libraryNeil Roberts2011-07-111-1/+10
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
* Use all core GL functions through indirect pointersNeil Roberts2011-07-081-8/+8
| | | | | | | | | cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
* cogl-internal: remove COGL_PRIVATE_FEATURE_EGL flagsRobert Bragg2011-07-051-3/+1
| | | | | | | | This removes the unused COGL_PRIVATE_FEATURE_EGL flags since check_egl_extensions doesn't refer to these flags it uses the COGL_EGL_WINSYS_FEATURE flags. Signed-off-by: Neil Roberts <neil@linux.intel.com>
* Adds _cogl_wayland_texture_2d_new_from_buffer APIRobert Bragg2011-06-011-2/+3
| | | | | | | | This adds internal API to be able to wrap a wayland buffer as a CoglTexture2D. There is a --enable-wayland-egl-server option to decide if Cogl should support this feature and potentially any EGL based winsys could support this through the EGL_KHR_image_base and EGL_WL_bind_display extensions.
* egl: Add x11 texture-from-pixmap supportRobert Bragg2011-06-011-1/+2
| | | | | | | By using the EGL_KHR_image_base/pixmap extensions this adds support for wrapping X11 pixmaps as CoglTexture2D textures. Clutter will automatically take advantage of this if using the ClutterX11TexturePixmap actor.
* Add _cogl_egl_texture_2d_new_from_image APIRobert Bragg2011-06-011-0/+5
| | | | | | This adds an internal texture_2d constructor that can wrap an EGLImage as a CoglTexture2D. The plan is to utilize this for texture-from-pixmap support with EGL as well as creating textures from wayland buffers.
* Moves all GLX code down from Clutter to CoglRobert Bragg2011-04-111-92/+10
| | | | | | | | This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
* remove unused _cogl_features_init prototypeRobert Bragg2011-04-111-3/+0
| | | | | | There is no corresponding implementation of _cogl_features_init any more so it was simply an oversight that the prototype wasn't removed when the implementation was removed.
* cogl-vertex-attribute: Use glVertexAttribPointer on GLES2Neil Roberts2010-12-131-6/+0
| | | | | | | | | | | When the GLES2 wrapper is removed we can't use the fixed function API such as glColorPointer to set the builtin attributes. Instead the GLSL progend now maintains a cache of attribute locations that are queried with glGetAttribLocation. The code that previously maintained a cache of the enabled texture coord arrays has been modified to also cache the enabled vertex attributes under GLES2. The vertex attribute API is now the only place that is using this cache so it has been moved into cogl-vertex-attribute.c
* Merge cogl-program-{gl,gles}.c into one cogl-program.cNeil Roberts2010-10-281-3/+1
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | This merges the two implementations of CoglProgram for the GLES2 and GL backends into one. The implementation is more like the GLES2 version which would track the uniform values and delay sending them to GL. CoglProgram is now effectively just a GList of CoglShaders along with an array of stored uniform values. CoglProgram never actually creates a GL program, instead this is left up to the GLSL material backend. This is necessary on GLES2 where we may need to relink the user's program with different generated shaders depending on the other emulated fixed function state. It will also be necessary in the future GLSL backends for regular OpenGL. The GLSL and ARBfp material backends are now the ones that create and link the GL program from the list of shaders. The linked program is attached to the private material state so that it can be reused if the CoglProgram is used again with the same material. This does mean the program will get relinked if the shader is used with multiple materials. This will be particularly bad if the legacy cogl_program_use function is used because that effectively always makes one-shot materials. This problem will hopefully be alleviated if we make a hash table with a cache of generated programs. The cogl program would then need to become part of the hash lookup. Each CoglProgram now has an age counter which is incremented every time a shader is added. This is used by the material backends to detect when we need to create a new GL program for the user program. The internal _cogl_use_program function now takes a GL program handle rather than a CoglProgram. It no longer needs any special differences for GLES2. The GLES2 wrapper function now also uses this function to bind its generated shaders. The ARBfp shaders no longer store a copy of the program source but instead just directly create a program object when cogl_shader_source is called. This avoids having to reupload the source if the same shader is used in multiple materials. There are currently a few gross hacks to get the GLES2 backend to work with this. The problem is that the GLSL material backend is now generating a complete GL program but the GLES2 wrapper still needs to add its fixed function emulation shaders if the program doesn't provide either a vertex or fragment shader. There is a new function in the GLES2 wrapper called _cogl_gles2_use_program which replaces the previous cogl_program_use implementation. It extracts the GL shaders from the GL program object and creates a new GL program containing all of the shaders plus its fixed function emulation. This new program is returned to the GLSL material backend so that it can still flush the custom uniforms using it. The user_program is attached to the GLES2 settings struct as before but its stored using a GL program handle rather than a CoglProgram pointer. This hack will go away once the GLSL material backend replaces the GLES2 wrapper by generating the code itself. Under Mesa this currently generates some GL errors when glClear is called in test-cogl-shader-glsl. I think this is due to a bug in Mesa however. When the user program on the material is changed the GLSL backend gets notified and deletes the GL program that it linked from the user shaders. The program will still be bound in GL however. Leaving a deleted shader bound exposes a bug in Mesa's glClear implementation. More details are here: https://bugs.freedesktop.org/show_bug.cgi?id=31194
* cogl: Adds a COGL_FEATURE_SHADERS_ARBFP feature flagRobert Bragg2010-08-091-1/+1
| | | | | This adds a public feature flag for ARBfp so developers can determine if the cogl API supports ARBfp or not.
* Pass all Xlib events through CoglNeil Roberts2010-06-221-0/+52
| | | | | | | | | | | | | | | | The Clutter X11 backend now passes all events through _cogl_xlib_handle_event. This function can now internally be hooked with _cogl_xlib_add_filter. These are added to a list of callbacks which are all called in turn by _cogl_xlib_handle_event. This is intended to be used internally in Cogl by any parts that need to see Xlib events. Cogl now also has an internally exposed function to set a pointer to the Xlib display. This is stored in a global variable. The Clutter X11 backend sets this. _cogl_xlib_handle_event and _cogl_xlib_set_display can be removed once Cogl gains a proper window system abstraction.
* CoglMaterial: Implements sparse materials designRobert Bragg2010-06-151-5/+4
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | This is a complete overhaul of the data structures used to manage CoglMaterial state. We have these requirements that were aiming to meet: (Note: the references to "renderlists" correspond to the effort to support scenegraph level shuffling of Clutter actor primitives so we can minimize GPU state changes) Sparse State: We wanted a design that allows sparse descriptions of state so it scales well as we make CoglMaterial responsible for more and more state. It needs to scale well in terms of memory usage and the cost of operations we need to apply to materials such as comparing, copying and flushing their state. I.e. we would rather have these things scale by the number of real changes a material represents not by how much overall state CoglMaterial becomes responsible for. Cheap Copies: As we add support for renderlists in Clutter we will need to be able to get an immutable handle for a given material's current state so that we can retain a record of a primitive with its associated material without worrying that changes to the original material will invalidate that record. No more flush override options: We want to get rid of the flush overrides mechanism we currently use to deal with texture fallbacks, wrap mode changes and to handle the use of highlevel CoglTextures that need to be resolved into lowlevel textures before flushing the material state. The flush options structure has been expanding in size and the structure is logged with every journal entry so it is not an approach that scales well at all. It also makes flushing material state that much more complex. Weak Materials: Again for renderlists we need a way to create materials derived from other materials but without the strict requirement that modifications to the original material wont affect the derived ("weak") material. The only requirement is that its possible to later check if the original material has been changed. A summary of the new design: A CoglMaterial now basically represents a diff against its parent. Each material has a single parent and a mask of state that it changes. Each group of state (such as the blending state) has an "authority" which is found by walking up from a given material through its ancestors checking the difference mask until a match for that group is found. There is only one root node to the graph of all materials, which is the default material first created when Cogl is being initialized. All the groups of state are divided into two types, such that infrequently changed state belongs in a separate "BigState" structure that is only allocated and attached to a material when necessary. CoglMaterialLayers are another sparse structure. Like CoglMaterials they represent a diff against their parent and all the layers are part of another graph with the "default_layer_0" layer being the root node that Cogl creates during initialization. Copying a material is now basically just a case of slice allocating a CoglMaterial, setting the parent to be the source being copied and zeroing the mask of changes. Flush overrides should now be handled by simply relying on the cheapness of copying a material and making changes to it. (This will be done in a follow on commit) Weak material support will be added in a follow on commit.
* cogl-clip-state: Export transform_point internally to CoglNeil Roberts2010-06-101-0/+7
| | | | | | | | The transform_point function takes a modelview matrix, projection matrix and a viewport and performs all three transformations on a point to give a Cogl window coordinate. This is useful in a number of places in Cogl so this patch moves it to cogl.c and adds it to cogl-internal.h
* material: Adds backend abstraction for fragment processingRobert Bragg2010-06-091-15/+0
| | | | | | | | | | | | | | | | | | | | | | | | As part of an effort to improve the architecture of CoglMaterial internally this overhauls how we flush layer state to OpenGL by adding a formal backend abstraction for fragment processing and further formalizing the CoglTextureUnit abstraction. There are three backends: "glsl", "arbfp" and "fixed". The fixed backend uses the OpenGL fixed function APIs to setup the fragment processing, the arbfp backend uses code generation to handle fragment processing using an ARBfp program, and the GLSL backend is currently only there as a formality to handle user programs associated with a material. (i.e. the glsl backend doesn't yet support code generation) The GLSL backend has highest precedence, then arbfp and finally the fixed. If a backend can't support some particular CoglMaterial feature then it will fallback to the next backend. This adds three new COGL_DEBUG options: * "disable-texturing" as expected should disable all texturing * "disable-arbfp" always make the arbfp backend fallback * "disable-glsl" always make the glsl backend fallback * "show-source" show code generated by the arbfp/glsl backends
* cogl: Introduce private feature flags and check for ARB_fpDamien Lespiau2010-06-091-0/+8
| | | | | | | | | | | | | | | The Cogl context has now a feature_flags_private enum that will allow us to query and use OpenGL features without exposing them in the public API. The ARB_fragment_program extension is the first user of those flags. Looking for this extension only happens in the gl driver as the gles drivers will not expose them. One can use _cogl_features_available_private() to check for the availability of such private features. While at it, reindent cogl-internal.h as described in CODING_STYLE.
* cogl: Record new enabled arrays in _cogl_disable_other_texcoord_arraysNeil Roberts2010-05-271-1/+2
| | | | | | | | | | | | When _cogl_disable_other_texcoord_arrays is called it disables the neccessary texcoord arrays and then removes the bits for the disabled arrays in ctx->texcoord_arrays_enabled. However none of the places that call the function then set any bits in ctx->texcoord_arrays_enabled so the arrays would never get marked and they would never get disabled again. This patch just changes it so that _cogl_disable_other_texcoord_arrays also sets the corresponding bits in ctx->texcoord_arrays_enabled.
* cogl: Use a CoglBitmask to store the list of used texcoord arraysNeil Roberts2010-05-241-1/+4
| | | | | | | | | | | | | Instead of directly using a guint32 to store a bitmask for each used texcoord array, it now stores them in a CoglBitmask. This removes the limitation of 32 layers (although there are still other places in Cogl that imply this restriction). To disable texcoord arrays code should call _cogl_disable_other_texcoord_arrays which takes a bitmask of texcoord arrays that should not be disabled. There are two extra bitmasks stored in the CoglContext which are used temporarily for this function to avoid allocating a new bitmask each time. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
* cogl-vertex-buffer: Don't disable layers with no texture coordsNeil Roberts2010-05-241-0/+3
| | | | | | | | | | | | | | | | | | | | | | | | | | It should be quite acceptable to use a texture without defining any texture coords. For example a shader may be in use that is doing texture lookups without referencing the texture coordinates. Also it should be possible to replace the vertex colors using a texture layer without a texture but with a constant layer color. enable_state_for_drawing_buffer no longer sets any disabled layers in the overrides. Instead of counting the number of units with texture coordinates it now keeps them in a mask. This means there can now be gaps in the list of enabled texture coordinate arrays. To cope with this, the Cogl context now also stores a mask to track the enabled arrays. Instead of code manually iterating each enabled array to disable them, there is now an internal function called _cogl_disable_texcoord_arrays which disables a given mask. I think this could also fix potential bugs when a vertex buffer has gaps in the texture coordinate attributes that it provides. For example if the vertex buffer only had texture coordinates for layer 2 then the disabling code would not disable the coordinates for layers 0 and 1 even though they are not used. This could cause a crash if the previous data for those arrays is no longer valid. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
* Stubs out _cogl_xlib_handle_eventRobert Bragg2010-05-191-0/+39
| | | | | | | | This stubs out an xlib event handling mechanism for Cogl. The intention is for Clutter to use this to forward all x11 events to Cogl. As we move winsys functionality down into Cogl, Cogl will become responsible for handling a number of X events: ConfigureNotify events for onscreen framebuffers, swap events and Damage events for cogl_x11_texture_pixmap.
* cogl: Support retained pathsNeil Roberts2010-04-081-28/+0
| | | | | | | | | | | | | | | | | | | | | | | | | | | | This adds three new API calls: CoglHandle cogl_path_get() void cogl_path_set(CoglHandle path) CoglHandle cogl_path_copy(CoglHandle path) All of the fields relating to the path have been moved from the Cogl context to a new CoglPath handle type. The cogl context now just contains a CoglPath handle. All of the existing path commands manipulate the data in the current path handle. cogl_path_new now just creates a new path handle and unrefs the old one. The path handle can be stored for later with cogl_path_get. The path can then be copied with cogl_path_copy. Internally it implements copy-on-write semantics with an extra optimisation that it will only copy the data if the new path is modified, but not if the original path is modified. It can do this because the only way to modify a path is by appending to it so the copied path is able to store its own path length and only render the nodes up to that length. For this to work the copied path also needs to keep its own copies of the path extents because the parent path may change these by adding nodes. The clip stack now uses the cogl_path_copy mechanism to store paths in the stack instead of directly copying the data. This should save some memory and processing time.
* cogl: rename cogl_enable to _cogl_enableRobert Bragg2010-04-011-2/+2
| | | | | | Every now and then someone sees the cogl_enable API and gets confused, thinking its public API so this renames the symbol to be clear that it's is an internal only API.
* Remove mentions of the FSF addressEmmanuele Bassi2010-03-011-3/+3
| | | | | | | | | | | | | | | Since using addresses that might change is something that finally the FSF acknowledge as a plausible scenario (after changing address twice), the license blurb in the source files should use the URI for getting the license in case the library did not come with it. Not that URIs cannot possibly change, but at least it's easier to set up a redirection at the same place. As a side note: this commit closes the oldes bug in Clutter's bug report tool. http://bugzilla.openedhand.com/show_bug.cgi?id=521
* cogl: cleanly separate primitives + paths codeRobert Bragg2010-02-121-0/+28
| | | | | | | | | | The function prototypes for the primitives API were spread between cogl-path.h and cogl-texture.h and should have been in a cogl-primitives.h. As well as shuffling the prototypes around into more sensible places this commit splits the cogl-path API out from cogl-primitives.c into a cogl-path.c
* cogl: improves header and coding style consistencyRobert Bragg2010-02-121-12/+20
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
* cogl: deprecates cogl_check_extensionRobert Bragg2010-02-121-0/+1
| | | | | | | | | OpenGL is an implementation detail for Cogl so it's not appropriate to expose OpenGL extensions through the Cogl API. Note: Clutter is currently still using this API, because it is still doing raw GL calls in ClutterGLXTexturePixmap, so this introduces a couple of (legitimate) build warnings while compiling Clutter.
* cogl: Introduce the GE_RET() debug macroDamien Lespiau2010-02-081-1/+13
| | | | | | | | Some GL functions have a return value that the GE() macro is not able to handle. Let's define a new Ge_RET() macro which will be able to handle functions such as glMapBuffer(). While at it, removed the unused variadic dots to the GE() macro.
* cogl: Fix checks of the number of available texture unitsDamien Lespiau2010-01-261-0/+2
| | | | | | | | | | | We were checking the number of texture units against the GL enum that is used in glGetInteger() to query that number. Let's abstract this in a little function. Took the opportunity to dig a bit on the usage of GL limits for the number of texture (image) units and document our use of them. We'll need something finer grained if we want to fully exploit texture image units with a programmable pipeline.
* build: Move CoglMatrixMode to cogl-matrix-stack.hEmmanuele Bassi2010-01-041-7/+0
| | | | | | | This avoids a redeclaration of _cogl_matrix_stack_flush_to_gl() from using GLenum to CoglMatrixMode. http://bugzilla.openedhand.com/show_bug.cgi?id=1928
* Remove _cogl_flush_matrix_stacks from cogl-internal.hNeil Roberts2009-11-121-2/+0
| | | | | The definition for this function was removed in f7d64e5abvoid so it should be removed from the header too.
* [cogl] Use clockwise face winding for offscreen buffers with culling enabledRobert Bragg2009-11-041-0/+9
| | | | | | | | | | | | | Because Cogl defines the origin for texture as top left and offscreen draw buffers can be used to render to textures, we (internally) force all offscreen rendering to be upside down. (because OpenGL defines the origin to be bottom left) By forcing the users scene to be rendered upside down though we also reverse the winding order of all the drawn triangles which may interfere with the users use of backface culling. This patch ensures that we reverse the winding order for a front face (if culling is in use) while rendering offscreen so we don't conflict with the users back face culling.
* [cogl] Removes the cogl-current-matrix abstractionRobert Bragg2009-10-201-3/+11
| | | | | | | | | | | | | The indirection through this API isn't necessary since we no longer arbitrate between the OpenGL matrix API and Cogl's client side API. Also it doesn't help to maintain an OpenGL style matrix mode API for internal use since it's awkward to keep restoring the MODELVIEW mode and easy enough to directly work with the matrix stacks of interest. This replaces use of the _cogl_current_matrix API with direct use of the _cogl_matrix_stack API. All the unused cogl_current_matrix API is removed and the matrix utility code left in cogl-current-matrix.c was moved to cogl.c.
* [current-matrix] Adds texture matrix stacks + removes GL matrix API usageRobert Bragg2009-10-201-0/+12
| | | | | | | | | | | | | This relates back to an earlier commitment to stop using the OpenGL matrix API which is considered deprecated. (ref 54159f5a1d029db) The new texture matrix stacks are hung from a list of (internal only) CoglTextureUnit structures which the CoglMaterial code internally references via _cogl_get_texure_unit (). So we would be left with only the cogl-matrix-stack code being responsible for glMatrixMode, glLoadMatrix and glLoadIdentity this commit updates the journal code so it now uses the matrix-stack API instead of GL directly.
* Intial Re-layout of the Cogl source code and introduction of a Cogl WinsysRobert Bragg2009-10-161-0/+88
As part of an incremental process to have Cogl be a standalone project we want to re-consider how we organise the Cogl source code. Currently this is the structure I'm aiming for: cogl/ cogl/ <put common source here> winsys/ cogl-glx.c cogl-wgl.c driver/ gl/ gles/ os/ ? utils/ cogl-fixed cogl-matrix-stack? cogl-journal? cogl-primitives? pango/ The new winsys component is a starting point for migrating window system code (i.e. x11,glx,wgl,osx,egl etc) from Clutter to Cogl. The utils/ and pango/ directories aren't added by this commit, but they are noted because I plan to add them soon. Overview of the planned structure: * The winsys/ API is the API that binds OpenGL to a specific window system, be that X11 or win32 etc. Example are glx, wgl and egl. Much of the logic under clutter/{glx,osx,win32 etc} should migrate here. * Note there is also the idea of a winsys-base that may represent a window system for which there are multiple winsys APIs. An example of this is x11, since glx and egl may both be used with x11. (currently only Clutter has the idea of a winsys-base) * The driver/ represents a specific varient of OpenGL. Currently we have "gl" representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing GLES 1.1 (fixed funciton) and 2.0 (fully shader based) * Everything under cogl/ should fundamentally be supporting access to the GPU. Essentially Cogl's most basic requirement is to provide a nice GPU Graphics API and drawing a line between this and the utility functionality we add to support Clutter should help keep this lean and maintainable. * Code under utils/ as suggested builds on cogl/ adding more convenient APIs or mechanism to optimize special cases. Broadly speaking you can compare cogl/ to OpenGL and utils/ to GLU. * clutter/pango will be moved to clutter/cogl/pango How some of the internal configure.ac/pkg-config terminology has changed: backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11" backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la" clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx" CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS clutterbackendlib -> CLUTTER_WINSYS_LIB CLUTTER_COGL -> COGL_DRIVER # e.g. "gl" Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps As the first thing to take advantage of the new winsys component in Cogl; cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into cogl/common/cogl.c and this common implementation first trys _cogl_winsys_get_proc_address() but if that fails then it falls back to gmodule.
View Lorry Controller Status