Struct ux::prelude::dx::Attribute [−][src]
pub struct Attribute(_, _);
Implementations
impl Attribute
[src]
impl Attribute
[src]pub fn new(
attribute_buffer: &AttributeBuffer,
name: &str,
stride: usize,
offset: usize,
components: i32,
type_: AttributeType
) -> Attribute
[src]
attribute_buffer: &AttributeBuffer,
name: &str,
stride: usize,
offset: usize,
components: i32,
type_: AttributeType
) -> Attribute
Describes the layout for a list of vertex attribute values (For example, a list of texture coordinates or colors).
The name
is used to access the attribute inside a GLSL vertex
shader and there are some special names you should use if they are
applicable:
<itemizedlist>
<listitem>
“position_in” (used for vertex positions)</listitem>
<listitem>
“color_in” (used for vertex colors)</listitem>
<listitem>
“tex_coord0_in”, “tex_coord1”, …
(used for vertex texture coordinates)</listitem>
<listitem>
“normal_in” (used for vertex normals)</listitem>
<listitem>
“point_size_in” (used to set the size of points
per-vertex. Note this can only be used if
COGL_FEATURE_ID_POINT_SIZE_ATTRIBUTE
is advertised and
Pipeline::set_per_vertex_point_size
is called on the pipeline.
</listitem>
</itemizedlist>
The attribute values corresponding to different vertices can either be tightly packed or interleaved with other attribute values. For example it’s common to define a structure for a single vertex like:
typedef struct
{
float x, y, z; /<!-- -->* position attribute *<!-- -->/
float s, t; /<!-- -->* texture coordinate attribute *<!-- -->/
} MyVertex;
And then create an array of vertex data something like:
MyVertex vertices[100] = { .... }
In this case, to describe either the position or texture coordinate
attribute you have to move <literal>
sizeof (MyVertex)</literal>
bytes to
move from one vertex to the next. This is called the attribute
stride
. If you weren’t interleving attributes and you instead had
a packed array of float x, y pairs then the attribute stride would
be <literal>
(2 * sizeof (float))</literal>
. So the stride
is the number of
bytes to move to find the attribute value of the next vertex.
Normally a list of attributes starts at the beginning of an array.
So for the <literal>
MyVertex</literal>
example above the offset
is the
offset inside the <literal>
MyVertex</literal>
structure to the first
component of the attribute. For the texture coordinate attribute
the offset would be <literal>
offsetof (MyVertex, s)</literal>
or instead of
using the offsetof macro you could use <literal>
sizeof (float) *
3</literal>
. If you’ve divided your array
into blocks of non-interleved
attributes then you will need to calculate the offset
as the number of
bytes in blocks preceding the attribute you’re describing.
An attribute often has more than one component. For example a color
is often comprised of 4 red, green, blue and alpha components
, and a
position may be comprised of 2 x and y components
. You should aim
to keep the number of components to a minimum as more components
means more data needs to be mapped into the GPU which can be a
bottlneck when dealing with a large number of vertices.
Finally you need to specify the component data type. Here you should aim to use the smallest type that meets your precision requirements. Again the larger the type then more data needs to be mapped into the GPU which can be a bottlneck when dealing with a large number of vertices.
attribute_buffer
The AttributeBuffer
containing the actual
attribute data
name
The name of the attribute (used to reference it from GLSL)
stride
The number of bytes to jump to get to the next attribute
value for the next vertex. (Usually
<literal>
sizeof (MyVertex)</literal>
)
offset
The byte offset from the start of attribute_buffer
for
the first attribute value. (Usually
<literal>
offsetof (MyVertex, component0)</literal>
components
The number of components (e.g. 4 for an rgba color or 3 for and (x,y,z) position)
type_
FIXME
Returns
A newly allocated Attribute
describing the layout for a list of attribute values
stored in array
.
pub fn new_const_1f(context: &Context, name: &str, value: f32) -> Attribute
[src]
Creates a new, single component, attribute whose value remains constant across all the vertices of a primitive without needing to duplicate the value for each vertex.
The constant value
is a single precision floating point scalar
which should have a corresponding declaration in GLSL code like:
[| attribute float name; |]
context
A Context
name
The name of the attribute (used to reference it from GLSL)
value
The constant value for the attribute
Returns
A newly allocated Attribute
representing the given constant value
.
pub fn new_const_2f(
context: &Context,
name: &str,
component0: f32,
component1: f32
) -> Attribute
[src]
context: &Context,
name: &str,
component0: f32,
component1: f32
) -> Attribute
Creates a new, 2 component, attribute whose value remains constant across all the vertices of a primitive without needing to duplicate the value for each vertex.
The constants (component0
, component1
) represent a 2 component
float vector which should have a corresponding declaration in GLSL
code like:
[| attribute vec2 name; |]
context
A Context
name
The name of the attribute (used to reference it from GLSL)
component0
The first component of a 2 component vector
component1
The second component of a 2 component vector
Returns
A newly allocated Attribute
representing the given constant vector.
pub fn new_const_2fv(
context: &Context,
name: &str,
value: &[f32; 2]
) -> Attribute
[src]
context: &Context,
name: &str,
value: &[f32; 2]
) -> Attribute
Creates a new, 2 component, attribute whose value remains constant across all the vertices of a primitive without needing to duplicate the value for each vertex.
The constants (value[0], value[1]) represent a 2 component float vector which should have a corresponding declaration in GLSL code like:
[| attribute vec2 name; |]
context
A Context
name
The name of the attribute (used to reference it from GLSL)
value
A pointer to a 2 component float vector
Returns
A newly allocated Attribute
representing the given constant vector.
pub fn new_const_2x2fv(
context: &Context,
name: &str,
matrix2x2: &[f32; 4],
transpose: bool
) -> Attribute
[src]
context: &Context,
name: &str,
matrix2x2: &[f32; 4],
transpose: bool
) -> Attribute
Creates a new matrix attribute whose value remains constant across all the vertices of a primitive without needing to duplicate the value for each vertex.
matrix2x2
represent a square 2 by 2 matrix specified in
column-major order (each pair of consecutive numbers represents a
column) which should have a corresponding declaration in GLSL code
like:
[| attribute mat2 name; |]
If transpose
is true
then all matrix components are rotated
around the diagonal of the matrix such that the first column
becomes the first row and the second column becomes the second row.
context
A Context
name
The name of the attribute (used to reference it from GLSL)
matrix2x2
A pointer to a 2 by 2 matrix
transpose
Whether the matrix should be transposed on upload or not
Returns
A newly allocated Attribute
representing the given constant matrix.
pub fn new_const_3f(
context: &Context,
name: &str,
component0: f32,
component1: f32,
component2: f32
) -> Attribute
[src]
context: &Context,
name: &str,
component0: f32,
component1: f32,
component2: f32
) -> Attribute
Creates a new, 3 component, attribute whose value remains constant across all the vertices of a primitive without needing to duplicate the value for each vertex.
The constants (component0
, component1
, component2
) represent a 3
component float vector which should have a corresponding
declaration in GLSL code like:
[| attribute vec3 name; |]
unless the built in name “normal_in” is being used where no explicit GLSL declaration need be made.
context
A Context
name
The name of the attribute (used to reference it from GLSL)
component0
The first component of a 3 component vector
component1
The second component of a 3 component vector
component2
The third component of a 3 component vector
Returns
A newly allocated Attribute
representing the given constant vector.
pub fn new_const_3fv(
context: &Context,
name: &str,
value: &[f32; 3]
) -> Attribute
[src]
context: &Context,
name: &str,
value: &[f32; 3]
) -> Attribute
Creates a new, 3 component, attribute whose value remains constant across all the vertices of a primitive without needing to duplicate the value for each vertex.
The constants (value[0], value[1], value[2]) represent a 3 component float vector which should have a corresponding declaration in GLSL code like:
[| attribute vec3 name; |]
unless the built in name “normal_in” is being used where no explicit GLSL declaration need be made.
context
A Context
name
The name of the attribute (used to reference it from GLSL)
value
A pointer to a 3 component float vector
Returns
A newly allocated Attribute
representing the given constant vector.
pub fn new_const_3x3fv(
context: &Context,
name: &str,
matrix3x3: &[f32; 9],
transpose: bool
) -> Attribute
[src]
context: &Context,
name: &str,
matrix3x3: &[f32; 9],
transpose: bool
) -> Attribute
Creates a new matrix attribute whose value remains constant across all the vertices of a primitive without needing to duplicate the value for each vertex.
matrix3x3
represent a square 3 by 3 matrix specified in
column-major order (each triple of consecutive numbers represents a
column) which should have a corresponding declaration in GLSL code
like:
[| attribute mat3 name; |]
If transpose
is true
then all matrix components are rotated
around the diagonal of the matrix such that the first column
becomes the first row and the second column becomes the second row
etc.
context
A Context
name
The name of the attribute (used to reference it from GLSL)
matrix3x3
A pointer to a 3 by 3 matrix
transpose
Whether the matrix should be transposed on upload or not
Returns
A newly allocated Attribute
representing the given constant matrix.
pub fn new_const_4f(
context: &Context,
name: &str,
component0: f32,
component1: f32,
component2: f32,
component3: f32
) -> Attribute
[src]
context: &Context,
name: &str,
component0: f32,
component1: f32,
component2: f32,
component3: f32
) -> Attribute
Creates a new, 4 component, attribute whose value remains constant across all the vertices of a primitive without needing to duplicate the value for each vertex.
The constants (component0
, component1
, component2
, constant3
)
represent a 4 component float vector which should have a
corresponding declaration in GLSL code like:
[| attribute vec4 name; |]
unless one of the built in names “color_in”, “tex_coord0_in or “tex_coord1_in” etc is being used where no explicit GLSL declaration need be made.
context
A Context
name
The name of the attribute (used to reference it from GLSL)
component0
The first component of a 4 component vector
component1
The second component of a 4 component vector
component2
The third component of a 4 component vector
component3
The fourth component of a 4 component vector
Returns
A newly allocated Attribute
representing the given constant vector.
pub fn new_const_4fv(
context: &Context,
name: &str,
value: &[f32; 4]
) -> Attribute
[src]
context: &Context,
name: &str,
value: &[f32; 4]
) -> Attribute
Creates a new, 4 component, attribute whose value remains constant across all the vertices of a primitive without needing to duplicate the value for each vertex.
The constants (value[0], value[1], value[2], value[3]) represent a 4 component float vector which should have a corresponding declaration in GLSL code like:
[| attribute vec4 name; |]
unless one of the built in names “color_in”, “tex_coord0_in or “tex_coord1_in” etc is being used where no explicit GLSL declaration need be made.
context
A Context
name
The name of the attribute (used to reference it from GLSL)
value
A pointer to a 4 component float vector
Returns
A newly allocated Attribute
representing the given constant vector.
pub fn new_const_4x4fv(
context: &Context,
name: &str,
matrix4x4: &[f32; 16],
transpose: bool
) -> Attribute
[src]
context: &Context,
name: &str,
matrix4x4: &[f32; 16],
transpose: bool
) -> Attribute
Creates a new matrix attribute whose value remains constant across all the vertices of a primitive without needing to duplicate the value for each vertex.
matrix4x4
represent a square 4 by 4 matrix specified in
column-major order (each 4-tuple of consecutive numbers represents a
column) which should have a corresponding declaration in GLSL code
like:
[| attribute mat4 name; |]
If transpose
is true
then all matrix components are rotated
around the diagonal of the matrix such that the first column
becomes the first row and the second column becomes the second row
etc.
context
A Context
name
The name of the attribute (used to reference it from GLSL)
matrix4x4
A pointer to a 4 by 4 matrix
transpose
Whether the matrix should be transposed on upload or not
Returns
A newly allocated Attribute
representing the given constant matrix.
pub fn get_buffer(&self) -> Option<AttributeBuffer>
[src]
Returns
the AttributeBuffer
that was
set with Attribute::set_buffer
or Attribute::new
.
pub fn get_normalized(&self) -> bool
[src]
Returns
the value of the normalized property set with
Attribute::set_normalized
.
pub fn set_buffer(&self, attribute_buffer: &AttributeBuffer)
[src]
pub fn set_normalized(&self, normalized: bool)
[src]
Sets whether fixed point attribute types are mapped to the range
0→1. For example when this property is TRUE and a
AttributeType::UnsignedByte
type is used then the value 255
will be mapped to 1.0.
The default value of this property depends on the name of the attribute. For the builtin properties color_in and normal_in it will default to TRUE and for all other names it will default to FALSE.
normalized
The new value for the normalized property.
Trait Implementations
impl<T> PartialEq<T> for Attribute where
T: ObjectType,
[src]
impl<T> PartialEq<T> for Attribute where
T: ObjectType,
[src]impl<T> PartialOrd<T> for Attribute where
T: ObjectType,
[src]
impl<T> PartialOrd<T> for Attribute where
T: ObjectType,
[src]impl StaticType for Attribute
[src]
impl StaticType for Attribute
[src]pub fn static_type() -> Type
[src]
Auto Trait Implementations
impl RefUnwindSafe for Attribute
impl RefUnwindSafe for Attribute
impl UnwindSafe for Attribute
impl UnwindSafe for Attribute
Blanket Implementations
impl<Super, Sub> CanDowncast<Sub> for Super where
Sub: IsA<Super>,
Super: IsA<Super>,
[src]
impl<Super, Sub> CanDowncast<Sub> for Super where
Sub: IsA<Super>,
Super: IsA<Super>,
[src]impl<T> Cast for T where
T: ObjectType,
[src]
impl<T> Cast for T where
T: ObjectType,
[src]pub fn upcast<T>(self) -> T where
Self: IsA<T>,
T: ObjectType,
[src]
Self: IsA<T>,
T: ObjectType,
pub fn upcast_ref<T>(&self) -> &T where
Self: IsA<T>,
T: ObjectType,
[src]
Self: IsA<T>,
T: ObjectType,
pub fn downcast<T>(self) -> Result<T, Self> where
Self: CanDowncast<T>,
T: ObjectType,
[src]
Self: CanDowncast<T>,
T: ObjectType,
pub fn downcast_ref<T>(&self) -> Option<&T> where
Self: CanDowncast<T>,
T: ObjectType,
[src]
Self: CanDowncast<T>,
T: ObjectType,
pub fn dynamic_cast<T>(self) -> Result<T, Self> where
T: ObjectType,
[src]
T: ObjectType,
pub fn dynamic_cast_ref<T>(&self) -> Option<&T> where
T: ObjectType,
[src]
T: ObjectType,
pub unsafe fn unsafe_cast<T>(self) -> T where
T: ObjectType,
[src]
T: ObjectType,
pub unsafe fn unsafe_cast_ref<T>(&self) -> &T where
T: ObjectType,
[src]
T: ObjectType,
impl<Fr, To> IntoColor<To> for Fr where
To: FromColor<Fr>,
[src]
impl<Fr, To> IntoColor<To> for Fr where
To: FromColor<Fr>,
[src]pub fn into_color(self) -> To
[src]
impl<T> ObjectExt for T where
T: ObjectType,
[src]
impl<T> ObjectExt for T where
T: ObjectType,
[src]pub fn is<U>(&self) -> bool where
U: StaticType,
[src]
U: StaticType,
pub fn get_type(&self) -> Type
[src]
pub fn get_object_class(&self) -> &ObjectClass
[src]
pub fn set_properties(
&self,
property_values: &[(&str, &dyn ToValue)]
) -> Result<(), BoolError>
[src]
&self,
property_values: &[(&str, &dyn ToValue)]
) -> Result<(), BoolError>
pub fn set_property<'a, N>(
&self,
property_name: N,
value: &dyn ToValue
) -> Result<(), BoolError> where
N: Into<&'a str>,
[src]
&self,
property_name: N,
value: &dyn ToValue
) -> Result<(), BoolError> where
N: Into<&'a str>,
pub fn get_property<'a, N>(&self, property_name: N) -> Result<Value, BoolError> where
N: Into<&'a str>,
[src]
N: Into<&'a str>,
pub unsafe fn set_qdata<QD>(&self, key: Quark, value: QD) where
QD: 'static,
[src]
QD: 'static,
pub unsafe fn get_qdata<QD>(&self, key: Quark) -> Option<&QD> where
QD: 'static,
[src]
QD: 'static,
pub unsafe fn steal_qdata<QD>(&self, key: Quark) -> Option<QD> where
QD: 'static,
[src]
QD: 'static,
pub unsafe fn set_data<QD>(&self, key: &str, value: QD) where
QD: 'static,
[src]
QD: 'static,
pub unsafe fn get_data<QD>(&self, key: &str) -> Option<&QD> where
QD: 'static,
[src]
QD: 'static,
pub unsafe fn steal_data<QD>(&self, key: &str) -> Option<QD> where
QD: 'static,
[src]
QD: 'static,
pub fn block_signal(&self, handler_id: &SignalHandlerId)
[src]
pub fn unblock_signal(&self, handler_id: &SignalHandlerId)
[src]
pub fn stop_signal_emission(&self, signal_name: &str)
[src]
pub fn disconnect(&self, handler_id: SignalHandlerId)
[src]
pub fn connect_notify<F>(&self, name: Option<&str>, f: F) -> SignalHandlerId where
F: 'static + Fn(&T, &ParamSpec) + Send + Sync,
[src]
F: 'static + Fn(&T, &ParamSpec) + Send + Sync,
pub unsafe fn connect_notify_unsafe<F>(
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: Fn(&T, &ParamSpec),
[src]
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: Fn(&T, &ParamSpec),
pub fn notify<'a, N>(&self, property_name: N) where
N: Into<&'a str>,
[src]
N: Into<&'a str>,
pub fn notify_by_pspec(&self, pspec: &ParamSpec)
[src]
pub fn has_property<'a, N>(&self, property_name: N, type_: Option<Type>) -> bool where
N: Into<&'a str>,
[src]
N: Into<&'a str>,
pub fn get_property_type<'a, N>(&self, property_name: N) -> Option<Type> where
N: Into<&'a str>,
[src]
N: Into<&'a str>,
pub fn find_property<'a, N>(&self, property_name: N) -> Option<ParamSpec> where
N: Into<&'a str>,
[src]
N: Into<&'a str>,
pub fn list_properties(&self) -> Vec<ParamSpec, Global>ⓘ
[src]
pub fn connect<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
[src]
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
pub fn connect_local<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: Fn(&[Value]) -> Option<Value> + 'static,
[src]
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: Fn(&[Value]) -> Option<Value> + 'static,
pub unsafe fn connect_unsafe<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: Fn(&[Value]) -> Option<Value>,
[src]
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: Fn(&[Value]) -> Option<Value>,
pub fn emit<'a, N>(
&self,
signal_name: N,
args: &[&dyn ToValue]
) -> Result<Option<Value>, BoolError> where
N: Into<&'a str>,
[src]
&self,
signal_name: N,
args: &[&dyn ToValue]
) -> Result<Option<Value>, BoolError> where
N: Into<&'a str>,
pub fn downgrade(&self) -> WeakRef<T>
[src]
pub fn bind_property<'a, O, N, M>(
&'a self,
source_property: N,
target: &'a O,
target_property: M
) -> BindingBuilder<'a> where
N: Into<&'a str>,
O: ObjectType,
M: Into<&'a str>,
[src]
&'a self,
source_property: N,
target: &'a O,
target_property: M
) -> BindingBuilder<'a> where
N: Into<&'a str>,
O: ObjectType,
M: Into<&'a str>,
pub fn ref_count(&self) -> u32
[src]
impl<T> ToSendValue for T where
T: SetValue + Send + ToValue + ?Sized,
[src]
impl<T> ToSendValue for T where
T: SetValue + Send + ToValue + ?Sized,
[src]pub fn to_send_value(&self) -> SendValue
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,