GetConceptualFaceXYZ2UV

This function returns UV coordinates for a specific conceptualFace given its real world coordinates.
The UV coordinates are expected to be both (inclusive) between 0. and 1., i.e. [0..1].

Syntax

C++ 32 bit

C++ 64 bit

C# 32 bit

C# 64 bit

//
//   Strong typing definition
//
bool            GetConceptualFaceXYZ2UV(
                        OwlInstance             owlInstance,
                        int64_t                 index,
                        double                  * u,
                        double                  * v,
                        double                  x,
                        double                  y,
                        double                  z
                    );

static  inline  bool    GetConceptualFaceXYZ2UV(
                                OwlInstance             owlInstance,
                                int64_t                 index,
                                double                  * out__VEC2,
                                const double            * in__VEC3
                            )
{
    return  GetConceptualFaceXYZ2UV(
                    owlInstance,
                    index,
                    &out__VEC2[0],                      //    u
                    &out__VEC2[1],                      //    v
                    in__VEC3[0],                       //    x
                    in__VEC3[1],                       //    y
                    in__VEC3[2]                            //    z
                );
}


//
//   Weak typing definition
//
bool    __declspec(dllexport) __stdcall GetConceptualFaceXYZ2UV(
                                                int64_t                 owlInstance,
                                                int64_t                 index,
                                                double                  * u,
                                                double                  * v,
                                                double                  x,
                                                double                  y,
                                                double                  z
                                            );

static  inline  bool    GetConceptualFaceXYZ2UV(
                                int64_t                 owlInstance,
                                int64_t                 index,
                                double                  * out__VEC2,
                                const double            * in__VEC3
                            )
{
    return  GetConceptualFaceXYZ2UV(
                    owlInstance,
                    index,
                    &out__VEC2[0],                      //    u
                    &out__VEC2[1],                      //    v
                    in__VEC3[0],                       //    x
                    in__VEC3[1],                       //    y
                    in__VEC3[2]                            //    z
                );
}

Property owlInstance

Size: 64 bit / 8 byte (value)
The handle to the specific instance in the design tree. The instance handle is static within one open model but is most probably different when the same instance is opened in another model. The instance is always exactly of one unique class.

Property index

Size: 64 bit / 8 byte (value)
This is the index (0 based) of the face in the set of conceptual faces available.

Property u

Size: 32 bit / 4 byte (reference)
???.

Property v

Size: 32 bit / 4 byte (reference)
???.

Property x

Size: 64 bit / 8 byte (value)
x Coordinate

Property y

Size: 64 bit / 8 byte (value)
y Coordinate

Property z

Size: 64 bit / 8 byte (value)
z Coordinate