src/Tizen.NUI/src/public/Vector4.cs

   1 /** Copyright (c) 2017 Samsung Electronics Co., Ltd.
   2 *
   3 * Licensed under the Apache License, Version 2.0 (the "License");
   4 * you may not use this file except in compliance with the License.
   5 * You may obtain a copy of the License at
   6 *
   7 * http://www.apache.org/licenses/LICENSE-2.0
   8 *
   9 * Unless required by applicable law or agreed to in writing, software
  10 * distributed under the License is distributed on an "AS IS" BASIS,
  11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 * See the License for the specific language governing permissions and
  13 * limitations under the License.
  14 *
  15 */
  16
  17 namespace Tizen.NUI
  18 {
  19
  20     /// <summary>
  21     /// A four-dimensional vector.
  22     /// </summary>
  23     public class Vector4 : global::System.IDisposable
  24     {
  25         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  26         protected bool swigCMemOwn;
  27
  28         internal Vector4(global::System.IntPtr cPtr, bool cMemoryOwn)
  29         {
  30             swigCMemOwn = cMemoryOwn;
  31             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  32         }
  33
  34         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Vector4 obj)
  35         {
  36             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  37         }
  38
  39         //A Flag to check who called Dispose(). (By User or DisposeQueue)
  40         private bool isDisposeQueued = false;
  41         //A Flat to check if it is already disposed.
  42         protected bool disposed = false;
  43
  44         ~Vector4()
  45         {
  46             if(!isDisposeQueued)
  47             {
  48                 isDisposeQueued = true;
  49                 DisposeQueue.Instance.Add(this);
  50             }
  51         }
  52
  53         public void Dispose()
  54         {
  55             //Throw excpetion if Dispose() is called in separate thread.
  56             if (!Window.IsInstalled())
  57             {
  58                 throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
  59             }
  60
  61             if (isDisposeQueued)
  62             {
  63                 Dispose(DisposeTypes.Implicit);
  64             }
  65             else
  66             {
  67                 Dispose(DisposeTypes.Explicit);
  68                 System.GC.SuppressFinalize(this);
  69             }
  70         }
  71
  72         protected virtual void Dispose(DisposeTypes type)
  73         {
  74             if (disposed)
  75             {
  76                 return;
  77             }
  78
  79             if(type == DisposeTypes.Explicit)
  80             {
  81                 //Called by User
  82                 //Release your own managed resources here.
  83                 //You should release all of your own disposable objects here.
  84             }
  85
  86             //Release your own unmanaged resources here.
  87             //You should not access any managed member here except static instance.
  88             //because the execution order of Finalizes is non-deterministic.
  89
  90             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  91             {
  92                 if (swigCMemOwn)
  93                 {
  94                     swigCMemOwn = false;
  95                     NDalicPINVOKE.delete_Vector4(swigCPtr);
  96                 }
  97                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  98             }
  99             disposed = true;
 100         }
 101
 102         /// <summary>
 103         /// The addition operator.
 104         /// </summary>
 105         /// <param name="arg1">The first value.</param>
 106         /// <param name="arg2">The second value.</param>
 107         /// <returns>The vector containing the result of the addition.</returns>
 108         /// <since_tizen> 3 </since_tizen>
 109         public static Vector4 operator +(Vector4 arg1, Vector4 arg2)
 110         {
 111             return arg1.Add(arg2);
 112         }
 113
 114         /// <summary>
 115         /// The subtraction operator.
 116         /// </summary>
 117         /// <param name="arg1">The first value.</param>
 118         /// <param name="arg2">The second value.</param>
 119         /// <returns>The vector containing the result of the subtraction.</returns>
 120         /// <since_tizen> 3 </since_tizen>
 121         public static Vector4 operator -(Vector4 arg1, Vector4 arg2)
 122         {
 123             return arg1.Subtract(arg2);
 124         }
 125
 126         /// <summary>
 127         /// The unary negation operator.
 128         /// </summary>
 129         /// <param name="arg1">The target value.</param>
 130         /// <returns>The vector containing the negation.</returns>
 131         /// <since_tizen> 3 </since_tizen>
 132         public static Vector4 operator -(Vector4 arg1)
 133         {
 134             return arg1.Subtract();
 135         }
 136
 137         /// <summary>
 138         /// The multiplication operator.
 139         /// </summary>
 140         /// <param name="arg1">The first value.</param>
 141         /// <param name="arg2">The second value.</param>
 142         /// <returns>The vector containing the result of the multiplication.</returns>
 143         /// <since_tizen> 3 </since_tizen>
 144         public static Vector4 operator *(Vector4 arg1, Vector4 arg2)
 145         {
 146             return arg1.Multiply(arg2);
 147         }
 148
 149         /// <summary>
 150         /// The multiplication operator.
 151         /// </summary>
 152         /// <param name="arg1">The first value.</param>
 153         /// <param name="arg2">The float value to scale the vector.</param>
 154         /// <returns>The vector containing the result of scaling.</returns>
 155         /// <since_tizen> 3 </since_tizen>
 156         public static Vector4 operator *(Vector4 arg1, float arg2)
 157         {
 158             return arg1.Multiply(arg2);
 159         }
 160
 161         /// <summary>
 162         /// The division operator.
 163         /// </summary>
 164         /// <param name="arg1">The first value.</param>
 165         /// <param name="arg2">The second value.</param>
 166         /// <returns>The vector containing the result of the division.</returns>
 167         /// <since_tizen> 3 </since_tizen>
 168         public static Vector4 operator /(Vector4 arg1, Vector4 arg2)
 169         {
 170             return arg1.Divide(arg2);
 171         }
 172
 173         /// <summary>
 174         /// The division operator.
 175         /// </summary>
 176         /// <param name="arg1">The first value.</param>
 177         /// <param name="arg2">The float value to scale the vector by.</param>
 178         /// <returns>The vector containing the result of scaling.</returns>
 179         /// <since_tizen> 3 </since_tizen>
 180         public static Vector4 operator /(Vector4 arg1, float arg2)
 181         {
 182             return arg1.Divide(arg2);
 183         }
 184
 185         /// <summary>
 186         /// The array subscript operator overload.
 187         /// </summary>
 188         /// <param name="index">The subscript index.</param>
 189         /// <returns>The float at the given index.</returns>
 190         /// <since_tizen> 3 </since_tizen>
 191         public float this[uint index]
 192         {
 193             get
 194             {
 195                 return ValueOfIndex(index);
 196             }
 197         }
 198
 199         internal static Vector4 GetVector4FromPtr(global::System.IntPtr cPtr)
 200         {
 201             Vector4 ret = new Vector4(cPtr, false);
 202             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 203             return ret;
 204         }
 205
 206         /// <summary>
 207         /// The default constructor initializes the vector to 0.
 208         /// </summary>
 209         /// <since_tizen> 3 </since_tizen>
 210         public Vector4() : this(NDalicPINVOKE.new_Vector4__SWIG_0(), true)
 211         {
 212             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 213         }
 214
 215         /// <summary>
 216         /// The conversion constructor from four floats.
 217         /// </summary>
 218         /// <param name="x">The x (or r/s) component.</param>
 219         /// <param name="y">The y (or g/t) component.</param>
 220         /// <param name="z">The z (or b/p) component.</param>
 221         /// <param name="w">The w (or a/q) component.</param>
 222         /// <since_tizen> 3 </since_tizen>
 223         public Vector4(float x, float y, float z, float w) : this(NDalicPINVOKE.new_Vector4__SWIG_1(x, y, z, w), true)
 224         {
 225             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 226         }
 227
 228         /// <summary>
 229         /// The conversion constructor from an array of four floats.
 230         /// </summary>
 231         /// <param name="array">The array of either xyzw/rgba/stpq.</param>
 232         /// <since_tizen> 3 </since_tizen>
 233         public Vector4(float[] array) : this(NDalicPINVOKE.new_Vector4__SWIG_2(array), true)
 234         {
 235             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 236         }
 237
 238         /// <summary>
 239         /// The conversion constructor from Vector2.
 240         /// </summary>
 241         /// <param name="vec2">Vector2 to copy from, z and w are initialized to 0.</param>
 242         /// <since_tizen> 3 </since_tizen>
 243         public Vector4(Vector2 vec2) : this(NDalicPINVOKE.new_Vector4__SWIG_3(Vector2.getCPtr(vec2)), true)
 244         {
 245             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 246         }
 247
 248         /// <summary>
 249         /// The conversion constructor from Vector3.
 250         /// </summary>
 251         /// <param name="vec3">Vector3 to copy from, w is initialized to 0.</param>
 252         /// <since_tizen> 3 </since_tizen>
 253         public Vector4(Vector3 vec3) : this(NDalicPINVOKE.new_Vector4__SWIG_4(Vector3.getCPtr(vec3)), true)
 254         {
 255             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 256         }
 257
 258         /// <summary>
 259         /// (1.0f,1.0f,1.0f,1.0f).
 260         /// </summary>
 261         /// <since_tizen> 3 </since_tizen>
 262         public static Vector4 One
 263         {
 264             get
 265             {
 266                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector4_ONE_get();
 267                 Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
 268                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 269                 return ret;
 270             }
 271         }
 272
 273         /// <summary>
 274         /// (1.0f,0.0f,0.0f,0.0f).
 275         /// </summary>
 276         /// <since_tizen> 3 </since_tizen>
 277         public static Vector4 XAxis
 278         {
 279             get
 280             {
 281                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector4_XAXIS_get();
 282                 Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
 283                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 284                 return ret;
 285             }
 286         }
 287
 288         /// <summary>
 289         /// (0.0f,1.0f,0.0f,0.0f).
 290         /// </summary>
 291         /// <since_tizen> 3 </since_tizen>
 292         public static Vector4 YAxis
 293         {
 294             get
 295             {
 296                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector4_YAXIS_get();
 297                 Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
 298                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 299                 return ret;
 300             }
 301         }
 302
 303         /// <summary>
 304         /// (0.0f,0.0f,1.0f,0.0f).
 305         /// </summary>
 306         /// <since_tizen> 3 </since_tizen>
 307         public static Vector4 ZAxis
 308         {
 309             get
 310             {
 311                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector4_ZAXIS_get();
 312                 Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
 313                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 314                 return ret;
 315             }
 316         }
 317
 318         /// <summary>
 319         /// (0.0f, 0.0f, 0.0f, 0.0f).
 320         /// </summary>
 321         /// <since_tizen> 3 </since_tizen>
 322         public static Vector4 Zero
 323         {
 324             get
 325             {
 326                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector4_ZERO_get();
 327                 Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
 328                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 329                 return ret;
 330             }
 331         }
 332
 333         private Vector4 Add(Vector4 rhs)
 334         {
 335             Vector4 ret = new Vector4(NDalicPINVOKE.Vector4_Add(swigCPtr, Vector4.getCPtr(rhs)), true);
 336             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 337             return ret;
 338         }
 339
 340         private Vector4 AddAssign(Vector4 rhs)
 341         {
 342             Vector4 ret = new Vector4(NDalicPINVOKE.Vector4_AddAssign(swigCPtr, Vector4.getCPtr(rhs)), false);
 343             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 344             return ret;
 345         }
 346
 347         private Vector4 Subtract(Vector4 rhs)
 348         {
 349             Vector4 ret = new Vector4(NDalicPINVOKE.Vector4_Subtract__SWIG_0(swigCPtr, Vector4.getCPtr(rhs)), true);
 350             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 351             return ret;
 352         }
 353
 354         private Vector4 SubtractAssign(Vector4 rhs)
 355         {
 356             Vector4 ret = new Vector4(NDalicPINVOKE.Vector4_SubtractAssign(swigCPtr, Vector4.getCPtr(rhs)), false);
 357             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 358             return ret;
 359         }
 360
 361         private Vector4 Multiply(Vector4 rhs)
 362         {
 363             Vector4 ret = new Vector4(NDalicPINVOKE.Vector4_Multiply__SWIG_0(swigCPtr, Vector4.getCPtr(rhs)), true);
 364             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 365             return ret;
 366         }
 367
 368         private Vector4 Multiply(float rhs)
 369         {
 370             Vector4 ret = new Vector4(NDalicPINVOKE.Vector4_Multiply__SWIG_1(swigCPtr, rhs), true);
 371             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 372             return ret;
 373         }
 374
 375         private Vector4 MultiplyAssign(Vector4 rhs)
 376         {
 377             Vector4 ret = new Vector4(NDalicPINVOKE.Vector4_MultiplyAssign__SWIG_0(swigCPtr, Vector4.getCPtr(rhs)), false);
 378             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 379             return ret;
 380         }
 381
 382         private Vector4 MultiplyAssign(float rhs)
 383         {
 384             Vector4 ret = new Vector4(NDalicPINVOKE.Vector4_MultiplyAssign__SWIG_1(swigCPtr, rhs), false);
 385             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 386             return ret;
 387         }
 388
 389         private Vector4 Divide(Vector4 rhs)
 390         {
 391             Vector4 ret = new Vector4(NDalicPINVOKE.Vector4_Divide__SWIG_0(swigCPtr, Vector4.getCPtr(rhs)), true);
 392             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 393             return ret;
 394         }
 395
 396         private Vector4 Divide(float rhs)
 397         {
 398             Vector4 ret = new Vector4(NDalicPINVOKE.Vector4_Divide__SWIG_1(swigCPtr, rhs), true);
 399             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 400             return ret;
 401         }
 402
 403         private Vector4 DivideAssign(Vector4 rhs)
 404         {
 405             Vector4 ret = new Vector4(NDalicPINVOKE.Vector4_DivideAssign__SWIG_0(swigCPtr, Vector4.getCPtr(rhs)), false);
 406             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 407             return ret;
 408         }
 409
 410         private Vector4 DivideAssign(float rhs)
 411         {
 412             Vector4 ret = new Vector4(NDalicPINVOKE.Vector4_DivideAssign__SWIG_1(swigCPtr, rhs), false);
 413             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 414             return ret;
 415         }
 416
 417         private Vector4 Subtract()
 418         {
 419             Vector4 ret = new Vector4(NDalicPINVOKE.Vector4_Subtract__SWIG_1(swigCPtr), true);
 420             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 421             return ret;
 422         }
 423
 424         private bool EqualTo(Vector4 rhs)
 425         {
 426             bool ret = NDalicPINVOKE.Vector4_EqualTo(swigCPtr, Vector4.getCPtr(rhs));
 427             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 428             return ret;
 429         }
 430
 431         private bool NotEqualTo(Vector4 rhs)
 432         {
 433             bool ret = NDalicPINVOKE.Vector4_NotEqualTo(swigCPtr, Vector4.getCPtr(rhs));
 434             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 435             return ret;
 436         }
 437
 438         private float ValueOfIndex(uint index)
 439         {
 440             float ret = NDalicPINVOKE.Vector4_ValueOfIndex__SWIG_0(swigCPtr, index);
 441             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 442             return ret;
 443         }
 444
 445         internal float Dot(Vector3 other)
 446         {
 447             float ret = NDalicPINVOKE.Vector4_Dot__SWIG_0(swigCPtr, Vector3.getCPtr(other));
 448             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 449             return ret;
 450         }
 451
 452         internal float Dot(Vector4 other)
 453         {
 454             float ret = NDalicPINVOKE.Vector4_Dot__SWIG_1(swigCPtr, Vector4.getCPtr(other));
 455             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 456             return ret;
 457         }
 458
 459         internal float Dot4(Vector4 other)
 460         {
 461             float ret = NDalicPINVOKE.Vector4_Dot4(swigCPtr, Vector4.getCPtr(other));
 462             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 463             return ret;
 464         }
 465
 466         internal Vector4 Cross(Vector4 other)
 467         {
 468             Vector4 ret = new Vector4(NDalicPINVOKE.Vector4_Cross(swigCPtr, Vector4.getCPtr(other)), true);
 469             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 470             return ret;
 471         }
 472
 473         /// <summary>
 474         /// Returns the length of the vector.
 475         /// </summary>
 476         /// <returns>The length.</returns>
 477         /// <since_tizen> 3 </since_tizen>
 478         public float Length()
 479         {
 480             float ret = NDalicPINVOKE.Vector4_Length(swigCPtr);
 481             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 482             return ret;
 483         }
 484
 485         /// <summary>
 486         /// Returns the length of the vector squared.<br>
 487         /// This is faster than using Length() when performing
 488         /// threshold checks as it avoids use of the square root.<br>
 489         /// </summary>
 490         /// <returns>The length of the vector squared.</returns>
 491         /// <since_tizen> 3 </since_tizen>
 492         public float LengthSquared()
 493         {
 494             float ret = NDalicPINVOKE.Vector4_LengthSquared(swigCPtr);
 495             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 496             return ret;
 497         }
 498
 499         /// <summary>
 500         /// Normalizes the vector.<br>
 501         /// Sets the vector to unit length whilst maintaining its direction.<br>
 502         /// </summary>
 503         /// <since_tizen> 3 </since_tizen>
 504         public void Normalize()
 505         {
 506             NDalicPINVOKE.Vector4_Normalize(swigCPtr);
 507             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 508         }
 509
 510         /// <summary>
 511         /// Clamps the vector between minimum and maximum vectors.
 512         /// </summary>
 513         /// <param name="min">The minimum vector.</param>
 514         /// <param name="max">The maximum vector.</param>
 515         /// <since_tizen> 3 </since_tizen>
 516         public void Clamp(Vector4 min, Vector4 max)
 517         {
 518             NDalicPINVOKE.Vector4_Clamp(swigCPtr, Vector4.getCPtr(min), Vector4.getCPtr(max));
 519             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 520         }
 521
 522         internal SWIGTYPE_p_float AsFloat()
 523         {
 524             global::System.IntPtr cPtr = NDalicPINVOKE.Vector4_AsFloat__SWIG_0(swigCPtr);
 525             SWIGTYPE_p_float ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_float(cPtr, false);
 526             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 527             return ret;
 528         }
 529
 530         /// <summary>
 531         /// The x component.
 532         /// </summary>
 533         /// <since_tizen> 3 </since_tizen>
 534         public float X
 535         {
 536             set
 537             {
 538                 NDalicPINVOKE.Vector4_X_set(swigCPtr, value);
 539                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 540             }
 541             get
 542             {
 543                 float ret = NDalicPINVOKE.Vector4_X_get(swigCPtr);
 544                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 545                 return ret;
 546             }
 547         }
 548
 549         /// <summary>
 550         /// The red component.
 551         /// </summary>
 552         /// <since_tizen> 3 </since_tizen>
 553         public float R
 554         {
 555             set
 556             {
 557                 NDalicPINVOKE.Vector4_r_set(swigCPtr, value);
 558                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 559             }
 560             get
 561             {
 562                 float ret = NDalicPINVOKE.Vector4_r_get(swigCPtr);
 563                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 564                 return ret;
 565             }
 566         }
 567
 568         /// <summary>
 569         /// The s component.
 570         /// </summary>
 571         /// <since_tizen> 3 </since_tizen>
 572         public float S
 573         {
 574             set
 575             {
 576                 NDalicPINVOKE.Vector4_s_set(swigCPtr, value);
 577                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 578             }
 579             get
 580             {
 581                 float ret = NDalicPINVOKE.Vector4_s_get(swigCPtr);
 582                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 583                 return ret;
 584             }
 585         }
 586
 587         /// <summary>
 588         /// The y component.
 589         /// </summary>
 590         /// <since_tizen> 3 </since_tizen>
 591         public float Y
 592         {
 593             set
 594             {
 595                 NDalicPINVOKE.Vector4_Y_set(swigCPtr, value);
 596                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 597             }
 598             get
 599             {
 600                 float ret = NDalicPINVOKE.Vector4_Y_get(swigCPtr);
 601                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 602                 return ret;
 603             }
 604         }
 605
 606         /// <summary>
 607         /// The green component.
 608         /// </summary>
 609         /// <since_tizen> 3 </since_tizen>
 610         public float G
 611         {
 612             set
 613             {
 614                 NDalicPINVOKE.Vector4_g_set(swigCPtr, value);
 615                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 616             }
 617             get
 618             {
 619                 float ret = NDalicPINVOKE.Vector4_g_get(swigCPtr);
 620                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 621                 return ret;
 622             }
 623         }
 624
 625         /// <summary>
 626         /// The t component.
 627         /// </summary>
 628         /// <since_tizen> 3 </since_tizen>
 629         public float T
 630         {
 631             set
 632             {
 633                 NDalicPINVOKE.Vector4_t_set(swigCPtr, value);
 634                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 635             }
 636             get
 637             {
 638                 float ret = NDalicPINVOKE.Vector4_t_get(swigCPtr);
 639                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 640                 return ret;
 641             }
 642         }
 643
 644         /// <summary>
 645         /// The z component.
 646         /// </summary>
 647         /// <since_tizen> 3 </since_tizen>
 648         public float Z
 649         {
 650             set
 651             {
 652                 NDalicPINVOKE.Vector4_Z_set(swigCPtr, value);
 653                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 654             }
 655             get
 656             {
 657                 float ret = NDalicPINVOKE.Vector4_Z_get(swigCPtr);
 658                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 659                 return ret;
 660             }
 661         }
 662
 663         /// <summary>
 664         /// The blue component.
 665         /// </summary>
 666         /// <since_tizen> 3 </since_tizen>
 667         public float B
 668         {
 669             set
 670             {
 671                 NDalicPINVOKE.Vector4_b_set(swigCPtr, value);
 672                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 673             }
 674             get
 675             {
 676                 float ret = NDalicPINVOKE.Vector4_b_get(swigCPtr);
 677                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 678                 return ret;
 679             }
 680         }
 681
 682         /// <summary>
 683         /// The p component.
 684         /// </summary>
 685         /// <since_tizen> 3 </since_tizen>
 686         public float P
 687         {
 688             set
 689             {
 690                 NDalicPINVOKE.Vector4_p_set(swigCPtr, value);
 691                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 692             }
 693             get
 694             {
 695                 float ret = NDalicPINVOKE.Vector4_p_get(swigCPtr);
 696                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 697                 return ret;
 698             }
 699         }
 700
 701         /// <summary>
 702         /// The w component.
 703         /// </summary>
 704         /// <since_tizen> 3 </since_tizen>
 705         public float W
 706         {
 707             set
 708             {
 709                 NDalicPINVOKE.Vector4_W_set(swigCPtr, value);
 710                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 711             }
 712             get
 713             {
 714                 float ret = NDalicPINVOKE.Vector4_W_get(swigCPtr);
 715                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 716                 return ret;
 717             }
 718         }
 719
 720         /// <summary>
 721         /// The alpha component.
 722         /// </summary>
 723         /// <since_tizen> 3 </since_tizen>
 724         public float A
 725         {
 726             set
 727             {
 728                 NDalicPINVOKE.Vector4_a_set(swigCPtr, value);
 729                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 730             }
 731             get
 732             {
 733                 float ret = NDalicPINVOKE.Vector4_a_get(swigCPtr);
 734                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 735                 return ret;
 736             }
 737         }
 738
 739         /// <summary>
 740         /// The q component.
 741         /// </summary>
 742         /// <since_tizen> 3 </since_tizen>
 743         public float Q
 744         {
 745             set
 746             {
 747                 NDalicPINVOKE.Vector4_q_set(swigCPtr, value);
 748                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 749             }
 750             get
 751             {
 752                 float ret = NDalicPINVOKE.Vector4_q_get(swigCPtr);
 753                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 754                 return ret;
 755             }
 756         }
 757
 758     }
 759
 760 }