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 override System.IntPtr NativeClass
347 if (((object)this).GetType() == typeof(IMappingConcrete))
349 return GetEflClassStatic();
353 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
358 [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
359 efl_gfx_mapping_mixin_get();
360 /// <summary>Initializes a new instance of the <see cref="IMapping"/> class.
361 /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
362 private IMappingConcrete(System.IntPtr raw) : base(raw)
366 /// <summary>Number of points of a map.
367 /// This sets the number of points of map. Currently, the number of points must be multiples of 4.
368 /// (Since EFL 1.22)</summary>
369 /// <returns>The number of points of map</returns>
370 public int GetMappingPointCount() {
371 var _ret_var = Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_point_count_get_ptr.Value.Delegate(this.NativeHandle);
372 Eina.Error.RaiseIfUnhandledException();
375 /// <summary>Number of points of a map.
376 /// This sets the number of points of map. Currently, the number of points must be multiples of 4.
377 /// (Since EFL 1.22)</summary>
378 /// <param name="count">The number of points of map</param>
379 public void SetMappingPointCount(int count) {
380 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_point_count_set_ptr.Value.Delegate(this.NativeHandle,count);
381 Eina.Error.RaiseIfUnhandledException();
383 /// <summary>Clockwise state of a map (read-only).
384 /// 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.
385 /// (Since EFL 1.22)</summary>
386 /// <returns><c>true</c> if clockwise, <c>false</c> if counter clockwise</returns>
387 public bool GetMappingClockwise() {
388 var _ret_var = Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_clockwise_get_ptr.Value.Delegate(this.NativeHandle);
389 Eina.Error.RaiseIfUnhandledException();
392 /// <summary>Smoothing state for map rendering.
393 /// 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.
394 /// (Since EFL 1.22)</summary>
395 /// <returns><c>true</c> by default.</returns>
396 public bool GetMappingSmooth() {
397 var _ret_var = Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_smooth_get_ptr.Value.Delegate(this.NativeHandle);
398 Eina.Error.RaiseIfUnhandledException();
401 /// <summary>Smoothing state for map rendering.
402 /// 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.
403 /// (Since EFL 1.22)</summary>
404 /// <param name="smooth"><c>true</c> by default.</param>
405 public void SetMappingSmooth(bool smooth) {
406 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_smooth_set_ptr.Value.Delegate(this.NativeHandle,smooth);
407 Eina.Error.RaiseIfUnhandledException();
409 /// <summary>Alpha flag for map rendering.
410 /// 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.
412 /// Note that this may conflict with <see cref="Efl.Gfx.IMapping.MappingSmooth"/> depending on which algorithm is used for anti-aliasing.
413 /// (Since EFL 1.22)</summary>
414 /// <returns><c>true</c> by default.</returns>
415 public bool GetMappingAlpha() {
416 var _ret_var = Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_alpha_get_ptr.Value.Delegate(this.NativeHandle);
417 Eina.Error.RaiseIfUnhandledException();
420 /// <summary>Alpha flag for map rendering.
421 /// 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.
423 /// Note that this may conflict with <see cref="Efl.Gfx.IMapping.MappingSmooth"/> depending on which algorithm is used for anti-aliasing.
424 /// (Since EFL 1.22)</summary>
425 /// <param name="alpha"><c>true</c> by default.</param>
426 public void SetMappingAlpha(bool alpha) {
427 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_alpha_set_ptr.Value.Delegate(this.NativeHandle,alpha);
428 Eina.Error.RaiseIfUnhandledException();
430 /// <summary>A point's absolute coordinate on the canvas.
431 /// 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.
433 /// 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.
435 /// Remember all coordinates are canvas global ones as with move and resize in the canvas.
437 /// This property can be read to get the 4 points positions on the canvas, or set to manually place them.
438 /// (Since EFL 1.22)</summary>
439 /// <param name="idx">ID of the point, from 0 to 3 (included).</param>
440 /// <param name="x">Point X coordinate in absolute pixel coordinates.</param>
441 /// <param name="y">Point Y coordinate in absolute pixel coordinates.</param>
442 /// <param name="z">Point Z coordinate hint (pre-perspective transform).</param>
443 public void GetMappingCoordAbsolute(int idx, out double x, out double y, out double z) {
444 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_coord_absolute_get_ptr.Value.Delegate(this.NativeHandle,idx, out x, out y, out z);
445 Eina.Error.RaiseIfUnhandledException();
447 /// <summary>A point's absolute coordinate on the canvas.
448 /// 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.
450 /// 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.
452 /// Remember all coordinates are canvas global ones as with move and resize in the canvas.
454 /// This property can be read to get the 4 points positions on the canvas, or set to manually place them.
455 /// (Since EFL 1.22)</summary>
456 /// <param name="idx">ID of the point, from 0 to 3 (included).</param>
457 /// <param name="x">Point X coordinate in absolute pixel coordinates.</param>
458 /// <param name="y">Point Y coordinate in absolute pixel coordinates.</param>
459 /// <param name="z">Point Z coordinate hint (pre-perspective transform).</param>
460 public void SetMappingCoordAbsolute(int idx, double x, double y, double z) {
461 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_coord_absolute_set_ptr.Value.Delegate(this.NativeHandle,idx, x, y, z);
462 Eina.Error.RaiseIfUnhandledException();
464 /// <summary>Map point's U and V texture source point.
465 /// 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.
467 /// 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).
468 /// (Since EFL 1.22)</summary>
469 /// <param name="idx">ID of the point, from 0 to 3 (included).</param>
470 /// <param name="u">Relative X coordinate within the image, from 0 to 1.</param>
471 /// <param name="v">Relative Y coordinate within the image, from 0 to 1.</param>
472 public void GetMappingUv(int idx, out double u, out double v) {
473 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_uv_get_ptr.Value.Delegate(this.NativeHandle,idx, out u, out v);
474 Eina.Error.RaiseIfUnhandledException();
476 /// <summary>Map point's U and V texture source point.
477 /// 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.
479 /// 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).
480 /// (Since EFL 1.22)</summary>
481 /// <param name="idx">ID of the point, from 0 to 3 (included).</param>
482 /// <param name="u">Relative X coordinate within the image, from 0 to 1.</param>
483 /// <param name="v">Relative Y coordinate within the image, from 0 to 1.</param>
484 public void SetMappingUv(int idx, double u, double v) {
485 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_uv_set_ptr.Value.Delegate(this.NativeHandle,idx, u, v);
486 Eina.Error.RaiseIfUnhandledException();
488 /// <summary>Color of a vertex in the map.
489 /// 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.
491 /// The color values must be premultiplied (ie. <c>a</c> >= {<c>r</c>, <c>g</c>, <c>b</c>}).
492 /// (Since EFL 1.22)</summary>
493 /// <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>
494 /// <param name="r">Red (0 - 255)</param>
495 /// <param name="g">Green (0 - 255)</param>
496 /// <param name="b">Blue (0 - 255)</param>
497 /// <param name="a">Alpha (0 - 255)</param>
498 public void GetMappingColor(int idx, out int r, out int g, out int b, out int a) {
499 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_color_get_ptr.Value.Delegate(this.NativeHandle,idx, out r, out g, out b, out a);
500 Eina.Error.RaiseIfUnhandledException();
502 /// <summary>Color of a vertex in the map.
503 /// 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.
505 /// The color values must be premultiplied (ie. <c>a</c> >= {<c>r</c>, <c>g</c>, <c>b</c>}).
506 /// (Since EFL 1.22)</summary>
507 /// <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>
508 /// <param name="r">Red (0 - 255)</param>
509 /// <param name="g">Green (0 - 255)</param>
510 /// <param name="b">Blue (0 - 255)</param>
511 /// <param name="a">Alpha (0 - 255)</param>
512 public void SetMappingColor(int idx, int r, int g, int b, int a) {
513 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_color_set_ptr.Value.Delegate(this.NativeHandle,idx, r, g, b, a);
514 Eina.Error.RaiseIfUnhandledException();
516 /// <summary>Read-only property indicating whether an object is mapped.
517 /// This will be <c>true</c> if any transformation is applied to this object.
518 /// (Since EFL 1.22)</summary>
519 /// <returns><c>true</c> if the object is mapped.</returns>
520 public bool HasMapping() {
521 var _ret_var = Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_has_ptr.Value.Delegate(this.NativeHandle);
522 Eina.Error.RaiseIfUnhandledException();
525 /// <summary>Resets the map transformation to its default state.
526 /// 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"/>.
527 /// (Since EFL 1.22)</summary>
528 public void ResetMapping() {
529 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_reset_ptr.Value.Delegate(this.NativeHandle);
530 Eina.Error.RaiseIfUnhandledException();
532 /// <summary>Apply a translation to the object using map.
533 /// This does not change the real geometry of the object but will affect its visible position.
534 /// (Since EFL 1.22)</summary>
535 /// <param name="dx">Distance in pixels along the X axis.</param>
536 /// <param name="dy">Distance in pixels along the Y axis.</param>
537 /// <param name="dz">Distance in pixels along the Z axis.</param>
538 public void Translate(double dx, double dy, double dz) {
539 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_translate_ptr.Value.Delegate(this.NativeHandle,dx, dy, dz);
540 Eina.Error.RaiseIfUnhandledException();
542 /// <summary>Apply a rotation to the object.
543 /// 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.
545 /// 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.
547 /// 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.
548 /// (Since EFL 1.22)</summary>
549 /// <param name="degrees">CCW rotation in degrees.</param>
550 /// <param name="pivot">A pivot object for the center point, can be <c>null</c>.</param>
551 /// <param name="cx">X relative coordinate of the center point.</param>
552 /// <param name="cy">y relative coordinate of the center point.</param>
553 public void Rotate(double degrees, Efl.Gfx.IEntity pivot, double cx, double cy) {
554 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_ptr.Value.Delegate(this.NativeHandle,degrees, pivot, cx, cy);
555 Eina.Error.RaiseIfUnhandledException();
557 /// <summary>Rotate the object around 3 axes in 3D.
558 /// 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.
560 /// 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.
561 /// (Since EFL 1.22)</summary>
562 /// <param name="dx">Rotation in degrees around X axis (0 to 360).</param>
563 /// <param name="dy">Rotation in degrees around Y axis (0 to 360).</param>
564 /// <param name="dz">Rotation in degrees around Z axis (0 to 360).</param>
565 /// <param name="pivot">A pivot object for the center point, can be <c>null</c>.</param>
566 /// <param name="cx">X relative coordinate of the center point.</param>
567 /// <param name="cy">y relative coordinate of the center point.</param>
568 /// <param name="cz">Z absolute coordinate of the center point.</param>
569 public void Rotate3d(double dx, double dy, double dz, Efl.Gfx.IEntity pivot, double cx, double cy, double cz) {
570 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_3d_ptr.Value.Delegate(this.NativeHandle,dx, dy, dz, pivot, cx, cy, cz);
571 Eina.Error.RaiseIfUnhandledException();
573 /// <summary>Rotate the object in 3D using a unit quaternion.
574 /// 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.
576 /// 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.
577 /// (Since EFL 1.22)</summary>
578 /// <param name="qx">The x component of the imaginary part of the quaternion.</param>
579 /// <param name="qy">The y component of the imaginary part of the quaternion.</param>
580 /// <param name="qz">The z component of the imaginary part of the quaternion.</param>
581 /// <param name="qw">The w component of the real part of the quaternion.</param>
582 /// <param name="pivot">A pivot object for the center point, can be <c>null</c>.</param>
583 /// <param name="cx">X relative coordinate of the center point.</param>
584 /// <param name="cy">y relative coordinate of the center point.</param>
585 /// <param name="cz">Z absolute coordinate of the center point.</param>
586 public void RotateQuat(double qx, double qy, double qz, double qw, Efl.Gfx.IEntity pivot, double cx, double cy, double cz) {
587 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_quat_ptr.Value.Delegate(this.NativeHandle,qx, qy, qz, qw, pivot, cx, cy, cz);
588 Eina.Error.RaiseIfUnhandledException();
590 /// <summary>Apply a zoom to the object.
591 /// 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.
593 /// By default, the center is at (0.5, 0.5). 0.0 means left or top while 1.0 means right or bottom.
594 /// (Since EFL 1.22)</summary>
595 /// <param name="zoomx">Zoom in X direction</param>
596 /// <param name="zoomy">Zoom in Y direction</param>
597 /// <param name="pivot">A pivot object for the center point, can be <c>null</c>.</param>
598 /// <param name="cx">X relative coordinate of the center point.</param>
599 /// <param name="cy">y relative coordinate of the center point.</param>
600 public void Zoom(double zoomx, double zoomy, Efl.Gfx.IEntity pivot, double cx, double cy) {
601 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_zoom_ptr.Value.Delegate(this.NativeHandle,zoomx, zoomy, pivot, cx, cy);
602 Eina.Error.RaiseIfUnhandledException();
604 /// <summary>Apply a lighting effect on the object.
605 /// 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.
607 /// 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.
608 /// (Since EFL 1.22)</summary>
609 /// <param name="pivot">A pivot object for the light point, can be <c>null</c>.</param>
610 /// <param name="lx">X relative coordinate in space of light point.</param>
611 /// <param name="ly">Y relative coordinate in space of light point.</param>
612 /// <param name="lz">Z absolute coordinate in space of light point.</param>
613 /// <param name="lr">Light red value (0 - 255).</param>
614 /// <param name="lg">Light green value (0 - 255).</param>
615 /// <param name="lb">Light blue value (0 - 255).</param>
616 /// <param name="ar">Ambient color red value (0 - 255).</param>
617 /// <param name="ag">Ambient color green value (0 - 255).</param>
618 /// <param name="ab">Ambient color blue value (0 - 255).</param>
619 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) {
620 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_lighting_3d_ptr.Value.Delegate(this.NativeHandle,pivot, lx, ly, lz, lr, lg, lb, ar, ag, ab);
621 Eina.Error.RaiseIfUnhandledException();
623 /// <summary>Apply a perspective transform to the map
624 /// 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.
626 /// 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.
627 /// (Since EFL 1.22)</summary>
628 /// <param name="pivot">A pivot object for the infinite point, can be <c>null</c>.</param>
629 /// <param name="px">The perspective distance X relative coordinate.</param>
630 /// <param name="py">The perspective distance Y relative coordinate.</param>
631 /// <param name="z0">The "0" Z plane value.</param>
632 /// <param name="foc">The focal distance, must be greater than 0.</param>
633 public void Perspective3d(Efl.Gfx.IEntity pivot, double px, double py, double z0, double foc) {
634 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_perspective_3d_ptr.Value.Delegate(this.NativeHandle,pivot, px, py, z0, foc);
635 Eina.Error.RaiseIfUnhandledException();
637 /// <summary>Apply a rotation to the object, using absolute coordinates.
638 /// 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.
640 /// The given coordinates are absolute values in pixels. See also <see cref="Efl.Gfx.IMapping.Rotate"/> for a relative coordinate version.
641 /// (Since EFL 1.22)</summary>
642 /// <param name="degrees">CCW rotation in degrees.</param>
643 /// <param name="cx">X absolute coordinate in pixels of the center point.</param>
644 /// <param name="cy">y absolute coordinate in pixels of the center point.</param>
645 public void RotateAbsolute(double degrees, double cx, double cy) {
646 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_absolute_ptr.Value.Delegate(this.NativeHandle,degrees, cx, cy);
647 Eina.Error.RaiseIfUnhandledException();
649 /// <summary>Rotate the object around 3 axes in 3D, using absolute coordinates.
650 /// 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.
652 /// 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.
653 /// (Since EFL 1.22)</summary>
654 /// <param name="dx">Rotation in degrees around X axis (0 to 360).</param>
655 /// <param name="dy">Rotation in degrees around Y axis (0 to 360).</param>
656 /// <param name="dz">Rotation in degrees around Z axis (0 to 360).</param>
657 /// <param name="cx">X absolute coordinate in pixels of the center point.</param>
658 /// <param name="cy">y absolute coordinate in pixels of the center point.</param>
659 /// <param name="cz">Z absolute coordinate of the center point.</param>
660 public void Rotate3dAbsolute(double dx, double dy, double dz, double cx, double cy, double cz) {
661 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_3d_absolute_ptr.Value.Delegate(this.NativeHandle,dx, dy, dz, cx, cy, cz);
662 Eina.Error.RaiseIfUnhandledException();
664 /// <summary>Rotate the object in 3D using a unit quaternion, using absolute coordinates.
665 /// 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.
667 /// 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.
668 /// (Since EFL 1.22)</summary>
669 /// <param name="qx">The x component of the imaginary part of the quaternion.</param>
670 /// <param name="qy">The y component of the imaginary part of the quaternion.</param>
671 /// <param name="qz">The z component of the imaginary part of the quaternion.</param>
672 /// <param name="qw">The w component of the real part of the quaternion.</param>
673 /// <param name="cx">X absolute coordinate in pixels of the center point.</param>
674 /// <param name="cy">y absolute coordinate in pixels of the center point.</param>
675 /// <param name="cz">Z absolute coordinate of the center point.</param>
676 public void RotateQuatAbsolute(double qx, double qy, double qz, double qw, double cx, double cy, double cz) {
677 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_quat_absolute_ptr.Value.Delegate(this.NativeHandle,qx, qy, qz, qw, cx, cy, cz);
678 Eina.Error.RaiseIfUnhandledException();
680 /// <summary>Apply a zoom to the object, using absolute coordinates.
681 /// 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.
683 /// 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.
684 /// (Since EFL 1.22)</summary>
685 /// <param name="zoomx">Zoom in X direction</param>
686 /// <param name="zoomy">Zoom in Y direction</param>
687 /// <param name="cx">X absolute coordinate in pixels of the center point.</param>
688 /// <param name="cy">y absolute coordinate in pixels of the center point.</param>
689 public void ZoomAbsolute(double zoomx, double zoomy, double cx, double cy) {
690 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_zoom_absolute_ptr.Value.Delegate(this.NativeHandle,zoomx, zoomy, cx, cy);
691 Eina.Error.RaiseIfUnhandledException();
693 /// <summary>Apply a lighting effect to the object.
694 /// 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.
696 /// 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.
697 /// (Since EFL 1.22)</summary>
698 /// <param name="lx">X absolute coordinate in pixels of the light point.</param>
699 /// <param name="ly">y absolute coordinate in pixels of the light point.</param>
700 /// <param name="lz">Z absolute coordinate in space of light point.</param>
701 /// <param name="lr">Light red value (0 - 255).</param>
702 /// <param name="lg">Light green value (0 - 255).</param>
703 /// <param name="lb">Light blue value (0 - 255).</param>
704 /// <param name="ar">Ambient color red value (0 - 255).</param>
705 /// <param name="ag">Ambient color green value (0 - 255).</param>
706 /// <param name="ab">Ambient color blue value (0 - 255).</param>
707 public void Lighting3dAbsolute(double lx, double ly, double lz, int lr, int lg, int lb, int ar, int ag, int ab) {
708 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_lighting_3d_absolute_ptr.Value.Delegate(this.NativeHandle,lx, ly, lz, lr, lg, lb, ar, ag, ab);
709 Eina.Error.RaiseIfUnhandledException();
711 /// <summary>Apply a perspective transform to the map
712 /// 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.
714 /// 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.
715 /// (Since EFL 1.22)</summary>
716 /// <param name="px">The perspective distance X relative coordinate.</param>
717 /// <param name="py">The perspective distance Y relative coordinate.</param>
718 /// <param name="z0">The "0" Z plane value.</param>
719 /// <param name="foc">The focal distance, must be greater than 0.</param>
720 public void Perspective3dAbsolute(double px, double py, double z0, double foc) {
721 Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_perspective_3d_absolute_ptr.Value.Delegate(this.NativeHandle,px, py, z0, foc);
722 Eina.Error.RaiseIfUnhandledException();
724 /// <summary>Number of points of a map.
725 /// This sets the number of points of map. Currently, the number of points must be multiples of 4.
726 /// (Since EFL 1.22)</summary>
727 /// <value>The number of points of map</value>
728 public int MappingPointCount {
729 get { return GetMappingPointCount(); }
730 set { SetMappingPointCount(value); }
732 /// <summary>Clockwise state of a map (read-only).
733 /// 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.
734 /// (Since EFL 1.22)</summary>
735 /// <value><c>true</c> if clockwise, <c>false</c> if counter clockwise</value>
736 public bool MappingClockwise {
737 get { return GetMappingClockwise(); }
739 /// <summary>Smoothing state for map rendering.
740 /// 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.
741 /// (Since EFL 1.22)</summary>
742 /// <value><c>true</c> by default.</value>
743 public bool MappingSmooth {
744 get { return GetMappingSmooth(); }
745 set { SetMappingSmooth(value); }
747 /// <summary>Alpha flag for map rendering.
748 /// 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.
750 /// Note that this may conflict with <see cref="Efl.Gfx.IMapping.MappingSmooth"/> depending on which algorithm is used for anti-aliasing.
751 /// (Since EFL 1.22)</summary>
752 /// <value><c>true</c> by default.</value>
753 public bool MappingAlpha {
754 get { return GetMappingAlpha(); }
755 set { SetMappingAlpha(value); }
757 private static IntPtr GetEflClassStatic()
759 return Efl.Gfx.IMappingConcrete.efl_gfx_mapping_mixin_get();
761 /// <summary>Wrapper for native methods and virtual method delegates.
762 /// For internal use by generated code only.</summary>
763 public class NativeMethods : Efl.Eo.NativeClass
765 private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule( efl.Libs.Evas);
766 /// <summary>Gets the list of Eo operations to override.</summary>
767 /// <returns>The list of Eo operations to be overload.</returns>
768 public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
770 var descs = new System.Collections.Generic.List<Efl_Op_Description>();
771 var methods = Efl.Eo.Globals.GetUserMethods(type);
773 if (efl_gfx_mapping_point_count_get_static_delegate == null)
775 efl_gfx_mapping_point_count_get_static_delegate = new efl_gfx_mapping_point_count_get_delegate(mapping_point_count_get);
778 if (methods.FirstOrDefault(m => m.Name == "GetMappingPointCount") != null)
780 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) });
783 if (efl_gfx_mapping_point_count_set_static_delegate == null)
785 efl_gfx_mapping_point_count_set_static_delegate = new efl_gfx_mapping_point_count_set_delegate(mapping_point_count_set);
788 if (methods.FirstOrDefault(m => m.Name == "SetMappingPointCount") != null)
790 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) });
793 if (efl_gfx_mapping_clockwise_get_static_delegate == null)
795 efl_gfx_mapping_clockwise_get_static_delegate = new efl_gfx_mapping_clockwise_get_delegate(mapping_clockwise_get);
798 if (methods.FirstOrDefault(m => m.Name == "GetMappingClockwise") != null)
800 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) });
803 if (efl_gfx_mapping_smooth_get_static_delegate == null)
805 efl_gfx_mapping_smooth_get_static_delegate = new efl_gfx_mapping_smooth_get_delegate(mapping_smooth_get);
808 if (methods.FirstOrDefault(m => m.Name == "GetMappingSmooth") != null)
810 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) });
813 if (efl_gfx_mapping_smooth_set_static_delegate == null)
815 efl_gfx_mapping_smooth_set_static_delegate = new efl_gfx_mapping_smooth_set_delegate(mapping_smooth_set);
818 if (methods.FirstOrDefault(m => m.Name == "SetMappingSmooth") != null)
820 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) });
823 if (efl_gfx_mapping_alpha_get_static_delegate == null)
825 efl_gfx_mapping_alpha_get_static_delegate = new efl_gfx_mapping_alpha_get_delegate(mapping_alpha_get);
828 if (methods.FirstOrDefault(m => m.Name == "GetMappingAlpha") != null)
830 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) });
833 if (efl_gfx_mapping_alpha_set_static_delegate == null)
835 efl_gfx_mapping_alpha_set_static_delegate = new efl_gfx_mapping_alpha_set_delegate(mapping_alpha_set);
838 if (methods.FirstOrDefault(m => m.Name == "SetMappingAlpha") != null)
840 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) });
843 if (efl_gfx_mapping_coord_absolute_get_static_delegate == null)
845 efl_gfx_mapping_coord_absolute_get_static_delegate = new efl_gfx_mapping_coord_absolute_get_delegate(mapping_coord_absolute_get);
848 if (methods.FirstOrDefault(m => m.Name == "GetMappingCoordAbsolute") != null)
850 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) });
853 if (efl_gfx_mapping_coord_absolute_set_static_delegate == null)
855 efl_gfx_mapping_coord_absolute_set_static_delegate = new efl_gfx_mapping_coord_absolute_set_delegate(mapping_coord_absolute_set);
858 if (methods.FirstOrDefault(m => m.Name == "SetMappingCoordAbsolute") != null)
860 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) });
863 if (efl_gfx_mapping_uv_get_static_delegate == null)
865 efl_gfx_mapping_uv_get_static_delegate = new efl_gfx_mapping_uv_get_delegate(mapping_uv_get);
868 if (methods.FirstOrDefault(m => m.Name == "GetMappingUv") != null)
870 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) });
873 if (efl_gfx_mapping_uv_set_static_delegate == null)
875 efl_gfx_mapping_uv_set_static_delegate = new efl_gfx_mapping_uv_set_delegate(mapping_uv_set);
878 if (methods.FirstOrDefault(m => m.Name == "SetMappingUv") != null)
880 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) });
883 if (efl_gfx_mapping_color_get_static_delegate == null)
885 efl_gfx_mapping_color_get_static_delegate = new efl_gfx_mapping_color_get_delegate(mapping_color_get);
888 if (methods.FirstOrDefault(m => m.Name == "GetMappingColor") != null)
890 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) });
893 if (efl_gfx_mapping_color_set_static_delegate == null)
895 efl_gfx_mapping_color_set_static_delegate = new efl_gfx_mapping_color_set_delegate(mapping_color_set);
898 if (methods.FirstOrDefault(m => m.Name == "SetMappingColor") != null)
900 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) });
903 if (efl_gfx_mapping_has_static_delegate == null)
905 efl_gfx_mapping_has_static_delegate = new efl_gfx_mapping_has_delegate(mapping_has);
908 if (methods.FirstOrDefault(m => m.Name == "HasMapping") != null)
910 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) });
913 if (efl_gfx_mapping_reset_static_delegate == null)
915 efl_gfx_mapping_reset_static_delegate = new efl_gfx_mapping_reset_delegate(mapping_reset);
918 if (methods.FirstOrDefault(m => m.Name == "ResetMapping") != null)
920 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) });
923 if (efl_gfx_mapping_translate_static_delegate == null)
925 efl_gfx_mapping_translate_static_delegate = new efl_gfx_mapping_translate_delegate(translate);
928 if (methods.FirstOrDefault(m => m.Name == "Translate") != null)
930 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) });
933 if (efl_gfx_mapping_rotate_static_delegate == null)
935 efl_gfx_mapping_rotate_static_delegate = new efl_gfx_mapping_rotate_delegate(rotate);
938 if (methods.FirstOrDefault(m => m.Name == "Rotate") != null)
940 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) });
943 if (efl_gfx_mapping_rotate_3d_static_delegate == null)
945 efl_gfx_mapping_rotate_3d_static_delegate = new efl_gfx_mapping_rotate_3d_delegate(rotate_3d);
948 if (methods.FirstOrDefault(m => m.Name == "Rotate3d") != null)
950 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) });
953 if (efl_gfx_mapping_rotate_quat_static_delegate == null)
955 efl_gfx_mapping_rotate_quat_static_delegate = new efl_gfx_mapping_rotate_quat_delegate(rotate_quat);
958 if (methods.FirstOrDefault(m => m.Name == "RotateQuat") != null)
960 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) });
963 if (efl_gfx_mapping_zoom_static_delegate == null)
965 efl_gfx_mapping_zoom_static_delegate = new efl_gfx_mapping_zoom_delegate(zoom);
968 if (methods.FirstOrDefault(m => m.Name == "Zoom") != null)
970 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) });
973 if (efl_gfx_mapping_lighting_3d_static_delegate == null)
975 efl_gfx_mapping_lighting_3d_static_delegate = new efl_gfx_mapping_lighting_3d_delegate(lighting_3d);
978 if (methods.FirstOrDefault(m => m.Name == "Lighting3d") != null)
980 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) });
983 if (efl_gfx_mapping_perspective_3d_static_delegate == null)
985 efl_gfx_mapping_perspective_3d_static_delegate = new efl_gfx_mapping_perspective_3d_delegate(perspective_3d);
988 if (methods.FirstOrDefault(m => m.Name == "Perspective3d") != null)
990 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) });
993 if (efl_gfx_mapping_rotate_absolute_static_delegate == null)
995 efl_gfx_mapping_rotate_absolute_static_delegate = new efl_gfx_mapping_rotate_absolute_delegate(rotate_absolute);
998 if (methods.FirstOrDefault(m => m.Name == "RotateAbsolute") != null)
1000 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) });
1003 if (efl_gfx_mapping_rotate_3d_absolute_static_delegate == null)
1005 efl_gfx_mapping_rotate_3d_absolute_static_delegate = new efl_gfx_mapping_rotate_3d_absolute_delegate(rotate_3d_absolute);
1008 if (methods.FirstOrDefault(m => m.Name == "Rotate3dAbsolute") != null)
1010 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) });
1013 if (efl_gfx_mapping_rotate_quat_absolute_static_delegate == null)
1015 efl_gfx_mapping_rotate_quat_absolute_static_delegate = new efl_gfx_mapping_rotate_quat_absolute_delegate(rotate_quat_absolute);
1018 if (methods.FirstOrDefault(m => m.Name == "RotateQuatAbsolute") != null)
1020 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) });
1023 if (efl_gfx_mapping_zoom_absolute_static_delegate == null)
1025 efl_gfx_mapping_zoom_absolute_static_delegate = new efl_gfx_mapping_zoom_absolute_delegate(zoom_absolute);
1028 if (methods.FirstOrDefault(m => m.Name == "ZoomAbsolute") != null)
1030 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) });
1033 if (efl_gfx_mapping_lighting_3d_absolute_static_delegate == null)
1035 efl_gfx_mapping_lighting_3d_absolute_static_delegate = new efl_gfx_mapping_lighting_3d_absolute_delegate(lighting_3d_absolute);
1038 if (methods.FirstOrDefault(m => m.Name == "Lighting3dAbsolute") != null)
1040 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) });
1043 if (efl_gfx_mapping_perspective_3d_absolute_static_delegate == null)
1045 efl_gfx_mapping_perspective_3d_absolute_static_delegate = new efl_gfx_mapping_perspective_3d_absolute_delegate(perspective_3d_absolute);
1048 if (methods.FirstOrDefault(m => m.Name == "Perspective3dAbsolute") != null)
1050 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) });
1055 /// <summary>Returns the Eo class for the native methods of this class.</summary>
1056 /// <returns>The native class pointer.</returns>
1057 public override IntPtr GetEflClass()
1059 return Efl.Gfx.IMappingConcrete.efl_gfx_mapping_mixin_get();
1062 #pragma warning disable CA1707, CS1591, SA1300, SA1600
1065 private delegate int efl_gfx_mapping_point_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
1068 public delegate int efl_gfx_mapping_point_count_get_api_delegate(System.IntPtr obj);
1070 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");
1072 private static int mapping_point_count_get(System.IntPtr obj, System.IntPtr pd)
1074 Eina.Log.Debug("function efl_gfx_mapping_point_count_get was called");
1075 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1078 int _ret_var = default(int);
1081 _ret_var = ((IMappingConcrete)ws.Target).GetMappingPointCount();
1085 Eina.Log.Warning($"Callback error: {e.ToString()}");
1086 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1094 return efl_gfx_mapping_point_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1098 private static efl_gfx_mapping_point_count_get_delegate efl_gfx_mapping_point_count_get_static_delegate;
1101 private delegate void efl_gfx_mapping_point_count_set_delegate(System.IntPtr obj, System.IntPtr pd, int count);
1104 public delegate void efl_gfx_mapping_point_count_set_api_delegate(System.IntPtr obj, int count);
1106 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");
1108 private static void mapping_point_count_set(System.IntPtr obj, System.IntPtr pd, int count)
1110 Eina.Log.Debug("function efl_gfx_mapping_point_count_set was called");
1111 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1117 ((IMappingConcrete)ws.Target).SetMappingPointCount(count);
1121 Eina.Log.Warning($"Callback error: {e.ToString()}");
1122 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1129 efl_gfx_mapping_point_count_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), count);
1133 private static efl_gfx_mapping_point_count_set_delegate efl_gfx_mapping_point_count_set_static_delegate;
1135 [return: MarshalAs(UnmanagedType.U1)]
1136 private delegate bool efl_gfx_mapping_clockwise_get_delegate(System.IntPtr obj, System.IntPtr pd);
1138 [return: MarshalAs(UnmanagedType.U1)]
1139 public delegate bool efl_gfx_mapping_clockwise_get_api_delegate(System.IntPtr obj);
1141 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");
1143 private static bool mapping_clockwise_get(System.IntPtr obj, System.IntPtr pd)
1145 Eina.Log.Debug("function efl_gfx_mapping_clockwise_get was called");
1146 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1149 bool _ret_var = default(bool);
1152 _ret_var = ((IMappingConcrete)ws.Target).GetMappingClockwise();
1156 Eina.Log.Warning($"Callback error: {e.ToString()}");
1157 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1165 return efl_gfx_mapping_clockwise_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1169 private static efl_gfx_mapping_clockwise_get_delegate efl_gfx_mapping_clockwise_get_static_delegate;
1171 [return: MarshalAs(UnmanagedType.U1)]
1172 private delegate bool efl_gfx_mapping_smooth_get_delegate(System.IntPtr obj, System.IntPtr pd);
1174 [return: MarshalAs(UnmanagedType.U1)]
1175 public delegate bool efl_gfx_mapping_smooth_get_api_delegate(System.IntPtr obj);
1177 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");
1179 private static bool mapping_smooth_get(System.IntPtr obj, System.IntPtr pd)
1181 Eina.Log.Debug("function efl_gfx_mapping_smooth_get was called");
1182 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1185 bool _ret_var = default(bool);
1188 _ret_var = ((IMappingConcrete)ws.Target).GetMappingSmooth();
1192 Eina.Log.Warning($"Callback error: {e.ToString()}");
1193 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1201 return efl_gfx_mapping_smooth_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1205 private static efl_gfx_mapping_smooth_get_delegate efl_gfx_mapping_smooth_get_static_delegate;
1208 private delegate void efl_gfx_mapping_smooth_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool smooth);
1211 public delegate void efl_gfx_mapping_smooth_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool smooth);
1213 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");
1215 private static void mapping_smooth_set(System.IntPtr obj, System.IntPtr pd, bool smooth)
1217 Eina.Log.Debug("function efl_gfx_mapping_smooth_set was called");
1218 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1224 ((IMappingConcrete)ws.Target).SetMappingSmooth(smooth);
1228 Eina.Log.Warning($"Callback error: {e.ToString()}");
1229 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1236 efl_gfx_mapping_smooth_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), smooth);
1240 private static efl_gfx_mapping_smooth_set_delegate efl_gfx_mapping_smooth_set_static_delegate;
1242 [return: MarshalAs(UnmanagedType.U1)]
1243 private delegate bool efl_gfx_mapping_alpha_get_delegate(System.IntPtr obj, System.IntPtr pd);
1245 [return: MarshalAs(UnmanagedType.U1)]
1246 public delegate bool efl_gfx_mapping_alpha_get_api_delegate(System.IntPtr obj);
1248 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");
1250 private static bool mapping_alpha_get(System.IntPtr obj, System.IntPtr pd)
1252 Eina.Log.Debug("function efl_gfx_mapping_alpha_get was called");
1253 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1256 bool _ret_var = default(bool);
1259 _ret_var = ((IMappingConcrete)ws.Target).GetMappingAlpha();
1263 Eina.Log.Warning($"Callback error: {e.ToString()}");
1264 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1272 return efl_gfx_mapping_alpha_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1276 private static efl_gfx_mapping_alpha_get_delegate efl_gfx_mapping_alpha_get_static_delegate;
1279 private delegate void efl_gfx_mapping_alpha_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool alpha);
1282 public delegate void efl_gfx_mapping_alpha_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool alpha);
1284 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");
1286 private static void mapping_alpha_set(System.IntPtr obj, System.IntPtr pd, bool alpha)
1288 Eina.Log.Debug("function efl_gfx_mapping_alpha_set was called");
1289 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1295 ((IMappingConcrete)ws.Target).SetMappingAlpha(alpha);
1299 Eina.Log.Warning($"Callback error: {e.ToString()}");
1300 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1307 efl_gfx_mapping_alpha_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), alpha);
1311 private static efl_gfx_mapping_alpha_set_delegate efl_gfx_mapping_alpha_set_static_delegate;
1314 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);
1317 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);
1319 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");
1321 private static void mapping_coord_absolute_get(System.IntPtr obj, System.IntPtr pd, int idx, out double x, out double y, out double z)
1323 Eina.Log.Debug("function efl_gfx_mapping_coord_absolute_get was called");
1324 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1327 x = default(double); y = default(double); z = default(double);
1330 ((IMappingConcrete)ws.Target).GetMappingCoordAbsolute(idx, out x, out y, out z);
1334 Eina.Log.Warning($"Callback error: {e.ToString()}");
1335 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1342 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);
1346 private static efl_gfx_mapping_coord_absolute_get_delegate efl_gfx_mapping_coord_absolute_get_static_delegate;
1349 private delegate void efl_gfx_mapping_coord_absolute_set_delegate(System.IntPtr obj, System.IntPtr pd, int idx, double x, double y, double z);
1352 public delegate void efl_gfx_mapping_coord_absolute_set_api_delegate(System.IntPtr obj, int idx, double x, double y, double z);
1354 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");
1356 private static void mapping_coord_absolute_set(System.IntPtr obj, System.IntPtr pd, int idx, double x, double y, double z)
1358 Eina.Log.Debug("function efl_gfx_mapping_coord_absolute_set was called");
1359 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1365 ((IMappingConcrete)ws.Target).SetMappingCoordAbsolute(idx, x, y, z);
1369 Eina.Log.Warning($"Callback error: {e.ToString()}");
1370 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1377 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);
1381 private static efl_gfx_mapping_coord_absolute_set_delegate efl_gfx_mapping_coord_absolute_set_static_delegate;
1384 private delegate void efl_gfx_mapping_uv_get_delegate(System.IntPtr obj, System.IntPtr pd, int idx, out double u, out double v);
1387 public delegate void efl_gfx_mapping_uv_get_api_delegate(System.IntPtr obj, int idx, out double u, out double v);
1389 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");
1391 private static void mapping_uv_get(System.IntPtr obj, System.IntPtr pd, int idx, out double u, out double v)
1393 Eina.Log.Debug("function efl_gfx_mapping_uv_get was called");
1394 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1397 u = default(double); v = default(double);
1400 ((IMappingConcrete)ws.Target).GetMappingUv(idx, out u, out v);
1404 Eina.Log.Warning($"Callback error: {e.ToString()}");
1405 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1412 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);
1416 private static efl_gfx_mapping_uv_get_delegate efl_gfx_mapping_uv_get_static_delegate;
1419 private delegate void efl_gfx_mapping_uv_set_delegate(System.IntPtr obj, System.IntPtr pd, int idx, double u, double v);
1422 public delegate void efl_gfx_mapping_uv_set_api_delegate(System.IntPtr obj, int idx, double u, double v);
1424 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");
1426 private static void mapping_uv_set(System.IntPtr obj, System.IntPtr pd, int idx, double u, double v)
1428 Eina.Log.Debug("function efl_gfx_mapping_uv_set was called");
1429 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1435 ((IMappingConcrete)ws.Target).SetMappingUv(idx, u, v);
1439 Eina.Log.Warning($"Callback error: {e.ToString()}");
1440 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1447 efl_gfx_mapping_uv_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), idx, u, v);
1451 private static efl_gfx_mapping_uv_set_delegate efl_gfx_mapping_uv_set_static_delegate;
1454 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);
1457 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);
1459 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");
1461 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)
1463 Eina.Log.Debug("function efl_gfx_mapping_color_get was called");
1464 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1467 r = default(int); g = default(int); b = default(int); a = default(int);
1470 ((IMappingConcrete)ws.Target).GetMappingColor(idx, out r, out g, out b, out a);
1474 Eina.Log.Warning($"Callback error: {e.ToString()}");
1475 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1482 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);
1486 private static efl_gfx_mapping_color_get_delegate efl_gfx_mapping_color_get_static_delegate;
1489 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);
1492 public delegate void efl_gfx_mapping_color_set_api_delegate(System.IntPtr obj, int idx, int r, int g, int b, int a);
1494 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");
1496 private static void mapping_color_set(System.IntPtr obj, System.IntPtr pd, int idx, int r, int g, int b, int a)
1498 Eina.Log.Debug("function efl_gfx_mapping_color_set was called");
1499 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1505 ((IMappingConcrete)ws.Target).SetMappingColor(idx, r, g, b, a);
1509 Eina.Log.Warning($"Callback error: {e.ToString()}");
1510 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1517 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);
1521 private static efl_gfx_mapping_color_set_delegate efl_gfx_mapping_color_set_static_delegate;
1523 [return: MarshalAs(UnmanagedType.U1)]
1524 private delegate bool efl_gfx_mapping_has_delegate(System.IntPtr obj, System.IntPtr pd);
1526 [return: MarshalAs(UnmanagedType.U1)]
1527 public delegate bool efl_gfx_mapping_has_api_delegate(System.IntPtr obj);
1529 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");
1531 private static bool mapping_has(System.IntPtr obj, System.IntPtr pd)
1533 Eina.Log.Debug("function efl_gfx_mapping_has was called");
1534 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1537 bool _ret_var = default(bool);
1540 _ret_var = ((IMappingConcrete)ws.Target).HasMapping();
1544 Eina.Log.Warning($"Callback error: {e.ToString()}");
1545 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1553 return efl_gfx_mapping_has_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1557 private static efl_gfx_mapping_has_delegate efl_gfx_mapping_has_static_delegate;
1560 private delegate void efl_gfx_mapping_reset_delegate(System.IntPtr obj, System.IntPtr pd);
1563 public delegate void efl_gfx_mapping_reset_api_delegate(System.IntPtr obj);
1565 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");
1567 private static void mapping_reset(System.IntPtr obj, System.IntPtr pd)
1569 Eina.Log.Debug("function efl_gfx_mapping_reset was called");
1570 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1576 ((IMappingConcrete)ws.Target).ResetMapping();
1580 Eina.Log.Warning($"Callback error: {e.ToString()}");
1581 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1588 efl_gfx_mapping_reset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1592 private static efl_gfx_mapping_reset_delegate efl_gfx_mapping_reset_static_delegate;
1595 private delegate void efl_gfx_mapping_translate_delegate(System.IntPtr obj, System.IntPtr pd, double dx, double dy, double dz);
1598 public delegate void efl_gfx_mapping_translate_api_delegate(System.IntPtr obj, double dx, double dy, double dz);
1600 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");
1602 private static void translate(System.IntPtr obj, System.IntPtr pd, double dx, double dy, double dz)
1604 Eina.Log.Debug("function efl_gfx_mapping_translate was called");
1605 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1611 ((IMappingConcrete)ws.Target).Translate(dx, dy, dz);
1615 Eina.Log.Warning($"Callback error: {e.ToString()}");
1616 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1623 efl_gfx_mapping_translate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dx, dy, dz);
1627 private static efl_gfx_mapping_translate_delegate efl_gfx_mapping_translate_static_delegate;
1630 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);
1633 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);
1635 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");
1637 private static void rotate(System.IntPtr obj, System.IntPtr pd, double degrees, Efl.Gfx.IEntity pivot, double cx, double cy)
1639 Eina.Log.Debug("function efl_gfx_mapping_rotate was called");
1640 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1646 ((IMappingConcrete)ws.Target).Rotate(degrees, pivot, cx, cy);
1650 Eina.Log.Warning($"Callback error: {e.ToString()}");
1651 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1658 efl_gfx_mapping_rotate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), degrees, pivot, cx, cy);
1662 private static efl_gfx_mapping_rotate_delegate efl_gfx_mapping_rotate_static_delegate;
1665 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);
1668 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);
1670 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");
1672 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)
1674 Eina.Log.Debug("function efl_gfx_mapping_rotate_3d was called");
1675 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1681 ((IMappingConcrete)ws.Target).Rotate3d(dx, dy, dz, pivot, cx, cy, cz);
1685 Eina.Log.Warning($"Callback error: {e.ToString()}");
1686 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1693 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);
1697 private static efl_gfx_mapping_rotate_3d_delegate efl_gfx_mapping_rotate_3d_static_delegate;
1700 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);
1703 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);
1705 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");
1707 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)
1709 Eina.Log.Debug("function efl_gfx_mapping_rotate_quat was called");
1710 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1716 ((IMappingConcrete)ws.Target).RotateQuat(qx, qy, qz, qw, pivot, cx, cy, cz);
1720 Eina.Log.Warning($"Callback error: {e.ToString()}");
1721 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1728 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);
1732 private static efl_gfx_mapping_rotate_quat_delegate efl_gfx_mapping_rotate_quat_static_delegate;
1735 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);
1738 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);
1740 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");
1742 private static void zoom(System.IntPtr obj, System.IntPtr pd, double zoomx, double zoomy, Efl.Gfx.IEntity pivot, double cx, double cy)
1744 Eina.Log.Debug("function efl_gfx_mapping_zoom was called");
1745 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1751 ((IMappingConcrete)ws.Target).Zoom(zoomx, zoomy, pivot, cx, cy);
1755 Eina.Log.Warning($"Callback error: {e.ToString()}");
1756 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1763 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);
1767 private static efl_gfx_mapping_zoom_delegate efl_gfx_mapping_zoom_static_delegate;
1770 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);
1773 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);
1775 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");
1777 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)
1779 Eina.Log.Debug("function efl_gfx_mapping_lighting_3d was called");
1780 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1786 ((IMappingConcrete)ws.Target).Lighting3d(pivot, lx, ly, lz, lr, lg, lb, ar, ag, ab);
1790 Eina.Log.Warning($"Callback error: {e.ToString()}");
1791 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1798 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);
1802 private static efl_gfx_mapping_lighting_3d_delegate efl_gfx_mapping_lighting_3d_static_delegate;
1805 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);
1808 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);
1810 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");
1812 private static void perspective_3d(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity pivot, double px, double py, double z0, double foc)
1814 Eina.Log.Debug("function efl_gfx_mapping_perspective_3d was called");
1815 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1821 ((IMappingConcrete)ws.Target).Perspective3d(pivot, px, py, z0, foc);
1825 Eina.Log.Warning($"Callback error: {e.ToString()}");
1826 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1833 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);
1837 private static efl_gfx_mapping_perspective_3d_delegate efl_gfx_mapping_perspective_3d_static_delegate;
1840 private delegate void efl_gfx_mapping_rotate_absolute_delegate(System.IntPtr obj, System.IntPtr pd, double degrees, double cx, double cy);
1843 public delegate void efl_gfx_mapping_rotate_absolute_api_delegate(System.IntPtr obj, double degrees, double cx, double cy);
1845 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");
1847 private static void rotate_absolute(System.IntPtr obj, System.IntPtr pd, double degrees, double cx, double cy)
1849 Eina.Log.Debug("function efl_gfx_mapping_rotate_absolute was called");
1850 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1856 ((IMappingConcrete)ws.Target).RotateAbsolute(degrees, cx, cy);
1860 Eina.Log.Warning($"Callback error: {e.ToString()}");
1861 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1868 efl_gfx_mapping_rotate_absolute_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), degrees, cx, cy);
1872 private static efl_gfx_mapping_rotate_absolute_delegate efl_gfx_mapping_rotate_absolute_static_delegate;
1875 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);
1878 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);
1880 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");
1882 private static void rotate_3d_absolute(System.IntPtr obj, System.IntPtr pd, double dx, double dy, double dz, double cx, double cy, double cz)
1884 Eina.Log.Debug("function efl_gfx_mapping_rotate_3d_absolute was called");
1885 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1891 ((IMappingConcrete)ws.Target).Rotate3dAbsolute(dx, dy, dz, cx, cy, cz);
1895 Eina.Log.Warning($"Callback error: {e.ToString()}");
1896 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1903 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);
1907 private static efl_gfx_mapping_rotate_3d_absolute_delegate efl_gfx_mapping_rotate_3d_absolute_static_delegate;
1910 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);
1913 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);
1915 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");
1917 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)
1919 Eina.Log.Debug("function efl_gfx_mapping_rotate_quat_absolute was called");
1920 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1926 ((IMappingConcrete)ws.Target).RotateQuatAbsolute(qx, qy, qz, qw, cx, cy, cz);
1930 Eina.Log.Warning($"Callback error: {e.ToString()}");
1931 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1938 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);
1942 private static efl_gfx_mapping_rotate_quat_absolute_delegate efl_gfx_mapping_rotate_quat_absolute_static_delegate;
1945 private delegate void efl_gfx_mapping_zoom_absolute_delegate(System.IntPtr obj, System.IntPtr pd, double zoomx, double zoomy, double cx, double cy);
1948 public delegate void efl_gfx_mapping_zoom_absolute_api_delegate(System.IntPtr obj, double zoomx, double zoomy, double cx, double cy);
1950 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");
1952 private static void zoom_absolute(System.IntPtr obj, System.IntPtr pd, double zoomx, double zoomy, double cx, double cy)
1954 Eina.Log.Debug("function efl_gfx_mapping_zoom_absolute was called");
1955 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1961 ((IMappingConcrete)ws.Target).ZoomAbsolute(zoomx, zoomy, cx, cy);
1965 Eina.Log.Warning($"Callback error: {e.ToString()}");
1966 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1973 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);
1977 private static efl_gfx_mapping_zoom_absolute_delegate efl_gfx_mapping_zoom_absolute_static_delegate;
1980 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);
1983 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);
1985 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");
1987 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)
1989 Eina.Log.Debug("function efl_gfx_mapping_lighting_3d_absolute was called");
1990 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1996 ((IMappingConcrete)ws.Target).Lighting3dAbsolute(lx, ly, lz, lr, lg, lb, ar, ag, ab);
2000 Eina.Log.Warning($"Callback error: {e.ToString()}");
2001 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2008 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);
2012 private static efl_gfx_mapping_lighting_3d_absolute_delegate efl_gfx_mapping_lighting_3d_absolute_static_delegate;
2015 private delegate void efl_gfx_mapping_perspective_3d_absolute_delegate(System.IntPtr obj, System.IntPtr pd, double px, double py, double z0, double foc);
2018 public delegate void efl_gfx_mapping_perspective_3d_absolute_api_delegate(System.IntPtr obj, double px, double py, double z0, double foc);
2020 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");
2022 private static void perspective_3d_absolute(System.IntPtr obj, System.IntPtr pd, double px, double py, double z0, double foc)
2024 Eina.Log.Debug("function efl_gfx_mapping_perspective_3d_absolute was called");
2025 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2031 ((IMappingConcrete)ws.Target).Perspective3dAbsolute(px, py, z0, foc);
2035 Eina.Log.Warning($"Callback error: {e.ToString()}");
2036 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2043 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);
2047 private static efl_gfx_mapping_perspective_3d_absolute_delegate efl_gfx_mapping_perspective_3d_absolute_static_delegate;
2049 #pragma warning restore CA1707, CS1591, SA1300, SA1600