Blog

If you sometimes find yourself confused about whether you should use
the word ‘fewer’ or ‘less’, here is a handy table to help you:

It is extremely important to pick the right word. For example if you
think there are too many pedantic people in your office you should say
‘my office has the manyest pedantic people’. If you were to
incorrectly say ‘my office has the most pedantic people’, your
listener would immediately assume you meant that the people in your
office are more pedantic than any other people. This could cause
untold confusion and misunderstanding. It is therefore essential that
if you hear a friend incorrectly say ‘more’ when they mean ‘manyer’
you must immediately interrupt and correct them.

Today is the first release of Rig. This is a project that Robert Bragg
and I have been working for the past few months. I won't try to
describe it here, but instead I will try to entice you with a
screenshot and ask you to take a look at Robert's
detailed blog post.

Cogl has been getting some love lately to move towards the 2.0 API
that will eventually replace the existing API. Now that Cogl has split
out from Clutter and it can be used as a standalone library we are
getting close to the goal of Cogl being a convenient replacement for
OpenGL. However one thing that until recently has been severely
lacking for Cogl to be a credible modern graphics library is good
support for shaders. Cogl has had a sort of shader support for a long
time but it has hardly been touched since the days when Cogl was just
a very thin wrapper over the GL API. Cogl has evolved a lot since then
so the previous shader support no longer fits with Cogl's design.

We've finally got around to improving this situation so there are now
a few changes in git master of Cogl to make this better. In 2.0 land,
instead of having to create a CoglProgram to replace the entire of
either the vertex or fragment pipeline you can now create
CoglSnippets. These can be inserted at specific hook points on a
CoglPipeline to either wrap around or completely replace a part of the
pipeline. For example, imagine we have a function in GLSL that can
take an input colour and convert it to black-and-white. If we wanted to
use this in Cogl we would previously have had to implement the entire
fragment pipeline. Usually this would mean having to create a sampler
uniform, update that uniform and writing the code to get a texel from
the sampler. If we wanted to use this shader in another situation
without texturing, for example when drawing a solid colour rectangle,
we would have to write another shader that includes the function
without the texturing.

With the snippets API we can now create an object that just contains
the black-and-white conversion in a single line, like this:

Then we can attach that snippet to any CoglPipeline and Cogl will fill
in the rest of the code needed to make it work. It can be attached to
multiple pipelines, for example one with texturing and one without.

The second feature that has landed recently is to be able to store
uniform values on a CoglPipeline. The idea behind the design of Cogl
is that you will store as much of the GL state as possible in a
CoglPipeline object and try to switch between these cached states
rather than redescribing the state to the graphics library every time
something is drawn. That way Cogl can minimise the state changes by
recognising the minimal set of differences between two pipelines. The
previous approach for uniforms - which was the same as OpenGL where
the uniform values are attached to the program object - doesn't match
well to this design. If you wanted to use a program multiple times
with different values then you would have to reset the values on the
program for every primitive.

In Cogl master you can instead encapsulate these uniform values on the
pipeline and Cogl can efficiently recognise which uniforms are
different between two pipelines sharing the same program and avoid
flushing uniforms that haven't changed. For example, imagine this
snippet which just replaces the red component of the fragment colour
based on the value of a uniform:

Cogl will quickly know that the two pipelines are using the same
program because they are copied from the same parent so it will only
flush the state for the new uniform value when switching between the
two.

The third recent addition to Cogl related to shaders is support for
custom attributes. The API has already been in place for this for a
while from both CoglPrimitive and the now deprecated
CoglVertexBuffer. However it was never actually connected together
properly so no-one could use it. The custom attributes can be set by
just naming them when a CoglAttribute is created. Here is a short
example:

I've uploaded the current documentation to a
temporary location if you want further details of the API. It's
all still experimental so we'd very much welcome any testing and
feedback. The Cogl developers can be contacted on the new mailing list or at
#clutter on GIMPnet.

Is anybody else using gtk-im-extra? If so
you might be interested to know I've made a git
repo (it's currently still in CVS!) and added some patches to make
it build with GTK+3. It would be really great if someone would get
this into a Fedora package so I don't have to keep building it.