1 #pragma warning disable CS1591
3 using System.Runtime.InteropServices;
4 using System.Collections.Generic;
6 using System.Threading;
7 using System.ComponentModel;
12 /// <summary>Texture UV mapping for all objects (rotation, perspective, 3d, ...).
13 /// Evas allows different transformations to be applied to all kinds of objects. These are applied by means of UV mapping.
15 /// With UV mapping, one maps points in the source object to a 3D space positioning at target. This allows rotation, perspective, scale and lots of other effects, depending on the map that is used.
17 /// Each map point may carry a multiplier color. If properly calculated, these can do shading effects on the object, producing 3D effects.
19 /// At the moment of writing, maps can only have 4 points (no more, no less).
20 /// (Since EFL 1.22)</summary>
21 [Efl.Gfx.IMappingConcrete.NativeMethods]
22 public interface IMapping :
23 Efl.Eo.IWrapper, IDisposable
25 /// <summary>Number of points of a map.
26 /// This sets the number of points of map. Currently, the number of points must be multiples of 4.
27 /// (Since EFL 1.22)</summary>
28 /// <returns>The number of points of map</returns>
29 int GetMappingPointCount();
30 /// <summary>Number of points of a map.
31 /// This sets the number of points of map. Currently, the number of points must be multiples of 4.
32 /// (Since EFL 1.22)</summary>
33 /// <param name="count">The number of points of map</param>
34 void SetMappingPointCount(int count);
35 /// <summary>Clockwise state of a map (read-only).
36 /// This determines if the output points (X and Y. Z is not used) are clockwise or counter-clockwise. This can be used for "back-face culling". This is where you hide objects that "face away" from you. In this case objects that are not clockwise.
37 /// (Since EFL 1.22)</summary>
38 /// <returns><c>true</c> if clockwise, <c>false</c> if counter clockwise</returns>
39 bool GetMappingClockwise();
40 /// <summary>Smoothing state for map rendering.
41 /// This sets smoothing for map rendering. If the object is a type that has its own smoothing settings, then both the smooth settings for this object and the map must be turned off. By default smooth maps are enabled.
42 /// (Since EFL 1.22)</summary>
43 /// <returns><c>true</c> by default.</returns>
44 bool GetMappingSmooth();
45 /// <summary>Smoothing state for map rendering.
46 /// This sets smoothing for map rendering. If the object is a type that has its own smoothing settings, then both the smooth settings for this object and the map must be turned off. By default smooth maps are enabled.
47 /// (Since EFL 1.22)</summary>
48 /// <param name="smooth"><c>true</c> by default.</param>
49 void SetMappingSmooth(bool smooth);
50 /// <summary>Alpha flag for map rendering.
51 /// This sets alpha flag for map rendering. If the object is a type that has its own alpha settings, then this will take precedence. Only image objects support this currently (<see cref="Efl.Canvas.Image"/> and its friends). Setting this to off stops alpha blending of the map area, and is useful if you know the object and/or all sub-objects is 100% solid.
53 /// Note that this may conflict with <see cref="Efl.Gfx.IMapping.MappingSmooth"/> depending on which algorithm is used for anti-aliasing.
54 /// (Since EFL 1.22)</summary>
55 /// <returns><c>true</c> by default.</returns>
56 bool GetMappingAlpha();
57 /// <summary>Alpha flag for map rendering.
58 /// This sets alpha flag for map rendering. If the object is a type that has its own alpha settings, then this will take precedence. Only image objects support this currently (<see cref="Efl.Canvas.Image"/> and its friends). Setting this to off stops alpha blending of the map area, and is useful if you know the object and/or all sub-objects is 100% solid.
60 /// Note that this may conflict with <see cref="Efl.Gfx.IMapping.MappingSmooth"/> depending on which algorithm is used for anti-aliasing.
61 /// (Since EFL 1.22)</summary>
62 /// <param name="alpha"><c>true</c> by default.</param>
63 void SetMappingAlpha(bool alpha);
64 /// <summary>A point's absolute coordinate on the canvas.
65 /// This sets/gets the fixed point's coordinate in the map. Note that points describe the outline of a quadrangle and are ordered either clockwise or counter-clockwise. Try to keep your quadrangles concave and non-complex. Though these polygon modes may work, they may not render a desired set of output. The quadrangle will use points 0 and 1 , 1 and 2, 2 and 3, and 3 and 0 to describe the edges of the quadrangle.
67 /// The X and Y and Z coordinates are in canvas units. Z is optional and may or may not be honored in drawing. Z is a hint and does not affect the X and Y rendered coordinates. It may be used for calculating fills with perspective correct rendering.
69 /// Remember all coordinates are canvas global ones as with move and resize in the canvas.
71 /// This property can be read to get the 4 points positions on the canvas, or set to manually place them.
72 /// (Since EFL 1.22)</summary>
73 /// <param name="idx">ID of the point, from 0 to 3 (included).</param>
74 /// <param name="x">Point X coordinate in absolute pixel coordinates.</param>
75 /// <param name="y">Point Y coordinate in absolute pixel coordinates.</param>
76 /// <param name="z">Point Z coordinate hint (pre-perspective transform).</param>
77 void GetMappingCoordAbsolute(int idx, out double x, out double y, out double z);
78 /// <summary>A point's absolute coordinate on the canvas.
79 /// This sets/gets the fixed point's coordinate in the map. Note that points describe the outline of a quadrangle and are ordered either clockwise or counter-clockwise. Try to keep your quadrangles concave and non-complex. Though these polygon modes may work, they may not render a desired set of output. The quadrangle will use points 0 and 1 , 1 and 2, 2 and 3, and 3 and 0 to describe the edges of the quadrangle.
81 /// The X and Y and Z coordinates are in canvas units. Z is optional and may or may not be honored in drawing. Z is a hint and does not affect the X and Y rendered coordinates. It may be used for calculating fills with perspective correct rendering.
83 /// Remember all coordinates are canvas global ones as with move and resize in the canvas.
85 /// This property can be read to get the 4 points positions on the canvas, or set to manually place them.
86 /// (Since EFL 1.22)</summary>
87 /// <param name="idx">ID of the point, from 0 to 3 (included).</param>
88 /// <param name="x">Point X coordinate in absolute pixel coordinates.</param>
89 /// <param name="y">Point Y coordinate in absolute pixel coordinates.</param>
90 /// <param name="z">Point Z coordinate hint (pre-perspective transform).</param>
91 void SetMappingCoordAbsolute(int idx, double x, double y, double z);
92 /// <summary>Map point's U and V texture source point.
93 /// This sets/gets the U and V coordinates for the point. This determines which coordinate in the source image is mapped to the given point, much like OpenGL and textures. Valid values range from 0.0 to 1.0.
95 /// By default the points are set in a clockwise order, as such: - 0: top-left, i.e. (0.0, 0.0), - 1: top-right, i.e. (1.0, 0.0), - 2: bottom-right, i.e. (1.0, 1.0), - 3: bottom-left, i.e. (0.0, 1.0).
96 /// (Since EFL 1.22)</summary>
97 /// <param name="idx">ID of the point, from 0 to 3 (included).</param>
98 /// <param name="u">Relative X coordinate within the image, from 0 to 1.</param>
99 /// <param name="v">Relative Y coordinate within the image, from 0 to 1.</param>
100 void GetMappingUv(int idx, out double u, out double v);
101 /// <summary>Map point's U and V texture source point.
102 /// This sets/gets the U and V coordinates for the point. This determines which coordinate in the source image is mapped to the given point, much like OpenGL and textures. Valid values range from 0.0 to 1.0.
104 /// By default the points are set in a clockwise order, as such: - 0: top-left, i.e. (0.0, 0.0), - 1: top-right, i.e. (1.0, 0.0), - 2: bottom-right, i.e. (1.0, 1.0), - 3: bottom-left, i.e. (0.0, 1.0).
105 /// (Since EFL 1.22)</summary>
106 /// <param name="idx">ID of the point, from 0 to 3 (included).</param>
107 /// <param name="u">Relative X coordinate within the image, from 0 to 1.</param>
108 /// <param name="v">Relative Y coordinate within the image, from 0 to 1.</param>
109 void SetMappingUv(int idx, double u, double v);
110 /// <summary>Color of a vertex in the map.
111 /// This sets the color of the vertex in the map. Colors will be linearly interpolated between vertex points through the map. Color will multiply the "texture" pixels (like GL_MODULATE in OpenGL). The default color of a vertex in a map is white solid (255, 255, 255, 255) which means it will have no affect on modifying the texture pixels.
113 /// The color values must be premultiplied (ie. <c>a</c> >= {<c>r</c>, <c>g</c>, <c>b</c>}).
114 /// (Since EFL 1.22)</summary>
115 /// <param name="idx">ID of the point, from 0 to 3 (included). -1 can be used to set the color for all points, but it is invalid for get().</param>
116 /// <param name="r">Red (0 - 255)</param>
117 /// <param name="g">Green (0 - 255)</param>
118 /// <param name="b">Blue (0 - 255)</param>
119 /// <param name="a">Alpha (0 - 255)</param>
120 void GetMappingColor(int idx, out int r, out int g, out int b, out int a);
121 /// <summary>Color of a vertex in the map.
122 /// This sets the color of the vertex in the map. Colors will be linearly interpolated between vertex points through the map. Color will multiply the "texture" pixels (like GL_MODULATE in OpenGL). The default color of a vertex in a map is white solid (255, 255, 255, 255) which means it will have no affect on modifying the texture pixels.
124 /// The color values must be premultiplied (ie. <c>a</c> >= {<c>r</c>, <c>g</c>, <c>b</c>}).
125 /// (Since EFL 1.22)</summary>
126 /// <param name="idx">ID of the point, from 0 to 3 (included). -1 can be used to set the color for all points, but it is invalid for get().</param>
127 /// <param name="r">Red (0 - 255)</param>
128 /// <param name="g">Green (0 - 255)</param>
129 /// <param name="b">Blue (0 - 255)</param>
130 /// <param name="a">Alpha (0 - 255)</param>
131 void SetMappingColor(int idx, int r, int g, int b, int a);
132 /// <summary>Read-only property indicating whether an object is mapped.
133 /// This will be <c>true</c> if any transformation is applied to this object.
134 /// (Since EFL 1.22)</summary>
135 /// <returns><c>true</c> if the object is mapped.</returns>
137 /// <summary>Resets the map transformation to its default state.
138 /// This will reset all transformations to identity, meaning the points' colors, positions and UV coordinates will be reset to their default values. <see cref="Efl.Gfx.IMapping.HasMapping"/> will then return <c>false</c>. This function will not modify the values of <see cref="Efl.Gfx.IMapping.MappingSmooth"/> or <see cref="Efl.Gfx.IMapping.MappingAlpha"/>.
139 /// (Since EFL 1.22)</summary>
141 /// <summary>Apply a translation to the object using map.
142 /// This does not change the real geometry of the object but will affect its visible position.
143 /// (Since EFL 1.22)</summary>
144 /// <param name="dx">Distance in pixels along the X axis.</param>
145 /// <param name="dy">Distance in pixels along the Y axis.</param>
146 /// <param name="dz">Distance in pixels along the Z axis.</param>
147 void Translate(double dx, double dy, double dz);
148 /// <summary>Apply a rotation to the object.
149 /// This rotates the object clockwise by <c>degrees</c> degrees, around the center specified by the relative position (<c>cx</c>, <c>cy</c>) in the <c>pivot</c> object. If <c>pivot</c> is <c>null</c> then this object is used as its own pivot center. 360 degrees is a full rotation, equivalent to no rotation. Negative values for <c>degrees</c> will rotate clockwise by that amount.
151 /// The coordinates are set relative to the given <c>pivot</c> object. If its geometry changes, then the absolute position of the rotation center will change accordingly.
153 /// By default, the center is at (0.5, 0.5). 0.0 means left or top while 1.0 means right or bottom of the <c>pivot</c> object.
154 /// (Since EFL 1.22)</summary>
155 /// <param name="degrees">CCW rotation in degrees.</param>
156 /// <param name="pivot">A pivot object for the center point, can be <c>null</c>.</param>
157 /// <param name="cx">X relative coordinate of the center point.</param>
158 /// <param name="cy">y relative coordinate of the center point.</param>
159 void Rotate(double degrees, Efl.Gfx.IEntity pivot, double cx, double cy);
160 /// <summary>Rotate the object around 3 axes in 3D.
161 /// This will rotate in 3D, not just around the "Z" axis as is the case with <see cref="Efl.Gfx.IMapping.Rotate"/>. You can rotate around the X, Y and Z axes. The Z axis points "into" the screen with low values at the screen and higher values further away. The X axis runs from left to right on the screen and the Y axis from top to bottom.
163 /// As with <see cref="Efl.Gfx.IMapping.Rotate"/>, you provide a pivot and center point to rotate around (in 3D). The Z coordinate of this center point is an absolute value, and not a relative one like X and Y, as objects are flat in a 2D space.
164 /// (Since EFL 1.22)</summary>
165 /// <param name="dx">Rotation in degrees around X axis (0 to 360).</param>
166 /// <param name="dy">Rotation in degrees around Y axis (0 to 360).</param>
167 /// <param name="dz">Rotation in degrees around Z axis (0 to 360).</param>
168 /// <param name="pivot">A pivot object for the center point, can be <c>null</c>.</param>
169 /// <param name="cx">X relative coordinate of the center point.</param>
170 /// <param name="cy">y relative coordinate of the center point.</param>
171 /// <param name="cz">Z absolute coordinate of the center point.</param>
172 void Rotate3d(double dx, double dy, double dz, Efl.Gfx.IEntity pivot, double cx, double cy, double cz);
173 /// <summary>Rotate the object in 3D using a unit quaternion.
174 /// This is similar to <see cref="Efl.Gfx.IMapping.Rotate3d"/> but uses a unit quaternion (also known as versor) rather than a direct angle-based rotation around a center point. Use this to avoid gimbal locks.
176 /// As with <see cref="Efl.Gfx.IMapping.Rotate"/>, you provide a pivot and center point to rotate around (in 3D). The Z coordinate of this center point is an absolute value, and not a relative one like X and Y, as objects are flat in a 2D space.
177 /// (Since EFL 1.22)</summary>
178 /// <param name="qx">The x component of the imaginary part of the quaternion.</param>
179 /// <param name="qy">The y component of the imaginary part of the quaternion.</param>
180 /// <param name="qz">The z component of the imaginary part of the quaternion.</param>
181 /// <param name="qw">The w component of the real part of the quaternion.</param>
182 /// <param name="pivot">A pivot object for the center point, can be <c>null</c>.</param>
183 /// <param name="cx">X relative coordinate of the center point.</param>
184 /// <param name="cy">y relative coordinate of the center point.</param>
185 /// <param name="cz">Z absolute coordinate of the center point.</param>
186 void RotateQuat(double qx, double qy, double qz, double qw, Efl.Gfx.IEntity pivot, double cx, double cy, double cz);
187 /// <summary>Apply a zoom to the object.
188 /// This zooms the points of the map from a center point. That center is defined by <c>cx</c> and <c>cy</c>. The <c>zoomx</c> and <c>zoomy</c> parameters specify how much to zoom in the X and Y direction respectively. A value of 1.0 means "don't zoom". 2.0 means "double the size". 0.5 is "half the size" etc.
190 /// By default, the center is at (0.5, 0.5). 0.0 means left or top while 1.0 means right or bottom.
191 /// (Since EFL 1.22)</summary>
192 /// <param name="zoomx">Zoom in X direction</param>
193 /// <param name="zoomy">Zoom in Y direction</param>
194 /// <param name="pivot">A pivot object for the center point, can be <c>null</c>.</param>
195 /// <param name="cx">X relative coordinate of the center point.</param>
196 /// <param name="cy">y relative coordinate of the center point.</param>
197 void Zoom(double zoomx, double zoomy, Efl.Gfx.IEntity pivot, double cx, double cy);
198 /// <summary>Apply a lighting effect on the object.
199 /// This is used to apply lighting calculations (from a single light source) to a given mapped object. The R, G and B values of each vertex will be modified to reflect the lighting based on the light point coordinates, the light color and the ambient color, and at what angle the map is facing the light source. A surface should have its points be declared in a clockwise fashion if the face is "facing" towards you (as opposed to away from you) as faces have a "logical" side for lighting.
201 /// The coordinates are set relative to the given <c>pivot</c> object. If its geometry changes, then the absolute position of the rotation center will change accordingly. The Z position is absolute. If the <c>pivot</c> is <c>null</c> then this object will be its own pivot.
202 /// (Since EFL 1.22)</summary>
203 /// <param name="pivot">A pivot object for the light point, can be <c>null</c>.</param>
204 /// <param name="lx">X relative coordinate in space of light point.</param>
205 /// <param name="ly">Y relative coordinate in space of light point.</param>
206 /// <param name="lz">Z absolute coordinate in space of light point.</param>
207 /// <param name="lr">Light red value (0 - 255).</param>
208 /// <param name="lg">Light green value (0 - 255).</param>
209 /// <param name="lb">Light blue value (0 - 255).</param>
210 /// <param name="ar">Ambient color red value (0 - 255).</param>
211 /// <param name="ag">Ambient color green value (0 - 255).</param>
212 /// <param name="ab">Ambient color blue value (0 - 255).</param>
213 void Lighting3d(Efl.Gfx.IEntity pivot, double lx, double ly, double lz, int lr, int lg, int lb, int ar, int ag, int ab);
214 /// <summary>Apply a perspective transform to the map
215 /// This applies a given perspective (3D) to the map coordinates. X, Y and Z values are used. The px and py points specify the "infinite distance" point in the 3D conversion (where all lines converge to like when artists draw 3D by hand). The <c>z0</c> value specifies the z value at which there is a 1:1 mapping between spatial coordinates and screen coordinates. Any points on this z value will not have their X and Y values modified in the transform. Those further away (Z value higher) will shrink into the distance, and those under this value will expand and become bigger. The <c>foc</c> value determines the "focal length" of the camera. This is in reality the distance between the camera lens plane itself (at or closer than this rendering results are undefined) and the "z0" z value. This allows for some "depth" control and <c>foc</c> must be greater than 0.
217 /// The coordinates are set relative to the given <c>pivot</c> object. If its geometry changes, then the absolute position of the rotation center will change accordingly. The Z position is absolute. If the <c>pivot</c> is <c>null</c> then this object will be its own pivot.
218 /// (Since EFL 1.22)</summary>
219 /// <param name="pivot">A pivot object for the infinite point, can be <c>null</c>.</param>
220 /// <param name="px">The perspective distance X relative coordinate.</param>
221 /// <param name="py">The perspective distance Y relative coordinate.</param>
222 /// <param name="z0">The "0" Z plane value.</param>
223 /// <param name="foc">The focal distance, must be greater than 0.</param>
224 void Perspective3d(Efl.Gfx.IEntity pivot, double px, double py, double z0, double foc);
225 /// <summary>Apply a rotation to the object, using absolute coordinates.
226 /// This rotates the object clockwise by <c>degrees</c> degrees, around the center specified by the relative position (<c>cx</c>, <c>cy</c>) in the <c>pivot</c> object. If <c>pivot</c> is <c>null</c> then this object is used as its own pivot center. 360 degrees is a full rotation, equivalent to no rotation. Negative values for <c>degrees</c> will rotate clockwise by that amount.
228 /// The given coordinates are absolute values in pixels. See also <see cref="Efl.Gfx.IMapping.Rotate"/> for a relative coordinate version.
229 /// (Since EFL 1.22)</summary>
230 /// <param name="degrees">CCW rotation in degrees.</param>
231 /// <param name="cx">X absolute coordinate in pixels of the center point.</param>
232 /// <param name="cy">y absolute coordinate in pixels of the center point.</param>
233 void RotateAbsolute(double degrees, double cx, double cy);
234 /// <summary>Rotate the object around 3 axes in 3D, using absolute coordinates.
235 /// This will rotate in 3D and not just around the "Z" axis as the case with <see cref="Efl.Gfx.IMapping.Rotate"/>. This will rotate around the X, Y and Z axes. The Z axis points "into" the screen with low values at the screen and higher values further away. The X axis runs from left to right on the screen and the Y axis from top to bottom.
237 /// The coordinates of the center point are given in absolute canvas coordinates. See also <see cref="Efl.Gfx.IMapping.Rotate3d"/> for a pivot-based 3D rotation.
238 /// (Since EFL 1.22)</summary>
239 /// <param name="dx">Rotation in degrees around X axis (0 to 360).</param>
240 /// <param name="dy">Rotation in degrees around Y axis (0 to 360).</param>
241 /// <param name="dz">Rotation in degrees around Z axis (0 to 360).</param>
242 /// <param name="cx">X absolute coordinate in pixels of the center point.</param>
243 /// <param name="cy">y absolute coordinate in pixels of the center point.</param>
244 /// <param name="cz">Z absolute coordinate of the center point.</param>
245 void Rotate3dAbsolute(double dx, double dy, double dz, double cx, double cy, double cz);
246 /// <summary>Rotate the object in 3D using a unit quaternion, using absolute coordinates.
247 /// This is similar to <see cref="Efl.Gfx.IMapping.Rotate3d"/> but uses a unit quaternion (also known as versor) rather than a direct angle-based rotation around a center point. Use this to avoid gimbal locks.
249 /// The coordinates of the center point are given in absolute canvas coordinates. See also <see cref="Efl.Gfx.IMapping.RotateQuat"/> for a pivot-based 3D rotation.
250 /// (Since EFL 1.22)</summary>
251 /// <param name="qx">The x component of the imaginary part of the quaternion.</param>
252 /// <param name="qy">The y component of the imaginary part of the quaternion.</param>
253 /// <param name="qz">The z component of the imaginary part of the quaternion.</param>
254 /// <param name="qw">The w component of the real part of the quaternion.</param>
255 /// <param name="cx">X absolute coordinate in pixels of the center point.</param>
256 /// <param name="cy">y absolute coordinate in pixels of the center point.</param>
257 /// <param name="cz">Z absolute coordinate of the center point.</param>
258 void RotateQuatAbsolute(double qx, double qy, double qz, double qw, double cx, double cy, double cz);
259 /// <summary>Apply a zoom to the object, using absolute coordinates.
260 /// This zooms the points of the map from a center point. That center is defined by <c>cx</c> and <c>cy</c>. The <c>zoomx</c> and <c>zoomy</c> parameters specify how much to zoom in the X and Y direction respectively. A value of 1.0 means "don't zoom". 2.0 means "double the size". 0.5 is "half the size" etc.
262 /// The coordinates of the center point are given in absolute canvas coordinates. See also <see cref="Efl.Gfx.IMapping.Zoom"/> for a pivot-based zoom.
263 /// (Since EFL 1.22)</summary>
264 /// <param name="zoomx">Zoom in X direction</param>
265 /// <param name="zoomy">Zoom in Y direction</param>
266 /// <param name="cx">X absolute coordinate in pixels of the center point.</param>
267 /// <param name="cy">y absolute coordinate in pixels of the center point.</param>
268 void ZoomAbsolute(double zoomx, double zoomy, double cx, double cy);
269 /// <summary>Apply a lighting effect to the object.
270 /// This is used to apply lighting calculations (from a single light source) to a given mapped object. The RGB values of each vertex will be modified to reflect the lighting based on the light point coordinates, the light color, the ambient color and at what angle the map is facing the light source. A surface should have its points be declared in a clockwise fashion if the face is "facing" towards you (as opposed to away from you) as faces have a "logical" side for lighting.
272 /// The coordinates of the center point are given in absolute canvas coordinates. See also <see cref="Efl.Gfx.IMapping.Lighting3d"/> for a pivot-based lighting effect.
273 /// (Since EFL 1.22)</summary>
274 /// <param name="lx">X absolute coordinate in pixels of the light point.</param>
275 /// <param name="ly">y absolute coordinate in pixels of the light point.</param>
276 /// <param name="lz">Z absolute coordinate in space of light point.</param>
277 /// <param name="lr">Light red value (0 - 255).</param>
278 /// <param name="lg">Light green value (0 - 255).</param>
279 /// <param name="lb">Light blue value (0 - 255).</param>
280 /// <param name="ar">Ambient color red value (0 - 255).</param>
281 /// <param name="ag">Ambient color green value (0 - 255).</param>
282 /// <param name="ab">Ambient color blue value (0 - 255).</param>
283 void Lighting3dAbsolute(double lx, double ly, double lz, int lr, int lg, int lb, int ar, int ag, int ab);
284 /// <summary>Apply a perspective transform to the map
285 /// This applies a given perspective (3D) to the map coordinates. X, Y and Z values are used. The px and py points specify the "infinite distance" point in the 3D conversion (where all lines converge to like when artists draw 3D by hand). The <c>z0</c> value specifies the z value at which there is a 1:1 mapping between spatial coordinates and screen coordinates. Any points on this z value will not have their X and Y values modified in the transform. Those further away (Z value higher) will shrink into the distance, and those less than this value will expand and become bigger. The <c>foc</c> value determines the "focal length" of the camera. This is in reality the distance between the camera lens plane itself (at or closer than this rendering results are undefined) and the "z0" z value. This allows for some "depth" control and <c>foc</c> must be greater than 0.
287 /// The coordinates of the center point are given in absolute canvas coordinates. See also <see cref="Efl.Gfx.IMapping.Perspective3d"/> for a pivot-based perspective effect.
288 /// (Since EFL 1.22)</summary>
289 /// <param name="px">The perspective distance X relative coordinate.</param>
290 /// <param name="py">The perspective distance Y relative coordinate.</param>
291 /// <param name="z0">The "0" Z plane value.</param>
292 /// <param name="foc">The focal distance, must be greater than 0.</param>
293 void Perspective3dAbsolute(double px, double py, double z0, double foc);
294 /// <summary>Number of points of a map.
295 /// This sets the number of points of map. Currently, the number of points must be multiples of 4.
296 /// (Since EFL 1.22)</summary>
297 /// <value>The number of points of map</value>
298 int MappingPointCount {
302 /// <summary>Clockwise state of a map (read-only).
303 /// This determines if the output points (X and Y. Z is not used) are clockwise or counter-clockwise. This can be used for "back-face culling". This is where you hide objects that "face away" from you. In this case objects that are not clockwise.
304 /// (Since EFL 1.22)</summary>
305 /// <value><c>true</c> if clockwise, <c>false</c> if counter clockwise</value>
306 bool MappingClockwise {
309 /// <summary>Smoothing state for map rendering.
310 /// This sets smoothing for map rendering. If the object is a type that has its own smoothing settings, then both the smooth settings for this object and the map must be turned off. By default smooth maps are enabled.
311 /// (Since EFL 1.22)</summary>
312 /// <value><c>true</c> by default.</value>
317 /// <summary>Alpha flag for map rendering.
318 /// This sets alpha flag for map rendering. If the object is a type that has its own alpha settings, then this will take precedence. Only image objects support this currently (<see cref="Efl.Canvas.Image"/> and its friends). Setting this to off stops alpha blending of the map area, and is useful if you know the object and/or all sub-objects is 100% solid.
320 /// Note that this may conflict with <see cref="Efl.Gfx.IMapping.MappingSmooth"/> depending on which algorithm is used for anti-aliasing.
321 /// (Since EFL 1.22)</summary>
322 /// <value><c>true</c> by default.</value>
328 /// <summary>Texture UV mapping for all objects (rotation, perspective, 3d, ...).
329 /// Evas allows different transformations to be applied to all kinds of objects. These are applied by means of UV mapping.
331 /// With UV mapping, one maps points in the source object to a 3D space positioning at target. This allows rotation, perspective, scale and lots of other effects, depending on the map that is used.
333 /// Each map point may carry a multiplier color. If properly calculated, these can do shading effects on the object, producing 3D effects.
335 /// At the moment of writing, maps can only have 4 points (no more, no less).
336 /// (Since EFL 1.22)</summary>
337 sealed public class IMappingConcrete :
342 ///<summary>Pointer to the native class description.</summary>
343 public System.IntPtr NativeClass
347 if (((object)this).GetType() == typeof(IMappingConcrete))
349 return GetEflClassStatic();
353 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
358 private System.IntPtr handle;
359 ///<summary>Pointer to the native instance.</summary>
360 public System.IntPtr NativeHandle
362 get { return handle; }
365 [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
366 efl_gfx_mapping_mixin_get();
367 /// <summary>Initializes a new instance of the <see cref="IMapping"/> class.
368 /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
369 private IMappingConcrete(System.IntPtr raw)
373 ///<summary>Destructor.</summary>
379 ///<summary>Releases the underlying native instance.</summary>
380 private void Dispose(bool disposing)
382 if (handle != System.IntPtr.Zero)
385 handle = IntPtr.Zero;
387 IntPtr gcHandlePtr = IntPtr.Zero;
390 Efl.Eo.Globals.efl_mono_native_dispose(h, gcHandlePtr);
394 Monitor.Enter(Efl.All.InitLock);
395 if (Efl.All.MainLoopInitialized)
397 Efl.Eo.Globals.efl_mono_thread_safe_native_dispose(h, gcHandlePtr);
400 Monitor.Exit(Efl.All.InitLock);
406 ///<summary>Releases the underlying native instance.</summary>
407 public void Dispose()
410 GC.SuppressFinalize(this);
413 /// <summary>Verifies if the given object is equal to this one.</summary>
414 /// <param name="instance">The object to compare to.</param>
415 /// <returns>True if both objects point to the same native object.</returns>
416 public override bool Equals(object instance)
418 var other = instance as Efl.Object;
423 return this.NativeHandle == other.NativeHandle;
426 /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
427 /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
428 public override int GetHashCode()
430 return this.NativeHandle.ToInt32();
433 /// <summary>Turns the native pointer into a string representation.</summary>
434 /// <returns>A string with the type and the native pointer for this object.</returns>
435 public override String ToString()
437 return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
440 /// <summary>Number of points of a map.
441 /// This sets the number of points of map. Currently, the number of points must be multiples of 4.
442 /// (Since EFL 1.22)</summary>
443 /// <returns>The number of points of map</returns>
444 public int GetMappingPointCount() {
445 var _ret_var = Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_point_count_get_ptr.Value.Delegate(this.NativeHandle);
446 Eina.Error.RaiseIfUnhandledException();
449 /// <summary>Number of points of a map.
450 /// This sets the number of points of map. Currently, the number of points must be multiples of 4.
451 /// (Since EFL 1.22)</summary>
452 /// <param name="count">The number of points of map</param>
453 public void SetMappingPointCount(int count) {
454 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_point_count_set_ptr.Value.Delegate(this.NativeHandle,count);
455 Eina.Error.RaiseIfUnhandledException();
457 /// <summary>Clockwise state of a map (read-only).
458 /// This determines if the output points (X and Y. Z is not used) are clockwise or counter-clockwise. This can be used for "back-face culling". This is where you hide objects that "face away" from you. In this case objects that are not clockwise.
459 /// (Since EFL 1.22)</summary>
460 /// <returns><c>true</c> if clockwise, <c>false</c> if counter clockwise</returns>
461 public bool GetMappingClockwise() {
462 var _ret_var = Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_clockwise_get_ptr.Value.Delegate(this.NativeHandle);
463 Eina.Error.RaiseIfUnhandledException();
466 /// <summary>Smoothing state for map rendering.
467 /// This sets smoothing for map rendering. If the object is a type that has its own smoothing settings, then both the smooth settings for this object and the map must be turned off. By default smooth maps are enabled.
468 /// (Since EFL 1.22)</summary>
469 /// <returns><c>true</c> by default.</returns>
470 public bool GetMappingSmooth() {
471 var _ret_var = Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_smooth_get_ptr.Value.Delegate(this.NativeHandle);
472 Eina.Error.RaiseIfUnhandledException();
475 /// <summary>Smoothing state for map rendering.
476 /// This sets smoothing for map rendering. If the object is a type that has its own smoothing settings, then both the smooth settings for this object and the map must be turned off. By default smooth maps are enabled.
477 /// (Since EFL 1.22)</summary>
478 /// <param name="smooth"><c>true</c> by default.</param>
479 public void SetMappingSmooth(bool smooth) {
480 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_smooth_set_ptr.Value.Delegate(this.NativeHandle,smooth);
481 Eina.Error.RaiseIfUnhandledException();
483 /// <summary>Alpha flag for map rendering.
484 /// This sets alpha flag for map rendering. If the object is a type that has its own alpha settings, then this will take precedence. Only image objects support this currently (<see cref="Efl.Canvas.Image"/> and its friends). Setting this to off stops alpha blending of the map area, and is useful if you know the object and/or all sub-objects is 100% solid.
486 /// Note that this may conflict with <see cref="Efl.Gfx.IMapping.MappingSmooth"/> depending on which algorithm is used for anti-aliasing.
487 /// (Since EFL 1.22)</summary>
488 /// <returns><c>true</c> by default.</returns>
489 public bool GetMappingAlpha() {
490 var _ret_var = Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_alpha_get_ptr.Value.Delegate(this.NativeHandle);
491 Eina.Error.RaiseIfUnhandledException();
494 /// <summary>Alpha flag for map rendering.
495 /// This sets alpha flag for map rendering. If the object is a type that has its own alpha settings, then this will take precedence. Only image objects support this currently (<see cref="Efl.Canvas.Image"/> and its friends). Setting this to off stops alpha blending of the map area, and is useful if you know the object and/or all sub-objects is 100% solid.
497 /// Note that this may conflict with <see cref="Efl.Gfx.IMapping.MappingSmooth"/> depending on which algorithm is used for anti-aliasing.
498 /// (Since EFL 1.22)</summary>
499 /// <param name="alpha"><c>true</c> by default.</param>
500 public void SetMappingAlpha(bool alpha) {
501 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_alpha_set_ptr.Value.Delegate(this.NativeHandle,alpha);
502 Eina.Error.RaiseIfUnhandledException();
504 /// <summary>A point's absolute coordinate on the canvas.
505 /// This sets/gets the fixed point's coordinate in the map. Note that points describe the outline of a quadrangle and are ordered either clockwise or counter-clockwise. Try to keep your quadrangles concave and non-complex. Though these polygon modes may work, they may not render a desired set of output. The quadrangle will use points 0 and 1 , 1 and 2, 2 and 3, and 3 and 0 to describe the edges of the quadrangle.
507 /// The X and Y and Z coordinates are in canvas units. Z is optional and may or may not be honored in drawing. Z is a hint and does not affect the X and Y rendered coordinates. It may be used for calculating fills with perspective correct rendering.
509 /// Remember all coordinates are canvas global ones as with move and resize in the canvas.
511 /// This property can be read to get the 4 points positions on the canvas, or set to manually place them.
512 /// (Since EFL 1.22)</summary>
513 /// <param name="idx">ID of the point, from 0 to 3 (included).</param>
514 /// <param name="x">Point X coordinate in absolute pixel coordinates.</param>
515 /// <param name="y">Point Y coordinate in absolute pixel coordinates.</param>
516 /// <param name="z">Point Z coordinate hint (pre-perspective transform).</param>
517 public void GetMappingCoordAbsolute(int idx, out double x, out double y, out double z) {
518 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_coord_absolute_get_ptr.Value.Delegate(this.NativeHandle,idx, out x, out y, out z);
519 Eina.Error.RaiseIfUnhandledException();
521 /// <summary>A point's absolute coordinate on the canvas.
522 /// This sets/gets the fixed point's coordinate in the map. Note that points describe the outline of a quadrangle and are ordered either clockwise or counter-clockwise. Try to keep your quadrangles concave and non-complex. Though these polygon modes may work, they may not render a desired set of output. The quadrangle will use points 0 and 1 , 1 and 2, 2 and 3, and 3 and 0 to describe the edges of the quadrangle.
524 /// The X and Y and Z coordinates are in canvas units. Z is optional and may or may not be honored in drawing. Z is a hint and does not affect the X and Y rendered coordinates. It may be used for calculating fills with perspective correct rendering.
526 /// Remember all coordinates are canvas global ones as with move and resize in the canvas.
528 /// This property can be read to get the 4 points positions on the canvas, or set to manually place them.
529 /// (Since EFL 1.22)</summary>
530 /// <param name="idx">ID of the point, from 0 to 3 (included).</param>
531 /// <param name="x">Point X coordinate in absolute pixel coordinates.</param>
532 /// <param name="y">Point Y coordinate in absolute pixel coordinates.</param>
533 /// <param name="z">Point Z coordinate hint (pre-perspective transform).</param>
534 public void SetMappingCoordAbsolute(int idx, double x, double y, double z) {
535 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_coord_absolute_set_ptr.Value.Delegate(this.NativeHandle,idx, x, y, z);
536 Eina.Error.RaiseIfUnhandledException();
538 /// <summary>Map point's U and V texture source point.
539 /// This sets/gets the U and V coordinates for the point. This determines which coordinate in the source image is mapped to the given point, much like OpenGL and textures. Valid values range from 0.0 to 1.0.
541 /// By default the points are set in a clockwise order, as such: - 0: top-left, i.e. (0.0, 0.0), - 1: top-right, i.e. (1.0, 0.0), - 2: bottom-right, i.e. (1.0, 1.0), - 3: bottom-left, i.e. (0.0, 1.0).
542 /// (Since EFL 1.22)</summary>
543 /// <param name="idx">ID of the point, from 0 to 3 (included).</param>
544 /// <param name="u">Relative X coordinate within the image, from 0 to 1.</param>
545 /// <param name="v">Relative Y coordinate within the image, from 0 to 1.</param>
546 public void GetMappingUv(int idx, out double u, out double v) {
547 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_uv_get_ptr.Value.Delegate(this.NativeHandle,idx, out u, out v);
548 Eina.Error.RaiseIfUnhandledException();
550 /// <summary>Map point's U and V texture source point.
551 /// This sets/gets the U and V coordinates for the point. This determines which coordinate in the source image is mapped to the given point, much like OpenGL and textures. Valid values range from 0.0 to 1.0.
553 /// By default the points are set in a clockwise order, as such: - 0: top-left, i.e. (0.0, 0.0), - 1: top-right, i.e. (1.0, 0.0), - 2: bottom-right, i.e. (1.0, 1.0), - 3: bottom-left, i.e. (0.0, 1.0).
554 /// (Since EFL 1.22)</summary>
555 /// <param name="idx">ID of the point, from 0 to 3 (included).</param>
556 /// <param name="u">Relative X coordinate within the image, from 0 to 1.</param>
557 /// <param name="v">Relative Y coordinate within the image, from 0 to 1.</param>
558 public void SetMappingUv(int idx, double u, double v) {
559 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_uv_set_ptr.Value.Delegate(this.NativeHandle,idx, u, v);
560 Eina.Error.RaiseIfUnhandledException();
562 /// <summary>Color of a vertex in the map.
563 /// This sets the color of the vertex in the map. Colors will be linearly interpolated between vertex points through the map. Color will multiply the "texture" pixels (like GL_MODULATE in OpenGL). The default color of a vertex in a map is white solid (255, 255, 255, 255) which means it will have no affect on modifying the texture pixels.
565 /// The color values must be premultiplied (ie. <c>a</c> >= {<c>r</c>, <c>g</c>, <c>b</c>}).
566 /// (Since EFL 1.22)</summary>
567 /// <param name="idx">ID of the point, from 0 to 3 (included). -1 can be used to set the color for all points, but it is invalid for get().</param>
568 /// <param name="r">Red (0 - 255)</param>
569 /// <param name="g">Green (0 - 255)</param>
570 /// <param name="b">Blue (0 - 255)</param>
571 /// <param name="a">Alpha (0 - 255)</param>
572 public void GetMappingColor(int idx, out int r, out int g, out int b, out int a) {
573 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_color_get_ptr.Value.Delegate(this.NativeHandle,idx, out r, out g, out b, out a);
574 Eina.Error.RaiseIfUnhandledException();
576 /// <summary>Color of a vertex in the map.
577 /// This sets the color of the vertex in the map. Colors will be linearly interpolated between vertex points through the map. Color will multiply the "texture" pixels (like GL_MODULATE in OpenGL). The default color of a vertex in a map is white solid (255, 255, 255, 255) which means it will have no affect on modifying the texture pixels.
579 /// The color values must be premultiplied (ie. <c>a</c> >= {<c>r</c>, <c>g</c>, <c>b</c>}).
580 /// (Since EFL 1.22)</summary>
581 /// <param name="idx">ID of the point, from 0 to 3 (included). -1 can be used to set the color for all points, but it is invalid for get().</param>
582 /// <param name="r">Red (0 - 255)</param>
583 /// <param name="g">Green (0 - 255)</param>
584 /// <param name="b">Blue (0 - 255)</param>
585 /// <param name="a">Alpha (0 - 255)</param>
586 public void SetMappingColor(int idx, int r, int g, int b, int a) {
587 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_color_set_ptr.Value.Delegate(this.NativeHandle,idx, r, g, b, a);
588 Eina.Error.RaiseIfUnhandledException();
590 /// <summary>Read-only property indicating whether an object is mapped.
591 /// This will be <c>true</c> if any transformation is applied to this object.
592 /// (Since EFL 1.22)</summary>
593 /// <returns><c>true</c> if the object is mapped.</returns>
594 public bool HasMapping() {
595 var _ret_var = Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_has_ptr.Value.Delegate(this.NativeHandle);
596 Eina.Error.RaiseIfUnhandledException();
599 /// <summary>Resets the map transformation to its default state.
600 /// This will reset all transformations to identity, meaning the points' colors, positions and UV coordinates will be reset to their default values. <see cref="Efl.Gfx.IMapping.HasMapping"/> will then return <c>false</c>. This function will not modify the values of <see cref="Efl.Gfx.IMapping.MappingSmooth"/> or <see cref="Efl.Gfx.IMapping.MappingAlpha"/>.
601 /// (Since EFL 1.22)</summary>
602 public void ResetMapping() {
603 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_reset_ptr.Value.Delegate(this.NativeHandle);
604 Eina.Error.RaiseIfUnhandledException();
606 /// <summary>Apply a translation to the object using map.
607 /// This does not change the real geometry of the object but will affect its visible position.
608 /// (Since EFL 1.22)</summary>
609 /// <param name="dx">Distance in pixels along the X axis.</param>
610 /// <param name="dy">Distance in pixels along the Y axis.</param>
611 /// <param name="dz">Distance in pixels along the Z axis.</param>
612 public void Translate(double dx, double dy, double dz) {
613 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_translate_ptr.Value.Delegate(this.NativeHandle,dx, dy, dz);
614 Eina.Error.RaiseIfUnhandledException();
616 /// <summary>Apply a rotation to the object.
617 /// This rotates the object clockwise by <c>degrees</c> degrees, around the center specified by the relative position (<c>cx</c>, <c>cy</c>) in the <c>pivot</c> object. If <c>pivot</c> is <c>null</c> then this object is used as its own pivot center. 360 degrees is a full rotation, equivalent to no rotation. Negative values for <c>degrees</c> will rotate clockwise by that amount.
619 /// The coordinates are set relative to the given <c>pivot</c> object. If its geometry changes, then the absolute position of the rotation center will change accordingly.
621 /// By default, the center is at (0.5, 0.5). 0.0 means left or top while 1.0 means right or bottom of the <c>pivot</c> object.
622 /// (Since EFL 1.22)</summary>
623 /// <param name="degrees">CCW rotation in degrees.</param>
624 /// <param name="pivot">A pivot object for the center point, can be <c>null</c>.</param>
625 /// <param name="cx">X relative coordinate of the center point.</param>
626 /// <param name="cy">y relative coordinate of the center point.</param>
627 public void Rotate(double degrees, Efl.Gfx.IEntity pivot, double cx, double cy) {
628 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_ptr.Value.Delegate(this.NativeHandle,degrees, pivot, cx, cy);
629 Eina.Error.RaiseIfUnhandledException();
631 /// <summary>Rotate the object around 3 axes in 3D.
632 /// This will rotate in 3D, not just around the "Z" axis as is the case with <see cref="Efl.Gfx.IMapping.Rotate"/>. You can rotate around the X, Y and Z axes. The Z axis points "into" the screen with low values at the screen and higher values further away. The X axis runs from left to right on the screen and the Y axis from top to bottom.
634 /// As with <see cref="Efl.Gfx.IMapping.Rotate"/>, you provide a pivot and center point to rotate around (in 3D). The Z coordinate of this center point is an absolute value, and not a relative one like X and Y, as objects are flat in a 2D space.
635 /// (Since EFL 1.22)</summary>
636 /// <param name="dx">Rotation in degrees around X axis (0 to 360).</param>
637 /// <param name="dy">Rotation in degrees around Y axis (0 to 360).</param>
638 /// <param name="dz">Rotation in degrees around Z axis (0 to 360).</param>
639 /// <param name="pivot">A pivot object for the center point, can be <c>null</c>.</param>
640 /// <param name="cx">X relative coordinate of the center point.</param>
641 /// <param name="cy">y relative coordinate of the center point.</param>
642 /// <param name="cz">Z absolute coordinate of the center point.</param>
643 public void Rotate3d(double dx, double dy, double dz, Efl.Gfx.IEntity pivot, double cx, double cy, double cz) {
644 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_3d_ptr.Value.Delegate(this.NativeHandle,dx, dy, dz, pivot, cx, cy, cz);
645 Eina.Error.RaiseIfUnhandledException();
647 /// <summary>Rotate the object in 3D using a unit quaternion.
648 /// This is similar to <see cref="Efl.Gfx.IMapping.Rotate3d"/> but uses a unit quaternion (also known as versor) rather than a direct angle-based rotation around a center point. Use this to avoid gimbal locks.
650 /// As with <see cref="Efl.Gfx.IMapping.Rotate"/>, you provide a pivot and center point to rotate around (in 3D). The Z coordinate of this center point is an absolute value, and not a relative one like X and Y, as objects are flat in a 2D space.
651 /// (Since EFL 1.22)</summary>
652 /// <param name="qx">The x component of the imaginary part of the quaternion.</param>
653 /// <param name="qy">The y component of the imaginary part of the quaternion.</param>
654 /// <param name="qz">The z component of the imaginary part of the quaternion.</param>
655 /// <param name="qw">The w component of the real part of the quaternion.</param>
656 /// <param name="pivot">A pivot object for the center point, can be <c>null</c>.</param>
657 /// <param name="cx">X relative coordinate of the center point.</param>
658 /// <param name="cy">y relative coordinate of the center point.</param>
659 /// <param name="cz">Z absolute coordinate of the center point.</param>
660 public void RotateQuat(double qx, double qy, double qz, double qw, Efl.Gfx.IEntity pivot, double cx, double cy, double cz) {
661 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_quat_ptr.Value.Delegate(this.NativeHandle,qx, qy, qz, qw, pivot, cx, cy, cz);
662 Eina.Error.RaiseIfUnhandledException();
664 /// <summary>Apply a zoom to the object.
665 /// This zooms the points of the map from a center point. That center is defined by <c>cx</c> and <c>cy</c>. The <c>zoomx</c> and <c>zoomy</c> parameters specify how much to zoom in the X and Y direction respectively. A value of 1.0 means "don't zoom". 2.0 means "double the size". 0.5 is "half the size" etc.
667 /// By default, the center is at (0.5, 0.5). 0.0 means left or top while 1.0 means right or bottom.
668 /// (Since EFL 1.22)</summary>
669 /// <param name="zoomx">Zoom in X direction</param>
670 /// <param name="zoomy">Zoom in Y direction</param>
671 /// <param name="pivot">A pivot object for the center point, can be <c>null</c>.</param>
672 /// <param name="cx">X relative coordinate of the center point.</param>
673 /// <param name="cy">y relative coordinate of the center point.</param>
674 public void Zoom(double zoomx, double zoomy, Efl.Gfx.IEntity pivot, double cx, double cy) {
675 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_zoom_ptr.Value.Delegate(this.NativeHandle,zoomx, zoomy, pivot, cx, cy);
676 Eina.Error.RaiseIfUnhandledException();
678 /// <summary>Apply a lighting effect on the object.
679 /// This is used to apply lighting calculations (from a single light source) to a given mapped object. The R, G and B values of each vertex will be modified to reflect the lighting based on the light point coordinates, the light color and the ambient color, and at what angle the map is facing the light source. A surface should have its points be declared in a clockwise fashion if the face is "facing" towards you (as opposed to away from you) as faces have a "logical" side for lighting.
681 /// The coordinates are set relative to the given <c>pivot</c> object. If its geometry changes, then the absolute position of the rotation center will change accordingly. The Z position is absolute. If the <c>pivot</c> is <c>null</c> then this object will be its own pivot.
682 /// (Since EFL 1.22)</summary>
683 /// <param name="pivot">A pivot object for the light point, can be <c>null</c>.</param>
684 /// <param name="lx">X relative coordinate in space of light point.</param>
685 /// <param name="ly">Y relative coordinate in space of light point.</param>
686 /// <param name="lz">Z absolute coordinate in space of light point.</param>
687 /// <param name="lr">Light red value (0 - 255).</param>
688 /// <param name="lg">Light green value (0 - 255).</param>
689 /// <param name="lb">Light blue value (0 - 255).</param>
690 /// <param name="ar">Ambient color red value (0 - 255).</param>
691 /// <param name="ag">Ambient color green value (0 - 255).</param>
692 /// <param name="ab">Ambient color blue value (0 - 255).</param>
693 public void Lighting3d(Efl.Gfx.IEntity pivot, double lx, double ly, double lz, int lr, int lg, int lb, int ar, int ag, int ab) {
694 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_lighting_3d_ptr.Value.Delegate(this.NativeHandle,pivot, lx, ly, lz, lr, lg, lb, ar, ag, ab);
695 Eina.Error.RaiseIfUnhandledException();
697 /// <summary>Apply a perspective transform to the map
698 /// This applies a given perspective (3D) to the map coordinates. X, Y and Z values are used. The px and py points specify the "infinite distance" point in the 3D conversion (where all lines converge to like when artists draw 3D by hand). The <c>z0</c> value specifies the z value at which there is a 1:1 mapping between spatial coordinates and screen coordinates. Any points on this z value will not have their X and Y values modified in the transform. Those further away (Z value higher) will shrink into the distance, and those under this value will expand and become bigger. The <c>foc</c> value determines the "focal length" of the camera. This is in reality the distance between the camera lens plane itself (at or closer than this rendering results are undefined) and the "z0" z value. This allows for some "depth" control and <c>foc</c> must be greater than 0.
700 /// The coordinates are set relative to the given <c>pivot</c> object. If its geometry changes, then the absolute position of the rotation center will change accordingly. The Z position is absolute. If the <c>pivot</c> is <c>null</c> then this object will be its own pivot.
701 /// (Since EFL 1.22)</summary>
702 /// <param name="pivot">A pivot object for the infinite point, can be <c>null</c>.</param>
703 /// <param name="px">The perspective distance X relative coordinate.</param>
704 /// <param name="py">The perspective distance Y relative coordinate.</param>
705 /// <param name="z0">The "0" Z plane value.</param>
706 /// <param name="foc">The focal distance, must be greater than 0.</param>
707 public void Perspective3d(Efl.Gfx.IEntity pivot, double px, double py, double z0, double foc) {
708 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_perspective_3d_ptr.Value.Delegate(this.NativeHandle,pivot, px, py, z0, foc);
709 Eina.Error.RaiseIfUnhandledException();
711 /// <summary>Apply a rotation to the object, using absolute coordinates.
712 /// This rotates the object clockwise by <c>degrees</c> degrees, around the center specified by the relative position (<c>cx</c>, <c>cy</c>) in the <c>pivot</c> object. If <c>pivot</c> is <c>null</c> then this object is used as its own pivot center. 360 degrees is a full rotation, equivalent to no rotation. Negative values for <c>degrees</c> will rotate clockwise by that amount.
714 /// The given coordinates are absolute values in pixels. See also <see cref="Efl.Gfx.IMapping.Rotate"/> for a relative coordinate version.
715 /// (Since EFL 1.22)</summary>
716 /// <param name="degrees">CCW rotation in degrees.</param>
717 /// <param name="cx">X absolute coordinate in pixels of the center point.</param>
718 /// <param name="cy">y absolute coordinate in pixels of the center point.</param>
719 public void RotateAbsolute(double degrees, double cx, double cy) {
720 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_absolute_ptr.Value.Delegate(this.NativeHandle,degrees, cx, cy);
721 Eina.Error.RaiseIfUnhandledException();
723 /// <summary>Rotate the object around 3 axes in 3D, using absolute coordinates.
724 /// This will rotate in 3D and not just around the "Z" axis as the case with <see cref="Efl.Gfx.IMapping.Rotate"/>. This will rotate around the X, Y and Z axes. The Z axis points "into" the screen with low values at the screen and higher values further away. The X axis runs from left to right on the screen and the Y axis from top to bottom.
726 /// The coordinates of the center point are given in absolute canvas coordinates. See also <see cref="Efl.Gfx.IMapping.Rotate3d"/> for a pivot-based 3D rotation.
727 /// (Since EFL 1.22)</summary>
728 /// <param name="dx">Rotation in degrees around X axis (0 to 360).</param>
729 /// <param name="dy">Rotation in degrees around Y axis (0 to 360).</param>
730 /// <param name="dz">Rotation in degrees around Z axis (0 to 360).</param>
731 /// <param name="cx">X absolute coordinate in pixels of the center point.</param>
732 /// <param name="cy">y absolute coordinate in pixels of the center point.</param>
733 /// <param name="cz">Z absolute coordinate of the center point.</param>
734 public void Rotate3dAbsolute(double dx, double dy, double dz, double cx, double cy, double cz) {
735 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_3d_absolute_ptr.Value.Delegate(this.NativeHandle,dx, dy, dz, cx, cy, cz);
736 Eina.Error.RaiseIfUnhandledException();
738 /// <summary>Rotate the object in 3D using a unit quaternion, using absolute coordinates.
739 /// This is similar to <see cref="Efl.Gfx.IMapping.Rotate3d"/> but uses a unit quaternion (also known as versor) rather than a direct angle-based rotation around a center point. Use this to avoid gimbal locks.
741 /// The coordinates of the center point are given in absolute canvas coordinates. See also <see cref="Efl.Gfx.IMapping.RotateQuat"/> for a pivot-based 3D rotation.
742 /// (Since EFL 1.22)</summary>
743 /// <param name="qx">The x component of the imaginary part of the quaternion.</param>
744 /// <param name="qy">The y component of the imaginary part of the quaternion.</param>
745 /// <param name="qz">The z component of the imaginary part of the quaternion.</param>
746 /// <param name="qw">The w component of the real part of the quaternion.</param>
747 /// <param name="cx">X absolute coordinate in pixels of the center point.</param>
748 /// <param name="cy">y absolute coordinate in pixels of the center point.</param>
749 /// <param name="cz">Z absolute coordinate of the center point.</param>
750 public void RotateQuatAbsolute(double qx, double qy, double qz, double qw, double cx, double cy, double cz) {
751 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_quat_absolute_ptr.Value.Delegate(this.NativeHandle,qx, qy, qz, qw, cx, cy, cz);
752 Eina.Error.RaiseIfUnhandledException();
754 /// <summary>Apply a zoom to the object, using absolute coordinates.
755 /// This zooms the points of the map from a center point. That center is defined by <c>cx</c> and <c>cy</c>. The <c>zoomx</c> and <c>zoomy</c> parameters specify how much to zoom in the X and Y direction respectively. A value of 1.0 means "don't zoom". 2.0 means "double the size". 0.5 is "half the size" etc.
757 /// The coordinates of the center point are given in absolute canvas coordinates. See also <see cref="Efl.Gfx.IMapping.Zoom"/> for a pivot-based zoom.
758 /// (Since EFL 1.22)</summary>
759 /// <param name="zoomx">Zoom in X direction</param>
760 /// <param name="zoomy">Zoom in Y direction</param>
761 /// <param name="cx">X absolute coordinate in pixels of the center point.</param>
762 /// <param name="cy">y absolute coordinate in pixels of the center point.</param>
763 public void ZoomAbsolute(double zoomx, double zoomy, double cx, double cy) {
764 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_zoom_absolute_ptr.Value.Delegate(this.NativeHandle,zoomx, zoomy, cx, cy);
765 Eina.Error.RaiseIfUnhandledException();
767 /// <summary>Apply a lighting effect to the object.
768 /// This is used to apply lighting calculations (from a single light source) to a given mapped object. The RGB values of each vertex will be modified to reflect the lighting based on the light point coordinates, the light color, the ambient color and at what angle the map is facing the light source. A surface should have its points be declared in a clockwise fashion if the face is "facing" towards you (as opposed to away from you) as faces have a "logical" side for lighting.
770 /// The coordinates of the center point are given in absolute canvas coordinates. See also <see cref="Efl.Gfx.IMapping.Lighting3d"/> for a pivot-based lighting effect.
771 /// (Since EFL 1.22)</summary>
772 /// <param name="lx">X absolute coordinate in pixels of the light point.</param>
773 /// <param name="ly">y absolute coordinate in pixels of the light point.</param>
774 /// <param name="lz">Z absolute coordinate in space of light point.</param>
775 /// <param name="lr">Light red value (0 - 255).</param>
776 /// <param name="lg">Light green value (0 - 255).</param>
777 /// <param name="lb">Light blue value (0 - 255).</param>
778 /// <param name="ar">Ambient color red value (0 - 255).</param>
779 /// <param name="ag">Ambient color green value (0 - 255).</param>
780 /// <param name="ab">Ambient color blue value (0 - 255).</param>
781 public void Lighting3dAbsolute(double lx, double ly, double lz, int lr, int lg, int lb, int ar, int ag, int ab) {
782 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_lighting_3d_absolute_ptr.Value.Delegate(this.NativeHandle,lx, ly, lz, lr, lg, lb, ar, ag, ab);
783 Eina.Error.RaiseIfUnhandledException();
785 /// <summary>Apply a perspective transform to the map
786 /// This applies a given perspective (3D) to the map coordinates. X, Y and Z values are used. The px and py points specify the "infinite distance" point in the 3D conversion (where all lines converge to like when artists draw 3D by hand). The <c>z0</c> value specifies the z value at which there is a 1:1 mapping between spatial coordinates and screen coordinates. Any points on this z value will not have their X and Y values modified in the transform. Those further away (Z value higher) will shrink into the distance, and those less than this value will expand and become bigger. The <c>foc</c> value determines the "focal length" of the camera. This is in reality the distance between the camera lens plane itself (at or closer than this rendering results are undefined) and the "z0" z value. This allows for some "depth" control and <c>foc</c> must be greater than 0.
788 /// The coordinates of the center point are given in absolute canvas coordinates. See also <see cref="Efl.Gfx.IMapping.Perspective3d"/> for a pivot-based perspective effect.
789 /// (Since EFL 1.22)</summary>
790 /// <param name="px">The perspective distance X relative coordinate.</param>
791 /// <param name="py">The perspective distance Y relative coordinate.</param>
792 /// <param name="z0">The "0" Z plane value.</param>
793 /// <param name="foc">The focal distance, must be greater than 0.</param>
794 public void Perspective3dAbsolute(double px, double py, double z0, double foc) {
795 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_perspective_3d_absolute_ptr.Value.Delegate(this.NativeHandle,px, py, z0, foc);
796 Eina.Error.RaiseIfUnhandledException();
798 /// <summary>Number of points of a map.
799 /// This sets the number of points of map. Currently, the number of points must be multiples of 4.
800 /// (Since EFL 1.22)</summary>
801 /// <value>The number of points of map</value>
802 public int MappingPointCount {
803 get { return GetMappingPointCount(); }
804 set { SetMappingPointCount(value); }
806 /// <summary>Clockwise state of a map (read-only).
807 /// This determines if the output points (X and Y. Z is not used) are clockwise or counter-clockwise. This can be used for "back-face culling". This is where you hide objects that "face away" from you. In this case objects that are not clockwise.
808 /// (Since EFL 1.22)</summary>
809 /// <value><c>true</c> if clockwise, <c>false</c> if counter clockwise</value>
810 public bool MappingClockwise {
811 get { return GetMappingClockwise(); }
813 /// <summary>Smoothing state for map rendering.
814 /// This sets smoothing for map rendering. If the object is a type that has its own smoothing settings, then both the smooth settings for this object and the map must be turned off. By default smooth maps are enabled.
815 /// (Since EFL 1.22)</summary>
816 /// <value><c>true</c> by default.</value>
817 public bool MappingSmooth {
818 get { return GetMappingSmooth(); }
819 set { SetMappingSmooth(value); }
821 /// <summary>Alpha flag for map rendering.
822 /// This sets alpha flag for map rendering. If the object is a type that has its own alpha settings, then this will take precedence. Only image objects support this currently (<see cref="Efl.Canvas.Image"/> and its friends). Setting this to off stops alpha blending of the map area, and is useful if you know the object and/or all sub-objects is 100% solid.
824 /// Note that this may conflict with <see cref="Efl.Gfx.IMapping.MappingSmooth"/> depending on which algorithm is used for anti-aliasing.
825 /// (Since EFL 1.22)</summary>
826 /// <value><c>true</c> by default.</value>
827 public bool MappingAlpha {
828 get { return GetMappingAlpha(); }
829 set { SetMappingAlpha(value); }
831 private static IntPtr GetEflClassStatic()
833 return Efl.Gfx.IMappingConcrete.efl_gfx_mapping_mixin_get();
835 /// <summary>Wrapper for native methods and virtual method delegates.
836 /// For internal use by generated code only.</summary>
837 public class NativeMethods : Efl.Eo.NativeClass
839 private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule( efl.Libs.Evas);
840 /// <summary>Gets the list of Eo operations to override.</summary>
841 /// <returns>The list of Eo operations to be overload.</returns>
842 public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
844 var descs = new System.Collections.Generic.List<Efl_Op_Description>();
845 var methods = Efl.Eo.Globals.GetUserMethods(type);
847 if (efl_gfx_mapping_point_count_get_static_delegate == null)
849 efl_gfx_mapping_point_count_get_static_delegate = new efl_gfx_mapping_point_count_get_delegate(mapping_point_count_get);
852 if (methods.FirstOrDefault(m => m.Name == "GetMappingPointCount") != null)
854 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_point_count_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_point_count_get_static_delegate) });
857 if (efl_gfx_mapping_point_count_set_static_delegate == null)
859 efl_gfx_mapping_point_count_set_static_delegate = new efl_gfx_mapping_point_count_set_delegate(mapping_point_count_set);
862 if (methods.FirstOrDefault(m => m.Name == "SetMappingPointCount") != null)
864 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_point_count_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_point_count_set_static_delegate) });
867 if (efl_gfx_mapping_clockwise_get_static_delegate == null)
869 efl_gfx_mapping_clockwise_get_static_delegate = new efl_gfx_mapping_clockwise_get_delegate(mapping_clockwise_get);
872 if (methods.FirstOrDefault(m => m.Name == "GetMappingClockwise") != null)
874 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_clockwise_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_clockwise_get_static_delegate) });
877 if (efl_gfx_mapping_smooth_get_static_delegate == null)
879 efl_gfx_mapping_smooth_get_static_delegate = new efl_gfx_mapping_smooth_get_delegate(mapping_smooth_get);
882 if (methods.FirstOrDefault(m => m.Name == "GetMappingSmooth") != null)
884 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_smooth_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_smooth_get_static_delegate) });
887 if (efl_gfx_mapping_smooth_set_static_delegate == null)
889 efl_gfx_mapping_smooth_set_static_delegate = new efl_gfx_mapping_smooth_set_delegate(mapping_smooth_set);
892 if (methods.FirstOrDefault(m => m.Name == "SetMappingSmooth") != null)
894 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_smooth_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_smooth_set_static_delegate) });
897 if (efl_gfx_mapping_alpha_get_static_delegate == null)
899 efl_gfx_mapping_alpha_get_static_delegate = new efl_gfx_mapping_alpha_get_delegate(mapping_alpha_get);
902 if (methods.FirstOrDefault(m => m.Name == "GetMappingAlpha") != null)
904 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_alpha_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_alpha_get_static_delegate) });
907 if (efl_gfx_mapping_alpha_set_static_delegate == null)
909 efl_gfx_mapping_alpha_set_static_delegate = new efl_gfx_mapping_alpha_set_delegate(mapping_alpha_set);
912 if (methods.FirstOrDefault(m => m.Name == "SetMappingAlpha") != null)
914 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_alpha_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_alpha_set_static_delegate) });
917 if (efl_gfx_mapping_coord_absolute_get_static_delegate == null)
919 efl_gfx_mapping_coord_absolute_get_static_delegate = new efl_gfx_mapping_coord_absolute_get_delegate(mapping_coord_absolute_get);
922 if (methods.FirstOrDefault(m => m.Name == "GetMappingCoordAbsolute") != null)
924 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_coord_absolute_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_coord_absolute_get_static_delegate) });
927 if (efl_gfx_mapping_coord_absolute_set_static_delegate == null)
929 efl_gfx_mapping_coord_absolute_set_static_delegate = new efl_gfx_mapping_coord_absolute_set_delegate(mapping_coord_absolute_set);
932 if (methods.FirstOrDefault(m => m.Name == "SetMappingCoordAbsolute") != null)
934 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_coord_absolute_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_coord_absolute_set_static_delegate) });
937 if (efl_gfx_mapping_uv_get_static_delegate == null)
939 efl_gfx_mapping_uv_get_static_delegate = new efl_gfx_mapping_uv_get_delegate(mapping_uv_get);
942 if (methods.FirstOrDefault(m => m.Name == "GetMappingUv") != null)
944 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_uv_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_uv_get_static_delegate) });
947 if (efl_gfx_mapping_uv_set_static_delegate == null)
949 efl_gfx_mapping_uv_set_static_delegate = new efl_gfx_mapping_uv_set_delegate(mapping_uv_set);
952 if (methods.FirstOrDefault(m => m.Name == "SetMappingUv") != null)
954 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_uv_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_uv_set_static_delegate) });
957 if (efl_gfx_mapping_color_get_static_delegate == null)
959 efl_gfx_mapping_color_get_static_delegate = new efl_gfx_mapping_color_get_delegate(mapping_color_get);
962 if (methods.FirstOrDefault(m => m.Name == "GetMappingColor") != null)
964 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_color_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_color_get_static_delegate) });
967 if (efl_gfx_mapping_color_set_static_delegate == null)
969 efl_gfx_mapping_color_set_static_delegate = new efl_gfx_mapping_color_set_delegate(mapping_color_set);
972 if (methods.FirstOrDefault(m => m.Name == "SetMappingColor") != null)
974 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_color_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_color_set_static_delegate) });
977 if (efl_gfx_mapping_has_static_delegate == null)
979 efl_gfx_mapping_has_static_delegate = new efl_gfx_mapping_has_delegate(mapping_has);
982 if (methods.FirstOrDefault(m => m.Name == "HasMapping") != null)
984 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_has"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_has_static_delegate) });
987 if (efl_gfx_mapping_reset_static_delegate == null)
989 efl_gfx_mapping_reset_static_delegate = new efl_gfx_mapping_reset_delegate(mapping_reset);
992 if (methods.FirstOrDefault(m => m.Name == "ResetMapping") != null)
994 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_reset"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_reset_static_delegate) });
997 if (efl_gfx_mapping_translate_static_delegate == null)
999 efl_gfx_mapping_translate_static_delegate = new efl_gfx_mapping_translate_delegate(translate);
1002 if (methods.FirstOrDefault(m => m.Name == "Translate") != null)
1004 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_translate"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_translate_static_delegate) });
1007 if (efl_gfx_mapping_rotate_static_delegate == null)
1009 efl_gfx_mapping_rotate_static_delegate = new efl_gfx_mapping_rotate_delegate(rotate);
1012 if (methods.FirstOrDefault(m => m.Name == "Rotate") != null)
1014 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_rotate"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_rotate_static_delegate) });
1017 if (efl_gfx_mapping_rotate_3d_static_delegate == null)
1019 efl_gfx_mapping_rotate_3d_static_delegate = new efl_gfx_mapping_rotate_3d_delegate(rotate_3d);
1022 if (methods.FirstOrDefault(m => m.Name == "Rotate3d") != null)
1024 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_rotate_3d"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_rotate_3d_static_delegate) });
1027 if (efl_gfx_mapping_rotate_quat_static_delegate == null)
1029 efl_gfx_mapping_rotate_quat_static_delegate = new efl_gfx_mapping_rotate_quat_delegate(rotate_quat);
1032 if (methods.FirstOrDefault(m => m.Name == "RotateQuat") != null)
1034 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_rotate_quat"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_rotate_quat_static_delegate) });
1037 if (efl_gfx_mapping_zoom_static_delegate == null)
1039 efl_gfx_mapping_zoom_static_delegate = new efl_gfx_mapping_zoom_delegate(zoom);
1042 if (methods.FirstOrDefault(m => m.Name == "Zoom") != null)
1044 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_zoom"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_zoom_static_delegate) });
1047 if (efl_gfx_mapping_lighting_3d_static_delegate == null)
1049 efl_gfx_mapping_lighting_3d_static_delegate = new efl_gfx_mapping_lighting_3d_delegate(lighting_3d);
1052 if (methods.FirstOrDefault(m => m.Name == "Lighting3d") != null)
1054 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_lighting_3d"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_lighting_3d_static_delegate) });
1057 if (efl_gfx_mapping_perspective_3d_static_delegate == null)
1059 efl_gfx_mapping_perspective_3d_static_delegate = new efl_gfx_mapping_perspective_3d_delegate(perspective_3d);
1062 if (methods.FirstOrDefault(m => m.Name == "Perspective3d") != null)
1064 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_perspective_3d"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_perspective_3d_static_delegate) });
1067 if (efl_gfx_mapping_rotate_absolute_static_delegate == null)
1069 efl_gfx_mapping_rotate_absolute_static_delegate = new efl_gfx_mapping_rotate_absolute_delegate(rotate_absolute);
1072 if (methods.FirstOrDefault(m => m.Name == "RotateAbsolute") != null)
1074 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_rotate_absolute"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_rotate_absolute_static_delegate) });
1077 if (efl_gfx_mapping_rotate_3d_absolute_static_delegate == null)
1079 efl_gfx_mapping_rotate_3d_absolute_static_delegate = new efl_gfx_mapping_rotate_3d_absolute_delegate(rotate_3d_absolute);
1082 if (methods.FirstOrDefault(m => m.Name == "Rotate3dAbsolute") != null)
1084 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_rotate_3d_absolute"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_rotate_3d_absolute_static_delegate) });
1087 if (efl_gfx_mapping_rotate_quat_absolute_static_delegate == null)
1089 efl_gfx_mapping_rotate_quat_absolute_static_delegate = new efl_gfx_mapping_rotate_quat_absolute_delegate(rotate_quat_absolute);
1092 if (methods.FirstOrDefault(m => m.Name == "RotateQuatAbsolute") != null)
1094 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_rotate_quat_absolute"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_rotate_quat_absolute_static_delegate) });
1097 if (efl_gfx_mapping_zoom_absolute_static_delegate == null)
1099 efl_gfx_mapping_zoom_absolute_static_delegate = new efl_gfx_mapping_zoom_absolute_delegate(zoom_absolute);
1102 if (methods.FirstOrDefault(m => m.Name == "ZoomAbsolute") != null)
1104 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_zoom_absolute"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_zoom_absolute_static_delegate) });
1107 if (efl_gfx_mapping_lighting_3d_absolute_static_delegate == null)
1109 efl_gfx_mapping_lighting_3d_absolute_static_delegate = new efl_gfx_mapping_lighting_3d_absolute_delegate(lighting_3d_absolute);
1112 if (methods.FirstOrDefault(m => m.Name == "Lighting3dAbsolute") != null)
1114 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_lighting_3d_absolute"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_lighting_3d_absolute_static_delegate) });
1117 if (efl_gfx_mapping_perspective_3d_absolute_static_delegate == null)
1119 efl_gfx_mapping_perspective_3d_absolute_static_delegate = new efl_gfx_mapping_perspective_3d_absolute_delegate(perspective_3d_absolute);
1122 if (methods.FirstOrDefault(m => m.Name == "Perspective3dAbsolute") != null)
1124 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_perspective_3d_absolute"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_perspective_3d_absolute_static_delegate) });
1129 /// <summary>Returns the Eo class for the native methods of this class.</summary>
1130 /// <returns>The native class pointer.</returns>
1131 public override IntPtr GetEflClass()
1133 return Efl.Gfx.IMappingConcrete.efl_gfx_mapping_mixin_get();
1136 #pragma warning disable CA1707, SA1300, SA1600
1139 private delegate int efl_gfx_mapping_point_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
1142 public delegate int efl_gfx_mapping_point_count_get_api_delegate(System.IntPtr obj);
1144 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_point_count_get_api_delegate> efl_gfx_mapping_point_count_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_point_count_get_api_delegate>(Module, "efl_gfx_mapping_point_count_get");
1146 private static int mapping_point_count_get(System.IntPtr obj, System.IntPtr pd)
1148 Eina.Log.Debug("function efl_gfx_mapping_point_count_get was called");
1149 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1150 if (wrapper != null)
1152 int _ret_var = default(int);
1155 _ret_var = ((IMappingConcrete)wrapper).GetMappingPointCount();
1159 Eina.Log.Warning($"Callback error: {e.ToString()}");
1160 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1168 return efl_gfx_mapping_point_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1172 private static efl_gfx_mapping_point_count_get_delegate efl_gfx_mapping_point_count_get_static_delegate;
1175 private delegate void efl_gfx_mapping_point_count_set_delegate(System.IntPtr obj, System.IntPtr pd, int count);
1178 public delegate void efl_gfx_mapping_point_count_set_api_delegate(System.IntPtr obj, int count);
1180 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_point_count_set_api_delegate> efl_gfx_mapping_point_count_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_point_count_set_api_delegate>(Module, "efl_gfx_mapping_point_count_set");
1182 private static void mapping_point_count_set(System.IntPtr obj, System.IntPtr pd, int count)
1184 Eina.Log.Debug("function efl_gfx_mapping_point_count_set was called");
1185 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1186 if (wrapper != null)
1191 ((IMappingConcrete)wrapper).SetMappingPointCount(count);
1195 Eina.Log.Warning($"Callback error: {e.ToString()}");
1196 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1203 efl_gfx_mapping_point_count_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), count);
1207 private static efl_gfx_mapping_point_count_set_delegate efl_gfx_mapping_point_count_set_static_delegate;
1209 [return: MarshalAs(UnmanagedType.U1)]
1210 private delegate bool efl_gfx_mapping_clockwise_get_delegate(System.IntPtr obj, System.IntPtr pd);
1212 [return: MarshalAs(UnmanagedType.U1)]
1213 public delegate bool efl_gfx_mapping_clockwise_get_api_delegate(System.IntPtr obj);
1215 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_clockwise_get_api_delegate> efl_gfx_mapping_clockwise_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_clockwise_get_api_delegate>(Module, "efl_gfx_mapping_clockwise_get");
1217 private static bool mapping_clockwise_get(System.IntPtr obj, System.IntPtr pd)
1219 Eina.Log.Debug("function efl_gfx_mapping_clockwise_get was called");
1220 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1221 if (wrapper != null)
1223 bool _ret_var = default(bool);
1226 _ret_var = ((IMappingConcrete)wrapper).GetMappingClockwise();
1230 Eina.Log.Warning($"Callback error: {e.ToString()}");
1231 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1239 return efl_gfx_mapping_clockwise_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1243 private static efl_gfx_mapping_clockwise_get_delegate efl_gfx_mapping_clockwise_get_static_delegate;
1245 [return: MarshalAs(UnmanagedType.U1)]
1246 private delegate bool efl_gfx_mapping_smooth_get_delegate(System.IntPtr obj, System.IntPtr pd);
1248 [return: MarshalAs(UnmanagedType.U1)]
1249 public delegate bool efl_gfx_mapping_smooth_get_api_delegate(System.IntPtr obj);
1251 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_smooth_get_api_delegate> efl_gfx_mapping_smooth_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_smooth_get_api_delegate>(Module, "efl_gfx_mapping_smooth_get");
1253 private static bool mapping_smooth_get(System.IntPtr obj, System.IntPtr pd)
1255 Eina.Log.Debug("function efl_gfx_mapping_smooth_get was called");
1256 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1257 if (wrapper != null)
1259 bool _ret_var = default(bool);
1262 _ret_var = ((IMappingConcrete)wrapper).GetMappingSmooth();
1266 Eina.Log.Warning($"Callback error: {e.ToString()}");
1267 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1275 return efl_gfx_mapping_smooth_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1279 private static efl_gfx_mapping_smooth_get_delegate efl_gfx_mapping_smooth_get_static_delegate;
1282 private delegate void efl_gfx_mapping_smooth_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool smooth);
1285 public delegate void efl_gfx_mapping_smooth_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool smooth);
1287 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_smooth_set_api_delegate> efl_gfx_mapping_smooth_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_smooth_set_api_delegate>(Module, "efl_gfx_mapping_smooth_set");
1289 private static void mapping_smooth_set(System.IntPtr obj, System.IntPtr pd, bool smooth)
1291 Eina.Log.Debug("function efl_gfx_mapping_smooth_set was called");
1292 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1293 if (wrapper != null)
1298 ((IMappingConcrete)wrapper).SetMappingSmooth(smooth);
1302 Eina.Log.Warning($"Callback error: {e.ToString()}");
1303 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1310 efl_gfx_mapping_smooth_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), smooth);
1314 private static efl_gfx_mapping_smooth_set_delegate efl_gfx_mapping_smooth_set_static_delegate;
1316 [return: MarshalAs(UnmanagedType.U1)]
1317 private delegate bool efl_gfx_mapping_alpha_get_delegate(System.IntPtr obj, System.IntPtr pd);
1319 [return: MarshalAs(UnmanagedType.U1)]
1320 public delegate bool efl_gfx_mapping_alpha_get_api_delegate(System.IntPtr obj);
1322 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_alpha_get_api_delegate> efl_gfx_mapping_alpha_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_alpha_get_api_delegate>(Module, "efl_gfx_mapping_alpha_get");
1324 private static bool mapping_alpha_get(System.IntPtr obj, System.IntPtr pd)
1326 Eina.Log.Debug("function efl_gfx_mapping_alpha_get was called");
1327 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1328 if (wrapper != null)
1330 bool _ret_var = default(bool);
1333 _ret_var = ((IMappingConcrete)wrapper).GetMappingAlpha();
1337 Eina.Log.Warning($"Callback error: {e.ToString()}");
1338 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1346 return efl_gfx_mapping_alpha_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1350 private static efl_gfx_mapping_alpha_get_delegate efl_gfx_mapping_alpha_get_static_delegate;
1353 private delegate void efl_gfx_mapping_alpha_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool alpha);
1356 public delegate void efl_gfx_mapping_alpha_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool alpha);
1358 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_alpha_set_api_delegate> efl_gfx_mapping_alpha_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_alpha_set_api_delegate>(Module, "efl_gfx_mapping_alpha_set");
1360 private static void mapping_alpha_set(System.IntPtr obj, System.IntPtr pd, bool alpha)
1362 Eina.Log.Debug("function efl_gfx_mapping_alpha_set was called");
1363 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1364 if (wrapper != null)
1369 ((IMappingConcrete)wrapper).SetMappingAlpha(alpha);
1373 Eina.Log.Warning($"Callback error: {e.ToString()}");
1374 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1381 efl_gfx_mapping_alpha_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), alpha);
1385 private static efl_gfx_mapping_alpha_set_delegate efl_gfx_mapping_alpha_set_static_delegate;
1388 private delegate void efl_gfx_mapping_coord_absolute_get_delegate(System.IntPtr obj, System.IntPtr pd, int idx, out double x, out double y, out double z);
1391 public delegate void efl_gfx_mapping_coord_absolute_get_api_delegate(System.IntPtr obj, int idx, out double x, out double y, out double z);
1393 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_coord_absolute_get_api_delegate> efl_gfx_mapping_coord_absolute_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_coord_absolute_get_api_delegate>(Module, "efl_gfx_mapping_coord_absolute_get");
1395 private static void mapping_coord_absolute_get(System.IntPtr obj, System.IntPtr pd, int idx, out double x, out double y, out double z)
1397 Eina.Log.Debug("function efl_gfx_mapping_coord_absolute_get was called");
1398 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1399 if (wrapper != null)
1401 x = default(double); y = default(double); z = default(double);
1404 ((IMappingConcrete)wrapper).GetMappingCoordAbsolute(idx, out x, out y, out z);
1408 Eina.Log.Warning($"Callback error: {e.ToString()}");
1409 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1416 efl_gfx_mapping_coord_absolute_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), idx, out x, out y, out z);
1420 private static efl_gfx_mapping_coord_absolute_get_delegate efl_gfx_mapping_coord_absolute_get_static_delegate;
1423 private delegate void efl_gfx_mapping_coord_absolute_set_delegate(System.IntPtr obj, System.IntPtr pd, int idx, double x, double y, double z);
1426 public delegate void efl_gfx_mapping_coord_absolute_set_api_delegate(System.IntPtr obj, int idx, double x, double y, double z);
1428 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_coord_absolute_set_api_delegate> efl_gfx_mapping_coord_absolute_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_coord_absolute_set_api_delegate>(Module, "efl_gfx_mapping_coord_absolute_set");
1430 private static void mapping_coord_absolute_set(System.IntPtr obj, System.IntPtr pd, int idx, double x, double y, double z)
1432 Eina.Log.Debug("function efl_gfx_mapping_coord_absolute_set was called");
1433 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1434 if (wrapper != null)
1439 ((IMappingConcrete)wrapper).SetMappingCoordAbsolute(idx, x, y, z);
1443 Eina.Log.Warning($"Callback error: {e.ToString()}");
1444 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1451 efl_gfx_mapping_coord_absolute_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), idx, x, y, z);
1455 private static efl_gfx_mapping_coord_absolute_set_delegate efl_gfx_mapping_coord_absolute_set_static_delegate;
1458 private delegate void efl_gfx_mapping_uv_get_delegate(System.IntPtr obj, System.IntPtr pd, int idx, out double u, out double v);
1461 public delegate void efl_gfx_mapping_uv_get_api_delegate(System.IntPtr obj, int idx, out double u, out double v);
1463 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_uv_get_api_delegate> efl_gfx_mapping_uv_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_uv_get_api_delegate>(Module, "efl_gfx_mapping_uv_get");
1465 private static void mapping_uv_get(System.IntPtr obj, System.IntPtr pd, int idx, out double u, out double v)
1467 Eina.Log.Debug("function efl_gfx_mapping_uv_get was called");
1468 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1469 if (wrapper != null)
1471 u = default(double); v = default(double);
1474 ((IMappingConcrete)wrapper).GetMappingUv(idx, out u, out v);
1478 Eina.Log.Warning($"Callback error: {e.ToString()}");
1479 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1486 efl_gfx_mapping_uv_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), idx, out u, out v);
1490 private static efl_gfx_mapping_uv_get_delegate efl_gfx_mapping_uv_get_static_delegate;
1493 private delegate void efl_gfx_mapping_uv_set_delegate(System.IntPtr obj, System.IntPtr pd, int idx, double u, double v);
1496 public delegate void efl_gfx_mapping_uv_set_api_delegate(System.IntPtr obj, int idx, double u, double v);
1498 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_uv_set_api_delegate> efl_gfx_mapping_uv_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_uv_set_api_delegate>(Module, "efl_gfx_mapping_uv_set");
1500 private static void mapping_uv_set(System.IntPtr obj, System.IntPtr pd, int idx, double u, double v)
1502 Eina.Log.Debug("function efl_gfx_mapping_uv_set was called");
1503 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1504 if (wrapper != null)
1509 ((IMappingConcrete)wrapper).SetMappingUv(idx, u, v);
1513 Eina.Log.Warning($"Callback error: {e.ToString()}");
1514 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1521 efl_gfx_mapping_uv_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), idx, u, v);
1525 private static efl_gfx_mapping_uv_set_delegate efl_gfx_mapping_uv_set_static_delegate;
1528 private delegate void efl_gfx_mapping_color_get_delegate(System.IntPtr obj, System.IntPtr pd, int idx, out int r, out int g, out int b, out int a);
1531 public delegate void efl_gfx_mapping_color_get_api_delegate(System.IntPtr obj, int idx, out int r, out int g, out int b, out int a);
1533 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_color_get_api_delegate> efl_gfx_mapping_color_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_color_get_api_delegate>(Module, "efl_gfx_mapping_color_get");
1535 private static void mapping_color_get(System.IntPtr obj, System.IntPtr pd, int idx, out int r, out int g, out int b, out int a)
1537 Eina.Log.Debug("function efl_gfx_mapping_color_get was called");
1538 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1539 if (wrapper != null)
1541 r = default(int); g = default(int); b = default(int); a = default(int);
1544 ((IMappingConcrete)wrapper).GetMappingColor(idx, out r, out g, out b, out a);
1548 Eina.Log.Warning($"Callback error: {e.ToString()}");
1549 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1556 efl_gfx_mapping_color_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), idx, out r, out g, out b, out a);
1560 private static efl_gfx_mapping_color_get_delegate efl_gfx_mapping_color_get_static_delegate;
1563 private delegate void efl_gfx_mapping_color_set_delegate(System.IntPtr obj, System.IntPtr pd, int idx, int r, int g, int b, int a);
1566 public delegate void efl_gfx_mapping_color_set_api_delegate(System.IntPtr obj, int idx, int r, int g, int b, int a);
1568 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_color_set_api_delegate> efl_gfx_mapping_color_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_color_set_api_delegate>(Module, "efl_gfx_mapping_color_set");
1570 private static void mapping_color_set(System.IntPtr obj, System.IntPtr pd, int idx, int r, int g, int b, int a)
1572 Eina.Log.Debug("function efl_gfx_mapping_color_set was called");
1573 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1574 if (wrapper != null)
1579 ((IMappingConcrete)wrapper).SetMappingColor(idx, r, g, b, a);
1583 Eina.Log.Warning($"Callback error: {e.ToString()}");
1584 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1591 efl_gfx_mapping_color_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), idx, r, g, b, a);
1595 private static efl_gfx_mapping_color_set_delegate efl_gfx_mapping_color_set_static_delegate;
1597 [return: MarshalAs(UnmanagedType.U1)]
1598 private delegate bool efl_gfx_mapping_has_delegate(System.IntPtr obj, System.IntPtr pd);
1600 [return: MarshalAs(UnmanagedType.U1)]
1601 public delegate bool efl_gfx_mapping_has_api_delegate(System.IntPtr obj);
1603 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_has_api_delegate> efl_gfx_mapping_has_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_has_api_delegate>(Module, "efl_gfx_mapping_has");
1605 private static bool mapping_has(System.IntPtr obj, System.IntPtr pd)
1607 Eina.Log.Debug("function efl_gfx_mapping_has was called");
1608 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1609 if (wrapper != null)
1611 bool _ret_var = default(bool);
1614 _ret_var = ((IMappingConcrete)wrapper).HasMapping();
1618 Eina.Log.Warning($"Callback error: {e.ToString()}");
1619 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1627 return efl_gfx_mapping_has_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1631 private static efl_gfx_mapping_has_delegate efl_gfx_mapping_has_static_delegate;
1634 private delegate void efl_gfx_mapping_reset_delegate(System.IntPtr obj, System.IntPtr pd);
1637 public delegate void efl_gfx_mapping_reset_api_delegate(System.IntPtr obj);
1639 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_reset_api_delegate> efl_gfx_mapping_reset_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_reset_api_delegate>(Module, "efl_gfx_mapping_reset");
1641 private static void mapping_reset(System.IntPtr obj, System.IntPtr pd)
1643 Eina.Log.Debug("function efl_gfx_mapping_reset was called");
1644 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1645 if (wrapper != null)
1650 ((IMappingConcrete)wrapper).ResetMapping();
1654 Eina.Log.Warning($"Callback error: {e.ToString()}");
1655 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1662 efl_gfx_mapping_reset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1666 private static efl_gfx_mapping_reset_delegate efl_gfx_mapping_reset_static_delegate;
1669 private delegate void efl_gfx_mapping_translate_delegate(System.IntPtr obj, System.IntPtr pd, double dx, double dy, double dz);
1672 public delegate void efl_gfx_mapping_translate_api_delegate(System.IntPtr obj, double dx, double dy, double dz);
1674 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_translate_api_delegate> efl_gfx_mapping_translate_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_translate_api_delegate>(Module, "efl_gfx_mapping_translate");
1676 private static void translate(System.IntPtr obj, System.IntPtr pd, double dx, double dy, double dz)
1678 Eina.Log.Debug("function efl_gfx_mapping_translate was called");
1679 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1680 if (wrapper != null)
1685 ((IMappingConcrete)wrapper).Translate(dx, dy, dz);
1689 Eina.Log.Warning($"Callback error: {e.ToString()}");
1690 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1697 efl_gfx_mapping_translate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dx, dy, dz);
1701 private static efl_gfx_mapping_translate_delegate efl_gfx_mapping_translate_static_delegate;
1704 private delegate void efl_gfx_mapping_rotate_delegate(System.IntPtr obj, System.IntPtr pd, double degrees, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot, double cx, double cy);
1707 public delegate void efl_gfx_mapping_rotate_api_delegate(System.IntPtr obj, double degrees, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot, double cx, double cy);
1709 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_api_delegate> efl_gfx_mapping_rotate_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_api_delegate>(Module, "efl_gfx_mapping_rotate");
1711 private static void rotate(System.IntPtr obj, System.IntPtr pd, double degrees, Efl.Gfx.IEntity pivot, double cx, double cy)
1713 Eina.Log.Debug("function efl_gfx_mapping_rotate was called");
1714 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1715 if (wrapper != null)
1720 ((IMappingConcrete)wrapper).Rotate(degrees, pivot, cx, cy);
1724 Eina.Log.Warning($"Callback error: {e.ToString()}");
1725 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1732 efl_gfx_mapping_rotate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), degrees, pivot, cx, cy);
1736 private static efl_gfx_mapping_rotate_delegate efl_gfx_mapping_rotate_static_delegate;
1739 private delegate void efl_gfx_mapping_rotate_3d_delegate(System.IntPtr obj, System.IntPtr pd, double dx, double dy, double dz, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot, double cx, double cy, double cz);
1742 public delegate void efl_gfx_mapping_rotate_3d_api_delegate(System.IntPtr obj, double dx, double dy, double dz, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot, double cx, double cy, double cz);
1744 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_3d_api_delegate> efl_gfx_mapping_rotate_3d_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_3d_api_delegate>(Module, "efl_gfx_mapping_rotate_3d");
1746 private static void rotate_3d(System.IntPtr obj, System.IntPtr pd, double dx, double dy, double dz, Efl.Gfx.IEntity pivot, double cx, double cy, double cz)
1748 Eina.Log.Debug("function efl_gfx_mapping_rotate_3d was called");
1749 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1750 if (wrapper != null)
1755 ((IMappingConcrete)wrapper).Rotate3d(dx, dy, dz, pivot, cx, cy, cz);
1759 Eina.Log.Warning($"Callback error: {e.ToString()}");
1760 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1767 efl_gfx_mapping_rotate_3d_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dx, dy, dz, pivot, cx, cy, cz);
1771 private static efl_gfx_mapping_rotate_3d_delegate efl_gfx_mapping_rotate_3d_static_delegate;
1774 private delegate void efl_gfx_mapping_rotate_quat_delegate(System.IntPtr obj, System.IntPtr pd, double qx, double qy, double qz, double qw, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot, double cx, double cy, double cz);
1777 public delegate void efl_gfx_mapping_rotate_quat_api_delegate(System.IntPtr obj, double qx, double qy, double qz, double qw, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot, double cx, double cy, double cz);
1779 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_quat_api_delegate> efl_gfx_mapping_rotate_quat_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_quat_api_delegate>(Module, "efl_gfx_mapping_rotate_quat");
1781 private static void rotate_quat(System.IntPtr obj, System.IntPtr pd, double qx, double qy, double qz, double qw, Efl.Gfx.IEntity pivot, double cx, double cy, double cz)
1783 Eina.Log.Debug("function efl_gfx_mapping_rotate_quat was called");
1784 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1785 if (wrapper != null)
1790 ((IMappingConcrete)wrapper).RotateQuat(qx, qy, qz, qw, pivot, cx, cy, cz);
1794 Eina.Log.Warning($"Callback error: {e.ToString()}");
1795 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1802 efl_gfx_mapping_rotate_quat_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), qx, qy, qz, qw, pivot, cx, cy, cz);
1806 private static efl_gfx_mapping_rotate_quat_delegate efl_gfx_mapping_rotate_quat_static_delegate;
1809 private delegate void efl_gfx_mapping_zoom_delegate(System.IntPtr obj, System.IntPtr pd, double zoomx, double zoomy, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot, double cx, double cy);
1812 public delegate void efl_gfx_mapping_zoom_api_delegate(System.IntPtr obj, double zoomx, double zoomy, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot, double cx, double cy);
1814 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_zoom_api_delegate> efl_gfx_mapping_zoom_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_zoom_api_delegate>(Module, "efl_gfx_mapping_zoom");
1816 private static void zoom(System.IntPtr obj, System.IntPtr pd, double zoomx, double zoomy, Efl.Gfx.IEntity pivot, double cx, double cy)
1818 Eina.Log.Debug("function efl_gfx_mapping_zoom was called");
1819 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1820 if (wrapper != null)
1825 ((IMappingConcrete)wrapper).Zoom(zoomx, zoomy, pivot, cx, cy);
1829 Eina.Log.Warning($"Callback error: {e.ToString()}");
1830 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1837 efl_gfx_mapping_zoom_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), zoomx, zoomy, pivot, cx, cy);
1841 private static efl_gfx_mapping_zoom_delegate efl_gfx_mapping_zoom_static_delegate;
1844 private delegate void efl_gfx_mapping_lighting_3d_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot, double lx, double ly, double lz, int lr, int lg, int lb, int ar, int ag, int ab);
1847 public delegate void efl_gfx_mapping_lighting_3d_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot, double lx, double ly, double lz, int lr, int lg, int lb, int ar, int ag, int ab);
1849 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_lighting_3d_api_delegate> efl_gfx_mapping_lighting_3d_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_lighting_3d_api_delegate>(Module, "efl_gfx_mapping_lighting_3d");
1851 private static void lighting_3d(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity pivot, double lx, double ly, double lz, int lr, int lg, int lb, int ar, int ag, int ab)
1853 Eina.Log.Debug("function efl_gfx_mapping_lighting_3d was called");
1854 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1855 if (wrapper != null)
1860 ((IMappingConcrete)wrapper).Lighting3d(pivot, lx, ly, lz, lr, lg, lb, ar, ag, ab);
1864 Eina.Log.Warning($"Callback error: {e.ToString()}");
1865 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1872 efl_gfx_mapping_lighting_3d_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pivot, lx, ly, lz, lr, lg, lb, ar, ag, ab);
1876 private static efl_gfx_mapping_lighting_3d_delegate efl_gfx_mapping_lighting_3d_static_delegate;
1879 private delegate void efl_gfx_mapping_perspective_3d_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot, double px, double py, double z0, double foc);
1882 public delegate void efl_gfx_mapping_perspective_3d_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot, double px, double py, double z0, double foc);
1884 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_perspective_3d_api_delegate> efl_gfx_mapping_perspective_3d_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_perspective_3d_api_delegate>(Module, "efl_gfx_mapping_perspective_3d");
1886 private static void perspective_3d(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity pivot, double px, double py, double z0, double foc)
1888 Eina.Log.Debug("function efl_gfx_mapping_perspective_3d was called");
1889 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1890 if (wrapper != null)
1895 ((IMappingConcrete)wrapper).Perspective3d(pivot, px, py, z0, foc);
1899 Eina.Log.Warning($"Callback error: {e.ToString()}");
1900 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1907 efl_gfx_mapping_perspective_3d_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pivot, px, py, z0, foc);
1911 private static efl_gfx_mapping_perspective_3d_delegate efl_gfx_mapping_perspective_3d_static_delegate;
1914 private delegate void efl_gfx_mapping_rotate_absolute_delegate(System.IntPtr obj, System.IntPtr pd, double degrees, double cx, double cy);
1917 public delegate void efl_gfx_mapping_rotate_absolute_api_delegate(System.IntPtr obj, double degrees, double cx, double cy);
1919 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_absolute_api_delegate> efl_gfx_mapping_rotate_absolute_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_absolute_api_delegate>(Module, "efl_gfx_mapping_rotate_absolute");
1921 private static void rotate_absolute(System.IntPtr obj, System.IntPtr pd, double degrees, double cx, double cy)
1923 Eina.Log.Debug("function efl_gfx_mapping_rotate_absolute was called");
1924 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1925 if (wrapper != null)
1930 ((IMappingConcrete)wrapper).RotateAbsolute(degrees, cx, cy);
1934 Eina.Log.Warning($"Callback error: {e.ToString()}");
1935 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1942 efl_gfx_mapping_rotate_absolute_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), degrees, cx, cy);
1946 private static efl_gfx_mapping_rotate_absolute_delegate efl_gfx_mapping_rotate_absolute_static_delegate;
1949 private delegate void efl_gfx_mapping_rotate_3d_absolute_delegate(System.IntPtr obj, System.IntPtr pd, double dx, double dy, double dz, double cx, double cy, double cz);
1952 public delegate void efl_gfx_mapping_rotate_3d_absolute_api_delegate(System.IntPtr obj, double dx, double dy, double dz, double cx, double cy, double cz);
1954 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_3d_absolute_api_delegate> efl_gfx_mapping_rotate_3d_absolute_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_3d_absolute_api_delegate>(Module, "efl_gfx_mapping_rotate_3d_absolute");
1956 private static void rotate_3d_absolute(System.IntPtr obj, System.IntPtr pd, double dx, double dy, double dz, double cx, double cy, double cz)
1958 Eina.Log.Debug("function efl_gfx_mapping_rotate_3d_absolute was called");
1959 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1960 if (wrapper != null)
1965 ((IMappingConcrete)wrapper).Rotate3dAbsolute(dx, dy, dz, cx, cy, cz);
1969 Eina.Log.Warning($"Callback error: {e.ToString()}");
1970 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1977 efl_gfx_mapping_rotate_3d_absolute_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dx, dy, dz, cx, cy, cz);
1981 private static efl_gfx_mapping_rotate_3d_absolute_delegate efl_gfx_mapping_rotate_3d_absolute_static_delegate;
1984 private delegate void efl_gfx_mapping_rotate_quat_absolute_delegate(System.IntPtr obj, System.IntPtr pd, double qx, double qy, double qz, double qw, double cx, double cy, double cz);
1987 public delegate void efl_gfx_mapping_rotate_quat_absolute_api_delegate(System.IntPtr obj, double qx, double qy, double qz, double qw, double cx, double cy, double cz);
1989 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_quat_absolute_api_delegate> efl_gfx_mapping_rotate_quat_absolute_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_quat_absolute_api_delegate>(Module, "efl_gfx_mapping_rotate_quat_absolute");
1991 private static void rotate_quat_absolute(System.IntPtr obj, System.IntPtr pd, double qx, double qy, double qz, double qw, double cx, double cy, double cz)
1993 Eina.Log.Debug("function efl_gfx_mapping_rotate_quat_absolute was called");
1994 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1995 if (wrapper != null)
2000 ((IMappingConcrete)wrapper).RotateQuatAbsolute(qx, qy, qz, qw, cx, cy, cz);
2004 Eina.Log.Warning($"Callback error: {e.ToString()}");
2005 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2012 efl_gfx_mapping_rotate_quat_absolute_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), qx, qy, qz, qw, cx, cy, cz);
2016 private static efl_gfx_mapping_rotate_quat_absolute_delegate efl_gfx_mapping_rotate_quat_absolute_static_delegate;
2019 private delegate void efl_gfx_mapping_zoom_absolute_delegate(System.IntPtr obj, System.IntPtr pd, double zoomx, double zoomy, double cx, double cy);
2022 public delegate void efl_gfx_mapping_zoom_absolute_api_delegate(System.IntPtr obj, double zoomx, double zoomy, double cx, double cy);
2024 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_zoom_absolute_api_delegate> efl_gfx_mapping_zoom_absolute_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_zoom_absolute_api_delegate>(Module, "efl_gfx_mapping_zoom_absolute");
2026 private static void zoom_absolute(System.IntPtr obj, System.IntPtr pd, double zoomx, double zoomy, double cx, double cy)
2028 Eina.Log.Debug("function efl_gfx_mapping_zoom_absolute was called");
2029 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2030 if (wrapper != null)
2035 ((IMappingConcrete)wrapper).ZoomAbsolute(zoomx, zoomy, cx, cy);
2039 Eina.Log.Warning($"Callback error: {e.ToString()}");
2040 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2047 efl_gfx_mapping_zoom_absolute_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), zoomx, zoomy, cx, cy);
2051 private static efl_gfx_mapping_zoom_absolute_delegate efl_gfx_mapping_zoom_absolute_static_delegate;
2054 private delegate void efl_gfx_mapping_lighting_3d_absolute_delegate(System.IntPtr obj, System.IntPtr pd, double lx, double ly, double lz, int lr, int lg, int lb, int ar, int ag, int ab);
2057 public delegate void efl_gfx_mapping_lighting_3d_absolute_api_delegate(System.IntPtr obj, double lx, double ly, double lz, int lr, int lg, int lb, int ar, int ag, int ab);
2059 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_lighting_3d_absolute_api_delegate> efl_gfx_mapping_lighting_3d_absolute_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_lighting_3d_absolute_api_delegate>(Module, "efl_gfx_mapping_lighting_3d_absolute");
2061 private static void lighting_3d_absolute(System.IntPtr obj, System.IntPtr pd, double lx, double ly, double lz, int lr, int lg, int lb, int ar, int ag, int ab)
2063 Eina.Log.Debug("function efl_gfx_mapping_lighting_3d_absolute was called");
2064 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2065 if (wrapper != null)
2070 ((IMappingConcrete)wrapper).Lighting3dAbsolute(lx, ly, lz, lr, lg, lb, ar, ag, ab);
2074 Eina.Log.Warning($"Callback error: {e.ToString()}");
2075 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2082 efl_gfx_mapping_lighting_3d_absolute_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), lx, ly, lz, lr, lg, lb, ar, ag, ab);
2086 private static efl_gfx_mapping_lighting_3d_absolute_delegate efl_gfx_mapping_lighting_3d_absolute_static_delegate;
2089 private delegate void efl_gfx_mapping_perspective_3d_absolute_delegate(System.IntPtr obj, System.IntPtr pd, double px, double py, double z0, double foc);
2092 public delegate void efl_gfx_mapping_perspective_3d_absolute_api_delegate(System.IntPtr obj, double px, double py, double z0, double foc);
2094 public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_perspective_3d_absolute_api_delegate> efl_gfx_mapping_perspective_3d_absolute_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_perspective_3d_absolute_api_delegate>(Module, "efl_gfx_mapping_perspective_3d_absolute");
2096 private static void perspective_3d_absolute(System.IntPtr obj, System.IntPtr pd, double px, double py, double z0, double foc)
2098 Eina.Log.Debug("function efl_gfx_mapping_perspective_3d_absolute was called");
2099 Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2100 if (wrapper != null)
2105 ((IMappingConcrete)wrapper).Perspective3dAbsolute(px, py, z0, foc);
2109 Eina.Log.Warning($"Callback error: {e.ToString()}");
2110 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2117 efl_gfx_mapping_perspective_3d_absolute_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), px, py, z0, foc);
2121 private static efl_gfx_mapping_perspective_3d_absolute_delegate efl_gfx_mapping_perspective_3d_absolute_static_delegate;
2123 #pragma warning restore CA1707, SA1300, SA1600