SetFormat

This function sets the type of export format, by setting a mask
bit 0 & 1:
    00 Each vertex is unique (although mostly irrelevant UpdateIndexBuffer() and
          UpdateTransformationBuffer() are still returning information)
    01 Each index is unique => vertices are not necessarily (although mostly
          irrelevant UpdateTransformationBuffer() is still returning information)
    10 Single level Transformations are used, most optimal when using DirectX till version 11
          and OpenGL till version 2
    11 Nested Transformations are used, most optimal but till 2011 no known support of
          low level 3D interfaces like DirectX and OpenGL
bit 2:
    0 Vertex items returned as float (4 byte/32 bit)
    1 Vertex items returned as double (8 byte/64 bit)
bit 3:
    0 Index items returned as int32_t (4 byte/32 bit)
    1 Index items returned as int64_t (8 byte/64 bit) (only available in 64 bit mode)

bit 4:
    0 Vertex does not contain 3D point info
    1 Vertex does contain 3D point info
bit 5:
    0 Vertex does not contain 3D normal vector info
    1 Vertex does contain 3D normal vector info => if set, bit 4 will also be set
bit 6:
    0 Vertex does not contain first 2D texture info
    1 Vertex does contain first 2D texture info
bit 7:
    0 Vertex does not contain second 2D texture info
    1 Vertex does contain second 2D texture info => if set, bit 6 will also be set

bit 8:
    0 No object form triangles are exported
    1 Object form triangles are exported (effective if instance contains faces and/or solids)
bit 9:
    0 No object polygon lines are exported
    1 Object polygon lines are exported (effective if instance contains line representations)
bit 10:
    0 No object points are exported
    1 Object points are exported (effective if instance contains point representations)

bit 11: Reserved, by default 0

bit 12:
    0 No object face polygon lines are exported
    1 Object face polygon lines (dense wireframe) are exported => if set, bit 8 will also be set
bit 13:
    0 No object conceptual face polygon lines are exported
    1 Object conceptual face polygon lines (wireframe) are exported => if set, bit 12 will also be set
bit 14:
    0 Polygon lines (wireframe) exported as list, i.e. typical 4 point polygon exported as 0 1 2 3 0 -1
    1 Polygon lines (wireframe) exported as tuples, i.e. typical 4 point polygon exported as 0 1 1 2 2 3 3 0

bit 15:
    0 All normals of triangles are transformed orthogonal to the 2D face they belong to
    1 Normals are exported to be in line with the original semantic form description (could be non orthogonal to the 2D face)

bit 16:
    0 no specific behavior
    1 Where possible DirectX compatibility is given to exported data (i.e. order of components in vertices)
        => [bit 20, bit 21 both UNSET]
        => if set, bit 17 will be unset

bit 17:
    0 no specific behavior
    1 Where possible OpenGL compatibility is given to exported data (i.e. order of components in vertices and inverted texture coordinates in Y direction)
        => [bit 20, bit 21 both SET]
        => if set, bit 16 will be unset

bit 18:
    0 All faces are defined as calculated
    1 Every face has exactly one opposite face (normally both index and vertex array are doubled in size)

bit 19: Reserved, by default 0

bit 20-23:
    0000 version 0 (used in case there is different behavior between versions in DirectX or OpenGL)
    .... ...
    1111 version 15

bit 20:
    0 Standard Triangle Rotation (LHS as expected by DirectX)
    1 Opposite Triangle Rotation (RHS as expected by OpenGL)
bit 21:
    0 X, Y, Z (nX, nY, nZ) formatted as considering internal concepts
    1 X, Y, Z (nX, nY, nZ) formatted as , i.e. X, -Z, Y (nX, -nZ, nY) considering internal concepts (OpenGL)

bit 24:
    0 Vertex does not contain Ambient color information
    1 Vertex does contain Ambient color information
bit 25:
    0 Vertex does not contain Diffuse color information
    1 Vertex does contain Diffuse color information
bit 26:
    0 Vertex does not contain Emissive color information
    1 Vertex does contain Emissive color information
bit 27:
    0 Vertex does not contain Specular color information
    1 Vertex does contain Specular color information

bit 28:
    0 Vertex does not contain tangent vector for first texture
    1 Vertex does contain tangent vector for first texture => if set, bit 6 will also be set
bit 29:
    0 Vertex does not contain binormal vector for first texture
    1 Vertex does contain binormal vector for first texture => if set, bit 6 will also be set
bit 30: ONLY WORKS IN 64 BIT MODE
    0 Vertex does not contain tangent vector for second texture
    1 Vertex does contain tangent vector for second texture => if set, bit 6 will also be set
bit 31: ONLY WORKS IN 64 BIT MODE
    0 Vertex does not contain binormal vector for second texture
    1 Vertex does contain binormal vector for second texture => if set, bit 6 will also be set

bit 26-31: Reserved, by default 0

bit 32-63: Reserved, by default 0

Note: default setting is 0000 0000 0000 0000 0000 0000 0000 0000 - 0000 0000 0000 0000 1000 0001 0011 0000 = h0000 0000 - 0000 8130 = 33072

Syntax

C++ 32 bit

C++ 64 bit

C# 32 bit

C# 64 bit

public const string EngineDLL = @"engine.dll";[DllImport(EngineDLL, EntryPoint = "SetFormat")]
public static extern Int64 SetFormat(Int64 model, Int64 setting, Int64 mask);

Property model

Size: 64 bit / 8 byte (value)
The handle to the model. The model handle is static during its existance. Several models can be opened simultaniously within one session. Different models are always independent, threads are allowed to be running on different models simultaniously.

Property setting

Size: 64 bit / 8 byte (value)
The setting is the data that is defined for bitwise operations, only bits set in the mask will be relevant.

Property mask

Size: 64 bit / 8 byte (value)
This mask or bitmask is data that is used for bitwise operations, i.e. the bits set in the mask are the bits affected in the setting or return value.

Example

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

using Engine;

const Int64 flagbit0 = 1;                           // 2^^0                          0000.0000..0000.0001
const Int64 flagbit1 = 2;                           // 2^^1                          0000.0000..0000.0010
const Int64 flagbit2 = 4;                           // 2^^2                          0000.0000..0000.0100
const Int64 flagbit3 = 8;                           // 2^^3                          0000.0000..0000.1000

const Int64 flagbit4 = 16;                          // 2^^4                          0000.0000..0001.0000
const Int64 flagbit5 = 32;                          // 2^^5                          0000.0000..0010.0000
const Int64 flagbit6 = 64;                          // 2^^6                          0000.0000..0100.0000
const Int64 flagbit7 = 128;                         // 2^^7                          0000.0000..1000.0000

const Int64 flagbit8 = 256;                         // 2^^8                          0000.0001..0000.0000
const Int64 flagbit9 = 512;                         // 2^^9                          0000.0010..0000.0000
const Int64 flagbit10 = 1024;                       // 2^^10                         0000.0100..0000.0000
const Int64 flagbit11 = 2048;                       // 2^^11                         0000.1000..0000.0000

const Int64 flagbit12 = 4096;                       // 2^^12                         0001.0000..0000.0000
const Int64 flagbit13 = 8192;                       // 2^^13                         0010.0000..0000.0000
const Int64 flagbit14 = 16384;                      // 2^^14                         0100.0000..0000.0000
const Int64 flagbit15 = 32768;                      // 2^^15                         1000.0000..0000.0000

const Int64 flagbit16 = 65536;                      // 2^^16   0000.0000..0000.0001  0000.0000..0000.0000
const Int64 flagbit17 = 131072;                     // 2^^17   0000.0000..0000.0010  0000.0000..0000.0000
const Int64 flagbit18 = 262144;                     // 2^^18   0000.0000..0000.0100  0000.0000..0000.0000
const Int64 flagbit19 = 524288;                     // 2^^19   0000.0000..0000.1000  0000.0000..0000.0000

const Int64 flagbit20 = 1048576;                    // 2^^20   0000.0000..0001.0000  0000.0000..0000.0000
const Int64 flagbit21 = 2097152;                    // 2^^21   0000.0000..0010.0000  0000.0000..0000.0000
const Int64 flagbit22 = 4194304;                    // 2^^22   0000.0000..0100.0000  0000.0000..0000.0000
const Int64 flagbit23 = 8388608;                    // 2^^23   0000.0000..1000.0000  0000.0000..0000.0000

const Int64 flagbit24 = 16777216;                   // 2^^24   0000.0001..0000.0000  0000.0000..0000.0000
const Int64 flagbit25 = 33554432;                   // 2^^25   0000.0010..0000.0000  0000.0000..0000.0000
const Int64 flagbit26 = 67108864;                   // 2^^26   0000.0100..0000.0000  0000.0000..0000.0000
const Int64 flagbit27 = 134217728;                  // 2^^27   0000.1000..0000.0000  0000.0000..0000.0000

const Int64 flagbit28 = 268435456;                  // 2^^28   0001.0000..0000.0000  0000.0000..0000.0000
const Int64 flagbit29 = 536870912;                  // 2^^29   0010.0000..0000.0000  0000.0000..0000.0000
const Int64 flagbit30 = (Int64) 1073741824;         // 2^^30   0100.0000..0000.0000  0000.0000..0000.0000
const Int64 flagbit31 = (Int64) 2147483648;         // 2^^31   1000.0000..0000.0000  0000.0000..0000.0000

static void Main(string[] args)
{
    Int64 model = Engine.x86_64.CreateModel();

    if (model != 0)
    {
        {
            //
            //  Initializing the mask with all possible options
            //
            Int64   setting = 0,
                    mask = Engine.x86_64.GetFormat(0, 0);

            setting += 0 * flagbit2;        //    SINGLE / DOUBLE PRECISION (float / double)
            setting += 0 * flagbit3;        //    32 / 63 BIT INDEX ARRAY (int32_t / int64_t)

            setting += 1 * flagbit4;        //    OFF / ON VECTORS (x, y, z) 
            setting += 1 * flagbit5;        //    OFF / ON NORMALS (Nx, Ny, Nz)
            setting += 0 * flagbit6;        //    OFF / ON TEXTURE I (u1, v1)
            setting += 0 * flagbit7;        //    OFF / ON TEXTURE II (u2, v2)

            setting += 1 * flagbit8;        //    OFF / ON TRIANGLES
            setting += 1 * flagbit9;        //    OFF / ON LINES
            setting += 1 * flagbit10;       //    OFF / ON POINTS

            setting += 0 * flagbit12;       //    OFF / ON WIREFRAME FACES
            setting += 0 * flagbit13;       //    OFF / ON WIREFRAME CONCEPTUAL FACES

            setting += 0 * flagbit14;       //    OFF / ON STRUCTURE WIREFRAME AS POLYGON / TUPLE
            setting += 0 * flagbit15;       //    OFF / ON ADVANCED NORMALS (I.E. FOLLOWING THE SEMANTIC MEANING OF THE CONCEPT)

            setting += 0 * flagbit16;       //    OFF / ON DIRECTX (COMBINATION SETTING BIT 20, 21, 22, 23)
            setting += 0 * flagbit17;       //    OFF / ON OPENGL (COMBINATION SETTING BIT 20, 21, 22, 23)

            setting += 0 * flagbit18;       //    OFF / ON EXPORT BOTH SIDES OF TRIANGLES

            setting += 0 * flagbit20;       //    OFF / ON EXPERT SETTING TRIANGLE WINDING CW / ACW
            setting += 0 * flagbit21;       //    OFF / ON EXPERT SETTING NONE / VERTEX + NORMAL Y = Z / Z = -Y
            setting += 0 * flagbit22;       //    OFF / ON EXPERT SETTING
            setting += 0 * flagbit23;       //    OFF / ON EXPERT SETTING

            setting += 0 * flagbit24;       //    OFF / ON AMBIENT COLOR COMPONENT
            setting += 0 * flagbit25;       //    OFF / ON DIFFUSE COLOR COMPONENT
            setting += 0 * flagbit26;       //    OFF / ON EMISSIVE COLOR COMPONENT
            setting += 0 * flagbit27;       //    OFF / ON SPECULAR COLOR COMPONENT

            setting += 0 * flagbit28;       //    OFF / ON TEXTURE I TANGENT
            setting += 0 * flagbit29;       //    OFF / ON TEXTURE I BINORMAL

            setting += 0 * flagbit30;       //    OFF / ON TEXTURE II TANGENT (64 BIT ONLY)
            setting += 0 * flagbit31;       //    OFF / ON TEXTURE II BINORMAL (64 BIT ONLY)

            Int64   vertexElementSizeInBytes = Engine.x86_64.SetFormat(model, setting, mask);
        }

        //
        //  Check if a certain option is set
        //
        if (Engine.x86_64.GetFormat(model, flagbit5) != 0)
        {
            //  Normal coordinates (Nx, Ny, Nz) are exported
        }
        else
        {
            //  Normal coordinates (Nx, Ny, Nz) are not exported
        }

        if (Engine.x86_64.GetFormat(model, flagbit27) != 0)
        {
            //  Specular color is exported
        }
        else
        {
            //  Specular color is not exported
        }

        {
            //
            //  Get all set options
            //
            Int64   setting = Engine.x86_64.GetFormat(model, Engine.x86_64.GetFormat(0, 0));

            if ((setting & flagbit5) != 0)
            {
                //  Normal coordinates (Nx, Ny, Nz) are exported
            }
            else
            {
                //  Normal coordinates (Nx, Ny, Nz) are not exported
            }

            if ((setting & flagbit27) != 0)
            {
                //  Specular color is exported
            }
            else
            {
                //  Specular color is not exported
            }
        }
    }
}