IMeshShape

Functions

	`SET_CID`
`RED_RC`	`GetVerticesCount`
`RED_RC`	`GetVertexArray`
`RED_RC`	`GetVertexArray`
`RED_RC`	`GetNormalArray`
`RED_RC`	`GetNormalArray`
`RED_RC`	`GetColorArray`
`RED_RC`	`GetColorArray`
`RED_RC`	`GetTextureArray`
`RED_RC`	`GetTextureArray`
`RED_RC`	`GetUserArray`
`RED_RC`	`GetUserArray`
`RED_RC`	`GetArray`
`RED_RC`	`GetArray`
`RED_RC`	`GetArray`
`RED_RC`	`GetArray`
`RED_RC`	`IsSharedArray`
`RED_RC`	`GetTriangles`
`RED_RC`	`GetTriangles`
`RED_RC`	`GetTrianglesCount`
`RED_RC`	`IsSharedTriangles`
`RED_RC`	`IsTrianglesAdjacency`
`RED_RC`	`SetArray`
`RED_RC`	`SetSharedArray`
`RED_RC`	`SetOwnedArray`
`RED_RC`	`DeleteArray`
`RED_RC`	`DeleteAllArrays`
`RED_RC`	`AddTriangles`
`RED_RC`	`AddTrianglesAdjacency`
`RED_RC`	`SetTriangle`
`RED_RC`	`SetTriangleAdjacency`
`RED_RC`	`SetSharedTriangles`
`RED_RC`	`SetOwnedTriangles`
`RED_RC`	`SetSharedTrianglesAdjacency`
`RED_RC`	`SetOwnedTrianglesAdjacency`
`RED_RC`	`DeleteTriangles`
`RED_RC`	`AddStrips`
`RED_RC`	`AddFans`
`RED_RC`	`Quad`
`RED_RC`	`Box`
`RED_RC`	`Sphere`
`RED_RC`	`Cylinder`
`RED_RC`	`Cone`
`RED_RC`	`Torus`
`RED_RC`	`Polygon`
`RED_RC`	`Polygon`
`RED_RC`	`Polygon`
`RED_RC`	`Polygon`
`RED_RC`	`AddBone`
`RED_RC`	`GetBonesCount`
`RED_RC`	`SetBoneMatrix`
`RED_RC`	`GetBoneMatrix`
`RED_RC`	`GetBoneNeutralPose`
`RED_RC`	`GetBoneParent`
`RED_RC`	`GetBoneName`
`RED_RC`	`GetBoneChildrenCount`
`RED_RC`	`GetBoneChild`
`RED_RC`	`SetSkinBonesCount`
`RED_RC`	`GetSkinBonesCount`
`RED_RC`	`SetSkinBone`
`RED_RC`	`GetSkinBone`
`RED_RC`	`SetSkinVerticesCount`
`RED_RC`	`GetSkinVerticesCount`
`RED_RC`	`SetSkinVertex`
`RED_RC`	`GetSkinVertex`
`RED_RC`	`SetBoneInfluencesCount`
`RED_RC`	`GetBoneInfluencesCount`
`RED_RC`	`SetBoneInfluence`
`RED_RC`	`GetBoneInfluence`
`RED_RC`	`InitializeSkinning`
`RED_RC`	`DoSkinning`
`RED_RC`	`ResetSkinning`
`RED_RC`	`HasSkinningData`
`RED_RC`	`ReverseTriangleWinding`
`RED_RC`	`BuildTangents`
`RED_RC`	`BuildTextureCoordinates`
`RED_RC`	`BuildEdges`
`RED_RC`	`BuildContourEdges`
`RED_RC`	`BuildBorderEdges`
`RED_RC`	`Shade`
`RED_RC`	`ShadeTJunction`
`RED_RC`	`Collapse`
`RED_RC`	`BuildCutMesh`
`RED_RC`	`SortPolygons`
`RED_RC`	`BuildTrianglesAdjacency`
`RED_RC`	`RemoveTrianglesAdjacency`
`RED_RC`	`CopyFrom`

Detailed Description

class IMeshShape : public RED::IREDObject 

This interface gives access to the mesh’s properties.

Meshes are built using indexed triangle lists. The mesh only uses triangle primitives. Strips and fans may be inserted in the mesh using the RED::IMeshShape::AddStrips and RED::IMeshShape::AddFans methods, however, they are internally broken down into triangles as this provides a better overall rendering performances in minimizing the number of rendering calls needed to draw the mesh.

A mesh has 16 data channels that can store 1 to 4 components of any RED::MESH_FORMAT kind. These data channels are used by the rendering shaders as source for their lighting calculations.

A mesh can source its data from external memory arrays. It does not necessarily own a copy of the data it draws. See the RED::IMeshShape::SetSharedArray and RED::IMeshShape::SetSharedTriangles for details on data sharing. Shared data can be used to bypass the REDsdk transaction system to save memory during dynamic edition of large datasets. Shared data are not saved to .red files. During the .red file save process, each shared array is natively saved in the shape’s data.

Public Functions

SET_CID(CID_class_REDIMeshShape)

virtual RED_RC GetVerticesCount(int &oCount, int iStateNumber = -1) const = 0

Gets the number of vertices in the mesh.

Returns the number of vertices in the mesh. Each used data channel is sized to contain information for the same number of vertices.

See also \ref bk_pointcloud.

Parameters

oCount – The number of vertices in the mesh.
iStateNumber – Queried state number.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.

virtual RED_RC GetVertexArray(const void *&oArray, int &oSize, RED::MESH_FORMAT &oFormat, int iStateNumber = -1) const = 0

Read-only access to the vertex array of the mesh.

Returns the vertex array of the mesh, and its size and type of data per vertex. If this mesh is intended for use with the ray-tracer, it expects three MFT_FLOAT coordinates.

See also \ref bk_pointcloud.

Parameters

oArray – Address of the vertex array of the mesh. Returns NULL if the mesh has no bound vertex array yet. The returned data is for read access only.
oSize – Number of coordinates per vertex (1,2,3, or 4).
oFormat – Format of the returned data.
iStateNumber – Queried state number.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.

virtual RED_RC GetVertexArray(void *&oArray, int &oSize, RED::MESH_FORMAT &oFormat, const RED::State &iState) = 0

Read-write access to the vertex array of the mesh.

Returns the current vertex array of the mesh, its size and type of data per vertex. If this mesh is intended for use with the ray-tracer, it expects three MFT_FLOAT coordinates. The data array can be modified, but the format and size of the array can’t be changed.

See also \ref bk_pointcloud.

Parameters

oArray – Address of the vertex array of the mesh. Returns NULL if the mesh has no bound vertex array yet. The returned data is for read access only.
oSize – Number of coordinates per vertex (1,2,3, or 4).
oFormat – Format of the returned data.
iState – Current transaction.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.

virtual RED_RC GetNormalArray(const void *&oArray, int &oSize, RED::MESH_FORMAT &oFormat, int iStateNumber = -1) const = 0

Read-only access to the normal array of the mesh.

Returns the normal array of the mesh, and its size and type of data per vertex. If this mesh is intended for use with the ray-tracer, it expects three MFT_FLOAT coordinates.

See also \ref bk_improving_cad_graphics.

Parameters

oArray – Address of the normal array of the mesh. Returns NULL if the mesh has no bound normal array. The returned data is for read access only.
oSize – Number of coordinates per vertex (1,2,3, or 4).
oFormat – Format of the returned data.
iStateNumber – Queried state number.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.

virtual RED_RC GetNormalArray(void *&oArray, int &oSize, RED::MESH_FORMAT &oFormat, const RED::State &iState) = 0

Read-write access to the normal array of the mesh.

Returns the normal array of the mesh, and its size and type of data per vertex. If this mesh is intended for use with the ray-tracer, it expects three MFT_FLOAT coordinates.

See also \ref bk_improving_cad_graphics.

Parameters

oArray – Address of the normal array of the mesh. Returns NULL if the mesh has no bound normal array. The returned data is for read / write access.
oSize – Number of coordinates per vertex (1,2,3, or 4).
oFormat – Format of the returned data.
iState – Current transaction.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.

virtual RED_RC GetColorArray(const void *&oArray, int &oSize, RED::MESH_FORMAT &oFormat, int iStateNumber = -1) const = 0

Read-only access to the color array of the mesh.

Returns the color array of the mesh, and its size and type of data per vertex. This channel is not used by the ray-tracer.

Parameters

oArray – The address of the color array of the mesh. Returns NULL if the mesh has no bound color array. The returned data is for read access only.
oSize – Number of coordinates per vertex (1,2,3, or 4).
oFormat – Format of the returned data.
iStateNumber – Queried state number.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.

virtual RED_RC GetColorArray(void *&oArray, int &oSize, RED::MESH_FORMAT &oFormat, const RED::State &iState) = 0

Read-write access to the color array of the mesh.

Returns the color array of the mesh, and its size and type of data per vertex. This channel is not used by the ray-tracer.

Parameters

oArray – The address of the color array of the mesh. Returns NULL if the mesh has no bound color array. The returned data is for read / write access.
oSize – Number of coordinates per vertex (1,2,3, or 4).
oFormat – Format of the returned data.
iState – Current transaction.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.

virtual RED_RC GetTextureArray(const void *&oArray, int &oSize, RED::MESH_FORMAT &oFormat, int iTexNum, int iStateNumber = -1) const = 0

Read-only access to a texture coordinates array of the mesh.

Returns one of the texture coordinates array of the mesh, its size and type of data per vertex. These channels may be used by the ray- tracer, that accepts all combinations of size and type.

Parameters

oArray – The address of the corresponding texture coordinate array of the mesh. Returns NULL if the mesh has no bound texture coordinate array. The returned data is for read access only.
oSize – Number of coordinates per vertex (1,2,3, or 4).
oFormat – Format of the returned data.
iTexNum – Number of the texture coordinate channel in [0-7].
iStateNumber – Queried state number.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.

virtual RED_RC GetTextureArray(void *&oArray, int &oSize, RED::MESH_FORMAT &oFormat, int iTexNum, const RED::State &iState) = 0

Read-write access to a texture coordinates array of the mesh.

Returns one of the texture coordinates array of the mesh, its size and type of data per vertex. These channels may be used by the ray- tracer, that accepts all combinations of size and type.

Parameters

oArray – The address of the corresponding texture coordinate array of the mesh. Returns NULL if the mesh has no bound texture coordinate array. The returned data is for read / write access.
oSize – Number of coordinates per vertex (1,2,3, or 4).
oFormat – Format of the returned data.
iTexNum – Number of the texture coordinate channel in [0-7].
iState – Current transaction.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.

virtual RED_RC GetUserArray(const void *&oArray, int &oSize, RED::MESH_FORMAT &oFormat, int iUserNum, int iStateNumber = -1) const = 0

Read-only access to an user array of the mesh.

Returns one of the user arrays of the mesh, its size and type of data per vertex. These channels are not used by the ray-tracer.

Parameters

oArray – The address of the corresponding user coordinate array of the mesh. Returns NULL if the mesh has no bound user coordinate array. The returned data is for read access only.
oSize – Number of coordinates per vertex (1,2,3, or 4).
oFormat – Format of the returned data.
iUserNum – Number of the user channel in [0-3].
iStateNumber – Queried state number.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.

virtual RED_RC GetUserArray(void *&oArray, int &oSize, RED::MESH_FORMAT &oFormat, int iUserNum, const RED::State &iState) = 0

Read-write access to an user array of the mesh.

Returns one of the user arrays of the mesh, its size and type of data per vertex. These channels are not used by the ray-tracer.

Parameters

oArray – The address of the corresponding user coordinate array of the mesh. Returns NULL if the mesh has no bound user coordinate array. The returned data is for read / write access.
oSize – Number of coordinates per vertex (1,2,3, or 4).
oFormat – Format of the returned data.
iUserNum – Number of the user channel in [0-3].
iState – Current transaction.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.

virtual RED_RC GetArray(const void *&oArray, int &oSize, RED::MESH_FORMAT &oFormat, RED::MESH_CHANNEL iChannelId, int iStateNumber = -1) const = 0

Read-only access an array through its channel identifier.

Returns the array whose channel identifier is ‘iChannelId’.

Parameters

oArray – The address of the array in the mesh. Returns NULL if the mesh has no data in that array. The returned data is for read access only.
oSize – Number of coordinates per vertex (1,2,3, or 4).
oFormat – Format of the returned data.
iChannelId – Requested channel id.
iStateNumber – Queried state number.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.

virtual RED_RC GetArray(void *&oArray, int &oSize, RED::MESH_FORMAT &oFormat, RED::MESH_CHANNEL iChannelId, const RED::State &iState) = 0

Read-write access an array through its channel identifier.

Returns the array whose channel identifier is ‘iChannelId’.

See also \ref bk_pointcloud.

Parameters

oArray – The address of the array in the mesh. Returns NULL if the mesh has no data in that array. The returned data is for read / write access.
oSize – Number of coordinates per vertex (1,2,3, or 4).
oFormat – Format of the returned data.
iChannelId – Requested channel id.
iState – Current transaction.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.

virtual RED_RC GetArray(const void *&oData, RED::MESH_CHANNEL iChannelId, int iStateNumber = -1) const = 0

Read-only access an array data through its channel identifier.

Returns the data in the array whose channel id is ‘iChannelId’.

See also \ref bk_pointcloud.

Parameters

oData – Address of the array in the mesh. Returns NULL if the mesh has no data in that array. The returned data is for read access only.
iChannelId – Requested channel id.
iStateNumber – Queried state number.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.

virtual RED_RC GetArray(void *&oData, RED::MESH_CHANNEL iChannelId, const RED::State &iState) = 0

Read-write access an array data through its channel identifier.

Returns the data in the array whose channel id is ‘iChannelId’.

See also \ref bk_pointcloud.

Parameters

oData – Address of the array in the mesh. Returns NULL if the mesh has no data in that array. The returned data is for read / write access.
iChannelId – Requested channel id.
iState – Current transaction.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.

virtual RED_RC IsSharedArray(bool &oShared, RED::MESH_CHANNEL iChannelId, int iStateNumber = -1) const = 0

Is the specified channel being shared?

Parameters

oShared – true if the data in ‘iChannelId’ is shared. false otherwise (not shared or no data).
iChannelId – Identifier of the channel to check.
iStateNumber – Queried state number.

Returns

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter.

virtual RED_RC GetTriangles(const int *&oTriIndex, int &oTriCount, int iStateNumber = -1) const = 0

Read-only access to the list of triangles in the mesh.

Returns the list of triangle sets in the mesh (isolated triangles). Each triangle is made of three or six consecutive entries in ‘oTriIndex’, for a total of 3 (or 6) * ‘oTriCount’ entries. The number of entries for a triangle is 3 by default, unless adjacency informations have been supplied, in which case, the number is 6. See RED::IMeshShape::IsTrianglesAdjacency for the query over the mesh data format.

An index value indicates the number of the vertex to access in the mesh arrays.

See also \ref bk_pointcloud.

Parameters

iChannelId – Targeted channel that’ll receive the contents of ‘iData’.
iData – Data array. NULL to let the method allocate an array itself.
iVerticesCount – Number of vertices for all channels.
iSize – Number of coordinates per vertex in [1-4].
iFormat – Format of each coordinate.
iState – Current transaction.

Returns

RED_OK when the data channel could have been defined,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_FAIL if the number of vertices does not match the current size of other channels.

virtual RED_RC SetSharedArray(RED::MESH_CHANNEL iChannelId, const void *iData, int iVerticesCount, int iSize, RED::MESH_FORMAT iFormat, const RED::State &iState) = 0

Defines the contents of a data channel.

This method is similar to RED::IMeshShape::SetArray, except that the memory control of the provided array is let to the caller’s responsibility. Shared arrays differ in their behaviors from regular arrays in several ways:

The address of a shared array do not change with new transactions. A regular array is copied to a new version when modified so that it can be modified without stalling a multi-threaded rendering that may occur on the last closed transaction version of the data. A shared array is not duplicated and therefore the returned address can’t be overwritten if multi-threaded rendering is used.
RED::IMeshShape::DeleteArray and RED::IMeshShape::DeleteAllArrays don’t release the shared memory but behave normally for all other aspects of the method.
RED::IMeshShape::BuildTangents can’t target a data channel used by a shared array.

Note that an array that is shared among different shapes will still be uploaded many times on the video memory except if it’s declared as a batch array on the material using RED::IMaterial::AddBatchArrays.

Parameters

iChannelId – Targeted channel.
iData – Shared data array.
iVerticesCount – Number of vertices for all channels.
iSize – Number of coordinates per vertex in [1-4].
iFormat – Format of each coordinate.
iState – Current transaction.

Returns

RED_OK when the data channel could have been shared,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_FAIL if the number of vertices does not match the current size of other channels.

virtual RED_RC SetOwnedArray(RED::MESH_CHANNEL iChannelId, const void *iData, int iVerticesCount, int iSize, RED::MESH_FORMAT iFormat, const RED::State &iState) = 0

Force an array list for the object.

This method bypasses the REDsdk transaction system. Use with care. It directly sets the address of the object’s specified array list in the last transaction container of the object (e.g. the RED::State::GetZeroState). Memory must have been managed using rmalloc / rrealloc / rfree. The method does not release any memory prior to have its memory storage overriden.

This method can be used to do ‘in place’ memory operations in thread safe areas of the rendering pipeline.

Arrays can’t be shared before the method is called. The array is owned by the object after the call. The number of vertices can temporarily differ among arrays of the shape while performing changes.

Parameters

iChannelId – Targeted channel.
iData – The data array address.
iVerticesCount – Number of vertices for all channels.
iSize – Number of coordinates per vertex in [1-4].
iFormat – Format of each coordinate.
iState – Current transaction.

Returns

RED_OK if the method could succeed,

RED_BAD_PARAM if the method has received an invalid parameter,

virtual RED_RC DeleteArray(RED::MESH_CHANNEL iChannelId, const RED::State &iState) = 0

Deletes the contents of a data channel.

This method deletes the contents of a data channel identified by its number in the object. The corresponding array - if found - is freed from memory.

Parameters

iChannelId – Id of the channel to release.
iState – Current transaction.

Returns

RED_OK when the channel’s data could be released,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_FAIL otherwise.

virtual RED_RC DeleteAllArrays(const RED::State &iState) = 0

Deletes the contents of all data channels.

Works as RED::IMeshShape::DeleteArray, for all channels in the object.

Parameters

iState – Current transaction.

Returns

RED_OK when the channel’s data could be released,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_FAIL otherwise.

virtual RED_RC AddTriangles(const int *iTriIndex, int iTriCount, const RED::State &iState) = 0

Adds triangles to the object’s list.

This method adds triangles to the list of triangles in the object. The input information is being copied and appended at the end of the existing information already set.

It’s possible to provide no triangle index array at all. In this case, the size of the triangle list is increased by ‘iNbTriangles’, and all indices in the added list are set to zero. Then the quick triangle edition method RED::IMeshShape::SetTriangle can be used to change the list on the fly, without memory allocations penalties that would occur with a 1 by 1 addition of all triangles.

If the object had a shared triangle list, this list is replaced by the data supplied to this method.

See also \ref bk_pointcloud.

Parameters

iTriIndex – Index array for the added triangles. Contains three (int) values per triangle. Each index points to the number of the vertex to reference in the mesh data channels. When NULL, the method creates an index array set to zero by default, sized to the number of requested triangles.
iTriCount – Number of triangles to add (must be >=0)
iState – Current transaction.

Returns

RED_OK when the triangles could be added,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal memory allocation has failed,

RED_FAIL otherwise.

virtual RED_RC AddTrianglesAdjacency(const int *iTriIndex, int iTriCount, const RED::State &iState) = 0

Adds triangles to the object’s list, with adjacency informations.

This method adds triangles to the list of triangles in the object. The input information is being copied and appended at the end of the existing information already set.

It’s possible to provide no triangle index array at all. In this case, the size of the triangle list is increased by ‘iNbTriangles’, and all indices in the added list are set to zero. Then the quick triangle edition method RED::IMeshShape::SetTriangleAdjacency can be used to change the list on the fly, without memory allocations penalties that would occur with a 1 by 1 addition of all triangles.

If the object had a shared triangle list, this list is replaced by the data supplied to this method.

Triangles with adjacency are defined as indicated below:

../build/doxygen/RED/xml/API_TrianglesAdjacency.png

Each mesh triangle must be defined with three adjacent vertices. The triangle is [ P0, P1, P2 ] and the set of 6 vertices 0, 1, 2, 3, 4, 5 are supplied to the method for each triangle, 0 being P0, 2 being P1 and 4 being P2.

Parameters

iTriIndex – Index array for the added triangles. Contains six (int) values per triangle. Each index points to the number of the vertex to reference in the mesh data channels. When NULL, the method creates an index array set to zero by default, sized to the number of requested triangles.
iTriCount – Number of triangles to add (must be >=0)
iState – Current transaction.

Returns

RED_OK when the triangles could be added,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal memory allocation has failed,

RED_FAIL otherwise.

virtual RED_RC SetTriangle(int iNumTri, int iP0, int iP1, int iP2, const RED::State &iState) = 0

Modifies indices defining a triangle.

This method can be used to quickly change the indices defining a triangle. The target triangle is ‘iNumTri’, and the new indices to use for it are [ iP0, iP1, iP2 ].

Parameters

iNumTri – Triangle to modify.
iP0 – First triangle vertex number.
iP1 – Second triangle vertex number.
iP2 – Third triangle vertex number.
iState – Current transaction.

Returns

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal memory allocation has failed,

RED_FAIL otherwise.

virtual RED_RC SetTriangleAdjacency(int iNumTri, int iV0, int iV1, int iV2, int iV3, int iV4, int iV5, const RED::State &iState) = 0

Modifies indices defining a triangle, with adjacency.

This method can be used to quickly change the indices defining a triangle. The target triangle is ‘iNumTri’, and the new indices to use for it are [ iV0, iV1, iV2, iV3, iV4, iV5 ].

See RED::IMeshShape::SetTrianglesAdjacency for details.

Parameters

iNumTri – Triangle to modify.
iV0 – First vertex number (is the first triangle vertex).
iV1 – Second vertex number.
iV2 – Third vertex number (is the second triangle vertex).
iV3 – Fourth vertex number.
iV4 – Fifth vertex number (is the third triangle vertex).
iV5 – Sixth vertex number.
iState – Current transaction.

Returns

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal memory allocation has failed,

RED_FAIL otherwise.

virtual RED_RC SetSharedTriangles(const int *iTriIndex, int iTriCount, const RED::State &iState) = 0

Uses a shared triangle list for the object.

If the object was owning a list of triangles, this list is deleted and replaced by the shared list provided to the method.

Parameters

iTriIndex – Index array for the added triangles. Must point on a valid array of three (int)s for each triangle vertices indices.
iTriCount – Number of triangles in ‘iTriIndex’.
iState – Current transaction.

Returns

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal memory allocation has failed,

RED_FAIL otherwise.

virtual RED_RC SetOwnedTriangles(const int *iTriIndex, int iTriCount, const RED::State &iState) = 0

Force the triangle list for the object.

This method bypasses the REDsdk transaction system. Use with care. It directly sets the address of the object’s triangle list and triangle count in the last transaction container of the object (e.g. the RED::State::GetZeroState). Memory must have been managed using rmalloc / rrealloc / rfree. The method does not release any memory prior to have its memory storage overriden.

This method can be used to do ‘in place’ memory operations in thread safe areas of the rendering pipeline.

Arrays can’t be shared before the method is called. The array is owned by the object after the call.

Parameters

iTriIndex – Index array that’ll replace the shape triangles. 3 ints for each triangle.
iTriCount – Number of triangles in ‘iTriIndex’.
iState – Current transaction. Must be RED::State::GetZeroState.

Returns

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal memory allocation has failed,

RED_FAIL otherwise.

virtual RED_RC SetSharedTrianglesAdjacency(const int *iTriIndex, int iTriCount, const RED::State &iState) = 0

Uses a shared triangle list with adjacency for the object.

If the object was owning a list of triangles, this list is deleted and replaced by the shared list provided to the method.

Parameters

iTriIndex – Index array for the added triangles. Must point on a valid array of six (int)s for each triangle vertices indices.
iTriCount – Number of triangles in ‘iTriIndex’.
iState – Current transaction.

Returns

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal memory allocation has failed,

RED_FAIL otherwise.

virtual RED_RC SetOwnedTrianglesAdjacency(const int *iTriIndex, int iTriCount, const RED::State &iState) = 0

Force the triangle list for the object.

Same as RED::IMeshShape::SetOwnedTriangles, but with adjacency.

Parameters

iTriIndex – Index array that’ll replace the shape triangles. 6 ints for each triangle.
iTriCount – Number of triangles in ‘iTriIndex’.
iState – Current transaction. Must be RED::State::GetZeroState.

Returns

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal memory allocation has failed,

RED_FAIL otherwise.

virtual RED_RC DeleteTriangles(const RED::State &iState) = 0

Deletes all triangles in the mesh list.

This method removes all triangles from the list within the mesh. The memory formerly used is released if the list was owned by the object.

Parameters

iState – Current transaction.

Returns

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal memory allocation has failed,

RED_FAIL otherwise.

virtual RED_RC AddStrips(const int *iStripIndex, const int *iStripCount, int iStripEntriesCount, const RED::State &iState) = 0

Adds triangle strips to the object contents.

This method adds triangles strips to the list of triangles in the object. The input information is being turned into triangles, then copied and appended at the end of the existing information set.

Calling this method replaces any shared triangle list that was stored in the object.

See also \ref wf_building_basic_primitives.

Parameters

iStripIndex – Indices of all strips in sequence. If for example, there are two strips added of length 4 and 5, then ‘iStripIndex’ should contain 9 floats referencing vertices numbers in the data channels of the object. For example, (0,1,2,3,8,9,10,11,12) is a valid content defining two strips of length 4 and 5.
iStripCount – Contains the list of number of vertices of each strip. Using the previous example, ‘iStripCount’ contains only two values set to 4 and 5.
iStripEntriesCount – Number of added strips. Still in our example, 2.
iState – Current transaction.

Returns

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal memory allocation has failed,

RED_FAIL otherwise.

virtual RED_RC AddFans(const int *iFanIndex, const int *iFanCount, int iFanEntriesCount, const RED::State &iState) = 0

Adds triangle fans to the object contents.

This method adds triangles fans to the list of fans in the object. The input information is being turned into triangles, then copied and appended at the end of the existing information set.

Calling this method replaces any shared triangle list that was stored in the object.

Parameters

iFanIndex – Indices of all fans in sequence. If there are two fans added of length 4 and 5, then ‘iFanIndex’ should contain 9 floats referencing vertices numbers in the data channels of the object. For example, (0,1,2,3,8,9,10,11,12) is a valid content defining two fans of length 4 and 5.
iFanCount – Contains the list of number of vertices of each fan. Using the previous example, ‘iFanCount’ contains only two values set to 4 and 5.
iFanEntriesCount – Number of added fans. Still in our example, 2.
iState – Current transaction.

Returns

RED_OK when the operation succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal memory allocation has failed,

RED_FAIL otherwise.

virtual RED_RC Quad(const RED::Vector3 &iCenter, float iHalfSizeX, float iHalfSizeY, const RED::State &iState) = 0

Creates a quad shape.

This method creates a quad shape. It sets vertices, normal and texture coordinates informations filling RED::MCL_VERTEX, RED::MCL_NORMAL and RED::MCL_TEX0 channels. The quad lays along the x and y axis, its normal is along the z axis.

Texture coordinates are built using a planar projection (see RED::MTCM_PLANAR). Corner (-x,-y) receive (0,0) as texture coordinates, corner (+x,-y) receives (1,0), corner (-x,+y) receives (0,1) and corner (+x,+y) receives (1,1).

If the shape already contains data, they are overridden.

../build/doxygen/RED/xml/API_PrimitiveQuad.png

See also \ref wf_hello_world.

Parameters

iTargetChannel – Channel that receive the tangents.
iTexChannel – Source texture coordinate channel.
iState – Current transaction.

Returns

RED_OK when the tangents could have been calculated,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_WORKFLOW_ERROR if the object does not have valid normals for the calculation,

RED_FAIL if the used channels are not of the appropriate format.

virtual RED_RC BuildTextureCoordinates(RED::MESH_CHANNEL iTargetChannel, RED::MESH_TEXCOORD_MAPPING iTextureMapping, const RED::Matrix &iTransform, const RED::State &iState) = 0

Builds texture coordinates of a mesh.

Texture coordinates are required for the mapping of textures over a mesh.

Texture coordinates are written as a channel with 2 coordinates per vertex, using the RED::MFT_FLOAT format. The target channel in the mesh is defined by ‘iTargetChannel’. Any old contents in this channel is overwritten.

The main source of the calculation is the mesh vertex channel RED::MCL_VERTEX. The mesh normal channel RED::MCL_NORMAL is also used to compute RED::MTCM_BOX and RED::MTCM_CYLINDRICAL_CAP mapping.

Each mapping method uses primitives centered on the mesh origin.

For planar mapping, the plane is calculated along the XY axis and is of size 1. U and V are aligned with world X and Y. The mapping is centered on 0 for X and Y, which mean that the uv (0;0) is mapped to the xy (-0.5;-0.5) and the uv (1;1) is mapped to the xy (0.5;0.5).
For spherical mapping, the sphere is of diameter 1. U follows the horizontal and V follows the vertical Z axis.
For cylindrical mapping, the cylinder follows the Z axis, its length and diameter are 1. U is the horizontal coordinate and V is the vertical one along Z.
For box mapping, the box is aligned on the XYZ axes and is of size 1. On each vertical face, U follows the horizontal and V follows the vertical Z. On top and bottom faces, U and V are projected like planar mapping (aligned with X and Y). The mapping is centered on 0 for X, Y and Z, i.e. the cube goes from (-0.5;-0.5;-0.5) to (0.5;0.5;0.5).

../build/doxygen/RED/xml/API_TexCoordMapping.png

Each mapping primitive used in the process can be transformed with the ‘iTransform’ matrix parameter. Using a transform allows to scale, translate and rotate the primitive and change the output texture coordinates.

Note that the method does not modify the object topology. Therefore, depending on the chosen texture coordinate mode for the generation of the UV channel, texture wrappings may appear at the frontiers of the image. This is mostly true for the RED::MTCM_SPHERICAL, RED::MTCM_CYLINDRICAL and RED::MTCM_BOX

mappings.

Let’s take for exemple the following illustration. The U texture coordinate goes from 0.9 to 0 at the sphere seam so the entire texture is applied between the first and last vertices.

../build/doxygen/RED/xml/API_TexCoordMapping2.png

Parameters

iTargetChannel – Channel that receive the texture coordinates.
iTextureMapping – Texture coordinates mapping type.
iTransform – Matrix used for texcoord transformations.
iState – Current transaction.

Returns

RED_OK when the texture coordinates could have been calculated,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_WORKFLOW_ERROR if the object does not have valid normals for the calculation,

RED_FAIL if the used channels are not of the appropriate format.

virtual RED_RC BuildEdges(RED::Object *oEdgeShape, RED::MESH_CHANNEL iTargetVertexChannel, RED::MESH_CHANNEL iSourceVertexChannel, const RED::State &iState) const = 0

Constructs edges of a mesh.

Given a valid RED::ILineShape supplied as ‘oEdgeShape’, this routine analyzes the triangles of ‘this’ to construct the filtered list of edges that exist in the mesh.

The built edges list is not associated to the source triangles it’s originated from. The list of vertices in the mesh is duplicated in ‘oEdgeShape’.

See a practical example in the \ref wf_adding_edges tutorial.

Parameters

oEdgeShape – a valid RED::ILineShape instance, that receives the edge list and vertices in ‘this’.
iTargetVertexChannel – Channel in which vertices are stored.
iSourceVertexChannel – Channel from which vertices are extracted.
iState – Current transaction.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_FAIL otherwise.

virtual RED_RC BuildContourEdges(RED::Object *oEdgeShape, RED::MESH_CHANNEL iTargetVertexChannel, RED::MESH_CHANNEL iTargetN1Channel, RED::MESH_CHANNEL iTargetN2Channel, RED::MESH_CHANNEL iSourceVertexChannel, const RED::State &iState) const = 0

Constructs edges of a mesh with contour extraction data.

This method works as RED::IMeshShape::BuildEdges except that it adds contour extraction information to the built list of edges. This contour information is basically made of normals of triangles that are using the edge.

An edge may be used by one, two or more triangles of the mesh. The method extracts at most two normals of two triangles that are sharing the edge.

Zero length normals are stored for frontier edges and for edges shared by more than two triangles.

Edges built by this method can be rendered by the RED::RenderShaderEdges.

See a practical example in the \ref wf_adding_edges tutorial.

Parameters

oEdgeShape – a valid RED::ILineShape instance, that receives all edge parameters.
iTargetVertexChannel – Target channel for vertex storage.
iTargetN1Channel – Target channel for first normal data.
iTargetN2Channel – Target channel for second normal data.
iSourceVertexChannel – Channel from which vertices are extracted. Vertices must have 3 floating point coordinates.
iState – Current transaction.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_FAIL if the source format is not matching the method requirements.

virtual RED_RC BuildBorderEdges(RED::Object *oEdgeShape, RED::MESH_CHANNEL iTargetVertexChannel, RED::MESH_CHANNEL iSourceVertexChannel, const RED::State &iState) const = 0

Constructs border edges of a mesh.

Given a valid RED::ILineShape supplied as ‘oEdgeShape’, this routine analyzes the triangles of ‘this’ to construct the filtered list of border edges that exist in the mesh.

A border edge belongs to a single triangle in the mesh. The list of vertices in the mesh is duplicated in ‘oEdgeShape’.

See a practical example in the \ref wf_adding_edges tutorial.

Parameters

oEdgeShape – a valid RED::ILineShape instance, that receives the edge list and vertices in ‘this’.
iTargetVertexChannel – Channel in which vertices are stored.
iSourceVertexChannel – Channel from which vertices are extracted.
iState – Current transaction.

Returns

RED_OK when the operation has succeeded,

RED_BAD_PARAM if the method received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_FAIL otherwise.

virtual RED_RC Shade(RED::MESH_CHANNEL iDestNormalChannel, RED::MESH_FORMAT iDestNormalFormat, RED::MESH_CHANNEL iSourceVertexChannel, const RED::State &iState) = 0

Edits or creates object normals.

This method define smooth normals for the object using the connectivity link that exist in the mesh. Each vertex receives a normal equal to the average normal of all triangles that are sharing it. Consequently this method smoothes all normals for all connected sets of vertices. Isolated faces in a mesh remain shaded separately.

If an array exists in ‘iDestNormalChannel’ then it’s overwritten and replaced by an array using 3 xyz normal coordinates stored using the ‘iDestNormalFormat’ format.

If a geometry has no triangles, any existing array in ‘iDestNormalChannel’ is left unmodified. If there’s no array in ‘iDestNormalChannel’, a normal array is created according to ‘iDestNormalFormat’ and filled with zero normals.

Parameters

iDestNormalChannel – Geometry channel that receive created normals.
iDestNormalFormat – Format of the created normal array.
iSourceVertexChannel – Source vertices in the mesh.
iState – Current transaction.

Returns

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_FAIL if a normal array format problem has occurred, or if an unexpected error has occurred.

virtual RED_RC ShadeTJunction(RED::MESH_CHANNEL iDestNormalChannel, RED::MESH_FORMAT iDestNormalFormat, RED::MESH_CHANNEL iSourceVertexChannel, int iLookupDepth, const RED::State &iState) = 0

Edits or creates object normals with T junction cracks.

This method behaves similarly to the RED::IMeshShape::Shade method, except that it takes into consideration T junction cracks in the shading at each vertex.

a T junction crack occurs at a vertex that is lying on an edge of a neighboring triangle, forming a ‘T’ shape if we look at the geometry edges.

Normal interpolation of T junction cracks is wrong because a standard smooth shading method will consider all triangles that share a given vertex in the shading equation, without taking into consideration other triangles that do not share the vertex at one of their extremities, but along one of their edges.

The method analyzes vertices at T junction and look for neighbors at the specified ‘iDepth’. Usually a depth of 1 or 2 is enough.

If an array exists in ‘iDestNormalChannel’ then it’s overwritten and replaced by an array using 3 xyz normal coordinates stored using the ‘iDestNormalFormat’ format.

If a geometry has no triangles, any existing array in ‘iDestNormalChannel’ is left unmodified. If there’s no array in ‘iDestNormalChannel’, a normal array is created according to ‘iDestNormalFormat’ and filled with zero normals.

The method does nothing if the mesh stores triangles with adjacency informations.

Parameters

iDestNormalChannel – Geometry channel that receive the created normals.
iDestNormalFormat – Format of the created normal array.
iSourceVertexChannel – Source vertices in the mesh.
iLookupDepth – Neighboring distance used in the T junction search. This value must in [ 1, 5 ].
iState – Current transaction.

Returns

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_FAIL if a normal array format problem has occurred, or if an unexpected error has occurred.

virtual RED_RC Collapse(double iDistanceTolerance, double iAngleTolerance, const RED::State &iState, const RED::Vector<RED::MESH_CHANNEL> *iDistanceToleranceChannels = NULL, const RED::Vector<RED::MESH_CHANNEL> *iAngleToleranceChannels = NULL) = 0

Removes duplicate vertices.

This method removes all duplicates vertices in the mesh and changes all triangles indices accordingly. Two vertices are considered identical if all the channels that are declared to be checked have identical values for the provided tolerancies.

The method offers two kinds of comparisons for two values in a vertex mesh channel:

Axis distance tolerancy: maximal distance between two vertices along each x,y,z,w axis.
Angular tolerancy: maximal angle in radians between two identical directions.

By default, if the two supplied lists of channels are NULL, the method will check all data channels in a mesh, using the following tolerancies:

Angular tolerancy is used for RED::MCL_NORMAL and RED::MCL_USER0.
Axis distance tolerancy is used for all other mesh channels.

Then, if a channel is not found in the two provided lists of channels, it’s ignored and during the vertex merge operation, any of the two values for this channel that exist will be used for the merged vertex.

All degenerated triangles resulting of collapsed geometries are removed.

Note that the method can’t operate on meshes with shared arrays as it needs to reallocate memory to eliminate redundancies. Similarly, the method has no effect on meshes that have adjacency elements.

See also \ref wf_generating_vector_graphics.

Parameters

iDistanceTolerance – Numerical tolerancy used for all channels to compare in distance. This value must be greater than or equal to zero.
iAngleTolerance – Maximal angle (in radians) that can exist between two identical normals. This value must be in [ 0.0, RED_PI ].
iState – Current transaction.
iDistanceToleranceChannels – List of channels to compare using the distance tolerance.
iAngleToleranceChannels – List of channels to compare using the angular tolerance.

Returns

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_BAD_PARAM if the same channel is in the two lists of channels,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_FAIL if an unexpected error has occurred,

RED_FAIL if the mesh has shared arrays.

virtual RED_RC BuildCutMesh(RED::Object *ioCutMesh, const RED::Vector<RED::Object*> &ioCutSection, const RED::Vector<RED::Object*> &ioCutContour, const RED::Vector<double> &iPlane, double iTolerance, const RED::State &iState) const = 0

Cut a mesh using a list of specified cutting planes.

This method can be used to cut a mesh by any number of cutting planes specified in iCuttingPlanes. The method does not actually modify the contents of this. It fills ioCutMesh, ioCutSection meshes and ioCutContour lines that have been sent to the method. Vertex coordinates are assumed to be in RED::MCL_VERTEX, normals in RED::MCL_NORMAL.

This is a software cut operation performed on mesh triangles that differ a lot from the RED::IMaterial::SetCuttingPlane method which is a GPU based real-time operation, as illustrated in the \ref wf_section_cutting tutorial.

It’s the responsibility of the caller to create ioCutMesh, ioCutSection and ioCutContour before the call and to release them after use. Please note that using ioCutSection and ioCutContour are optional and can be empty vectors or both must have a number of entries equal to the number of planes involved in the cut operation. ioCutMesh and ioCutSection must contain CID_REDMeshShape. ioCutContour must contain CID_REDLineShape objects.

The resulting cut contours are parametrized line shapes (see RED::ILineShape::Parametrize), and should be rendered with a parametrization material (RED::IResourceManager::CreateParametrizationMaterial).

The resulting section shapes have vertices and normal attributes set. Vertex normals are set as the corresponding cut plane normal to ensure a proper shading.

The source mesh (this) must have a correct topology for the operation to work. It must be a closed non manifold solid shape. This means that each edge in the source mesh must be exactly shared twice by triangles that define the mesh (without considering duplicate vertices that result of shading). So a source mesh that is closed but that has duplicate vertices for shading purposes is correct. For instance a cube has 24 vertices at 8 real positions in space, each vertex being duplicated three times to store per face normals that are requested for shading. After a collapse operation, this cube has only 8 vertices and is a closed solid whose topology is suitable for the operation.

The source mesh (this) should not have any adjacency information stored, otherwise, the method will return RED_WORKFLOW_ERROR.

Parameters

ioCutMesh – Resulting mesh containing the sliced triangles after the cut operation. Must be set to a valid mesh shape address.
ioCutSection – Resulting meshes containing the polygonal sliced sections. One mesh shape needs to be supplied for each input plane. The number of cut contours must be equal to the number of cut sections.
ioCutContour – Resulting contours resulting of the cut operation. One line shape needs to be supplied for each input plane. The number of cut contours must be equal to the number of cut sections.
iPlane – List of plane equations that cut this. The positive side of the plane is discarded (e.g if we have a plane with normal equal to +z, we keep the negative z part of the mesh). Each plane is specified by its equation (4 doubles A, B, C, D for A*x + B*y + C*z + D = 0).
iTolerance – Numerical tolerancy used to collapse the source mesh internally to get it as a plain closed solid. If the tolerancy is too small, the collapse operation may fail to turn this as a plain solid, resulting in erroneous output of the method.
iState – Current transaction.

Returns

RED_OK if the operation has succeeded,

RED_BAD_PARAM if the method has received an invalid parameter,

RED_BAD_PARAM if iPlane doesn’t have 4 values per plane,

RED_BAD_PARAM if we have inconsistent lists in ioCutSection and ioCutContour,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_WORKFLOW_ERROR if this stores triangle adjacency,

RED_FAIL if an unexpected error has occurred.

virtual RED_RC SortPolygons(const RED::Vector3 &iDirection, int iTrianglesCount, const RED::State &iState) = 0

Performs a distance sorting of polygons in a mesh.

This method will process all the triangles of the mesh, by packs of ‘iTrianglesCount’ triangles and it’ll reorder the index array of the mesh so that polygons are sorted back to front in distance along the specified ‘iDirection’.

If ‘iTrianglesCount’ is equal to 1, then all triangles are separatedly sorted. If ‘iTrianglesCount’ is equal to 2, then the method sorts groups of 2 triangles (generally quads). Larger groups of triangles can be sorted too.

Parameters

iDirection – Depth sorting axis.
iTrianglesCount – Number of triangles to group for each sorted entity.
iState – Current transaction.

Returns

RED_OK if the operation has succeeded,

RED_BAD_PARAM if iTrianglesCount is lower than 1,

RED_WORKFLOW_ERROR if the shape contains lines or points instead of triangles,

RED_WORKFLOW_ERROR if the shape has triangles with adjacency informations,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_FAIL if the number of triangles in the shape is not an exact multiple of iTrianglesCount,

RED_FAIL if an unexpected error has occurred.

virtual RED_RC BuildTrianglesAdjacency(const RED::State &iState) = 0

Constructs triangle adjacency for the current object.

This method takes the current list of triangles in this and replaces it with a list of triangles that contain adjacency informations, as a call to RED::IMeshShape::AddTrianglesAdjacency would do.

If the object already has adjacency informations, the method does nothing.

The method does not work on shared lists of triangles.

The method does not work on manifold topologies.

The opposite operation is performed by RED::IMeshShape::RemoveTrianglesAdjacency.

Parameters

iState – Current transaction.

Returns

RED_OK if the operation has succeeded,

RED_WORKFLOW_ERROR if the shape has a shared list of triangles,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_FAIL if the source mesh is a manifold topology,

RED_FAIL if an unexpected error has occurred.

virtual RED_RC RemoveTrianglesAdjacency(const RED::State &iState) = 0

Removes triangle adjacency from the current object.

This method does the opposite of RED::IMeshShape::BuildTrianglesAdjacency: it removes all adjacency information from the shape and replaces its list of triangles with adjacency by a list of triangles with no adjacency informations.

If the shape has no adjacency informations, the method does nothing. The method does not work on shared lists of triangles.

Parameters

iState – Current transaction.

Returns

RED_OK if the operation has succeeded,

RED_WORKFLOW_ERROR if the shape has a shared list of triangles,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_FAIL if an unexpected error has occurred.

virtual RED_RC CopyFrom(const RED::Object &iMesh, const RED::State &iState, int iSrcStateNumber = -1) = 0

Copies the content of a RED::IMeshShape instance to the current object.

This method will work for only two instances of the same concrete class.

Parameters

iMesh – Reference to the object to copy from.
iState – Current transaction.
iSrcStateNumber – State from which the source mesh must be copied.

Returns

RED_OK on success,

RED_BAD_PARAM if ‘iMesh’ and ‘this’ are from different classes, or if ‘iSrcStateNumber’ is invalid,

RED_ALLOC_FAILURE if an internal allocation has failed,

RED_FAIL for any other error.