internals/src/EflSharp/EflSharp/efl/efl_gfx_mapping.eo.cs

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Gfx {
  11
  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.
  14 ///
  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.
  16 ///
  17 /// Each map point may carry a multiplier color. If properly calculated, these can do shading effects on the object, producing 3D effects.
  18 ///
  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
  24 {
  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 &quot;back-face culling&quot;. This is where you hide objects that &quot;face away&quot; 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.
  52 ///
  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.
  59 ///
  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&apos;s absolute coordinate on the canvas.
  65 /// This sets/gets the fixed point&apos;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.
  66 ///
  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.
  68 ///
  69 /// Remember all coordinates are canvas global ones as with move and resize in the canvas.
  70 ///
  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&apos;s absolute coordinate on the canvas.
  79 /// This sets/gets the fixed point&apos;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.
  80 ///
  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.
  82 ///
  83 /// Remember all coordinates are canvas global ones as with move and resize in the canvas.
  84 ///
  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&apos;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.
  94 ///
  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&apos;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.
 103 ///
 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 &quot;texture&quot; 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.
 112 ///
 113 /// The color values must be premultiplied (ie. <c>a</c> &gt;= {<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 &quot;texture&quot; 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.
 123 ///
 124 /// The color values must be premultiplied (ie. <c>a</c> &gt;= {<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>
 136 bool HasMapping();
 137     /// <summary>Resets the map transformation to its default state.
 138 /// This will reset all transformations to identity, meaning the points&apos; 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>
 140 void ResetMapping();
 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.
 150 ///
 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.
 152 ///
 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 &quot;Z&quot; 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 &quot;into&quot; 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.
 162 ///
 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.
 175 ///
 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 &quot;don&apos;t zoom&quot;. 2.0 means &quot;double the size&quot;. 0.5 is &quot;half the size&quot; etc.
 189 ///
 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 &quot;facing&quot; towards you (as opposed to away from you) as faces have a &quot;logical&quot; side for lighting.
 200 ///
 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 &quot;infinite distance&quot; 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 &quot;focal length&quot; 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 &quot;z0&quot; z value. This allows for some &quot;depth&quot; control and <c>foc</c> must be greater than 0.
 216 ///
 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 &quot;0&quot; 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.
 227 ///
 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 &quot;Z&quot; 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 &quot;into&quot; 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.
 236 ///
 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.
 248 ///
 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 &quot;don&apos;t zoom&quot;. 2.0 means &quot;double the size&quot;. 0.5 is &quot;half the size&quot; etc.
 261 ///
 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 &quot;facing&quot; towards you (as opposed to away from you) as faces have a &quot;logical&quot; side for lighting.
 271 ///
 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 &quot;infinite distance&quot; 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 &quot;focal length&quot; 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 &quot;z0&quot; z value. This allows for some &quot;depth&quot; control and <c>foc</c> must be greater than 0.
 286 ///
 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 &quot;0&quot; 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 {
 299         get ;
 300         set ;
 301     }
 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 &quot;back-face culling&quot;. This is where you hide objects that &quot;face away&quot; 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 {
 307         get ;
 308     }
 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>
 313     bool MappingSmooth {
 314         get ;
 315         set ;
 316     }
 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.
 319 ///
 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>
 323     bool MappingAlpha {
 324         get ;
 325         set ;
 326     }
 327 }
 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.
 330 ///
 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.
 332 ///
 333 /// Each map point may carry a multiplier color. If properly calculated, these can do shading effects on the object, producing 3D effects.
 334 ///
 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 :
 338
 339 IMapping
 340
 341 {
 342     ///<summary>Pointer to the native class description.</summary>
 343     public System.IntPtr NativeClass
 344     {
 345         get
 346         {
 347             if (((object)this).GetType() == typeof(IMappingConcrete))
 348             {
 349                 return GetEflClassStatic();
 350             }
 351             else
 352             {
 353                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 354             }
 355         }
 356     }
 357
 358     private  System.IntPtr handle;
 359     ///<summary>Pointer to the native instance.</summary>
 360     public System.IntPtr NativeHandle
 361     {
 362         get { return handle; }
 363     }
 364
 365     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
 366         efl_gfx_mapping_mixin_get();
 367     /// <summary>Initializes a new instance of the <see cref="IMapping"/> class.
 368     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 369     private IMappingConcrete(System.IntPtr raw)
 370     {
 371         handle = raw;
 372     }
 373     ///<summary>Destructor.</summary>
 374     ~IMappingConcrete()
 375     {
 376         Dispose(false);
 377     }
 378
 379     ///<summary>Releases the underlying native instance.</summary>
 380     private void Dispose(bool disposing)
 381     {
 382         if (handle != System.IntPtr.Zero)
 383         {
 384             IntPtr h = handle;
 385             handle = IntPtr.Zero;
 386
 387             IntPtr gcHandlePtr = IntPtr.Zero;
 388             if (disposing)
 389             {
 390                 Efl.Eo.Globals.efl_mono_native_dispose(h, gcHandlePtr);
 391             }
 392             else
 393             {
 394                 Monitor.Enter(Efl.All.InitLock);
 395                 if (Efl.All.MainLoopInitialized)
 396                 {
 397                     Efl.Eo.Globals.efl_mono_thread_safe_native_dispose(h, gcHandlePtr);
 398                 }
 399
 400                 Monitor.Exit(Efl.All.InitLock);
 401             }
 402         }
 403
 404     }
 405
 406     ///<summary>Releases the underlying native instance.</summary>
 407     public void Dispose()
 408     {
 409         Dispose(true);
 410         GC.SuppressFinalize(this);
 411     }
 412
 413     /// <summary>Verifies if the given object is equal to this one.</summary>
 414     /// <param name="instance">The object to compare to.</param>
 415     /// <returns>True if both objects point to the same native object.</returns>
 416     public override bool Equals(object instance)
 417     {
 418         var other = instance as Efl.Object;
 419         if (other == null)
 420         {
 421             return false;
 422         }
 423         return this.NativeHandle == other.NativeHandle;
 424     }
 425
 426     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 427     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
 428     public override int GetHashCode()
 429     {
 430         return this.NativeHandle.ToInt32();
 431     }
 432
 433     /// <summary>Turns the native pointer into a string representation.</summary>
 434     /// <returns>A string with the type and the native pointer for this object.</returns>
 435     public override String ToString()
 436     {
 437         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 438     }
 439
 440     /// <summary>Number of points of a map.
 441     /// This sets the number of points of map. Currently, the number of points must be multiples of 4.
 442     /// (Since EFL 1.22)</summary>
 443     /// <returns>The number of points of map</returns>
 444     public int GetMappingPointCount() {
 445          var _ret_var = Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_point_count_get_ptr.Value.Delegate(this.NativeHandle);
 446         Eina.Error.RaiseIfUnhandledException();
 447         return _ret_var;
 448  }
 449     /// <summary>Number of points of a map.
 450     /// This sets the number of points of map. Currently, the number of points must be multiples of 4.
 451     /// (Since EFL 1.22)</summary>
 452     /// <param name="count">The number of points of map</param>
 453     public void SetMappingPointCount(int count) {
 454                                  Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_point_count_set_ptr.Value.Delegate(this.NativeHandle,count);
 455         Eina.Error.RaiseIfUnhandledException();
 456                          }
 457     /// <summary>Clockwise state of a map (read-only).
 458     /// This determines if the output points (X and Y. Z is not used) are clockwise or counter-clockwise. This can be used for &quot;back-face culling&quot;. This is where you hide objects that &quot;face away&quot; from you. In this case objects that are not clockwise.
 459     /// (Since EFL 1.22)</summary>
 460     /// <returns><c>true</c> if clockwise, <c>false</c> if counter clockwise</returns>
 461     public bool GetMappingClockwise() {
 462          var _ret_var = Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_clockwise_get_ptr.Value.Delegate(this.NativeHandle);
 463         Eina.Error.RaiseIfUnhandledException();
 464         return _ret_var;
 465  }
 466     /// <summary>Smoothing state for map rendering.
 467     /// This sets smoothing for map rendering. If the object is a type that has its own smoothing settings, then both the smooth settings for this object and the map must be turned off. By default smooth maps are enabled.
 468     /// (Since EFL 1.22)</summary>
 469     /// <returns><c>true</c> by default.</returns>
 470     public bool GetMappingSmooth() {
 471          var _ret_var = Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_smooth_get_ptr.Value.Delegate(this.NativeHandle);
 472         Eina.Error.RaiseIfUnhandledException();
 473         return _ret_var;
 474  }
 475     /// <summary>Smoothing state for map rendering.
 476     /// This sets smoothing for map rendering. If the object is a type that has its own smoothing settings, then both the smooth settings for this object and the map must be turned off. By default smooth maps are enabled.
 477     /// (Since EFL 1.22)</summary>
 478     /// <param name="smooth"><c>true</c> by default.</param>
 479     public void SetMappingSmooth(bool smooth) {
 480                                  Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_smooth_set_ptr.Value.Delegate(this.NativeHandle,smooth);
 481         Eina.Error.RaiseIfUnhandledException();
 482                          }
 483     /// <summary>Alpha flag for map rendering.
 484     /// This sets alpha flag for map rendering. If the object is a type that has its own alpha settings, then this will take precedence. Only image objects support this currently (<see cref="Efl.Canvas.Image"/> and its friends). Setting this to off stops alpha blending of the map area, and is useful if you know the object and/or all sub-objects is 100% solid.
 485     ///
 486     /// Note that this may conflict with <see cref="Efl.Gfx.IMapping.MappingSmooth"/> depending on which algorithm is used for anti-aliasing.
 487     /// (Since EFL 1.22)</summary>
 488     /// <returns><c>true</c> by default.</returns>
 489     public bool GetMappingAlpha() {
 490          var _ret_var = Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_alpha_get_ptr.Value.Delegate(this.NativeHandle);
 491         Eina.Error.RaiseIfUnhandledException();
 492         return _ret_var;
 493  }
 494     /// <summary>Alpha flag for map rendering.
 495     /// This sets alpha flag for map rendering. If the object is a type that has its own alpha settings, then this will take precedence. Only image objects support this currently (<see cref="Efl.Canvas.Image"/> and its friends). Setting this to off stops alpha blending of the map area, and is useful if you know the object and/or all sub-objects is 100% solid.
 496     ///
 497     /// Note that this may conflict with <see cref="Efl.Gfx.IMapping.MappingSmooth"/> depending on which algorithm is used for anti-aliasing.
 498     /// (Since EFL 1.22)</summary>
 499     /// <param name="alpha"><c>true</c> by default.</param>
 500     public void SetMappingAlpha(bool alpha) {
 501                                  Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_alpha_set_ptr.Value.Delegate(this.NativeHandle,alpha);
 502         Eina.Error.RaiseIfUnhandledException();
 503                          }
 504     /// <summary>A point&apos;s absolute coordinate on the canvas.
 505     /// This sets/gets the fixed point&apos;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.
 506     ///
 507     /// The X and Y and Z coordinates are in canvas units. Z is optional and may or may not be honored in drawing. Z is a hint and does not affect the X and Y rendered coordinates. It may be used for calculating fills with perspective correct rendering.
 508     ///
 509     /// Remember all coordinates are canvas global ones as with move and resize in the canvas.
 510     ///
 511     /// This property can be read to get the 4 points positions on the canvas, or set to manually place them.
 512     /// (Since EFL 1.22)</summary>
 513     /// <param name="idx">ID of the point, from 0 to 3 (included).</param>
 514     /// <param name="x">Point X coordinate in absolute pixel coordinates.</param>
 515     /// <param name="y">Point Y coordinate in absolute pixel coordinates.</param>
 516     /// <param name="z">Point Z coordinate hint (pre-perspective transform).</param>
 517     public void GetMappingCoordAbsolute(int idx, out double x, out double y, out double z) {
 518                                                                                                          Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_coord_absolute_get_ptr.Value.Delegate(this.NativeHandle,idx, out x, out y, out z);
 519         Eina.Error.RaiseIfUnhandledException();
 520                                                                          }
 521     /// <summary>A point&apos;s absolute coordinate on the canvas.
 522     /// This sets/gets the fixed point&apos;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.
 523     ///
 524     /// The X and Y and Z coordinates are in canvas units. Z is optional and may or may not be honored in drawing. Z is a hint and does not affect the X and Y rendered coordinates. It may be used for calculating fills with perspective correct rendering.
 525     ///
 526     /// Remember all coordinates are canvas global ones as with move and resize in the canvas.
 527     ///
 528     /// This property can be read to get the 4 points positions on the canvas, or set to manually place them.
 529     /// (Since EFL 1.22)</summary>
 530     /// <param name="idx">ID of the point, from 0 to 3 (included).</param>
 531     /// <param name="x">Point X coordinate in absolute pixel coordinates.</param>
 532     /// <param name="y">Point Y coordinate in absolute pixel coordinates.</param>
 533     /// <param name="z">Point Z coordinate hint (pre-perspective transform).</param>
 534     public void SetMappingCoordAbsolute(int idx, double x, double y, double z) {
 535                                                                                                          Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_coord_absolute_set_ptr.Value.Delegate(this.NativeHandle,idx, x, y, z);
 536         Eina.Error.RaiseIfUnhandledException();
 537                                                                          }
 538     /// <summary>Map point&apos;s U and V texture source point.
 539     /// This sets/gets the U and V coordinates for the point. This determines which coordinate in the source image is mapped to the given point, much like OpenGL and textures. Valid values range from 0.0 to 1.0.
 540     ///
 541     /// By default the points are set in a clockwise order, as such: - 0: top-left, i.e. (0.0, 0.0), - 1: top-right, i.e. (1.0, 0.0), - 2: bottom-right, i.e. (1.0, 1.0), - 3: bottom-left, i.e. (0.0, 1.0).
 542     /// (Since EFL 1.22)</summary>
 543     /// <param name="idx">ID of the point, from 0 to 3 (included).</param>
 544     /// <param name="u">Relative X coordinate within the image, from 0 to 1.</param>
 545     /// <param name="v">Relative Y coordinate within the image, from 0 to 1.</param>
 546     public void GetMappingUv(int idx, out double u, out double v) {
 547                                                                                  Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_uv_get_ptr.Value.Delegate(this.NativeHandle,idx, out u, out v);
 548         Eina.Error.RaiseIfUnhandledException();
 549                                                          }
 550     /// <summary>Map point&apos;s U and V texture source point.
 551     /// This sets/gets the U and V coordinates for the point. This determines which coordinate in the source image is mapped to the given point, much like OpenGL and textures. Valid values range from 0.0 to 1.0.
 552     ///
 553     /// By default the points are set in a clockwise order, as such: - 0: top-left, i.e. (0.0, 0.0), - 1: top-right, i.e. (1.0, 0.0), - 2: bottom-right, i.e. (1.0, 1.0), - 3: bottom-left, i.e. (0.0, 1.0).
 554     /// (Since EFL 1.22)</summary>
 555     /// <param name="idx">ID of the point, from 0 to 3 (included).</param>
 556     /// <param name="u">Relative X coordinate within the image, from 0 to 1.</param>
 557     /// <param name="v">Relative Y coordinate within the image, from 0 to 1.</param>
 558     public void SetMappingUv(int idx, double u, double v) {
 559                                                                                  Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_uv_set_ptr.Value.Delegate(this.NativeHandle,idx, u, v);
 560         Eina.Error.RaiseIfUnhandledException();
 561                                                          }
 562     /// <summary>Color of a vertex in the map.
 563     /// This sets the color of the vertex in the map. Colors will be linearly interpolated between vertex points through the map. Color will multiply the &quot;texture&quot; 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.
 564     ///
 565     /// The color values must be premultiplied (ie. <c>a</c> &gt;= {<c>r</c>, <c>g</c>, <c>b</c>}).
 566     /// (Since EFL 1.22)</summary>
 567     /// <param name="idx">ID of the point, from 0 to 3 (included). -1 can be used to set the color for all points, but it is invalid for get().</param>
 568     /// <param name="r">Red (0 - 255)</param>
 569     /// <param name="g">Green (0 - 255)</param>
 570     /// <param name="b">Blue (0 - 255)</param>
 571     /// <param name="a">Alpha (0 - 255)</param>
 572     public void GetMappingColor(int idx, out int r, out int g, out int b, out int a) {
 573                                                                                                                                  Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_color_get_ptr.Value.Delegate(this.NativeHandle,idx, out r, out g, out b, out a);
 574         Eina.Error.RaiseIfUnhandledException();
 575                                                                                          }
 576     /// <summary>Color of a vertex in the map.
 577     /// This sets the color of the vertex in the map. Colors will be linearly interpolated between vertex points through the map. Color will multiply the &quot;texture&quot; 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.
 578     ///
 579     /// The color values must be premultiplied (ie. <c>a</c> &gt;= {<c>r</c>, <c>g</c>, <c>b</c>}).
 580     /// (Since EFL 1.22)</summary>
 581     /// <param name="idx">ID of the point, from 0 to 3 (included). -1 can be used to set the color for all points, but it is invalid for get().</param>
 582     /// <param name="r">Red (0 - 255)</param>
 583     /// <param name="g">Green (0 - 255)</param>
 584     /// <param name="b">Blue (0 - 255)</param>
 585     /// <param name="a">Alpha (0 - 255)</param>
 586     public void SetMappingColor(int idx, int r, int g, int b, int a) {
 587                                                                                                                                  Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_color_set_ptr.Value.Delegate(this.NativeHandle,idx, r, g, b, a);
 588         Eina.Error.RaiseIfUnhandledException();
 589                                                                                          }
 590     /// <summary>Read-only property indicating whether an object is mapped.
 591     /// This will be <c>true</c> if any transformation is applied to this object.
 592     /// (Since EFL 1.22)</summary>
 593     /// <returns><c>true</c> if the object is mapped.</returns>
 594     public bool HasMapping() {
 595          var _ret_var = Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_has_ptr.Value.Delegate(this.NativeHandle);
 596         Eina.Error.RaiseIfUnhandledException();
 597         return _ret_var;
 598  }
 599     /// <summary>Resets the map transformation to its default state.
 600     /// This will reset all transformations to identity, meaning the points&apos; colors, positions and UV coordinates will be reset to their default values. <see cref="Efl.Gfx.IMapping.HasMapping"/> will then return <c>false</c>. This function will not modify the values of <see cref="Efl.Gfx.IMapping.MappingSmooth"/> or <see cref="Efl.Gfx.IMapping.MappingAlpha"/>.
 601     /// (Since EFL 1.22)</summary>
 602     public void ResetMapping() {
 603          Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_reset_ptr.Value.Delegate(this.NativeHandle);
 604         Eina.Error.RaiseIfUnhandledException();
 605          }
 606     /// <summary>Apply a translation to the object using map.
 607     /// This does not change the real geometry of the object but will affect its visible position.
 608     /// (Since EFL 1.22)</summary>
 609     /// <param name="dx">Distance in pixels along the X axis.</param>
 610     /// <param name="dy">Distance in pixels along the Y axis.</param>
 611     /// <param name="dz">Distance in pixels along the Z axis.</param>
 612     public void Translate(double dx, double dy, double dz) {
 613                                                                                  Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_translate_ptr.Value.Delegate(this.NativeHandle,dx, dy, dz);
 614         Eina.Error.RaiseIfUnhandledException();
 615                                                          }
 616     /// <summary>Apply a rotation to the object.
 617     /// This rotates the object clockwise by <c>degrees</c> degrees, around the center specified by the relative position (<c>cx</c>, <c>cy</c>) in the <c>pivot</c> object. If <c>pivot</c> is <c>null</c> then this object is used as its own pivot center. 360 degrees is a full rotation, equivalent to no rotation. Negative values for <c>degrees</c> will rotate clockwise by that amount.
 618     ///
 619     /// The coordinates are set relative to the given <c>pivot</c> object. If its geometry changes, then the absolute position of the rotation center will change accordingly.
 620     ///
 621     /// By default, the center is at (0.5, 0.5). 0.0 means left or top while 1.0 means right or bottom of the <c>pivot</c> object.
 622     /// (Since EFL 1.22)</summary>
 623     /// <param name="degrees">CCW rotation in degrees.</param>
 624     /// <param name="pivot">A pivot object for the center point, can be <c>null</c>.</param>
 625     /// <param name="cx">X relative coordinate of the center point.</param>
 626     /// <param name="cy">y relative coordinate of the center point.</param>
 627     public void Rotate(double degrees, Efl.Gfx.IEntity pivot, double cx, double cy) {
 628                                                                                                          Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_ptr.Value.Delegate(this.NativeHandle,degrees, pivot, cx, cy);
 629         Eina.Error.RaiseIfUnhandledException();
 630                                                                          }
 631     /// <summary>Rotate the object around 3 axes in 3D.
 632     /// This will rotate in 3D, not just around the &quot;Z&quot; 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 &quot;into&quot; 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.
 633     ///
 634     /// As with <see cref="Efl.Gfx.IMapping.Rotate"/>, you provide a pivot and center point to rotate around (in 3D). The Z coordinate of this center point is an absolute value, and not a relative one like X and Y, as objects are flat in a 2D space.
 635     /// (Since EFL 1.22)</summary>
 636     /// <param name="dx">Rotation in degrees around X axis (0 to 360).</param>
 637     /// <param name="dy">Rotation in degrees around Y axis (0 to 360).</param>
 638     /// <param name="dz">Rotation in degrees around Z axis (0 to 360).</param>
 639     /// <param name="pivot">A pivot object for the center point, can be <c>null</c>.</param>
 640     /// <param name="cx">X relative coordinate of the center point.</param>
 641     /// <param name="cy">y relative coordinate of the center point.</param>
 642     /// <param name="cz">Z absolute coordinate of the center point.</param>
 643     public void Rotate3d(double dx, double dy, double dz, Efl.Gfx.IEntity pivot, double cx, double cy, double cz) {
 644                                                                                                                                                                                  Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_3d_ptr.Value.Delegate(this.NativeHandle,dx, dy, dz, pivot, cx, cy, cz);
 645         Eina.Error.RaiseIfUnhandledException();
 646                                                                                                                          }
 647     /// <summary>Rotate the object in 3D using a unit quaternion.
 648     /// This is similar to <see cref="Efl.Gfx.IMapping.Rotate3d"/> but uses a unit quaternion (also known as versor) rather than a direct angle-based rotation around a center point. Use this to avoid gimbal locks.
 649     ///
 650     /// As with <see cref="Efl.Gfx.IMapping.Rotate"/>, you provide a pivot and center point to rotate around (in 3D). The Z coordinate of this center point is an absolute value, and not a relative one like X and Y, as objects are flat in a 2D space.
 651     /// (Since EFL 1.22)</summary>
 652     /// <param name="qx">The x component of the imaginary part of the quaternion.</param>
 653     /// <param name="qy">The y component of the imaginary part of the quaternion.</param>
 654     /// <param name="qz">The z component of the imaginary part of the quaternion.</param>
 655     /// <param name="qw">The w component of the real part of the quaternion.</param>
 656     /// <param name="pivot">A pivot object for the center point, can be <c>null</c>.</param>
 657     /// <param name="cx">X relative coordinate of the center point.</param>
 658     /// <param name="cy">y relative coordinate of the center point.</param>
 659     /// <param name="cz">Z absolute coordinate of the center point.</param>
 660     public void RotateQuat(double qx, double qy, double qz, double qw, Efl.Gfx.IEntity pivot, double cx, double cy, double cz) {
 661                                                                                                                                                                                                          Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_quat_ptr.Value.Delegate(this.NativeHandle,qx, qy, qz, qw, pivot, cx, cy, cz);
 662         Eina.Error.RaiseIfUnhandledException();
 663                                                                                                                                          }
 664     /// <summary>Apply a zoom to the object.
 665     /// This zooms the points of the map from a center point. That center is defined by <c>cx</c> and <c>cy</c>. The <c>zoomx</c> and <c>zoomy</c> parameters specify how much to zoom in the X and Y direction respectively. A value of 1.0 means &quot;don&apos;t zoom&quot;. 2.0 means &quot;double the size&quot;. 0.5 is &quot;half the size&quot; etc.
 666     ///
 667     /// By default, the center is at (0.5, 0.5). 0.0 means left or top while 1.0 means right or bottom.
 668     /// (Since EFL 1.22)</summary>
 669     /// <param name="zoomx">Zoom in X direction</param>
 670     /// <param name="zoomy">Zoom in Y direction</param>
 671     /// <param name="pivot">A pivot object for the center point, can be <c>null</c>.</param>
 672     /// <param name="cx">X relative coordinate of the center point.</param>
 673     /// <param name="cy">y relative coordinate of the center point.</param>
 674     public void Zoom(double zoomx, double zoomy, Efl.Gfx.IEntity pivot, double cx, double cy) {
 675                                                                                                                                  Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_zoom_ptr.Value.Delegate(this.NativeHandle,zoomx, zoomy, pivot, cx, cy);
 676         Eina.Error.RaiseIfUnhandledException();
 677                                                                                          }
 678     /// <summary>Apply a lighting effect on the object.
 679     /// This is used to apply lighting calculations (from a single light source) to a given mapped object. The R, G and B values of each vertex will be modified to reflect the lighting based on the light point coordinates, the light color and the ambient color, and at what angle the map is facing the light source. A surface should have its points be declared in a clockwise fashion if the face is &quot;facing&quot; towards you (as opposed to away from you) as faces have a &quot;logical&quot; side for lighting.
 680     ///
 681     /// The coordinates are set relative to the given <c>pivot</c> object. If its geometry changes, then the absolute position of the rotation center will change accordingly. The Z position is absolute. If the <c>pivot</c> is <c>null</c> then this object will be its own pivot.
 682     /// (Since EFL 1.22)</summary>
 683     /// <param name="pivot">A pivot object for the light point, can be <c>null</c>.</param>
 684     /// <param name="lx">X relative coordinate in space of light point.</param>
 685     /// <param name="ly">Y relative coordinate in space of light point.</param>
 686     /// <param name="lz">Z absolute coordinate in space of light point.</param>
 687     /// <param name="lr">Light red value (0 - 255).</param>
 688     /// <param name="lg">Light green value (0 - 255).</param>
 689     /// <param name="lb">Light blue value (0 - 255).</param>
 690     /// <param name="ar">Ambient color red value (0 - 255).</param>
 691     /// <param name="ag">Ambient color green value (0 - 255).</param>
 692     /// <param name="ab">Ambient color blue value (0 - 255).</param>
 693     public void Lighting3d(Efl.Gfx.IEntity pivot, double lx, double ly, double lz, int lr, int lg, int lb, int ar, int ag, int ab) {
 694                                                                                                                                                                                                                                                          Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_lighting_3d_ptr.Value.Delegate(this.NativeHandle,pivot, lx, ly, lz, lr, lg, lb, ar, ag, ab);
 695         Eina.Error.RaiseIfUnhandledException();
 696                                                                                                                                                                          }
 697     /// <summary>Apply a perspective transform to the map
 698     /// This applies a given perspective (3D) to the map coordinates. X, Y and Z values are used. The px and py points specify the &quot;infinite distance&quot; 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 &quot;focal length&quot; 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 &quot;z0&quot; z value. This allows for some &quot;depth&quot; control and <c>foc</c> must be greater than 0.
 699     ///
 700     /// The coordinates are set relative to the given <c>pivot</c> object. If its geometry changes, then the absolute position of the rotation center will change accordingly. The Z position is absolute. If the <c>pivot</c> is <c>null</c> then this object will be its own pivot.
 701     /// (Since EFL 1.22)</summary>
 702     /// <param name="pivot">A pivot object for the infinite point, can be <c>null</c>.</param>
 703     /// <param name="px">The perspective distance X relative coordinate.</param>
 704     /// <param name="py">The perspective distance Y relative coordinate.</param>
 705     /// <param name="z0">The &quot;0&quot; Z plane value.</param>
 706     /// <param name="foc">The focal distance, must be greater than 0.</param>
 707     public void Perspective3d(Efl.Gfx.IEntity pivot, double px, double py, double z0, double foc) {
 708                                                                                                                                  Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_perspective_3d_ptr.Value.Delegate(this.NativeHandle,pivot, px, py, z0, foc);
 709         Eina.Error.RaiseIfUnhandledException();
 710                                                                                          }
 711     /// <summary>Apply a rotation to the object, using absolute coordinates.
 712     /// This rotates the object clockwise by <c>degrees</c> degrees, around the center specified by the relative position (<c>cx</c>, <c>cy</c>) in the <c>pivot</c> object. If <c>pivot</c> is <c>null</c> then this object is used as its own pivot center. 360 degrees is a full rotation, equivalent to no rotation. Negative values for <c>degrees</c> will rotate clockwise by that amount.
 713     ///
 714     /// The given coordinates are absolute values in pixels. See also <see cref="Efl.Gfx.IMapping.Rotate"/> for a relative coordinate version.
 715     /// (Since EFL 1.22)</summary>
 716     /// <param name="degrees">CCW rotation in degrees.</param>
 717     /// <param name="cx">X absolute coordinate in pixels of the center point.</param>
 718     /// <param name="cy">y absolute coordinate in pixels of the center point.</param>
 719     public void RotateAbsolute(double degrees, double cx, double cy) {
 720                                                                                  Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_absolute_ptr.Value.Delegate(this.NativeHandle,degrees, cx, cy);
 721         Eina.Error.RaiseIfUnhandledException();
 722                                                          }
 723     /// <summary>Rotate the object around 3 axes in 3D, using absolute coordinates.
 724     /// This will rotate in 3D and not just around the &quot;Z&quot; 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 &quot;into&quot; 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.
 725     ///
 726     /// The coordinates of the center point are given in absolute canvas coordinates. See also <see cref="Efl.Gfx.IMapping.Rotate3d"/> for a pivot-based 3D rotation.
 727     /// (Since EFL 1.22)</summary>
 728     /// <param name="dx">Rotation in degrees around X axis (0 to 360).</param>
 729     /// <param name="dy">Rotation in degrees around Y axis (0 to 360).</param>
 730     /// <param name="dz">Rotation in degrees around Z axis (0 to 360).</param>
 731     /// <param name="cx">X absolute coordinate in pixels of the center point.</param>
 732     /// <param name="cy">y absolute coordinate in pixels of the center point.</param>
 733     /// <param name="cz">Z absolute coordinate of the center point.</param>
 734     public void Rotate3dAbsolute(double dx, double dy, double dz, double cx, double cy, double cz) {
 735                                                                                                                                                          Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_3d_absolute_ptr.Value.Delegate(this.NativeHandle,dx, dy, dz, cx, cy, cz);
 736         Eina.Error.RaiseIfUnhandledException();
 737                                                                                                          }
 738     /// <summary>Rotate the object in 3D using a unit quaternion, using absolute coordinates.
 739     /// This is similar to <see cref="Efl.Gfx.IMapping.Rotate3d"/> but uses a unit quaternion (also known as versor) rather than a direct angle-based rotation around a center point. Use this to avoid gimbal locks.
 740     ///
 741     /// The coordinates of the center point are given in absolute canvas coordinates. See also <see cref="Efl.Gfx.IMapping.RotateQuat"/> for a pivot-based 3D rotation.
 742     /// (Since EFL 1.22)</summary>
 743     /// <param name="qx">The x component of the imaginary part of the quaternion.</param>
 744     /// <param name="qy">The y component of the imaginary part of the quaternion.</param>
 745     /// <param name="qz">The z component of the imaginary part of the quaternion.</param>
 746     /// <param name="qw">The w component of the real part of the quaternion.</param>
 747     /// <param name="cx">X absolute coordinate in pixels of the center point.</param>
 748     /// <param name="cy">y absolute coordinate in pixels of the center point.</param>
 749     /// <param name="cz">Z absolute coordinate of the center point.</param>
 750     public void RotateQuatAbsolute(double qx, double qy, double qz, double qw, double cx, double cy, double cz) {
 751                                                                                                                                                                                  Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_rotate_quat_absolute_ptr.Value.Delegate(this.NativeHandle,qx, qy, qz, qw, cx, cy, cz);
 752         Eina.Error.RaiseIfUnhandledException();
 753                                                                                                                          }
 754     /// <summary>Apply a zoom to the object, using absolute coordinates.
 755     /// This zooms the points of the map from a center point. That center is defined by <c>cx</c> and <c>cy</c>. The <c>zoomx</c> and <c>zoomy</c> parameters specify how much to zoom in the X and Y direction respectively. A value of 1.0 means &quot;don&apos;t zoom&quot;. 2.0 means &quot;double the size&quot;. 0.5 is &quot;half the size&quot; etc.
 756     ///
 757     /// The coordinates of the center point are given in absolute canvas coordinates. See also <see cref="Efl.Gfx.IMapping.Zoom"/> for a pivot-based zoom.
 758     /// (Since EFL 1.22)</summary>
 759     /// <param name="zoomx">Zoom in X direction</param>
 760     /// <param name="zoomy">Zoom in Y direction</param>
 761     /// <param name="cx">X absolute coordinate in pixels of the center point.</param>
 762     /// <param name="cy">y absolute coordinate in pixels of the center point.</param>
 763     public void ZoomAbsolute(double zoomx, double zoomy, double cx, double cy) {
 764                                                                                                          Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_zoom_absolute_ptr.Value.Delegate(this.NativeHandle,zoomx, zoomy, cx, cy);
 765         Eina.Error.RaiseIfUnhandledException();
 766                                                                          }
 767     /// <summary>Apply a lighting effect to the object.
 768     /// This is used to apply lighting calculations (from a single light source) to a given mapped object. The RGB values of each vertex will be modified to reflect the lighting based on the light point coordinates, the light color, the ambient color and at what angle the map is facing the light source. A surface should have its points be declared in a clockwise fashion if the face is &quot;facing&quot; towards you (as opposed to away from you) as faces have a &quot;logical&quot; side for lighting.
 769     ///
 770     /// The coordinates of the center point are given in absolute canvas coordinates. See also <see cref="Efl.Gfx.IMapping.Lighting3d"/> for a pivot-based lighting effect.
 771     /// (Since EFL 1.22)</summary>
 772     /// <param name="lx">X absolute coordinate in pixels of the light point.</param>
 773     /// <param name="ly">y absolute coordinate in pixels of the light point.</param>
 774     /// <param name="lz">Z absolute coordinate in space of light point.</param>
 775     /// <param name="lr">Light red value (0 - 255).</param>
 776     /// <param name="lg">Light green value (0 - 255).</param>
 777     /// <param name="lb">Light blue value (0 - 255).</param>
 778     /// <param name="ar">Ambient color red value (0 - 255).</param>
 779     /// <param name="ag">Ambient color green value (0 - 255).</param>
 780     /// <param name="ab">Ambient color blue value (0 - 255).</param>
 781     public void Lighting3dAbsolute(double lx, double ly, double lz, int lr, int lg, int lb, int ar, int ag, int ab) {
 782                                                                                                                                                                                                                                  Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_lighting_3d_absolute_ptr.Value.Delegate(this.NativeHandle,lx, ly, lz, lr, lg, lb, ar, ag, ab);
 783         Eina.Error.RaiseIfUnhandledException();
 784                                                                                                                                                          }
 785     /// <summary>Apply a perspective transform to the map
 786     /// This applies a given perspective (3D) to the map coordinates. X, Y and Z values are used. The px and py points specify the &quot;infinite distance&quot; 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 &quot;focal length&quot; 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 &quot;z0&quot; z value. This allows for some &quot;depth&quot; control and <c>foc</c> must be greater than 0.
 787     ///
 788     /// The coordinates of the center point are given in absolute canvas coordinates. See also <see cref="Efl.Gfx.IMapping.Perspective3d"/> for a pivot-based perspective effect.
 789     /// (Since EFL 1.22)</summary>
 790     /// <param name="px">The perspective distance X relative coordinate.</param>
 791     /// <param name="py">The perspective distance Y relative coordinate.</param>
 792     /// <param name="z0">The &quot;0&quot; Z plane value.</param>
 793     /// <param name="foc">The focal distance, must be greater than 0.</param>
 794     public void Perspective3dAbsolute(double px, double py, double z0, double foc) {
 795                                                                                                          Efl.Gfx.IMappingConcrete.NativeMethods.efl_gfx_mapping_perspective_3d_absolute_ptr.Value.Delegate(this.NativeHandle,px, py, z0, foc);
 796         Eina.Error.RaiseIfUnhandledException();
 797                                                                          }
 798     /// <summary>Number of points of a map.
 799 /// This sets the number of points of map. Currently, the number of points must be multiples of 4.
 800 /// (Since EFL 1.22)</summary>
 801 /// <value>The number of points of map</value>
 802     public int MappingPointCount {
 803         get { return GetMappingPointCount(); }
 804         set { SetMappingPointCount(value); }
 805     }
 806     /// <summary>Clockwise state of a map (read-only).
 807 /// This determines if the output points (X and Y. Z is not used) are clockwise or counter-clockwise. This can be used for &quot;back-face culling&quot;. This is where you hide objects that &quot;face away&quot; from you. In this case objects that are not clockwise.
 808 /// (Since EFL 1.22)</summary>
 809 /// <value><c>true</c> if clockwise, <c>false</c> if counter clockwise</value>
 810     public bool MappingClockwise {
 811         get { return GetMappingClockwise(); }
 812     }
 813     /// <summary>Smoothing state for map rendering.
 814 /// This sets smoothing for map rendering. If the object is a type that has its own smoothing settings, then both the smooth settings for this object and the map must be turned off. By default smooth maps are enabled.
 815 /// (Since EFL 1.22)</summary>
 816 /// <value><c>true</c> by default.</value>
 817     public bool MappingSmooth {
 818         get { return GetMappingSmooth(); }
 819         set { SetMappingSmooth(value); }
 820     }
 821     /// <summary>Alpha flag for map rendering.
 822 /// This sets alpha flag for map rendering. If the object is a type that has its own alpha settings, then this will take precedence. Only image objects support this currently (<see cref="Efl.Canvas.Image"/> and its friends). Setting this to off stops alpha blending of the map area, and is useful if you know the object and/or all sub-objects is 100% solid.
 823 ///
 824 /// Note that this may conflict with <see cref="Efl.Gfx.IMapping.MappingSmooth"/> depending on which algorithm is used for anti-aliasing.
 825 /// (Since EFL 1.22)</summary>
 826 /// <value><c>true</c> by default.</value>
 827     public bool MappingAlpha {
 828         get { return GetMappingAlpha(); }
 829         set { SetMappingAlpha(value); }
 830     }
 831     private static IntPtr GetEflClassStatic()
 832     {
 833         return Efl.Gfx.IMappingConcrete.efl_gfx_mapping_mixin_get();
 834     }
 835     /// <summary>Wrapper for native methods and virtual method delegates.
 836     /// For internal use by generated code only.</summary>
 837     public class NativeMethods  : Efl.Eo.NativeClass
 838     {
 839         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Evas);
 840         /// <summary>Gets the list of Eo operations to override.</summary>
 841         /// <returns>The list of Eo operations to be overload.</returns>
 842         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 843         {
 844             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 845             var methods = Efl.Eo.Globals.GetUserMethods(type);
 846
 847             if (efl_gfx_mapping_point_count_get_static_delegate == null)
 848             {
 849                 efl_gfx_mapping_point_count_get_static_delegate = new efl_gfx_mapping_point_count_get_delegate(mapping_point_count_get);
 850             }
 851
 852             if (methods.FirstOrDefault(m => m.Name == "GetMappingPointCount") != null)
 853             {
 854                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_point_count_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_point_count_get_static_delegate) });
 855             }
 856
 857             if (efl_gfx_mapping_point_count_set_static_delegate == null)
 858             {
 859                 efl_gfx_mapping_point_count_set_static_delegate = new efl_gfx_mapping_point_count_set_delegate(mapping_point_count_set);
 860             }
 861
 862             if (methods.FirstOrDefault(m => m.Name == "SetMappingPointCount") != null)
 863             {
 864                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_point_count_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_point_count_set_static_delegate) });
 865             }
 866
 867             if (efl_gfx_mapping_clockwise_get_static_delegate == null)
 868             {
 869                 efl_gfx_mapping_clockwise_get_static_delegate = new efl_gfx_mapping_clockwise_get_delegate(mapping_clockwise_get);
 870             }
 871
 872             if (methods.FirstOrDefault(m => m.Name == "GetMappingClockwise") != null)
 873             {
 874                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_clockwise_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_clockwise_get_static_delegate) });
 875             }
 876
 877             if (efl_gfx_mapping_smooth_get_static_delegate == null)
 878             {
 879                 efl_gfx_mapping_smooth_get_static_delegate = new efl_gfx_mapping_smooth_get_delegate(mapping_smooth_get);
 880             }
 881
 882             if (methods.FirstOrDefault(m => m.Name == "GetMappingSmooth") != null)
 883             {
 884                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_smooth_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_smooth_get_static_delegate) });
 885             }
 886
 887             if (efl_gfx_mapping_smooth_set_static_delegate == null)
 888             {
 889                 efl_gfx_mapping_smooth_set_static_delegate = new efl_gfx_mapping_smooth_set_delegate(mapping_smooth_set);
 890             }
 891
 892             if (methods.FirstOrDefault(m => m.Name == "SetMappingSmooth") != null)
 893             {
 894                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_smooth_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_smooth_set_static_delegate) });
 895             }
 896
 897             if (efl_gfx_mapping_alpha_get_static_delegate == null)
 898             {
 899                 efl_gfx_mapping_alpha_get_static_delegate = new efl_gfx_mapping_alpha_get_delegate(mapping_alpha_get);
 900             }
 901
 902             if (methods.FirstOrDefault(m => m.Name == "GetMappingAlpha") != null)
 903             {
 904                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_alpha_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_alpha_get_static_delegate) });
 905             }
 906
 907             if (efl_gfx_mapping_alpha_set_static_delegate == null)
 908             {
 909                 efl_gfx_mapping_alpha_set_static_delegate = new efl_gfx_mapping_alpha_set_delegate(mapping_alpha_set);
 910             }
 911
 912             if (methods.FirstOrDefault(m => m.Name == "SetMappingAlpha") != null)
 913             {
 914                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_alpha_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_alpha_set_static_delegate) });
 915             }
 916
 917             if (efl_gfx_mapping_coord_absolute_get_static_delegate == null)
 918             {
 919                 efl_gfx_mapping_coord_absolute_get_static_delegate = new efl_gfx_mapping_coord_absolute_get_delegate(mapping_coord_absolute_get);
 920             }
 921
 922             if (methods.FirstOrDefault(m => m.Name == "GetMappingCoordAbsolute") != null)
 923             {
 924                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_coord_absolute_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_coord_absolute_get_static_delegate) });
 925             }
 926
 927             if (efl_gfx_mapping_coord_absolute_set_static_delegate == null)
 928             {
 929                 efl_gfx_mapping_coord_absolute_set_static_delegate = new efl_gfx_mapping_coord_absolute_set_delegate(mapping_coord_absolute_set);
 930             }
 931
 932             if (methods.FirstOrDefault(m => m.Name == "SetMappingCoordAbsolute") != null)
 933             {
 934                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_coord_absolute_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_coord_absolute_set_static_delegate) });
 935             }
 936
 937             if (efl_gfx_mapping_uv_get_static_delegate == null)
 938             {
 939                 efl_gfx_mapping_uv_get_static_delegate = new efl_gfx_mapping_uv_get_delegate(mapping_uv_get);
 940             }
 941
 942             if (methods.FirstOrDefault(m => m.Name == "GetMappingUv") != null)
 943             {
 944                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_uv_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_uv_get_static_delegate) });
 945             }
 946
 947             if (efl_gfx_mapping_uv_set_static_delegate == null)
 948             {
 949                 efl_gfx_mapping_uv_set_static_delegate = new efl_gfx_mapping_uv_set_delegate(mapping_uv_set);
 950             }
 951
 952             if (methods.FirstOrDefault(m => m.Name == "SetMappingUv") != null)
 953             {
 954                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_uv_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_uv_set_static_delegate) });
 955             }
 956
 957             if (efl_gfx_mapping_color_get_static_delegate == null)
 958             {
 959                 efl_gfx_mapping_color_get_static_delegate = new efl_gfx_mapping_color_get_delegate(mapping_color_get);
 960             }
 961
 962             if (methods.FirstOrDefault(m => m.Name == "GetMappingColor") != null)
 963             {
 964                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_color_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_color_get_static_delegate) });
 965             }
 966
 967             if (efl_gfx_mapping_color_set_static_delegate == null)
 968             {
 969                 efl_gfx_mapping_color_set_static_delegate = new efl_gfx_mapping_color_set_delegate(mapping_color_set);
 970             }
 971
 972             if (methods.FirstOrDefault(m => m.Name == "SetMappingColor") != null)
 973             {
 974                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_color_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_color_set_static_delegate) });
 975             }
 976
 977             if (efl_gfx_mapping_has_static_delegate == null)
 978             {
 979                 efl_gfx_mapping_has_static_delegate = new efl_gfx_mapping_has_delegate(mapping_has);
 980             }
 981
 982             if (methods.FirstOrDefault(m => m.Name == "HasMapping") != null)
 983             {
 984                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_has"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_has_static_delegate) });
 985             }
 986
 987             if (efl_gfx_mapping_reset_static_delegate == null)
 988             {
 989                 efl_gfx_mapping_reset_static_delegate = new efl_gfx_mapping_reset_delegate(mapping_reset);
 990             }
 991
 992             if (methods.FirstOrDefault(m => m.Name == "ResetMapping") != null)
 993             {
 994                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_reset"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_reset_static_delegate) });
 995             }
 996
 997             if (efl_gfx_mapping_translate_static_delegate == null)
 998             {
 999                 efl_gfx_mapping_translate_static_delegate = new efl_gfx_mapping_translate_delegate(translate);
1000             }
1001
1002             if (methods.FirstOrDefault(m => m.Name == "Translate") != null)
1003             {
1004                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_translate"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_translate_static_delegate) });
1005             }
1006
1007             if (efl_gfx_mapping_rotate_static_delegate == null)
1008             {
1009                 efl_gfx_mapping_rotate_static_delegate = new efl_gfx_mapping_rotate_delegate(rotate);
1010             }
1011
1012             if (methods.FirstOrDefault(m => m.Name == "Rotate") != null)
1013             {
1014                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_rotate"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_rotate_static_delegate) });
1015             }
1016
1017             if (efl_gfx_mapping_rotate_3d_static_delegate == null)
1018             {
1019                 efl_gfx_mapping_rotate_3d_static_delegate = new efl_gfx_mapping_rotate_3d_delegate(rotate_3d);
1020             }
1021
1022             if (methods.FirstOrDefault(m => m.Name == "Rotate3d") != null)
1023             {
1024                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_rotate_3d"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_rotate_3d_static_delegate) });
1025             }
1026
1027             if (efl_gfx_mapping_rotate_quat_static_delegate == null)
1028             {
1029                 efl_gfx_mapping_rotate_quat_static_delegate = new efl_gfx_mapping_rotate_quat_delegate(rotate_quat);
1030             }
1031
1032             if (methods.FirstOrDefault(m => m.Name == "RotateQuat") != null)
1033             {
1034                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_rotate_quat"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_rotate_quat_static_delegate) });
1035             }
1036
1037             if (efl_gfx_mapping_zoom_static_delegate == null)
1038             {
1039                 efl_gfx_mapping_zoom_static_delegate = new efl_gfx_mapping_zoom_delegate(zoom);
1040             }
1041
1042             if (methods.FirstOrDefault(m => m.Name == "Zoom") != null)
1043             {
1044                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_zoom"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_zoom_static_delegate) });
1045             }
1046
1047             if (efl_gfx_mapping_lighting_3d_static_delegate == null)
1048             {
1049                 efl_gfx_mapping_lighting_3d_static_delegate = new efl_gfx_mapping_lighting_3d_delegate(lighting_3d);
1050             }
1051
1052             if (methods.FirstOrDefault(m => m.Name == "Lighting3d") != null)
1053             {
1054                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_lighting_3d"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_lighting_3d_static_delegate) });
1055             }
1056
1057             if (efl_gfx_mapping_perspective_3d_static_delegate == null)
1058             {
1059                 efl_gfx_mapping_perspective_3d_static_delegate = new efl_gfx_mapping_perspective_3d_delegate(perspective_3d);
1060             }
1061
1062             if (methods.FirstOrDefault(m => m.Name == "Perspective3d") != null)
1063             {
1064                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_perspective_3d"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_perspective_3d_static_delegate) });
1065             }
1066
1067             if (efl_gfx_mapping_rotate_absolute_static_delegate == null)
1068             {
1069                 efl_gfx_mapping_rotate_absolute_static_delegate = new efl_gfx_mapping_rotate_absolute_delegate(rotate_absolute);
1070             }
1071
1072             if (methods.FirstOrDefault(m => m.Name == "RotateAbsolute") != null)
1073             {
1074                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_rotate_absolute"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_rotate_absolute_static_delegate) });
1075             }
1076
1077             if (efl_gfx_mapping_rotate_3d_absolute_static_delegate == null)
1078             {
1079                 efl_gfx_mapping_rotate_3d_absolute_static_delegate = new efl_gfx_mapping_rotate_3d_absolute_delegate(rotate_3d_absolute);
1080             }
1081
1082             if (methods.FirstOrDefault(m => m.Name == "Rotate3dAbsolute") != null)
1083             {
1084                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_rotate_3d_absolute"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_rotate_3d_absolute_static_delegate) });
1085             }
1086
1087             if (efl_gfx_mapping_rotate_quat_absolute_static_delegate == null)
1088             {
1089                 efl_gfx_mapping_rotate_quat_absolute_static_delegate = new efl_gfx_mapping_rotate_quat_absolute_delegate(rotate_quat_absolute);
1090             }
1091
1092             if (methods.FirstOrDefault(m => m.Name == "RotateQuatAbsolute") != null)
1093             {
1094                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_rotate_quat_absolute"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_rotate_quat_absolute_static_delegate) });
1095             }
1096
1097             if (efl_gfx_mapping_zoom_absolute_static_delegate == null)
1098             {
1099                 efl_gfx_mapping_zoom_absolute_static_delegate = new efl_gfx_mapping_zoom_absolute_delegate(zoom_absolute);
1100             }
1101
1102             if (methods.FirstOrDefault(m => m.Name == "ZoomAbsolute") != null)
1103             {
1104                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_zoom_absolute"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_zoom_absolute_static_delegate) });
1105             }
1106
1107             if (efl_gfx_mapping_lighting_3d_absolute_static_delegate == null)
1108             {
1109                 efl_gfx_mapping_lighting_3d_absolute_static_delegate = new efl_gfx_mapping_lighting_3d_absolute_delegate(lighting_3d_absolute);
1110             }
1111
1112             if (methods.FirstOrDefault(m => m.Name == "Lighting3dAbsolute") != null)
1113             {
1114                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_lighting_3d_absolute"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_lighting_3d_absolute_static_delegate) });
1115             }
1116
1117             if (efl_gfx_mapping_perspective_3d_absolute_static_delegate == null)
1118             {
1119                 efl_gfx_mapping_perspective_3d_absolute_static_delegate = new efl_gfx_mapping_perspective_3d_absolute_delegate(perspective_3d_absolute);
1120             }
1121
1122             if (methods.FirstOrDefault(m => m.Name == "Perspective3dAbsolute") != null)
1123             {
1124                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_mapping_perspective_3d_absolute"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_mapping_perspective_3d_absolute_static_delegate) });
1125             }
1126
1127             return descs;
1128         }
1129         /// <summary>Returns the Eo class for the native methods of this class.</summary>
1130         /// <returns>The native class pointer.</returns>
1131         public override IntPtr GetEflClass()
1132         {
1133             return Efl.Gfx.IMappingConcrete.efl_gfx_mapping_mixin_get();
1134         }
1135
1136         #pragma warning disable CA1707, SA1300, SA1600
1137
1138
1139         private delegate int efl_gfx_mapping_point_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
1140
1141
1142         public delegate int efl_gfx_mapping_point_count_get_api_delegate(System.IntPtr obj);
1143
1144         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_point_count_get_api_delegate> efl_gfx_mapping_point_count_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_point_count_get_api_delegate>(Module, "efl_gfx_mapping_point_count_get");
1145
1146         private static int mapping_point_count_get(System.IntPtr obj, System.IntPtr pd)
1147         {
1148             Eina.Log.Debug("function efl_gfx_mapping_point_count_get was called");
1149             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1150             if (wrapper != null)
1151             {
1152             int _ret_var = default(int);
1153                 try
1154                 {
1155                     _ret_var = ((IMappingConcrete)wrapper).GetMappingPointCount();
1156                 }
1157                 catch (Exception e)
1158                 {
1159                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1160                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1161                 }
1162
1163         return _ret_var;
1164
1165             }
1166             else
1167             {
1168                 return efl_gfx_mapping_point_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1169             }
1170         }
1171
1172         private static efl_gfx_mapping_point_count_get_delegate efl_gfx_mapping_point_count_get_static_delegate;
1173
1174
1175         private delegate void efl_gfx_mapping_point_count_set_delegate(System.IntPtr obj, System.IntPtr pd,  int count);
1176
1177
1178         public delegate void efl_gfx_mapping_point_count_set_api_delegate(System.IntPtr obj,  int count);
1179
1180         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_point_count_set_api_delegate> efl_gfx_mapping_point_count_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_point_count_set_api_delegate>(Module, "efl_gfx_mapping_point_count_set");
1181
1182         private static void mapping_point_count_set(System.IntPtr obj, System.IntPtr pd, int count)
1183         {
1184             Eina.Log.Debug("function efl_gfx_mapping_point_count_set was called");
1185             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1186             if (wrapper != null)
1187             {
1188
1189                 try
1190                 {
1191                     ((IMappingConcrete)wrapper).SetMappingPointCount(count);
1192                 }
1193                 catch (Exception e)
1194                 {
1195                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1196                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1197                 }
1198
1199
1200             }
1201             else
1202             {
1203                 efl_gfx_mapping_point_count_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), count);
1204             }
1205         }
1206
1207         private static efl_gfx_mapping_point_count_set_delegate efl_gfx_mapping_point_count_set_static_delegate;
1208
1209         [return: MarshalAs(UnmanagedType.U1)]
1210         private delegate bool efl_gfx_mapping_clockwise_get_delegate(System.IntPtr obj, System.IntPtr pd);
1211
1212         [return: MarshalAs(UnmanagedType.U1)]
1213         public delegate bool efl_gfx_mapping_clockwise_get_api_delegate(System.IntPtr obj);
1214
1215         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_clockwise_get_api_delegate> efl_gfx_mapping_clockwise_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_clockwise_get_api_delegate>(Module, "efl_gfx_mapping_clockwise_get");
1216
1217         private static bool mapping_clockwise_get(System.IntPtr obj, System.IntPtr pd)
1218         {
1219             Eina.Log.Debug("function efl_gfx_mapping_clockwise_get was called");
1220             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1221             if (wrapper != null)
1222             {
1223             bool _ret_var = default(bool);
1224                 try
1225                 {
1226                     _ret_var = ((IMappingConcrete)wrapper).GetMappingClockwise();
1227                 }
1228                 catch (Exception e)
1229                 {
1230                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1231                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1232                 }
1233
1234         return _ret_var;
1235
1236             }
1237             else
1238             {
1239                 return efl_gfx_mapping_clockwise_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1240             }
1241         }
1242
1243         private static efl_gfx_mapping_clockwise_get_delegate efl_gfx_mapping_clockwise_get_static_delegate;
1244
1245         [return: MarshalAs(UnmanagedType.U1)]
1246         private delegate bool efl_gfx_mapping_smooth_get_delegate(System.IntPtr obj, System.IntPtr pd);
1247
1248         [return: MarshalAs(UnmanagedType.U1)]
1249         public delegate bool efl_gfx_mapping_smooth_get_api_delegate(System.IntPtr obj);
1250
1251         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_smooth_get_api_delegate> efl_gfx_mapping_smooth_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_smooth_get_api_delegate>(Module, "efl_gfx_mapping_smooth_get");
1252
1253         private static bool mapping_smooth_get(System.IntPtr obj, System.IntPtr pd)
1254         {
1255             Eina.Log.Debug("function efl_gfx_mapping_smooth_get was called");
1256             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1257             if (wrapper != null)
1258             {
1259             bool _ret_var = default(bool);
1260                 try
1261                 {
1262                     _ret_var = ((IMappingConcrete)wrapper).GetMappingSmooth();
1263                 }
1264                 catch (Exception e)
1265                 {
1266                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1267                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1268                 }
1269
1270         return _ret_var;
1271
1272             }
1273             else
1274             {
1275                 return efl_gfx_mapping_smooth_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1276             }
1277         }
1278
1279         private static efl_gfx_mapping_smooth_get_delegate efl_gfx_mapping_smooth_get_static_delegate;
1280
1281
1282         private delegate void efl_gfx_mapping_smooth_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool smooth);
1283
1284
1285         public delegate void efl_gfx_mapping_smooth_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool smooth);
1286
1287         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_smooth_set_api_delegate> efl_gfx_mapping_smooth_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_smooth_set_api_delegate>(Module, "efl_gfx_mapping_smooth_set");
1288
1289         private static void mapping_smooth_set(System.IntPtr obj, System.IntPtr pd, bool smooth)
1290         {
1291             Eina.Log.Debug("function efl_gfx_mapping_smooth_set was called");
1292             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1293             if (wrapper != null)
1294             {
1295
1296                 try
1297                 {
1298                     ((IMappingConcrete)wrapper).SetMappingSmooth(smooth);
1299                 }
1300                 catch (Exception e)
1301                 {
1302                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1303                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1304                 }
1305
1306
1307             }
1308             else
1309             {
1310                 efl_gfx_mapping_smooth_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), smooth);
1311             }
1312         }
1313
1314         private static efl_gfx_mapping_smooth_set_delegate efl_gfx_mapping_smooth_set_static_delegate;
1315
1316         [return: MarshalAs(UnmanagedType.U1)]
1317         private delegate bool efl_gfx_mapping_alpha_get_delegate(System.IntPtr obj, System.IntPtr pd);
1318
1319         [return: MarshalAs(UnmanagedType.U1)]
1320         public delegate bool efl_gfx_mapping_alpha_get_api_delegate(System.IntPtr obj);
1321
1322         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_alpha_get_api_delegate> efl_gfx_mapping_alpha_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_alpha_get_api_delegate>(Module, "efl_gfx_mapping_alpha_get");
1323
1324         private static bool mapping_alpha_get(System.IntPtr obj, System.IntPtr pd)
1325         {
1326             Eina.Log.Debug("function efl_gfx_mapping_alpha_get was called");
1327             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1328             if (wrapper != null)
1329             {
1330             bool _ret_var = default(bool);
1331                 try
1332                 {
1333                     _ret_var = ((IMappingConcrete)wrapper).GetMappingAlpha();
1334                 }
1335                 catch (Exception e)
1336                 {
1337                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1338                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1339                 }
1340
1341         return _ret_var;
1342
1343             }
1344             else
1345             {
1346                 return efl_gfx_mapping_alpha_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1347             }
1348         }
1349
1350         private static efl_gfx_mapping_alpha_get_delegate efl_gfx_mapping_alpha_get_static_delegate;
1351
1352
1353         private delegate void efl_gfx_mapping_alpha_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool alpha);
1354
1355
1356         public delegate void efl_gfx_mapping_alpha_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool alpha);
1357
1358         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_alpha_set_api_delegate> efl_gfx_mapping_alpha_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_alpha_set_api_delegate>(Module, "efl_gfx_mapping_alpha_set");
1359
1360         private static void mapping_alpha_set(System.IntPtr obj, System.IntPtr pd, bool alpha)
1361         {
1362             Eina.Log.Debug("function efl_gfx_mapping_alpha_set was called");
1363             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1364             if (wrapper != null)
1365             {
1366
1367                 try
1368                 {
1369                     ((IMappingConcrete)wrapper).SetMappingAlpha(alpha);
1370                 }
1371                 catch (Exception e)
1372                 {
1373                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1374                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1375                 }
1376
1377
1378             }
1379             else
1380             {
1381                 efl_gfx_mapping_alpha_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), alpha);
1382             }
1383         }
1384
1385         private static efl_gfx_mapping_alpha_set_delegate efl_gfx_mapping_alpha_set_static_delegate;
1386
1387
1388         private delegate void efl_gfx_mapping_coord_absolute_get_delegate(System.IntPtr obj, System.IntPtr pd,  int idx,  out double x,  out double y,  out double z);
1389
1390
1391         public delegate void efl_gfx_mapping_coord_absolute_get_api_delegate(System.IntPtr obj,  int idx,  out double x,  out double y,  out double z);
1392
1393         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_coord_absolute_get_api_delegate> efl_gfx_mapping_coord_absolute_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_coord_absolute_get_api_delegate>(Module, "efl_gfx_mapping_coord_absolute_get");
1394
1395         private static void mapping_coord_absolute_get(System.IntPtr obj, System.IntPtr pd, int idx, out double x, out double y, out double z)
1396         {
1397             Eina.Log.Debug("function efl_gfx_mapping_coord_absolute_get was called");
1398             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1399             if (wrapper != null)
1400             {
1401                                                 x = default(double);        y = default(double);        z = default(double);
1402                 try
1403                 {
1404                     ((IMappingConcrete)wrapper).GetMappingCoordAbsolute(idx, out x, out y, out z);
1405                 }
1406                 catch (Exception e)
1407                 {
1408                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1409                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1410                 }
1411
1412
1413             }
1414             else
1415             {
1416                 efl_gfx_mapping_coord_absolute_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), idx, out x, out y, out z);
1417             }
1418         }
1419
1420         private static efl_gfx_mapping_coord_absolute_get_delegate efl_gfx_mapping_coord_absolute_get_static_delegate;
1421
1422
1423         private delegate void efl_gfx_mapping_coord_absolute_set_delegate(System.IntPtr obj, System.IntPtr pd,  int idx,  double x,  double y,  double z);
1424
1425
1426         public delegate void efl_gfx_mapping_coord_absolute_set_api_delegate(System.IntPtr obj,  int idx,  double x,  double y,  double z);
1427
1428         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_coord_absolute_set_api_delegate> efl_gfx_mapping_coord_absolute_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_coord_absolute_set_api_delegate>(Module, "efl_gfx_mapping_coord_absolute_set");
1429
1430         private static void mapping_coord_absolute_set(System.IntPtr obj, System.IntPtr pd, int idx, double x, double y, double z)
1431         {
1432             Eina.Log.Debug("function efl_gfx_mapping_coord_absolute_set was called");
1433             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1434             if (wrapper != null)
1435             {
1436
1437                 try
1438                 {
1439                     ((IMappingConcrete)wrapper).SetMappingCoordAbsolute(idx, x, y, z);
1440                 }
1441                 catch (Exception e)
1442                 {
1443                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1444                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1445                 }
1446
1447
1448             }
1449             else
1450             {
1451                 efl_gfx_mapping_coord_absolute_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), idx, x, y, z);
1452             }
1453         }
1454
1455         private static efl_gfx_mapping_coord_absolute_set_delegate efl_gfx_mapping_coord_absolute_set_static_delegate;
1456
1457
1458         private delegate void efl_gfx_mapping_uv_get_delegate(System.IntPtr obj, System.IntPtr pd,  int idx,  out double u,  out double v);
1459
1460
1461         public delegate void efl_gfx_mapping_uv_get_api_delegate(System.IntPtr obj,  int idx,  out double u,  out double v);
1462
1463         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_uv_get_api_delegate> efl_gfx_mapping_uv_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_uv_get_api_delegate>(Module, "efl_gfx_mapping_uv_get");
1464
1465         private static void mapping_uv_get(System.IntPtr obj, System.IntPtr pd, int idx, out double u, out double v)
1466         {
1467             Eina.Log.Debug("function efl_gfx_mapping_uv_get was called");
1468             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1469             if (wrapper != null)
1470             {
1471                                         u = default(double);        v = default(double);
1472                 try
1473                 {
1474                     ((IMappingConcrete)wrapper).GetMappingUv(idx, out u, out v);
1475                 }
1476                 catch (Exception e)
1477                 {
1478                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1479                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1480                 }
1481
1482
1483             }
1484             else
1485             {
1486                 efl_gfx_mapping_uv_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), idx, out u, out v);
1487             }
1488         }
1489
1490         private static efl_gfx_mapping_uv_get_delegate efl_gfx_mapping_uv_get_static_delegate;
1491
1492
1493         private delegate void efl_gfx_mapping_uv_set_delegate(System.IntPtr obj, System.IntPtr pd,  int idx,  double u,  double v);
1494
1495
1496         public delegate void efl_gfx_mapping_uv_set_api_delegate(System.IntPtr obj,  int idx,  double u,  double v);
1497
1498         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_uv_set_api_delegate> efl_gfx_mapping_uv_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_uv_set_api_delegate>(Module, "efl_gfx_mapping_uv_set");
1499
1500         private static void mapping_uv_set(System.IntPtr obj, System.IntPtr pd, int idx, double u, double v)
1501         {
1502             Eina.Log.Debug("function efl_gfx_mapping_uv_set was called");
1503             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1504             if (wrapper != null)
1505             {
1506
1507                 try
1508                 {
1509                     ((IMappingConcrete)wrapper).SetMappingUv(idx, u, v);
1510                 }
1511                 catch (Exception e)
1512                 {
1513                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1514                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1515                 }
1516
1517
1518             }
1519             else
1520             {
1521                 efl_gfx_mapping_uv_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), idx, u, v);
1522             }
1523         }
1524
1525         private static efl_gfx_mapping_uv_set_delegate efl_gfx_mapping_uv_set_static_delegate;
1526
1527
1528         private delegate void efl_gfx_mapping_color_get_delegate(System.IntPtr obj, System.IntPtr pd,  int idx,  out int r,  out int g,  out int b,  out int a);
1529
1530
1531         public delegate void efl_gfx_mapping_color_get_api_delegate(System.IntPtr obj,  int idx,  out int r,  out int g,  out int b,  out int a);
1532
1533         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_color_get_api_delegate> efl_gfx_mapping_color_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_color_get_api_delegate>(Module, "efl_gfx_mapping_color_get");
1534
1535         private static void mapping_color_get(System.IntPtr obj, System.IntPtr pd, int idx, out int r, out int g, out int b, out int a)
1536         {
1537             Eina.Log.Debug("function efl_gfx_mapping_color_get was called");
1538             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1539             if (wrapper != null)
1540             {
1541                                                         r = default(int);        g = default(int);        b = default(int);        a = default(int);
1542                 try
1543                 {
1544                     ((IMappingConcrete)wrapper).GetMappingColor(idx, out r, out g, out b, out a);
1545                 }
1546                 catch (Exception e)
1547                 {
1548                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1549                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1550                 }
1551
1552
1553             }
1554             else
1555             {
1556                 efl_gfx_mapping_color_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), idx, out r, out g, out b, out a);
1557             }
1558         }
1559
1560         private static efl_gfx_mapping_color_get_delegate efl_gfx_mapping_color_get_static_delegate;
1561
1562
1563         private delegate void efl_gfx_mapping_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  int idx,  int r,  int g,  int b,  int a);
1564
1565
1566         public delegate void efl_gfx_mapping_color_set_api_delegate(System.IntPtr obj,  int idx,  int r,  int g,  int b,  int a);
1567
1568         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_color_set_api_delegate> efl_gfx_mapping_color_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_color_set_api_delegate>(Module, "efl_gfx_mapping_color_set");
1569
1570         private static void mapping_color_set(System.IntPtr obj, System.IntPtr pd, int idx, int r, int g, int b, int a)
1571         {
1572             Eina.Log.Debug("function efl_gfx_mapping_color_set was called");
1573             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1574             if (wrapper != null)
1575             {
1576
1577                 try
1578                 {
1579                     ((IMappingConcrete)wrapper).SetMappingColor(idx, r, g, b, a);
1580                 }
1581                 catch (Exception e)
1582                 {
1583                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1584                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1585                 }
1586
1587
1588             }
1589             else
1590             {
1591                 efl_gfx_mapping_color_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), idx, r, g, b, a);
1592             }
1593         }
1594
1595         private static efl_gfx_mapping_color_set_delegate efl_gfx_mapping_color_set_static_delegate;
1596
1597         [return: MarshalAs(UnmanagedType.U1)]
1598         private delegate bool efl_gfx_mapping_has_delegate(System.IntPtr obj, System.IntPtr pd);
1599
1600         [return: MarshalAs(UnmanagedType.U1)]
1601         public delegate bool efl_gfx_mapping_has_api_delegate(System.IntPtr obj);
1602
1603         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_has_api_delegate> efl_gfx_mapping_has_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_has_api_delegate>(Module, "efl_gfx_mapping_has");
1604
1605         private static bool mapping_has(System.IntPtr obj, System.IntPtr pd)
1606         {
1607             Eina.Log.Debug("function efl_gfx_mapping_has was called");
1608             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1609             if (wrapper != null)
1610             {
1611             bool _ret_var = default(bool);
1612                 try
1613                 {
1614                     _ret_var = ((IMappingConcrete)wrapper).HasMapping();
1615                 }
1616                 catch (Exception e)
1617                 {
1618                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1619                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1620                 }
1621
1622         return _ret_var;
1623
1624             }
1625             else
1626             {
1627                 return efl_gfx_mapping_has_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1628             }
1629         }
1630
1631         private static efl_gfx_mapping_has_delegate efl_gfx_mapping_has_static_delegate;
1632
1633
1634         private delegate void efl_gfx_mapping_reset_delegate(System.IntPtr obj, System.IntPtr pd);
1635
1636
1637         public delegate void efl_gfx_mapping_reset_api_delegate(System.IntPtr obj);
1638
1639         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_reset_api_delegate> efl_gfx_mapping_reset_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_reset_api_delegate>(Module, "efl_gfx_mapping_reset");
1640
1641         private static void mapping_reset(System.IntPtr obj, System.IntPtr pd)
1642         {
1643             Eina.Log.Debug("function efl_gfx_mapping_reset was called");
1644             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1645             if (wrapper != null)
1646             {
1647
1648                 try
1649                 {
1650                     ((IMappingConcrete)wrapper).ResetMapping();
1651                 }
1652                 catch (Exception e)
1653                 {
1654                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1655                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1656                 }
1657
1658
1659             }
1660             else
1661             {
1662                 efl_gfx_mapping_reset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1663             }
1664         }
1665
1666         private static efl_gfx_mapping_reset_delegate efl_gfx_mapping_reset_static_delegate;
1667
1668
1669         private delegate void efl_gfx_mapping_translate_delegate(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy,  double dz);
1670
1671
1672         public delegate void efl_gfx_mapping_translate_api_delegate(System.IntPtr obj,  double dx,  double dy,  double dz);
1673
1674         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_translate_api_delegate> efl_gfx_mapping_translate_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_translate_api_delegate>(Module, "efl_gfx_mapping_translate");
1675
1676         private static void translate(System.IntPtr obj, System.IntPtr pd, double dx, double dy, double dz)
1677         {
1678             Eina.Log.Debug("function efl_gfx_mapping_translate was called");
1679             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1680             if (wrapper != null)
1681             {
1682
1683                 try
1684                 {
1685                     ((IMappingConcrete)wrapper).Translate(dx, dy, dz);
1686                 }
1687                 catch (Exception e)
1688                 {
1689                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1690                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1691                 }
1692
1693
1694             }
1695             else
1696             {
1697                 efl_gfx_mapping_translate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dx, dy, dz);
1698             }
1699         }
1700
1701         private static efl_gfx_mapping_translate_delegate efl_gfx_mapping_translate_static_delegate;
1702
1703
1704         private delegate void efl_gfx_mapping_rotate_delegate(System.IntPtr obj, System.IntPtr pd,  double degrees, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot,  double cx,  double cy);
1705
1706
1707         public delegate void efl_gfx_mapping_rotate_api_delegate(System.IntPtr obj,  double degrees, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot,  double cx,  double cy);
1708
1709         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_api_delegate> efl_gfx_mapping_rotate_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_api_delegate>(Module, "efl_gfx_mapping_rotate");
1710
1711         private static void rotate(System.IntPtr obj, System.IntPtr pd, double degrees, Efl.Gfx.IEntity pivot, double cx, double cy)
1712         {
1713             Eina.Log.Debug("function efl_gfx_mapping_rotate was called");
1714             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1715             if (wrapper != null)
1716             {
1717
1718                 try
1719                 {
1720                     ((IMappingConcrete)wrapper).Rotate(degrees, pivot, cx, cy);
1721                 }
1722                 catch (Exception e)
1723                 {
1724                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1725                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1726                 }
1727
1728
1729             }
1730             else
1731             {
1732                 efl_gfx_mapping_rotate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), degrees, pivot, cx, cy);
1733             }
1734         }
1735
1736         private static efl_gfx_mapping_rotate_delegate efl_gfx_mapping_rotate_static_delegate;
1737
1738
1739         private delegate void efl_gfx_mapping_rotate_3d_delegate(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy,  double dz, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot,  double cx,  double cy,  double cz);
1740
1741
1742         public delegate void efl_gfx_mapping_rotate_3d_api_delegate(System.IntPtr obj,  double dx,  double dy,  double dz, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot,  double cx,  double cy,  double cz);
1743
1744         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_3d_api_delegate> efl_gfx_mapping_rotate_3d_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_3d_api_delegate>(Module, "efl_gfx_mapping_rotate_3d");
1745
1746         private static void rotate_3d(System.IntPtr obj, System.IntPtr pd, double dx, double dy, double dz, Efl.Gfx.IEntity pivot, double cx, double cy, double cz)
1747         {
1748             Eina.Log.Debug("function efl_gfx_mapping_rotate_3d was called");
1749             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1750             if (wrapper != null)
1751             {
1752
1753                 try
1754                 {
1755                     ((IMappingConcrete)wrapper).Rotate3d(dx, dy, dz, pivot, cx, cy, cz);
1756                 }
1757                 catch (Exception e)
1758                 {
1759                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1760                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1761                 }
1762
1763
1764             }
1765             else
1766             {
1767                 efl_gfx_mapping_rotate_3d_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dx, dy, dz, pivot, cx, cy, cz);
1768             }
1769         }
1770
1771         private static efl_gfx_mapping_rotate_3d_delegate efl_gfx_mapping_rotate_3d_static_delegate;
1772
1773
1774         private delegate void efl_gfx_mapping_rotate_quat_delegate(System.IntPtr obj, System.IntPtr pd,  double qx,  double qy,  double qz,  double qw, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot,  double cx,  double cy,  double cz);
1775
1776
1777         public delegate void efl_gfx_mapping_rotate_quat_api_delegate(System.IntPtr obj,  double qx,  double qy,  double qz,  double qw, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot,  double cx,  double cy,  double cz);
1778
1779         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_quat_api_delegate> efl_gfx_mapping_rotate_quat_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_quat_api_delegate>(Module, "efl_gfx_mapping_rotate_quat");
1780
1781         private static void rotate_quat(System.IntPtr obj, System.IntPtr pd, double qx, double qy, double qz, double qw, Efl.Gfx.IEntity pivot, double cx, double cy, double cz)
1782         {
1783             Eina.Log.Debug("function efl_gfx_mapping_rotate_quat was called");
1784             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1785             if (wrapper != null)
1786             {
1787
1788                 try
1789                 {
1790                     ((IMappingConcrete)wrapper).RotateQuat(qx, qy, qz, qw, pivot, cx, cy, cz);
1791                 }
1792                 catch (Exception e)
1793                 {
1794                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1795                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1796                 }
1797
1798
1799             }
1800             else
1801             {
1802                 efl_gfx_mapping_rotate_quat_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), qx, qy, qz, qw, pivot, cx, cy, cz);
1803             }
1804         }
1805
1806         private static efl_gfx_mapping_rotate_quat_delegate efl_gfx_mapping_rotate_quat_static_delegate;
1807
1808
1809         private delegate void efl_gfx_mapping_zoom_delegate(System.IntPtr obj, System.IntPtr pd,  double zoomx,  double zoomy, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot,  double cx,  double cy);
1810
1811
1812         public delegate void efl_gfx_mapping_zoom_api_delegate(System.IntPtr obj,  double zoomx,  double zoomy, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot,  double cx,  double cy);
1813
1814         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_zoom_api_delegate> efl_gfx_mapping_zoom_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_zoom_api_delegate>(Module, "efl_gfx_mapping_zoom");
1815
1816         private static void zoom(System.IntPtr obj, System.IntPtr pd, double zoomx, double zoomy, Efl.Gfx.IEntity pivot, double cx, double cy)
1817         {
1818             Eina.Log.Debug("function efl_gfx_mapping_zoom was called");
1819             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1820             if (wrapper != null)
1821             {
1822
1823                 try
1824                 {
1825                     ((IMappingConcrete)wrapper).Zoom(zoomx, zoomy, pivot, cx, cy);
1826                 }
1827                 catch (Exception e)
1828                 {
1829                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1830                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1831                 }
1832
1833
1834             }
1835             else
1836             {
1837                 efl_gfx_mapping_zoom_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), zoomx, zoomy, pivot, cx, cy);
1838             }
1839         }
1840
1841         private static efl_gfx_mapping_zoom_delegate efl_gfx_mapping_zoom_static_delegate;
1842
1843
1844         private delegate void efl_gfx_mapping_lighting_3d_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot,  double lx,  double ly,  double lz,  int lr,  int lg,  int lb,  int ar,  int ag,  int ab);
1845
1846
1847         public delegate void efl_gfx_mapping_lighting_3d_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot,  double lx,  double ly,  double lz,  int lr,  int lg,  int lb,  int ar,  int ag,  int ab);
1848
1849         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_lighting_3d_api_delegate> efl_gfx_mapping_lighting_3d_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_lighting_3d_api_delegate>(Module, "efl_gfx_mapping_lighting_3d");
1850
1851         private static void lighting_3d(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity pivot, double lx, double ly, double lz, int lr, int lg, int lb, int ar, int ag, int ab)
1852         {
1853             Eina.Log.Debug("function efl_gfx_mapping_lighting_3d was called");
1854             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1855             if (wrapper != null)
1856             {
1857
1858                 try
1859                 {
1860                     ((IMappingConcrete)wrapper).Lighting3d(pivot, lx, ly, lz, lr, lg, lb, ar, ag, ab);
1861                 }
1862                 catch (Exception e)
1863                 {
1864                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1865                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1866                 }
1867
1868
1869             }
1870             else
1871             {
1872                 efl_gfx_mapping_lighting_3d_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pivot, lx, ly, lz, lr, lg, lb, ar, ag, ab);
1873             }
1874         }
1875
1876         private static efl_gfx_mapping_lighting_3d_delegate efl_gfx_mapping_lighting_3d_static_delegate;
1877
1878
1879         private delegate void efl_gfx_mapping_perspective_3d_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot,  double px,  double py,  double z0,  double foc);
1880
1881
1882         public delegate void efl_gfx_mapping_perspective_3d_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity pivot,  double px,  double py,  double z0,  double foc);
1883
1884         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_perspective_3d_api_delegate> efl_gfx_mapping_perspective_3d_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_perspective_3d_api_delegate>(Module, "efl_gfx_mapping_perspective_3d");
1885
1886         private static void perspective_3d(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity pivot, double px, double py, double z0, double foc)
1887         {
1888             Eina.Log.Debug("function efl_gfx_mapping_perspective_3d was called");
1889             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1890             if (wrapper != null)
1891             {
1892
1893                 try
1894                 {
1895                     ((IMappingConcrete)wrapper).Perspective3d(pivot, px, py, z0, foc);
1896                 }
1897                 catch (Exception e)
1898                 {
1899                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1900                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1901                 }
1902
1903
1904             }
1905             else
1906             {
1907                 efl_gfx_mapping_perspective_3d_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pivot, px, py, z0, foc);
1908             }
1909         }
1910
1911         private static efl_gfx_mapping_perspective_3d_delegate efl_gfx_mapping_perspective_3d_static_delegate;
1912
1913
1914         private delegate void efl_gfx_mapping_rotate_absolute_delegate(System.IntPtr obj, System.IntPtr pd,  double degrees,  double cx,  double cy);
1915
1916
1917         public delegate void efl_gfx_mapping_rotate_absolute_api_delegate(System.IntPtr obj,  double degrees,  double cx,  double cy);
1918
1919         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_absolute_api_delegate> efl_gfx_mapping_rotate_absolute_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_absolute_api_delegate>(Module, "efl_gfx_mapping_rotate_absolute");
1920
1921         private static void rotate_absolute(System.IntPtr obj, System.IntPtr pd, double degrees, double cx, double cy)
1922         {
1923             Eina.Log.Debug("function efl_gfx_mapping_rotate_absolute was called");
1924             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1925             if (wrapper != null)
1926             {
1927
1928                 try
1929                 {
1930                     ((IMappingConcrete)wrapper).RotateAbsolute(degrees, cx, cy);
1931                 }
1932                 catch (Exception e)
1933                 {
1934                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1935                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1936                 }
1937
1938
1939             }
1940             else
1941             {
1942                 efl_gfx_mapping_rotate_absolute_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), degrees, cx, cy);
1943             }
1944         }
1945
1946         private static efl_gfx_mapping_rotate_absolute_delegate efl_gfx_mapping_rotate_absolute_static_delegate;
1947
1948
1949         private delegate void efl_gfx_mapping_rotate_3d_absolute_delegate(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy,  double dz,  double cx,  double cy,  double cz);
1950
1951
1952         public delegate void efl_gfx_mapping_rotate_3d_absolute_api_delegate(System.IntPtr obj,  double dx,  double dy,  double dz,  double cx,  double cy,  double cz);
1953
1954         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_3d_absolute_api_delegate> efl_gfx_mapping_rotate_3d_absolute_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_3d_absolute_api_delegate>(Module, "efl_gfx_mapping_rotate_3d_absolute");
1955
1956         private static void rotate_3d_absolute(System.IntPtr obj, System.IntPtr pd, double dx, double dy, double dz, double cx, double cy, double cz)
1957         {
1958             Eina.Log.Debug("function efl_gfx_mapping_rotate_3d_absolute was called");
1959             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1960             if (wrapper != null)
1961             {
1962
1963                 try
1964                 {
1965                     ((IMappingConcrete)wrapper).Rotate3dAbsolute(dx, dy, dz, cx, cy, cz);
1966                 }
1967                 catch (Exception e)
1968                 {
1969                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1970                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1971                 }
1972
1973
1974             }
1975             else
1976             {
1977                 efl_gfx_mapping_rotate_3d_absolute_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dx, dy, dz, cx, cy, cz);
1978             }
1979         }
1980
1981         private static efl_gfx_mapping_rotate_3d_absolute_delegate efl_gfx_mapping_rotate_3d_absolute_static_delegate;
1982
1983
1984         private delegate void efl_gfx_mapping_rotate_quat_absolute_delegate(System.IntPtr obj, System.IntPtr pd,  double qx,  double qy,  double qz,  double qw,  double cx,  double cy,  double cz);
1985
1986
1987         public delegate void efl_gfx_mapping_rotate_quat_absolute_api_delegate(System.IntPtr obj,  double qx,  double qy,  double qz,  double qw,  double cx,  double cy,  double cz);
1988
1989         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_quat_absolute_api_delegate> efl_gfx_mapping_rotate_quat_absolute_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_rotate_quat_absolute_api_delegate>(Module, "efl_gfx_mapping_rotate_quat_absolute");
1990
1991         private static void rotate_quat_absolute(System.IntPtr obj, System.IntPtr pd, double qx, double qy, double qz, double qw, double cx, double cy, double cz)
1992         {
1993             Eina.Log.Debug("function efl_gfx_mapping_rotate_quat_absolute was called");
1994             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1995             if (wrapper != null)
1996             {
1997
1998                 try
1999                 {
2000                     ((IMappingConcrete)wrapper).RotateQuatAbsolute(qx, qy, qz, qw, cx, cy, cz);
2001                 }
2002                 catch (Exception e)
2003                 {
2004                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2005                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2006                 }
2007
2008
2009             }
2010             else
2011             {
2012                 efl_gfx_mapping_rotate_quat_absolute_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), qx, qy, qz, qw, cx, cy, cz);
2013             }
2014         }
2015
2016         private static efl_gfx_mapping_rotate_quat_absolute_delegate efl_gfx_mapping_rotate_quat_absolute_static_delegate;
2017
2018
2019         private delegate void efl_gfx_mapping_zoom_absolute_delegate(System.IntPtr obj, System.IntPtr pd,  double zoomx,  double zoomy,  double cx,  double cy);
2020
2021
2022         public delegate void efl_gfx_mapping_zoom_absolute_api_delegate(System.IntPtr obj,  double zoomx,  double zoomy,  double cx,  double cy);
2023
2024         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_zoom_absolute_api_delegate> efl_gfx_mapping_zoom_absolute_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_zoom_absolute_api_delegate>(Module, "efl_gfx_mapping_zoom_absolute");
2025
2026         private static void zoom_absolute(System.IntPtr obj, System.IntPtr pd, double zoomx, double zoomy, double cx, double cy)
2027         {
2028             Eina.Log.Debug("function efl_gfx_mapping_zoom_absolute was called");
2029             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2030             if (wrapper != null)
2031             {
2032
2033                 try
2034                 {
2035                     ((IMappingConcrete)wrapper).ZoomAbsolute(zoomx, zoomy, cx, cy);
2036                 }
2037                 catch (Exception e)
2038                 {
2039                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2040                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2041                 }
2042
2043
2044             }
2045             else
2046             {
2047                 efl_gfx_mapping_zoom_absolute_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), zoomx, zoomy, cx, cy);
2048             }
2049         }
2050
2051         private static efl_gfx_mapping_zoom_absolute_delegate efl_gfx_mapping_zoom_absolute_static_delegate;
2052
2053
2054         private delegate void efl_gfx_mapping_lighting_3d_absolute_delegate(System.IntPtr obj, System.IntPtr pd,  double lx,  double ly,  double lz,  int lr,  int lg,  int lb,  int ar,  int ag,  int ab);
2055
2056
2057         public delegate void efl_gfx_mapping_lighting_3d_absolute_api_delegate(System.IntPtr obj,  double lx,  double ly,  double lz,  int lr,  int lg,  int lb,  int ar,  int ag,  int ab);
2058
2059         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_lighting_3d_absolute_api_delegate> efl_gfx_mapping_lighting_3d_absolute_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_lighting_3d_absolute_api_delegate>(Module, "efl_gfx_mapping_lighting_3d_absolute");
2060
2061         private static void lighting_3d_absolute(System.IntPtr obj, System.IntPtr pd, double lx, double ly, double lz, int lr, int lg, int lb, int ar, int ag, int ab)
2062         {
2063             Eina.Log.Debug("function efl_gfx_mapping_lighting_3d_absolute was called");
2064             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2065             if (wrapper != null)
2066             {
2067
2068                 try
2069                 {
2070                     ((IMappingConcrete)wrapper).Lighting3dAbsolute(lx, ly, lz, lr, lg, lb, ar, ag, ab);
2071                 }
2072                 catch (Exception e)
2073                 {
2074                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2075                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2076                 }
2077
2078
2079             }
2080             else
2081             {
2082                 efl_gfx_mapping_lighting_3d_absolute_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), lx, ly, lz, lr, lg, lb, ar, ag, ab);
2083             }
2084         }
2085
2086         private static efl_gfx_mapping_lighting_3d_absolute_delegate efl_gfx_mapping_lighting_3d_absolute_static_delegate;
2087
2088
2089         private delegate void efl_gfx_mapping_perspective_3d_absolute_delegate(System.IntPtr obj, System.IntPtr pd,  double px,  double py,  double z0,  double foc);
2090
2091
2092         public delegate void efl_gfx_mapping_perspective_3d_absolute_api_delegate(System.IntPtr obj,  double px,  double py,  double z0,  double foc);
2093
2094         public static Efl.Eo.FunctionWrapper<efl_gfx_mapping_perspective_3d_absolute_api_delegate> efl_gfx_mapping_perspective_3d_absolute_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_mapping_perspective_3d_absolute_api_delegate>(Module, "efl_gfx_mapping_perspective_3d_absolute");
2095
2096         private static void perspective_3d_absolute(System.IntPtr obj, System.IntPtr pd, double px, double py, double z0, double foc)
2097         {
2098             Eina.Log.Debug("function efl_gfx_mapping_perspective_3d_absolute was called");
2099             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2100             if (wrapper != null)
2101             {
2102
2103                 try
2104                 {
2105                     ((IMappingConcrete)wrapper).Perspective3dAbsolute(px, py, z0, foc);
2106                 }
2107                 catch (Exception e)
2108                 {
2109                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2110                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2111                 }
2112
2113
2114             }
2115             else
2116             {
2117                 efl_gfx_mapping_perspective_3d_absolute_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), px, py, z0, foc);
2118             }
2119         }
2120
2121         private static efl_gfx_mapping_perspective_3d_absolute_delegate efl_gfx_mapping_perspective_3d_absolute_static_delegate;
2122
2123         #pragma warning restore CA1707, SA1300, SA1600
2124
2125 }
2126 }
2127 }
2128
2129 }
2130