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