GetConceptualFacePerimeter

This function returns the perimeter of a given Conceptual Face.

Syntax

//   Visual Studio for Windows
public:
double __declspec(dllexport) __stdcall GetConceptualFacePerimeter(
            __int64             conceptualFace
        );

//   Linux, OS-X and non-Visual Studio Windows solutions
public:
double GetConceptualFacePerimeter(
            int64_t             conceptualFace
        );

Property conceptualFace

Size: 64 bit / 8 byte (value)
A conceptual face is a face that does not have to be placed within one plane. For example a Cylinder has typically 3 conceptual faces where a Box typically has 6 conceptual faces. In case of a Box the 'normal' face count is equal to the conceptual face count, in case of a Cylinder the 'normal' face count depends on the segmentation, for example in case of 36 segments, it will have 38 faces but still 3 conceptual faces.

Example

Here you can find code snippits that show how the API call GetConceptualFacePerimeter can be used.

#include "engine/include/engine.h"

void    main()
{
    int64_t model = CreateModel();

    if (model) {
        //
        //  Classes
        //
        int64_t classBox = GetClassByName(model, "Box");

        //
        //  Datatype Properties (attributes)
        //
        int64_t propertyLength = GetPropertyByName(model, "length"),
                propertyWidth = GetPropertyByName(model, "width"),
                propertyHeight = GetPropertyByName(model, "height");

        //
        //  Instances (creating)
        //
        int64_t instanceBox = CreateInstance(classBox, nullptr);

        double  length = 2.8,
                width = 1.3,
                height = 1.4;

        SetDatatypeProperty(instanceBox, propertyLength, &length, 1);
        SetDatatypeProperty(instanceBox, propertyWidth, &width, 1);
        SetDatatypeProperty(instanceBox, propertyHeight, &height, 1);

        int64_t vertexBufferSize = 0,
                indexBufferSize = 0;
        CalculateInstance(instanceBox, &vertexBufferSize, &indexBufferSize, 0);
        if (vertexBufferSize && indexBufferSize) {
            float   * vertexBuffer = new float[6 * vertexBufferSize];
            UpdateInstanceVertexBuffer(instanceBox, vertexBuffer);

            int32_t * indexBuffer = new int32_t[indexBufferSize];
            UpdateInstanceIndexBuffer(instanceBox, indexBuffer);

            int64_t conceptualFaceCnt = GetConceptualFaceCnt(instanceBox);
            for (int64_t index = 0; index < conceptualFaceCnt; index++) {
                int64_t startIndexTriangles = 0,
                        noIndicesTriangles = 0,
                        conceptualFace =
                    GetConceptualFaceEx(
                            instanceBox, index,
                            &startIndexTriangles, &noIndicesTriangles,
                            nullptr, nullptr,
                            nullptr, nullptr,
                            nullptr, nullptr,
                            nullptr, nullptr
                        );

                double  conceptualFaceArea =
                            GetConceptualFaceArea(
                                    conceptualFace,
                                    vertexBuffer,
                                    indexBuffer
                                ),
                        conceptualFacePerimeter =
                            GetConceptualFacePerimeter(
                                    conceptualFace
                                );
            }
        }

        //
        //  The resulting model can be viewed in 3D-Editor.exe
        //
        SaveModel(model, "c:\\created\\myFile.bin");
        CloseModel(model);
    }
}