cogl: Remove cogl-defines.h.in from the driver make files

Commit 7fae8ac051292 changed cogl-defines.h.in so there is only a
single copy in clutter/cogl/ instead of one for each driver. However
the old files were still mentioned in the EXTRA_DIST of the
Makefile.am so make distcheck was failing.

cogl-path: Disable texture coord arrays before drawing

It was possible that the texture co-ord arrays were left enabled during
stroking, which could possibly cause a crash.

clutter-animation: Fix for using fixed:: from clutter_actor_animatev

When using clutter_actor_animatev it would set a boolean whenever a
property begins with "fixed::". However it would never clear the
variable so it would end up marking all subsequent properties as
fixed.

http://bugzilla.openedhand.com/show_bug.cgi?id=2180

http://bugzilla.clutter-project.org/show_bug.cgi?id=2149

Revert 7e6b60270d1951f0789868740b8df6acfe677d57

You should not commit patches based on the bugzilla description alone.
You should not commit patches based on the bugzilla description alone.
You should not commit patches based on the bugzilla description alone.
...

Fix the libdir in the pkg-config file

texture-pixmap-x11: don't assume anything about the GLXFBConfig type

A pedantic change to get_fbconfig_for_depth() so that we don't need to
make any assumptions about the GLXFBConfig typedef or what values
we can overload to indicate an invalid config.

get_fbconfig_for_depth() now simply returns FALSE if it fails to find a
config.

drag-action: Disable picking during drag

While dragging we don't need to perform picking to determine the actor
underneath the pointer, for two reasons:

  • we use a capture on the stage to determine the motion delta.
  • we know the actor underneath the pointer because that's the
    actor we are dragging around.

This change should make dragging actors in complex scenes a bit faster.

Silence another compiler warning

cogl-texture-pixmap-x11: Use NULL instead of None for invalid GLXFBConfig

GLXFBConfigs are opaque pointers not XIDs so it doesn't make sense to
return None from get_fbconfig_for_depth. Instead it now returns NULL.

Add test-cogl-texture-pixmap-x11 to the ignore file

Silence some compiler warnings

docs: Fix release notes wording

docs: Fix links in the README

docs: Remove the 'copyright-waiver' section

There is no need to toggle the copyright-waiver flag on Bugzilla
any more.

Use -Bsymbolic-functions

The -Bsymbolic-functions linker flag allows to avoid intra-library
PLT jumps on ELF platforms. It is similar to the aliasing hack in
GLib and GTK+, but definitely less messy.

The configure script should look for the flags, in order to support
platforms/linkers that do not have it.

conform: Do not use deprecated API in test-clutter-units

Setting the DPI is done through the ClutterSettings:font-dpi property.

Do not hardcode paths in pkgconfig file

The pkgconfig file correctly sets $prefix to @prefix@, but the other
paths should be relative to $prefix.

Add a test case for CoglTexturePixmapX11

clutter-{glx,x11}-texture-pixmap: Use CoglTexturePixmapX11

The pixmap handling of both of the texture pixmap actors in Clutter is
now removed and instead it just creates a CoglTexturePixmapX11. Both
actors are now equivalent so there is no need to choose between the
two.

Add a CoglTexturePixmapX11 texture backend

This is a publicly exposed texture backend to create a texture which
contains the contents of an X11 pixmap. The API is currently marked as
experimental.

The backend internally holds a handle to another texture. All of the
backend virtuals simply redirect to the internal texture.

The texture can optionally be automatically updated if the
automatic_updates parameter is TRUE. If set then Cogl will listen for
damage events on the pixmap and update the texture accordingly.
Alternatively a damage object can be created externally and passed
down to Cogl.

The updates can be performed with XGetImage, XShmGetImage or the
GLX_EXT_texture_pixmap extension. If the TFP extension is used it will
optionally try to create a rectangle texture if the driver does not
support NPOTs or it is forced through the
COGL_PIXMAP_TEXTURE_RECTANGLE or CLUTTER_PIXMAP_TEXTURE_RECTANGLE
environment variables.

If the GLXFBConfig does not support mipmapping then it will fallback
to using X{Shm,}GetImage. It keeps a separate texture around for this
so that it can later start using the TFP texture again if the texture
is later drawn with mipmaps disabled.

test-pixmap: Use the 'm' key to toggle texture quality

When the 'm' key is pressed it will now recursively look for all
ClutterTexture subclasses on the stage and toggle the texture quality
between high and low. This is useful to test the mipmap fallback.

test-pixmap: Draw something more interesting when the mouse is clicked

When the mouse button is pressed it would previously draw a small
1-pixel wide fully transparent line to the pixmap. This is a useful
feature to help test the automatic updates but the line is quite hard
to see so it's to easy miss. This patch changes it to draw a thick
black circle. The circle is drawn at a different position every time
the button is clicked.

test-pixmap: Add a --disable-animation option

Sometimes the animation makes debugging awkward so this patch adds a
--disable-animation option to simplify the test.

test-pixmap: Enable automatic updates for the hand

The hand actor has a feature that if you click on the stage it will
draw a line to the actor. However it's not possible to see the results
of this because automatic updates were disabled so the texture would
never be updated.

test-pixmap: Implement the --disable-x11 option

test-pixmap has long had a --disable-x11 option that didn't do
anything. This patch adds the neccessary if (disable_x11) to disable
adding the ClutterX11TexturePixmap actor when the option is given.

Add -DCOGL_ENABLE_EXPERIMENTAL_API to Makefiles for Cogl and x11/glx

Cogl and Clutter should be able to use the experimental API so this
adds the required define to the CPPFLAGS in the Makefiles.

cogl-defines.h: Add a COGL_HAS_X11 define

This will be defined in cogl-defines.h whenever Cogl is built using a
winsys that supports X11. This implies CoglTexturePixmapX11 will be
available.

To make this work the two separate cogl-defines.h.in files have been
merged into one. The configure script now makes a @COGL_DEFINES@
substitution variable which contains the #define lines to put in
rather than directly having them in the seperate files.

cogl: Add _cogl_xlib_{,un}trap_errors

This is similar to clutter_x11_{,un}trap_errors except that it stores
the previous trap state in a caller-allocated struct so that it can be
re-entrant.

Make _cogl_xlib_trap_errors re-entrant

(this will be squashed into an earlier commit)

cogl-texture: Avoid premult conversion if the dst format has no alpha

The _cogl_texture_needs_premult_conversion function was already
checking whether the source format had an alpha channel before
returning TRUE, but it also doesn't make sense to do the premult
conversion if the destination format has no alpha. This patch adds
that check in too.

cogl: Add the infrastructure for checking for winsys extensions

This adds the framework needed to check for winsys specific extensions
(such as GLX extensions) using a similar mechanism to the
cogl-feature-functions header. There is a separate
cogl-winsys-feature-functions header which will contain macros to list
the extensions and functions. cogl_create_context_winsys now calls
_cogl_feature_check for each of these functions. _cogl_feature_check
has had to be changed to accept the driver prefix as the first
parameter so that it can prepend "GLX" rather than "GL" in this case.

Pass all Xlib events through Cogl

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.

cogl: Add a struct for winsys-specific data to CoglContext

This creates a separate struct to store the fields of the context that
are specific to the winsys. This is all stored in one file but ideally
this could work more like the CoglContextDriver struct and have a
different header for each winsys.

cogl: Add an internal CoglTextureRectangle backend

This adds an internal rectangle texture backend which is mostly based
on the CoglTexture2D backend. It will throw assert failures if any
operations are attempted that rectangle textures don't support, such
as mipmapping or hardware repeating.

cogl-texture: Replace the ensure_mipmaps virtual with pre_paint

Instead of the ensure_mipmaps virtual that is only called whenever the
texture is about to be rendered with a min filter that needs the
mipmap, there is now a pre_paint virtual that is always called when
the texture is about to be painted in any way. It has a flags
parameter which is used to specify whether the mipmap will be needed.

This is useful for CoglTexturePixmapX11 because it needs to do stuff
before painting that is unrelated to mipmapping.

cogl-texture: List texture subclass types rather than hardcoding them

Instead of having a hardcoded series of if-statements in
cogl_is_texture to determine which types should appear as texture
subclasses, they are now stored in a GSList attached to the Cogl
context. The list is amended to using a new cogl_texture_register_type
function. There is a convenience macro called COGL_TEXTURE_DEFINE
which uses COGL_HANDLE_DEFINE_WITH_CODE to register the texture type
when the _get_type() function is first called.

Add COGL_{OBJECT,HANDLE}_DEFINE_WITH_CODE

This macro is similar to COGL_HANDLE_DEFINE_WITH_CODE except that it
allows a snippet of code to be inserted into the _get_type()
function. This is similar to how G_DEFINE_TYPE_WITH_CODE
works. COGL_HANDLE_DEFINE is now just a wrapper around
COGL_HANDLE_DEFINE_WITH_CODE.

Add _cogl_texture_2d_externally_modified

_cogl_texture_2d_externally_modified is a function specific to the
CoglTexture2D texture backend that should be called whenever the
contents of the texture are modified without the backend knowing about
it. It simply marks the mipmap tree as invalid.

cogl: Fix the include path in driver/*/Makefile.am

The include path for the winsys and driver folder was given relative
to $(srcdir) so it would end up relative to the driver folder which is
wrong. It is now specified as $(srcdir)/../../winsys to get the right
location. The driver folder is removed because it is actually just
$(srcdir) and that is already included.

test-shader: guard GLES2 specific changes with COGL_HAS_GLES2

Previously we were using an internal only HAVE_COGL_GLES2 define to
guard GLES 2 specific changes so for instance the precision modifiers
weren't being emitted in the shader source.

http://bugzilla.o-hand.com/show_bug.cgi?id=2178

gles2: don't disable clip planes for GLES2

GLES2 doesn't provide user clip planes (you would have to use a vertex +
fragment shader to achieve the same kind of result) so we make sure not
to call glEnable/Disable with any of the GL_CLIP_PLANE0..3 defines.

http://bugzilla.o-hand.com/show_bug.cgi?id=2177

material: fix a typo in _cogl_material_journal_unref

The function had a line like:

CoglMaterial *material =
    material = _cogl_material_pointer_from_handle (material_handle);

where the duplicate "material =" wasn't intended, so this patch removes
it.

json: Bump up the requirement of json-glib

We're actually using a symbol (the JSON_NODE_HOLDS macro) that was
defined in json-glib 0.10, so we need to bump up the dependency.

json: Backport JSON_NODE_HOLDS macros

Unbreak the compilation with the internal copy of json-glib.

x11: Use the _clutter symbols for xsettings_* API

Instead of using the bare xsettings_* API; this maintains consistency.

backend: Undeprecated clutter_backend_get_resolution()

Since the Settings:font-dpi property is exposed as 1024 * real_dpi in
order to make the setting as neutral as possible (and allow XSETTINGS
to use it natively) we need a simple API returning the DPI using a
floating point value.

Deprecate the Backend settings

The Settings instance is the preferred way of accessing the settings.

Remove default settings from backends

The defaults are set in the Settings instance.

docs: Add Settings to the API reference

And document properties.

settings: freeze notification on XSETTINGS notify

x11: Add the XSETTINGS machinery

Use the XSETTINGS machinery to get notification from foreign
environments about settings that might interest Clutter itself - namely:
the default font name, the font DPI, and the Xft font options that can
be mapped on cairo_font_options_t.

settings: Migrate Backend settings to a new object

Instead of storing settings inside the Backend instance we should use a
separate public object.

configure.ac only explicitly add -lGL if no pkgconfig file

When configuring the glx flavour we were always explicitly adding -lGL
to the linker flags even when a pkg-config file was found which should
take care of that option for us.

configure.ac: Use pkg-config for gles1/2 if available

When building for gles1/2 we now always try and look for a libglesv1_cm
or libglesv2 .pc file with details about where to find the library and
headers.

egl: Consolidates eglx and eglnative into one "egl" winsys

This remove quite a lot of redundant code by consolidating the eglx and
eglnative window system backends.

tslib: Add USE_TSLIB conditional for clutter-event-tslib.c

This adds an automake USE_TSLIB condition to decide when we should
compile clutter-event-tslib.c. This is in preparation for consolidating
the eglx and eglnative backends.

egl: rename clutter-event-egl.c -> clutter-event-tslib.c

clutter-event-egl had nothing to do with EGL, it's code for opening
tslib devices and creating a GSource for touch screen events. It just
happens that this only ever gets used with the eglnative backend.

clutter event egl: fixes lots of compiler warnings

The way the #ifdef HAVE_TSLIB guards were spread around it meant there
were lots of warnings about unused variables when building without
tslib.

egl: support creating OpenGL contexts

Right before we create the EGL context, we check if we were built with
OpenGL or OpenGLES support and it was OpenGL then we call eglBindAPI
(EGL_OPENGL_API); This also explicitly requests a EGL_RENDERABLE_TYPE
supporting the EGL_OPENGL_BIT.

This will let us add a new ./configure flavour that combines OpenGL and
EGL instead of OpenGL and GLX.

egl: Unify the eglx and eglnative backends

Without actually consolidating the two backends this patch brings their
code within a cats whisker of each other in preparation for
consolidation.

build: Adds a new opengl-egl-xlib build flavour

With this patch if you ./configure clutter using
--with-flavour=opengl-egl-xlib then it will use EGL + OpenGL instead of
the default GLX and OpenGL.

These days upstream driver work is more focused on improving EGL than it
is GLX so likewise we want to make sure Clutter has good support for
EGL.

build: distinguish CLUTTER_WINSYS and CLUTTER_SONAME_INFIX

This adds a separate variable name "CLUTTER_SONAME_INFIX" to define the
infix for the clutter library that gets linked. Currently the WINSYS
corresponds to the directory we enter when building to compile the
window system and input support, but it is desirable to be able to
define multiple flavours that use the same WINSYS but should result in
different library names.

For example we are planning to combine the eglx and eglnative window
systems into one "egl" winsys but we will need to preserve the current
library names for the eglx and eglnative flavours.

configure.ac: avoid some duplication

When we check the flavour we now just set boolean variables for the
following things:

SUPPORT_X11=1
SUPPORT_XLIB=1
SUPPORT_GLX=1
SUPPORT_EGL=1
SUPPORT_EGL_POWERVR_X11=1
SUPPORT_EGL_POWERVR_NULL=1

This lets us avoid some duplication and also some error prone tests for
lists of flavours used, for example, to determine when we need to check
for x libraries.

configure.ac: distinguish CLUTTER_FLAVOUR and CLUTTER_WINSYS

It's desirable to have a separation between the "flavour" and the
"winsys". The flavour is a concept internal to the configure script and
is a convenient name to represent the users choice of window system,
opengl driver and input backend. The CLUTTER_WINSYS currently defines
the subdirectory under clutter/ that should be compiled to handle the
window system and input.

With a separation we could add a flavour with no correspondence to which
clutter/subdirectory needs to be built.

configure.ac: move the special handling of the fruity flavour

After checking the flavour option the user gives we were checking for
the fruity flavour to override the glesversion. Now that the glsl
checking has been moved this can instead just wait until the AS_CASE
that handles all the flavour configuration.

configure.ac: move gles checks after the flavour checks

The flavour AS_CASE should define whether a flavour uses the gl or gles
COGL_DRIVER and so we shouldn't need to have an expanding list of
tests to gate when we check for a gles driver because if we move the
checks for gles after the flavour checks we can just look at
$COGL_DRIVER.

configure.ac: don't have so many XYX_{LIBS,CFLAGS} vars

This removes EGL_{LIBS,CFLAGS}, GLX_{LIBS,CFLAGS}, OSX_{LIBS,CFLAGS},
WIN32_{LIBS,CFLAGS}, and GLES_{LIBS,CFLAGS} and instead we just append
to FLAVOUR_{LIBS,CFLAGS}.

This makes more of the file relocatable because there were previously
dependencies on the order that some variables were setup in.

clutter-stage: Use g_array_free instead of g_array_unref

g_array_unref was only added in GLib 2.22 so we should really update
the requirements in the configure script if we want to use that
function. However the array doesn't appear to have any extra reference
taken on it anywhere so it should be safe to use g_array_free instead.

cogl-context: Use the function pointer for glActiveUnit

Under WGL, any functions that were defined after GL 1.1 are not
directly exported in the DLL so we need to reference them via the
function pointers. A new call to glActiveUnit was missed in
cogl-context.c

cogl-material: Don't use the symbol 'near'

The window headers contain the line

 #define near

so it's not possible to use the symbol 'near' in code that's portable
to Windows. This replaces it with 'near_val'.

I think the define is meant to improve compatibility with code written
for Windows 3.1 where near would be a keyword to make it a smaller
pointer size.

actor: Parse actions, constraints and effects members

ClutterActor should allow attaching actions, constraints and effects
just like it allows behaviours, e.g.:

  {
    ...
    "constraints" : [
      {
        "type" : "ClutterAlignConstraint",
        "source" : "stage",
        "align-axis" : "x-axis",
        "factor" : 0.5
      },
      {
        "type" : "ClutterAlignConstraint",
        "source" : "stage",
        "align-axis" : "y-axis",
        "factor" : 0.5
      }
    ],
    ...
  }

or:

  {
    ...
    "actions" : [
      {
        "type" : "ClutterDragAction",
        "signals" : [
          { "name" : "drag-end", "handler" : "on_drag_end" }
        ]
      }
    ],
    ...
  }

In order to do so, we use the Scriptable interface implementation and
add three new custom properties accepting an array; then we parse each
member of the array as a new object.

constraints: Allow Align and Bind sources to be NULL

Since constructing AlignConstraint and BindConstraint instances could be
deferred (think ClutterScript) we need to make their :source properties
setters accept NULL. This does not break the constraints because they
need to handle that condition in case they actor to which they are
applied is destroyed and somebody is holding a reference on them anyway.

script-parser: Expose extracting the id from a node

The get_id_from_node() internal function should be exposed inside
Clutter (as a private function) because it can be useful to other
custom parsing code. The code is pretty trivial, but it would be
pointless to re-implement it.

actor: Disable the layout cycle warning with debug disabled

If Clutter has been configured with --enable-debug set to 'no' then we
hide most of the warnings.

bind-constraint: Add accessor methods

ClutterBindConstraint should have accessor methods for its properties,
to allow direct manipulation instead of going through GObject's API.

state: add a duration property

Adding a duration property to ClutterState allows the json parsing
to parse the default transition duration with the generic code paths.

state: avoid walking off empty list

When removing the last key in a list, the last part of the for statement
could cause dereferencing (NULL)->next and thus segfaulting.

animator: avoid walking off empty list

When removing the last key in a list, the last part of the for statement
could cause dereferencing (NULL)->next and thus segfaulting.

shader-effect: Add a size check

Similar to the one in commit 2a354d9650bb8215dd75a90b947fb82734c35b78
that went into clutter_value_set_shader_*. We end up in the same
situation, but it's better to fail from within ClutterShaderEffect.

shader-types: Check the size of the values

Emit a critical error if the user tries to send more data than
the static shader GValues can hold.

This fixes the random memory corruption you get when specifying
size > 4.

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

cairo-texture: Disable :sync-size

The :sync-size property of ClutterTexture should be set to FALSE by
default by ClutterCairoTexture. The preferred size of the
ClutterCairoTexture is already the size of the internal Cairo surface,
and we override the preferred width/height getters to that effect.

The :sync-size property is also responsible of changing the size of
the Texture actor when changing the texture handle - but since we
encourage that to happen during the CairoTexture allocation, we get a
queue_relayout() invocation (and a warning) when we change the size
of the Cairo image surface.

Since GObject doesn't make it easy to override the default value of the
:sync-size property in sub-classes, we should simply call the setter
function during the ClutterCairoTexture instance initialization.

We should also change one of the interactive tests using a CairoTexture
to rebuild the contents of the actor in response to an allocation.

cairo-texture: Clean up style

align-constraint: Publish the properties accessors

The accessor methods for the AlignConstraint properties should be
public.

build: Fix a compiler warning when using make dist

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

stage-glx: Never promote clipped redraws to full redraws.

When clipped redraws were first supported in Clutter a heuristic was
added to promote tall clipped redraws into full redraws due to a concern
that using glXCopySubBuffer for tall rectangles would block the GPU for
too long waiting for the vtrace to be in a suitable position so that
tearing isn't seen. We've so far been unable to measure any impact from
this blocking even with full height windows so we are removing the
arbitrary threshold of 300px that was originally "plucked out of thin
air".

http://bugzilla.o-hand.com/show_bug.cgi?id=2136

Split out the ignored test files

Add cogl-depth-test to the Git ignore file

Set the initial value of a variable

Fixes a compiler warning.

material: Adds arbfp compile counter

This adds a uprof counter to track how many ARBfp programs get compiled
by an application.

material: Support sparse ARBfp program generation

We don't need to generate a new ARBfp program for every material created
if we can find an ancestor whos state will result in the same program
being generated.

The more code we can have adopt the coding pattern of deriving their
materials from other similar materials using cogl_material_copy() the
more likely this metric will be good enough on its own to minimize the
set of arbfp programs necessary to support a given application.

material: free any layer cache in material_set_parent

Previously in _cogl_material_pre_change_notify we manually freed the
layer caches of a material if we caused a reparent, but it makes more
sense to have _cogl_material_set_parent do this directly instead.

Adds an internal weak material mechanism

This adds a _cogl_material_weak_copy() function that can be used to
create materials that don't count as strong dependants on their parents.
This means the parent can be modified without worrying about how it will
affect weak materials. The material age of the parent can potentially be
queried to determine if a weak material might need to be re-created.

material: Adds a simple material age getter

When we add support for weak materials it's expected that Clutter will
want to attach them as private data to other materials and it needs a
mechanism to determine when a weak material should be re-created because
its parent has changed somehow.

This adds the concept of a material age (internal only currently) which
increments whenever a material is modified. Clutter can then save the
age of the material which its weak materials are derived from and later
determine when the weak material may be invalid.

primitives: we were memsetting the wrong wrap mode overrides pointer

In _cogl_texture_quad_multiple_primitives we weren't memsetting the
CoglMaterialWrapModeOverrides structure we were memsetting
&state.wrap_mode_overrides where state.wrap_mode_overrides is just a
pointer that might potentially later point to the
CoglMaterialWrapModeOverrides structure.

material: generalize how we compare simple material properties

In _cogl_material_equal we were repeating the same code pattern to
compare several of the state groups so this just adds
simple_property_equal function that's now used instead.

material: Make CoglMaterial responsible for depth state

This redirects the legacy depth testing APIs through CoglMaterial and
adds a new experimental cogl_material_ API for handling the depth
testing state.

This adds the following new functions:
cogl_material_set_depth_test_enabled
cogl_material_get_depth_test_enabled
cogl_material_set_depth_writing_enabled
cogl_material_get_depth_writing_enabled
cogl_material_set_depth_test_function
cogl_material_get_depth_test_function
cogl_material_set_depth_range
cogl_material_get_depth_range

As with other experimental Cogl API you need to define
COGL_ENABLE_EXPERIMENTAL_API to access them and their stability isn't
yet guaranteed.

cogl docs: Improve documentation for cogl_ortho

cogl_ortho is one of those APIs whos style was, for better or worse,
copied from OpenGL and for some inexplicable reason the near and far
arguments are inconsistent with the left, right, top, bottom arguments
because they don't take z coordinates they take a "distance" which
should be negative for a plane behind the viewer.

This updates the documentation to explain this.

primitives: no longer assume _get_layers list remains valid

The internal CoglMaterialLayer pointers associated with a material may
change whenever layer properties are modified so it's no longer ok to
assume that a list of layers returned by cogl_material_get_layers
remains valid if the layers have been changed.

material: Adds simple breadcrumb debugging mechanism

Since it can sometimes be awkward to figure out where a particular
material came from when debugging, this adds a breadcrumb mechanism that
lets you associate a const string with a material that may give a clue
about its origin.

material: remove override options from _cogl_material_equal

As a follow on to using cogl_material_copy instead of flush options this
patch now removes the ability to pass flush options to
_cogl_material_equal which is the final reference to the
CoglMaterialFlushOptions mechanism.

cogl: remove _cogl_material_flush_gl_state flush options

Since cogl_material_copy should now be cheap to use we can simplify
how we handle fallbacks and wrap mode overrides etc by simply copying
the original material and making our override changes on the new
material. This avoids the need for a sideband state structure that has
been growing in size and makes flushing material state more complex.

Note the plan is to eventually use weak materials for these override
materials and attach these as private data to the original materials so
we aren't making so many one-shot materials.