Пример #1
0
        public GfVec3d GetNormalized()
        {
            GfVec3d ret = new GfVec3d(UsdCsPINVOKE.GfVec3d_GetNormalized__SWIG_1(swigCPtr), true);

            return(ret);
        }
Пример #2
0
        public GfVec3d GetPoint(double t)
        {
            GfVec3d ret = new GfVec3d(UsdCsPINVOKE.GfLine_GetPoint(swigCPtr, t), true);

            return(ret);
        }
Пример #3
0
        public GfVec3d FindClosestPoint(GfVec3d point)
        {
            GfVec3d ret = new GfVec3d(UsdCsPINVOKE.GfLine_FindClosestPoint__SWIG_1(swigCPtr, GfVec3d.getCPtr(point)), true);

            if (UsdCsPINVOKE.SWIGPendingException.Pending)
            {
                throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
            }
            return(ret);
        }
Пример #4
0
        public GfVec3d GetPoint(double distance)
        {
            GfVec3d ret = new GfVec3d(UsdCsPINVOKE.GfRay_GetPoint(swigCPtr, distance), true);

            return(ret);
        }
Пример #5
0
 public GfQuatd(double real, GfVec3d imaginary) : this(UsdCsPINVOKE.new_GfQuatd__SWIG_3(real, GfVec3d.getCPtr(imaginary)), true)
 {
     if (UsdCsPINVOKE.SWIGPendingException.Pending)
     {
         throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
     }
 }
Пример #6
0
        public bool Intersect(GfVec3d origin, GfVec3d axis, double radius, double height)
        {
            bool ret = UsdCsPINVOKE.GfRay_Intersect__SWIG_22(swigCPtr, GfVec3d.getCPtr(origin), GfVec3d.getCPtr(axis), radius, height);

            if (UsdCsPINVOKE.SWIGPendingException.Pending)
            {
                throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
            }
            return(ret);
        }
Пример #7
0
 public void SetPointAndDirection(GfVec3d startPoint, GfVec3d direction)
 {
     UsdCsPINVOKE.GfRay_SetPointAndDirection(swigCPtr, GfVec3d.getCPtr(startPoint), GfVec3d.getCPtr(direction));
     if (UsdCsPINVOKE.SWIGPendingException.Pending)
     {
         throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
     }
 }
Пример #8
0
        public static GfVec3d YAxis()
        {
            GfVec3d ret = new GfVec3d(UsdCsPINVOKE.GfVec3d_YAxis(), true);

            return(ret);
        }
Пример #9
0
        public GfVec3d ComputeCentroid()
        {
            GfVec3d ret = new GfVec3d(UsdCsPINVOKE.GfBBox3d_ComputeCentroid(swigCPtr), true);

            return(ret);
        }
Пример #10
0
 internal static global::System.Runtime.InteropServices.HandleRef getCPtr(GfVec3d obj)
 {
     return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
 }
Пример #11
0
 override public bool Equals(object rhs)
 {
     return(GfVec3d.Equals(this, rhs as GfVec3d));
 }
Пример #12
0
 public void BuildOrthonormalFrame(GfVec3d v1, GfVec3d v2)
 {
     UsdCsPINVOKE.GfVec3d_BuildOrthonormalFrame__SWIG_1(swigCPtr, GfVec3d.getCPtr(v1), GfVec3d.getCPtr(v2));
 }
Пример #13
0
 public void BuildOrthonormalFrame(GfVec3d v1, GfVec3d v2, double eps)
 {
     UsdCsPINVOKE.GfVec3d_BuildOrthonormalFrame__SWIG_0(swigCPtr, GfVec3d.getCPtr(v1), GfVec3d.getCPtr(v2), eps);
 }
Пример #14
0
        public static bool OrthogonalizeBasis(GfVec3d tx, GfVec3d ty, GfVec3d tz, bool normalize)
        {
            bool ret = UsdCsPINVOKE.GfVec3d_OrthogonalizeBasis__SWIG_1(GfVec3d.getCPtr(tx), GfVec3d.getCPtr(ty), GfVec3d.getCPtr(tz), normalize);

            return(ret);
        }
Пример #15
0
        public bool Intersect(GfVec3d p0, GfVec3d p1, GfVec3d p2)
        {
            bool ret = UsdCsPINVOKE.GfRay_Intersect__SWIG_4(swigCPtr, GfVec3d.getCPtr(p0), GfVec3d.getCPtr(p1), GfVec3d.getCPtr(p2));

            if (UsdCsPINVOKE.SWIGPendingException.Pending)
            {
                throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
            }
            return(ret);
        }
Пример #16
0
        public GfVec3d GetColumn(int i)
        {
            GfVec3d ret = new GfVec3d(UsdCsPINVOKE.GfMatrix3d_GetColumn(swigCPtr, i), true);

            return(ret);
        }
Пример #17
0
        public bool Intersect(GfVec3d origin, GfVec3d axis, double radius, out double enterDistance, out double exitDistance)
        {
            bool ret = UsdCsPINVOKE.GfRay_Intersect__SWIG_17(swigCPtr, GfVec3d.getCPtr(origin), GfVec3d.getCPtr(axis), radius, out enterDistance, out exitDistance);

            if (UsdCsPINVOKE.SWIGPendingException.Pending)
            {
                throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
            }
            return(ret);
        }
Пример #18
0
        public GfMatrix3d SetDiagonal(GfVec3d arg0)
        {
            GfMatrix3d ret = new GfMatrix3d(UsdCsPINVOKE.GfMatrix3d_SetDiagonal__SWIG_1(swigCPtr, GfVec3d.getCPtr(arg0)), false);

            if (UsdCsPINVOKE.SWIGPendingException.Pending)
            {
                throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
            }
            return(ret);
        }
Пример #19
0
 public GfRay(GfVec3d startPoint, GfVec3d direction) : this(UsdCsPINVOKE.new_GfRay__SWIG_1(GfVec3d.getCPtr(startPoint), GfVec3d.getCPtr(direction)), true)
 {
     if (UsdCsPINVOKE.SWIGPendingException.Pending)
     {
         throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
     }
 }
Пример #20
0
        public GfMatrix3d SetScale(GfVec3d scaleFactors)
        {
            GfMatrix3d ret = new GfMatrix3d(UsdCsPINVOKE.GfMatrix3d_SetScale__SWIG_1(swigCPtr, GfVec3d.getCPtr(scaleFactors)), false);

            if (UsdCsPINVOKE.SWIGPendingException.Pending)
            {
                throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
            }
            return(ret);
        }
Пример #21
0
        public GfVec3d GetStartPoint()
        {
            GfVec3d ret = new GfVec3d(UsdCsPINVOKE.GfRay_GetStartPoint(swigCPtr), false);

            return(ret);
        }
Пример #22
0
        public GfVec3d DecomposeRotation(GfVec3d axis0, GfVec3d axis1, GfVec3d axis2)
        {
            GfVec3d ret = new GfVec3d(UsdCsPINVOKE.GfMatrix3d_DecomposeRotation(swigCPtr, GfVec3d.getCPtr(axis0), GfVec3d.getCPtr(axis1), GfVec3d.getCPtr(axis2)), true);

            if (UsdCsPINVOKE.SWIGPendingException.Pending)
            {
                throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
            }
            return(ret);
        }
Пример #23
0
        public GfVec3d GetImaginary()
        {
            GfVec3d ret = new GfVec3d(UsdCsPINVOKE.GfQuatd_GetImaginary(swigCPtr), false);

            return(ret);
        }
Пример #24
0
        public GfVec3d TransformAffine(GfVec3d vec)
        {
            GfVec3d ret = new GfVec3d(UsdCsPINVOKE.GfMatrix4f_TransformAffine__SWIG_0(swigCPtr, GfVec3d.getCPtr(vec)), true);

            if (UsdCsPINVOKE.SWIGPendingException.Pending)
            {
                throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
            }
            return(ret);
        }
Пример #25
0
 public GfLine(GfVec3d p0, GfVec3d dir) : this(UsdCsPINVOKE.new_GfLine__SWIG_1(GfVec3d.getCPtr(p0), GfVec3d.getCPtr(dir)), true)
 {
     if (UsdCsPINVOKE.SWIGPendingException.Pending)
     {
         throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
     }
 }
Пример #26
0
        public GfVec3d FindClosestPoint(GfVec3d point, out double rayDistance)
        {
            GfVec3d ret = new GfVec3d(UsdCsPINVOKE.GfRay_FindClosestPoint__SWIG_0(swigCPtr, GfVec3d.getCPtr(point), out rayDistance), true);

            if (UsdCsPINVOKE.SWIGPendingException.Pending)
            {
                throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
            }
            return(ret);
        }
Пример #27
0
        public GfVec3d GetDirection()
        {
            GfVec3d ret = new GfVec3d(UsdCsPINVOKE.GfLine_GetDirection(swigCPtr), false);

            return(ret);
        }
Пример #28
0
        public bool Intersect(GfVec3d p0, GfVec3d p1, GfVec3d p2, out double distance, GfVec3d barycentricCoords)
        {
            bool ret = UsdCsPINVOKE.GfRay_Intersect__SWIG_2(swigCPtr, GfVec3d.getCPtr(p0), GfVec3d.getCPtr(p1), GfVec3d.getCPtr(p2), out distance, GfVec3d.getCPtr(barycentricCoords));

            if (UsdCsPINVOKE.SWIGPendingException.Pending)
            {
                throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
            }
            return(ret);
        }
Пример #29
0
 public void Set(GfVec3d p0, GfVec3d p1, GfVec3d p2)
 {
     UsdCsPINVOKE.GfPlane_Set__SWIG_2(swigCPtr, GfVec3d.getCPtr(p0), GfVec3d.getCPtr(p1), GfVec3d.getCPtr(p2));
     if (UsdCsPINVOKE.SWIGPendingException.Pending)
     {
         throw UsdCsPINVOKE.SWIGPendingException.Retrieve();
     }
 }
Пример #30
0
        public GfVec3d GetNormalized(double eps)
        {
            GfVec3d ret = new GfVec3d(UsdCsPINVOKE.GfVec3d_GetNormalized__SWIG_0(swigCPtr, eps), true);

            return(ret);
        }