Adds a shader snippet that will hook on to the given layer of the pipeline. The exact part of the pipeline that the snippet wraps around depends on the hook that is given to cogl_snippet_new(). Note that some hooks can't be used with a layer and need to be added with cogl_pipeline_add_snippet() instead.
Adds a shader snippet to pipeline. The snippet will wrap around or
replace some part of the pipeline as defined by the hook point in
snippet. Note that some hook points are specific to a layer and
must be added with cogl_pipeline_add_layer_snippet() instead.
Creates a binding between source_property on source and target_property
on target.
Whenever the source_property is changed the target_property is
updated using the same value. For instance:
g_object_bind_property (action, "active", widget, "sensitive", 0);
Will result in the "sensitive" property of the widget #GObject instance to be updated with the same value of the "active" property of the action #GObject instance.
If flags contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
if target_property on target changes then the source_property on source
will be updated as well.
The binding will automatically be removed when either the source or the
target instances are finalized. To remove the binding without affecting the
source and the target you can just call g_object_unref() on the returned
#GBinding instance.
Removing the binding by calling g_object_unref() on it must only be done if
the binding, source and target are only used from a single thread and it
is clear that both source and target outlive the binding. Especially it
is not safe to rely on this if the binding, source or target can be
finalized from different threads. Keep another reference to the binding and
use g_binding_unbind() instead to be on the safe side.
A #GObject can have multiple bindings.
the property on source to bind
the target #GObject
the property on target to bind
flags to pass to #GBinding
Creates a binding between source_property on source and target_property
on target, allowing you to set the transformation functions to be used by
the binding.
This function is the language bindings friendly version of g_object_bind_property_full(), using #GClosures instead of function pointers.
the property on source to bind
the target #GObject
the property on target to bind
flags to pass to #GBinding
a #GClosure wrapping the transformation function from the source to the target, or %NULL to use the default
a #GClosure wrapping the transformation function from the target to the source, or %NULL to use the default
Creates a new pipeline with the configuration copied from the source pipeline.
We would strongly advise developers to always aim to use cogl_pipeline_copy() instead of cogl_pipeline_new() whenever there will be any similarity between two pipelines. Copying a pipeline helps Cogl keep track of a pipelines ancestry which we may use to help minimize GPU state changes.
This function is intended for #GObject implementations to re-enforce a [floating][floating-ref] object reference. Doing this is seldom required: all #GInitiallyUnowneds are created with a floating reference which usually just needs to be sunken by calling g_object_ref_sink().
Iterates all the layer indices of the given pipeline.
A #CoglPipelineLayerCallback to be called for each layer index
Increases the freeze count on object. If the freeze count is
non-zero, the emission of "notify" signals on object is
stopped. The signals are queued until the freeze count is decreased
to zero. Duplicate notifications are squashed so that at most one
#GObject::notify signal is emitted for each property modified while the
object is frozen.
This is necessary for accessors that modify multiple properties to prevent premature notification while the object is still being modified.
Gets a named field from the objects table of associations (see g_object_set_data()).
name of the key for that association
Retrieves the current depth state configuration for the given
pipeline as previously set using cogl_pipeline_set_depth_state().
The order of the vertices within a primitive specifies whether it is considered to be front or back facing. This function specifies which order is considered to be the front faces. %COGL_WINDING_COUNTER_CLOCKWISE sets the front faces to primitives with vertices in a counter-clockwise order and %COGL_WINDING_CLOCKWISE sets them to be clockwise. The default is %COGL_WINDING_COUNTER_CLOCKWISE.
Retrieves the currently set magnification #CoglPipelineFilter set on the specified layer. The magnification filter determines how the layer should be sampled when up-scaled.
The default filter is %COGL_PIPELINE_FILTER_LINEAR but this can be changed using cogl_pipeline_set_layer_filters().
the layer number to change.
Retrieves the currently set minification #CoglPipelineFilter set on the specified layer. The miniifcation filter determines how the layer should be sampled when down-scaled.
The default filter is %COGL_PIPELINE_FILTER_LINEAR but this can be changed using cogl_pipeline_set_layer_filters().
the layer number to change.
Gets whether point sprite coordinate generation is enabled for this texture layer.
the layer number to check.
Returns the wrap mode for the 'p' coordinate of texture lookups on this layer.
the layer number to change.
Returns the wrap mode for the 's' coordinate of texture lookups on this layer.
the layer number to change.
Returns the wrap mode for the 't' coordinate of texture lookups on this layer.
the layer number to change.
Retrieves the number of layers defined for the given pipeline
Get the size of points drawn when %COGL_VERTICES_MODE_POINTS is used with the vertex buffer API.
Gets a property of an object.
The value can be:
In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling g_value_unset().
Note that g_object_get_property() is really intended for language bindings, g_object_get() is much more convenient for C programming.
the name of the property to get
return location for the property value
This function gets back user data pointers stored via g_object_set_qdata().
A #GQuark, naming the user data pointer
Retrieves the pipelines current emission color.
This is used to get an integer representing the uniform with the
name uniform_name. The integer can be passed to functions such as
cogl_pipeline_set_uniform_1f() to set the value of a uniform.
This function will always return a valid integer. Ie, unlike OpenGL, it does not return -1 if the uniform is not available in this pipeline so it can not be used to test whether uniforms are present. It is not necessary to set the program on the pipeline before calling this function.
The name of a uniform
Queries what user program has been associated with the given
pipeline using cogl_pipeline_set_user_program().
Gets n_properties properties for an object.
Obtained properties will be set to values. All properties must be valid.
Warnings will be emitted and undefined behaviour may result if invalid
properties are passed in.
the names of each property to get
the values of each property to get
Checks whether object has a [floating][floating-ref] reference.
Emits a "notify" signal for the property property_name on object.
When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead.
Note that emission of the notify signal may be blocked with g_object_freeze_notify(). In this case, the signal emissions are queued and will be emitted (in reverse order) when g_object_thaw_notify() is called.
the name of a property installed on the class of object.
Emits a "notify" signal for the property specified by pspec on object.
This function omits the property name lookup, hence it is faster than g_object_notify().
One way to avoid using g_object_notify() from within the class that registered the properties, and using g_object_notify_by_pspec() instead, is to store the GParamSpec used with g_object_class_install_property() inside a static array, e.g.:
enum
{
PROP_0,
PROP_FOO,
PROP_LAST
};
static GParamSpec *properties[PROP_LAST];
static void
my_object_class_init (MyObjectClass *klass)
{
properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
0, 100,
50,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class,
PROP_FOO,
properties[PROP_FOO]);
}
and then notify a change on the "foo" property with:
g_object_notify_by_pspec (self, properties[PROP_FOO]);
the #GParamSpec of a property installed on the class of object.
Increase the reference count of object, and possibly remove the
[floating][floating-ref] reference, if object has a floating reference.
In other words, if the object is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference by clearing the floating flag while leaving the reference count unchanged. If the object is not floating, then this call adds a new normal reference increasing the reference count by one.
Since GLib 2.56, the type of object will be propagated to the return type
under the same conditions as for g_object_ref().
This function removes a layer from your pipeline
Specifies the layer you want to remove
Releases all references to other objects. This can be used to break reference cycles.
This function should only be called from object system implementations.
Before a primitive is blended with the framebuffer, it goes through an alpha test stage which lets you discard fragments based on the current alpha value. This function lets you change the function used to evaluate the alpha channel, and thus determine which fragments are discarded and which continue on to the blending stage.
The default is %COGL_PIPELINE_ALPHA_FUNC_ALWAYS
A CoglPipelineAlphaFunc constant
A reference point that the chosen alpha function uses to compare incoming fragments to.
Sets the pipeline's ambient color, in the standard OpenGL lighting model. The ambient color affects the overall color of the object.
Since the diffuse color will be intense when the light hits the surface directly, the ambient will be most apparent where the light hits at a slant.
The default value is (0.2, 0.2, 0.2, 1.0)
Conveniently sets the diffuse and ambient color of pipeline at the same
time. See cogl_pipeline_set_ambient() and cogl_pipeline_set_diffuse().
The default ambient color is (0.2, 0.2, 0.2, 1.0)
The default diffuse color is (0.8, 0.8, 0.8, 1.0)
If not already familiar; please refer here for an overview of what blend strings are, and their syntax.
Blending occurs after the alpha test function, and combines fragments with the framebuffer.
Currently the only blend function Cogl exposes is ADD(). So any valid blend statements will be of the form:
|[ <channel-mask>=ADD(SRC_COLOR*(<factor>), DST_COLOR*(<factor>))
This is the list of source-names usable as blend factors:
<itemizedlist>
<listitem><para>SRC_COLOR: The color of the in comming fragment</para></listitem>
<listitem><para>DST_COLOR: The color of the framebuffer</para></listitem>
<listitem><para>CONSTANT: The constant set via cogl_pipeline_set_blend_constant()</para></listitem>
</itemizedlist>
The source names can be used according to the
<link linkend="cogl-Blend-String-syntax">color-source and factor syntax</link>,
so for example "(1-SRC_COLOR[A])" would be a valid factor, as would
"(CONSTANT[RGB])"
These can also be used as factors:
<itemizedlist>
<listitem>0: (0, 0, 0, 0)</listitem>
<listitem>1: (1, 1, 1, 1)</listitem>
<listitem>SRC_ALPHA_SATURATE_FACTOR: (f,f,f,1) where f = MIN(SRC_COLOR[A],1-DST_COLOR[A])</listitem>
</itemizedlist>
<note>Remember; all color components are normalized to the range [0, 1]
before computing the result of blending.</note>
<example id="cogl-Blend-Strings-blend-unpremul">
<title>Blend Strings/1</title>
<para>Blend a non-premultiplied source over a destination with
premultiplied alpha:</para>
<programlisting>
"RGB = ADD(SRC_COLOR*(SRC_COLOR[A]), DST_COLOR*(1-SRC_COLOR[A]))"
"A = ADD(SRC_COLOR, DST_COLOR*(1-SRC_COLOR[A]))"
</programlisting>
</example>
<example id="cogl-Blend-Strings-blend-premul">
<title>Blend Strings/2</title>
<para>Blend a premultiplied source over a destination with
premultiplied alpha</para>
<programlisting>
"RGBA = ADD(SRC_COLOR, DST_COLOR*(1-SRC_COLOR[A]))"
</programlisting>
</example>
The default blend string is:
|[
RGBA = ADD (SRC_COLOR, DST_COLOR*(1-SRC_COLOR[A]))
That gives normal alpha-blending when the calculated color for the pipeline is in premultiplied form.
A Cogl blend string describing the desired blend function.
Sets the basic color of the pipeline, used when no lighting is enabled.
Note that if you don't add any layers to the pipeline then the color will be blended unmodified with the destination; the default blend expects premultiplied colors: for example, use (0.5, 0.0, 0.0, 0.5) for semi-transparent red. See cogl_color_premultiply().
The default value is (1.0, 1.0, 1.0, 1.0)
Sets the basic color of the pipeline, used when no lighting is enabled.
The default value is (1.0, 1.0, 1.0, 1.0)
The red component
The green component
The blue component
The alpha component
Sets the basic color of the pipeline, used when no lighting is enabled.
The default value is (0xff, 0xff, 0xff, 0xff)
The red component
The green component
The blue component
The alpha component
Sets which faces will be culled when drawing. Face culling can be used to increase efficiency by avoiding drawing faces that would get overridden. For example, if a model has gaps so that it is impossible to see the inside then faces which are facing away from the screen will never be seen so there is no point in drawing them. This can be acheived by setting the cull face mode to %COGL_PIPELINE_CULL_FACE_MODE_BACK.
Face culling relies on the primitives being drawn with a specific order to represent which faces are facing inside and outside the model. This order can be specified by calling cogl_pipeline_set_front_face_winding().
Status: Unstable
The new mode to set
Each object carries around a table of associations from strings to pointers. This function lets you set an association.
If the object already had an association with that name, the old association will be destroyed.
Internally, the key is converted to a #GQuark using g_quark_from_string().
This means a copy of key is kept permanently (even after object has been
finalized) — so it is recommended to only use a small, bounded set of values
for key in your program, to avoid the #GQuark storage growing unbounded.
name of the key
data to associate with that key
This commits all the depth state configured in state struct to the
given pipeline. The configuration values are copied into the
pipeline so there is no requirement to keep the #CoglDepthState
struct around if you don't need it any more.
Note: Since some platforms do not support the depth range feature
it is possible for this function to fail and report an error.
A #CoglDepthState struct
Sets the pipeline's diffuse color, in the standard OpenGL lighting model. The diffuse color is most intense where the light hits the surface directly - perpendicular to the surface.
The default value is (0.8, 0.8, 0.8, 1.0)
The order of the vertices within a primitive specifies whether it is considered to be front or back facing. This function specifies which order is considered to be the front faces. %COGL_WINDING_COUNTER_CLOCKWISE sets the front faces to primitives with vertices in a counter-clockwise order and %COGL_WINDING_CLOCKWISE sets them to be clockwise. The default is %COGL_WINDING_COUNTER_CLOCKWISE.
Status: Unstable
If not already familiar; you can refer
here for an overview of what blend strings are and there syntax.These are all the functions available for texture combining:
Refer to the
color-source syntax for describing the arguments. The valid source names for texture combining are:Specifies the layer you want define a combine function for
A Cogl blend string describing the desired texture combine function.
Changes the decimation and interpolation filters used when a texture is drawn at other scales than 100%.
the layer number to change.
the filter used when scaling a texture down.
the filter used when magnifying a texture.
Sets the texture for this layer to be the default texture for the given type. This is equivalent to calling cogl_pipeline_set_layer_texture() with %NULL for the texture argument except that you can also specify the type of default texture to use. The default texture is a 1x1 pixel white texture.
This function is mostly useful if you want to create a base pipeline that you want to create multiple copies from using cogl_pipeline_copy(). In that case this function can be used to specify the texture type so that any pipeline copies can share the internal texture type state for efficiency.
The layer number to modify
The type of the default texture to use
When rendering points, if enable is %TRUE then the texture
coordinates for this layer will be replaced with coordinates that
vary from 0.0 to 1.0 across the primitive. The top left of the
point will have the coordinates 0.0,0.0 and the bottom right will
have 1.0,1.0. If enable is %FALSE then the coordinates will be
fixed for the entire point.
This function will only work if %COGL_FEATURE_ID_POINT_SPRITE is
available. If the feature is not available then the function will
return %FALSE and set error.
the layer number to change.
whether to enable point sprite coord generation.
Sets the wrap mode for all three coordinates of texture lookups on this layer. This is equivalent to calling cogl_pipeline_set_layer_wrap_mode_s(), cogl_pipeline_set_layer_wrap_mode_t() and cogl_pipeline_set_layer_wrap_mode_p() separately.
the layer number to change.
the new wrap mode
Sets the wrap mode for the 'p' coordinate of texture lookups on this layer. 'p' is the third coordinate.
the layer number to change.
the new wrap mode
Sets the wrap mode for the 's' coordinate of texture lookups on this layer.
the layer number to change.
the new wrap mode
Sets the wrap mode for the 't' coordinate of texture lookups on this layer.
the layer number to change.
the new wrap mode
Sets whether to use a per-vertex point size or to use the value set by cogl_pipeline_set_point_size(). If per-vertex point size is enabled then the point size can be set for an individual point either by drawing with a #CoglAttribute with the name ‘cogl_point_size_in’ or by writing to the GLSL builtin ‘cogl_point_size_out’ from a vertex shader snippet.
If per-vertex point size is enabled and this attribute is not used and cogl_point_size_out is not written to then the results are undefined.
Note that enabling this will only work if the %COGL_FEATURE_ID_PER_VERTEX_POINT_SIZE feature is available. If this is not available then the function will return %FALSE and set a #CoglError.
whether to enable per-vertex point size
Changes the size of points drawn when %COGL_VERTICES_MODE_POINTS is used with the attribute buffer API. Note that typically the GPU will only support a limited minimum and maximum range of point sizes. If the chosen point size is outside that range then the nearest value within that range will be used instead. The size of a point is in screen space so it will be the same regardless of any transformations.
If the point size is set to 0.0 then drawing points with the pipeline will have undefined results. This is the default value so if an application wants to draw points it must make sure to use a pipeline that has an explicit point size set on it.
the new point size.
Sets a property on an object.
the name of the property to set
the value
Sets the shininess of the pipeline, in the standard OpenGL lighting
model, which determines the size of the specular highlights. A
higher shininess will produce smaller highlights which makes the
object appear more shiny.
The default value is 0.0
The desired shininess; must be >= 0.0
Sets the pipeline's specular color, in the standard OpenGL lighting model. The intensity of the specular color depends on the viewport position, and is brightest along the lines of reflection.
The default value is (0.0, 0.0, 0.0, 1.0)
Sets a new value for the uniform at uniform_location. If this
pipeline has a user program attached and is later used as a source
for drawing, the given value will be assigned to the uniform which
can be accessed from the shader's source. The value for
uniform_location should be retrieved from the string name of the
uniform by calling cogl_pipeline_get_uniform_location().
This function should be used to set uniforms that are of type float. It can also be used to set a single member of a float array uniform.
The uniform's location identifier
The new value for the uniform
Sets a new value for the uniform at uniform_location. If this
pipeline has a user program attached and is later used as a source
for drawing, the given value will be assigned to the uniform which
can be accessed from the shader's source. The value for
uniform_location should be retrieved from the string name of the
uniform by calling cogl_pipeline_get_uniform_location().
This function should be used to set uniforms that are of type int. It can also be used to set a single member of a int array uniform or a sampler uniform.
The uniform's location identifier
The new value for the uniform
Sets new values for the uniform at uniform_location. If this
pipeline has a user program attached and is later used as a source
for drawing, the given values will be assigned to the uniform which
can be accessed from the shader's source. The value for
uniform_location should be retrieved from the string name of the
uniform by calling cogl_pipeline_get_uniform_location().
This function can be used to set any floating point type uniform,
including float arrays and float vectors. For example, to set a
single vec4 uniform you would use 4 for n_components and 1 for
count. To set an array of 8 float values, you could use 1 for
n_components and 8 for count.
The uniform's location identifier
The number of components in the corresponding uniform's type
The number of values to set
Pointer to the new values to set
Sets new values for the uniform at uniform_location. If this
pipeline has a user program attached and is later used as a source
for drawing, the given values will be assigned to the uniform which
can be accessed from the shader's source. The value for
uniform_location should be retrieved from the string name of the
uniform by calling cogl_pipeline_get_uniform_location().
This function can be used to set any integer type uniform,
including int arrays and int vectors. For example, to set a single
ivec4 uniform you would use 4 for n_components and 1 for
count. To set an array of 8 int values, you could use 1 for
n_components and 8 for count.
The uniform's location identifier
The number of components in the corresponding uniform's type
The number of values to set
Pointer to the new values to set
Sets new values for the uniform at uniform_location. If this
pipeline has a user program attached and is later used as a source
for drawing, the given values will be assigned to the uniform which
can be accessed from the shader's source. The value for
uniform_location should be retrieved from the string name of the
uniform by calling cogl_pipeline_get_uniform_location().
This function can be used to set any matrix type uniform, including
matrix arrays. For example, to set a single mat4 uniform you would
use 4 for dimensions and 1 for count. To set an array of 8
mat3 values, you could use 3 for dimensions and 8 for count.
If transpose is %FALSE then the matrix is expected to be in
column-major order or if it is %TRUE then the matrix is in
row-major order. You can pass a #CoglMatrix by calling by passing
the result of cogl_matrix_get_array() in value and setting
transpose to %FALSE.
The uniform's location identifier
The size of the matrix
The number of values to set
Whether to transpose the matrix
Pointer to the new values to set
Associates a linked CoglProgram with the given pipeline so that the program can take full control of vertex and/or fragment processing.
This is an example of how it can be used to associate an ARBfp program with a #CoglPipeline: |[ CoglHandle shader; CoglHandle program; CoglPipeline *pipeline;
shader = cogl_create_shader (COGL_SHADER_TYPE_FRAGMENT); cogl_shader_source (shader, "!!ARBfp1.0\n" "MOV result.color,fragment.color;\n" "END\n"); cogl_shader_compile (shader);
program = cogl_create_program (); cogl_program_attach_shader (program, shader); cogl_program_link (program);
pipeline = cogl_pipeline_new (); cogl_pipeline_set_user_program (pipeline, program);
cogl_set_source_color4ub (0xff, 0x00, 0x00, 0xff); cogl_rectangle (0, 0, 100, 100);
It is possibly worth keeping in mind that this API is not part of
the long term design for how we want to expose shaders to Cogl
developers (We are planning on deprecating the cogl_program and
cogl_shader APIs in favour of a "snippet" framework) but in the
meantime we hope this will handle most practical GLSL and ARBfp
requirements.
Also remember you need to check for either the
%COGL_FEATURE_SHADERS_GLSL or %COGL_FEATURE_SHADERS_ARBFP before
using the cogl_program or cogl_shader API.
@param program A #CoglHandle to a linked CoglProgram
Remove a specified datum from the object's data associations, without invoking the association's destroy handler.
name of the key
This function gets back user data pointers stored via
g_object_set_qdata() and removes the data from object
without invoking its destroy() function (if any was
set).
Usually, calling this function is only required to update
user data pointers with a destroy notifier, for example:
void
object_add_to_user_list (GObject *object,
const gchar *new_string)
{
// the quark, naming the object data
GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
// retrieve the old string list
GList *list = g_object_steal_qdata (object, quark_string_list);
// prepend new string
list = g_list_prepend (list, g_strdup (new_string));
// this changed 'list', so we need to set it again
g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
}
static void
free_string_list (gpointer data)
{
GList *node, *list = data;
for (node = list; node; node = node->next)
g_free (node->data);
g_list_free (list);
}
Using g_object_get_qdata() in the above example, instead of g_object_steal_qdata() would have left the destroy function set, and thus the partial string list would have been freed upon g_object_set_qdata_full().
A #GQuark, naming the user data pointer
Reverts the effect of a previous call to
g_object_freeze_notify(). The freeze count is decreased on object
and when it reaches zero, queued "notify" signals are emitted.
Duplicate notifications for each property are squashed so that at most one #GObject::notify signal is emitted for each property, in the reverse order in which they have been queued.
It is an error to call this function when the freeze count is zero.
Decreases the reference count of object. When its reference count
drops to 0, the object is finalized (i.e. its memory is freed).
If the pointer to the #GObject may be reused in future (for example, if it is an instance variable of another object), it is recommended to clear the pointer to %NULL rather than retain a dangling pointer to a potentially invalid #GObject instance. Use g_clear_object() for this.
Emits a "notify" signal for the property property_name on object.
When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead.
Note that emission of the notify signal may be blocked with g_object_freeze_notify(). In this case, the signal emissions are queued and will be emitted (in reverse order) when g_object_thaw_notify() is called.
This function essentially limits the life time of the closure to
the life time of the object. That is, when the object is finalized,
the closure is invalidated by calling g_closure_invalidate() on
it, in order to prevent invocations of the closure with a finalized
(nonexisting) object. Also, g_object_ref() and g_object_unref() are
added as marshal guards to the closure, to ensure that an extra
reference count is held on object during invocation of the
closure. Usually, this function will be called on closures that
use this object as closure data.
#GClosure to watch
Find the #GParamSpec with the given name for an
interface. Generally, the interface vtable passed in as g_iface
will be the default vtable from g_type_default_interface_ref(), or,
if you know the interface has already been loaded,
g_type_default_interface_peek().
any interface vtable for the interface, or the default vtable for the interface
name of a property to look up.
Add a property to an interface; this is only useful for interfaces that are added to GObject-derived types. Adding a property to an interface forces all objects classes with that interface to have a compatible property. The compatible property could be a newly created #GParamSpec, but normally g_object_class_override_property() will be used so that the object class only needs to provide an implementation and inherits the property description, default value, bounds, and so forth from the interface property.
This function is meant to be called from the interface's default
vtable initialization function (the class_init member of
#GTypeInfo.) It must not be called after after class_init has
been called for any object types implementing this interface.
If pspec is a floating reference, it will be consumed.
any interface vtable for the interface, or the default vtable for the interface.
the #GParamSpec for the new property
Lists the properties of an interface.Generally, the interface
vtable passed in as g_iface will be the default vtable from
g_type_default_interface_ref(), or, if you know the interface has
already been loaded, g_type_default_interface_peek().
any interface vtable for the interface, or the default vtable for the interface
Creates a new instance of a #GObject subtype and sets its properties.
Construction parameters (see %G_PARAM_CONSTRUCT, %G_PARAM_CONSTRUCT_ONLY) which are not explicitly specified are set to their default values.
the type id of the #GObject subtype to instantiate
an array of #GParameter
Allocates and initializes a default simple pipeline that will color a primitive white.