If we don't specify the dependency we may end up linking against a stale
libcogl.la, or, worse, a globally installed one.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
The get_all_uniform_values function tries to walk the parent hierarchy
of pipelines to find pipelines overriding the uniforms state and then
grabs the values from the override. However it was accessing data
inside the ‘big state’ even if the pipeline didn't override the
uniforms state so it would crash if it encountered a parent pipeline
with no big state.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
This adds a test for doing custom sampling using the cogl_sampler
variable in the texture lookup hook.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
There were lots of tests bundled into a single long function which was
becoming a bit unwieldy. It was also quite difficult to match up the
test's drawing with its color test. This patch just moves each little
sub test into its own function.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
The snippet hook COGL_SNIPPET_HOOK_TEXTURE_LOOKUP now gets passed an
extra variable called cogl_sampler which is the sampler attached to
this layer. For example this will be useful when implementing the blur
effect in Clutter so that it can make the texture hook for that layer
sample the texture multiple times.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
There might be custom hooks that want to sample arbitrary layers
even though they aren't referenced as part of the auto generated layer
combine code. This ensures the sampler uniforms are always output for
non-null layers so at least these can be used.
We may consider changing this later to always emit a wrapper
cogl_sampleX() function for each layer so all samples of a layer can
consistently be modified by a COGL_SNIPPET_HOOK_TEXTURE_LOOKUP hook.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
When generating GLSL code, the names of the builtin uniforms for the
sampler and the layer constant have been renamed to use the layer
number not the unit number. This will make it easier if we ever want
to make them public.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
In a combine string the application can specify TEXTURE_? as a source
to sample from the texture attached to a particular unit. The number
specified here was being interpreted as a unit index. This is not
helpful to applications because theoretically the unit index is an
internal implementation detail so they can't reliably determine what
it is. This patch changes them to be interpreted as layer indices
instead.
To make this work the enums in CoglPipelineCombineSource are no longer
directly mapped to GLenums. Otherwise it implies a low limit on the
number of layer indices because there are only 32 reserved numbers
between GL_TEXTURE0 and GL_ACTIVE_TEXTURE.
This also fixes a bug in the ARBfp fragend where it was generating
code using the texture type of the layer doing the referencing rather
than the layer that was being referenced.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
This adds _cogl_pipeline_get_layer_with_flags which takes a set of
flags to modify the behaviour. The only flag currently available is
one to disable creating the layer if the layer index does not already
exist.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
There are currently quite a few places in Cogl where we muddle the
layer index and the texture unit number. The theory is that these two
numbers shouldn't be related and it should be possible to pick large
layer numbers with gaps.
This patch adds a test case to check that we can reference a large
layer number from a texture combine string by creating a pipeline with
only three layers but that have very large layer indices. This doesn't
currently work because Cogl interprets the numbers in the combine
strings to be the unit indices and not the layer indices. The
documentation however calls these numbers layer numbers so presumably
it is not meant to work that way.
There are probably many other bugs related to this that the test case
doesn't pick up so it would be good to add some more tests here, for
example to test that you can bind an attribute to the texture
coordinates for a large layer index.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
The ARBfp fragend has a bug when the texture combine string references
another texture unit where it will use the texture type of the current
layer rather than the texture type of the layer the string refers to.
This patch adds a small test which demonstrates that.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
This adds a public function to replace the texture for a layer with
the default white texture. It is equivalent to calling
cogl_pipeline_set_layer_texture with NULL for the texture object
except that it also lets you choose a type for the texture. The idea
is that applications using a base pipeline to make multiple copies
that can share the generated shaders can use this function to make the
layer come into existence with the right texture type. Previously the
idiom would be to create a 1x1 dummy texture of the right type but
this ends up creating lots of redundant little textures.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
When comparing the texture data for a pipeline layer it tries to get
the GL texture handle out of the texture object. However it's valid
for a layer to have a NULL texture object but in that case the code
would just crash. This patch fixes it to compare the texture types
when the texture object is NULL.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
Instead of storing the GLenum for the target of the last used texture
for a layer it now stores the CoglTextureType instead. The state name
has been renamed to 'texture type' instead of 'texture target'.
Previously the default pipeline layer would store 0 here to represent
that there is no texture. This has been changed to store
COGL_TEXTURE_TYPE_2D instead which means that all pipeline layers
always have a valid value for the texture type. Any places that were
previously fetching the texture from a layer to determine the target
(for example when generating shaders or when enabling a particular
texture target) now use the texture type instead. This means they will
work even for layers that don't have a texture.
This also changes it so that when binding a fallback texture instead
of always using a 2D texture it will now use the default texture
corresponding to the texture type of the layer. That way when the
generated shader tries to do a texture lookup for that type of texture
it will get a valid texture object. To make this work the patch adds a
default texture for 3D textures to the context and also makes the
default rectangle texture actually be a rectangle texture instead of
using a 2D texture.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
This adds an internal function to get the type of the underlying
hardware texture for any CoglTexture. It can return one of three
values to represent 2D textures, 3D textures or rectangle textures.
The idea is that this can be used as a replacement for
cogl_texture_get_gl_texture when only the target is required to make
it a bit less GL-centric. The implementation adds a new virtual
function which all of the texture backends now implement.
The enum is in a public header because a later patch will want to use
it from the CoglPipeline API. We may want to consider making the
function public too later.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
Just being a bit paranoid here, as the SDL winsys sources are dealt in the
projects as they are not built for all configurations to avoid them
included more than once in the projects, which can cause trouble.
https://bugzilla.gnome.org/show_bug.cgi?id=669785
Reviewed-by: Neil Roberts <neil@linux.intel.com>
-Adapt to the removal of _EXP mangling from many of the experimental
functions
-Adapt to newly added/replaced APIs
-_cogl_handle_atlas_texture_get_type is gone
https://bugzilla.gnome.org/show_bug.cgi?id=669785
Reviewed-by: Neil Roberts <neil@linux.intel.com>
-Add a define for COGL_HAS_GLIB_SUPPORT, the Visual C++ projects will build
GLib support for COGL for all builds at this time, unless there is a
significant call for the need of a COGL Visual C++ build with no
dependency on GLib
-Pre-define COGL_SYSDEF_POLL* as listed in the default values in commit
74974752 since Windows does not have poll.h and thus does not have special
values for these.
https://bugzilla.gnome.org/show_bug.cgi?id=669785
Reviewed-by: Neil Roberts <neil@linux.intel.com>
All CoglBuffer constructors now take an explicit CoglContext
constructor. This is part of the on going effort to adapt to Cogl API so
it no longer depends on a global, default context.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
When using COGL_DEBUG=wireframe we were overlaying a wireframe of the
users geometry over the top of what was drawn for each primitive. It
seems to be more useful though that if the wireframe debug option has
been enabled then we should draw only the wireframes instead of
overlaying them.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
Use of cogl_set_depth_test_enabled() has been deprecated for some time
and cogl-create already uses the new api for enabling depth testing so
it was just an oversight that we forgot to remove the old call to
cogl_set_depth_test_enabled().
Reviewed-by: Neil Roberts <neil@linux.intel.com>
Since we are adapting the Cogl api to be less stateful one of the things
we no longer require is the cogl_set_source() api since a pipeline can
be explicitly passed as an argument when drawing. This means the term
"source" has been deprecated and internally we should aim to
consistently use the term "pipeline" instead. This patch updates the
journal code to use the term pipeline instead of source.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
Although we internally had a COGL_DEBUG_WINSYS enum we weren't providing
a way to enable that via the COGL_DEBUG environment variable. This adds
a "winsys" option that can be used to enable printing of winsys debug
notes.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
We are in the process of removing all _EXP suffix mangling for
experimental APIs (Ref: c6528c4b6c) and adding missing gtk-doc
comments so that we can instead rely on the "Stability: unstable"
markers in the gtk-doc comments. This patch tackles the display api
symbols.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
This adds cogl_framebuffer_ apis for drawing attributes and primitives
that replace corresponding apis that depend on the default CoglContext.
This is part of the on going effort to adapt the Cogl api so it no
longer depends on a global context variable.
All the new drawing functions also take an explicit pipeline argument
since we are also aiming to avoid being a stateful api like Cairo and
OpenGL. Being stateless makes it easier for orthogonal components to
share access to the GPU. Being stateless should also minimize any
impedance miss-match for those wanting to build higher level stateless
apis on top of Cogl.
Note: none of the legacy, global state options such as
cogl_set_depth_test_enabled(), cogl_set_backface_culling_enabled() or
cogl_program_use() are supported by these new drawing apis and if set
will simply be silently ignored.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
Instead of using apis like cogl_push/pop_matrix, cogl_rotate,
cogl_translate and cogl_scale all the examples now use the
cogl_framebuffer_* equivalents. Our aim is to remove the need for the
default CoglContext and so we are switching towards apis that
are explicitly tied to a specific context.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
cogl_clear depends on the default CoglContext which we are trying to
steer the API away from requiring. cogl_framebuffer_clear4f is
explicitly passed a framebuffer pointer which is implicitly related to a
specific context.
This updates all the examples to use cogl_framebuffer_clear4f instead of
cogl_clear and removes any redundant CoglColor that was previously
passed to cogl_clear.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
It used to be that cogl_framebuffer_allocate() had to be done explicitly
but we have since made Cogl lazily allocate framebuffers when they are
first used if they haven't already been explicitly allocated. Developers
only need to explicitly allocate framebuffers if they are planning to
gracefully handle any errors. In cases where the program will simply
abort due to an allocation error they can simply rely on implicit
allocation which will cause an abort on error.
This updates the examples to not explicitly allocate the framebuffers
since they all just abort on error anyway.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
Previously when using the cogl_rectangle_* family of functions with a
pipeline that doesn't have a texture for a particular layer then
validate_tex_coords_cb would bail out immediately leaving the texture
coords for that layer uninitialised. This patch changes it so that it
bails out after copying in the texture coordinates instead. This was
causing problems for pipelines that were trying to completely generate
the texture values in a CoglSnippet because they wouldn't get any
texture coordinates.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
This ensures we don't call swap buffer notify callback functions
immediately when they are received since it could be awkward for
applications to ensure they have dropped all necessary locks if they
don't know when callbacks might be invoked.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
This adds a cogl_kms_renderer_get_kms_fd() function that lets developers
access the kms file descriptor being used for controlling the kernel
mode setting.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
The recent patch to add an api for explicitly constraining how a
renderer backend is chosen had a typo which this patch fixes.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
When creating a texture from a wayland buffer we create an intermediate
EGLImage that we then create a GL texture from, but we were never
destroying that EGLImage. This patch ensures we destroy the image right
after we've created the texture so we don't leak a reference to the
underlying buffer.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
Instead of having each winsys implement its own list of callbacks the
list is now just attached directly to the CoglOnscreen using code in
cogl-onscreen.c. The winsys's can invoke this list of callbacks by
calling _cogl_onscreen_notify_swap_buffers(). All of the winsys's
would probably have a very similar implementation for this anyway and
I don't think it makes much sense to try and save the cost of a list
pointer in the CoglOnscreen struct.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
This adds a little test which makes a copy of a CoglPrimitive and
verifies that all of the properties on the new primitive are the same
as the old one.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
This adds a public function to iterate the attributes of a
CoglPrimitive. Previously there was no way to query back the
attributes but there was methods to query back all of the other
properties.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
This adds a public function to make a copy of a primitive. The copy is
shallow which means it will share the same attributes and attribute
buffers. This could be useful for code that wants to have multiple
similar primitives with slightly modified properties.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
There was no other way to get a pointer to the texture attached to a
pipeline layer apart from the using the CoglMaterial API but I think
this was just an oversight so we should add this in. It is already
maked in the sections file for the gtk-doc.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
