Data Structures

MRY_MSH_QUAD_EXT

struct MRY_MSH_QUAD_EXT;

The struct MRY_MSH_QUAD_EXT is used by the fnGetQuad and fnModifyQuad functions of the MRY_WIREFRAME_BUILDING struct to retrieve and modify the quads used in the polygon representation of an object.

The MRY_MSH_QUAD_EXT struct has the following members:

nPn - the index into the vertex list of the nth vertex of the quad.
nNn - the index into the normal list of the normal at the nth vertex of the quad.
nUVn - the index into the UV coordinates list of the UV coordinate at the nth vertex of the quad.
lColor - the color of the quad (32-bit integer 0x00RRGGBB)

See Also

MRY_MSH_FACE

struct MRY_MSH_FACE;

The struct MRY_MSH_FACE is used by the fnGetFace and fnModifyFace functions of the MRY_WIREFRAME_BUILDING struct to retrieve and modify the faces used in the polygon representation of an object.

The MRY_MSH_FACE struct has the following members:

nNumVertices - the number of vertices in the face. Must be either 3 or 4!
nPn - the index into the vertex list of the nth vertex of the quad.
nNn - the index into the normal list of the normal at the nth vertex of the quad.
nUVn - the index into the UV coordinates list of the UV coordinate at the nth vertex of the quad.
lColor - the color of the quad (32-bit integer 0x00RRGGBB)
lMaterialIndex - the index into the material list. This is only relevant if the wireframe belongs to a Mesh object. In this case, materials are defined by calling functions in the mesh part of the MRY_OBJ_SPECIFIC struct (retrieved by GetAttributes).
nVertexTag1n, nEdgeTagn and nSectorTagn - are currently reserved.
nFlags - is a bit field that is currently reserved.

See Also

MRY_OBJ_TRIANGLE_EXT

struct MRY_OBJ_TRIANGLE_EXT;

The struct MRY_OBJ_TRIANGLE_EXT is used by the fnAddMeshTriangle function of the MRY_WIREFRAME_BUILDING struct to add a triangle to the wireframe of an plugin object.

The MRY_OBJ_TRIANGLE_EXT struct has the following members:

nVersion - the version of this struct
nFlags - flags that indicate which members are valid.
The following flags are supported:
- MRY_OBJ_TRI_INVERTED - the triangle is inverted (Moray will invert the triangle).
- MRY_OBJ_TRI_USE_NORMALS - the normals are valid.
- MRY_OBJ_TRI_USE_UVCOORDS - the UV coordinates are valid.
vVertexn - the X, Y, Z coordinate of the nth vertex.
vNormaln - the X, Y, Z components of the normal at the nth vertex.
vUVn - the U, V coordinate at the nth vertex (places in the dX and dY components of the MRY_VECTOR. The Z coordinate is preserved but ignored).

Note that Moray uses counter-clockwise triangles, so it may be neccessary to invert the triangle for Moray to be able to use it properly. You can pass the MRY_OBJ_TRI_INVERTED flag in this struct to make Moray do the grunt work of inverting it for you.

See Also

MRY_OBJ_QUAD_EXT

struct MRY_OBJ_QUAD_EXT;

The struct MRY_OBJ_QUAD_EXT is used by the fnAddMeshQuad function of the MRY_WIREFRAME_BUILDING struct to add a quad to the wireframe of an plugin object.

The MRY_OBJ_QUAD_EXT struct has the following members:

nVersion - the version of this struct
nFlags - flags that indicate which members are valid.
The following flags are supported:
- MRY_OBJ_TRI_INVERTED - the quad is inverted (Moray will invert the quad).
- MRY_OBJ_TRI_USE_NORMALS - the normals are valid.
- MRY_OBJ_TRI_USE_UVCOORDS - the UV coordinates are valid.
vVertexn - the X, Y, Z coordinate of the nth vertex.
vNormaln - the X, Y, Z components of the normal at the nth vertex.
vUVn - the U, V coordinate at the nth vertex (places in the dX and dY components of the MRY_VECTOR. The Z coordinate is preserved but ignored).

Note that Moray uses counter-clockwise quads, so it may be neccessary to invert the quad for Moray to be able to use it properly. You can pass the MRY_OBJ_TRI_INVERTED flag in this struct to make Moray do the grunt work of inverting it for you.

See Also

MRY_WIREFRAME_BUILDING.fnGetWireInfo

The function MRY_WIREFRAME_BUILDING.fnGetWireInfo is a member function of the MRY_WIREFRAME_BUILDING struct and retrieves info about the wireframe.

long WINAPI fnGetWireInfo(long hWireFrameID, long *pnNumVertices, long *pnNumNormals, long *pnNumUVCoords, long *pnNumTriangles, long *pnNumQuads);

Parameters

hWireframeID	contains the handle of the wireframe that is being modified
pnNumVertices	contains a pointer to where the number of vertices should be written
pnNumNormals	contains a pointer to where the number of normals should be written
pnNumUVCoords	contains a pointer to where the number of UV coordinates should be written
pnNumTriangles	contains a pointer to where the number of triangles should be written
pnNumQuads	contains a pointer to where the number of quads should be written

Return Values

MRY_SUCCESS	if the structure was successfully filled.
MRY_ERR_NULL_POINTER	if hWireFrameID is NULL.

Remarks

This function is obsolete. Please use fnGetWireFaceInfo instead. If any of the pointers are NULL, the information will not be written.

See Also

MRY_WIREFRAME_BUILDING.fnAllocateMemory

The function MRY_WIREFRAME_BUILDING.fnAllocateMemory is a member function of the MRY_WIREFRAME_BUILDING struct that tells Moray how much memory to allocate for the wireframe elements.

long WINAPI fnAllocateMemory(long hWireframeID, long nNumVertices, long nNumEdges, long nNumNormals, long nNumUVCoords);

Parameters

hWireframeID	contains Morays handle of the wireframe being built.
nNumVertices	contains the exact number of vertices that this object will use. Moray allocates enough memory to hold exactly this amount.
nNumEdges	contains the exact number of edges that this object will use. Moray allocates enough memory to hold exactly this amount.
nNumNormals	contains the exact number of normals that this object will use. Moray allocates enough memory to hold exactly this amount.
nNumUVCoords	contains the exact number of UV coords that this object will use. Moray allocates enough memory to hold exactly this amount.

Return Values

MRY_SUCCESS	if the allocation was successful.
MRY_ERR_NULL_POINTER	if hWireframeID was NULL.
MRY_ERR_INTERNAL_ERROR	if something went very wrong.
MRY_ERR_OUT_OF_MEMORY	if not enough memory was available.

Remarks

Only nNumNormals and nNumUVCoords can be 0.

MRY_WIREFRAME_BUILDING.fnPolygonCountHint

The function MRY_WIREFRAME_BUILDING.fnPolygonCountHint is a member function of the MRY_WIREFRAME_BUILDING struct that function to tell Moray approximately how much memory to allocate for the polygon elements.

long WINAPI fnPolygonCountHint(long hWireframeID, long nApproxTriangles, long nApproxQuads);

Parameters

hWireframeID	contains Morays handle of the wireframe being built.
nApproxTriangles	The approximate number of triangles the plugin will be creating for this object. See Remarks.
nApproxQuads	The approximate number of quads the plugin will be creating for this object. See Remarks.

Return Values

MRY_SUCCESS	if the allocation was successful.
MRY_ERR_NULL_POINTER	if hWireframeID was NULL.
MRY_ERR_OUT_OF_MEMORY	if not enough memory was available.

Remarks

You do not need to differentiate between triangles and quads. Simply pass in the number of faces as one of the arguments. The face list is dynamic and grows if it overflows. To prevent memory fragmentation and too many reallocations, this function allows the plugin to give a rough estimate of how many faces are likely to be created. Moray uses these numbers as initial values for memory allocation, allocating memory for at least 16 faces. The plugin should be on the safe side so that not too many reallocations need to occur. The array size is doubled everytime an overflow occurs.

If you do not intend to create triangles or quads, you do not need to call this function.

MRY_WIREFRAME_BUILDING.fnAddVertices

The function MRY_WIREFRAME_BUILDING.fnAddVertices is a member function of the MRY_WIREFRAME_BUILDING struct that adds one or more vertices to the wireframe.

long WINAPI fnAddVertices(long hWireframeID, long nNumVertices, MRY_VECTOR *pvVertices);

Parameters

hWireframeID	contains Morays handle of the wireframe being built.
nNumVertices	the number of vertices that are to be added to the vertex list.
pvVertices	A pointer to an array of MRY_VECTORs that contain the vertices.

Return Values

MRY_SUCCESS	if the vertices were appended to the list.
MRY_ERR_NULL_POINTER	if hWireframeID was NULL.
MRY_ERR_INTERNAL_ERROR	if something went very wrong.
MRY_ERR_WIRE_TOO_MANY_VERTICES	if more vertices were passed in than were specified in the call to fnAllocateMemory.

Remarks

The vertices are appended to the end of the vertex list. It is up to the plugin to keep track of the indeces where vertices are being added (if the plugin needs to).

The vertices are copied from pvVertices, no memory is grabbed from the plugin. They are not shuffled about, so they stay in the same order in which the plugin passes them in.

MRY_WIREFRAME_BUILDING.fnAddVertex

The function MRY_WIREFRAME_BUILDING.fnAddVertex is a member function of the MRY_WIREFRAME_BUILDING struct that adds a single vertex to the wireframe.

long WINAPI fnAddVertex(long hWireframeID, double dX, double dY, double dZ);

Parameters

hWireframeID	contains Morays handle of the wireframe being built.
dX, dY, dZ	The coordinates of the vertex to be added.

Return Values

MRY_SUCCESS	if the vertex was appended to the list.
MRY_ERR_NULL_POINTER	if hWireframeID was NULL.
MRY_ERR_INTERNAL_ERROR	if something went very wrong.
MRY_ERR_WIRE_TOO_MANY_VERTICES	if more vertices were passed in than were specified in the call to fnAllocateMemory.

Remarks

The vertex is appended to the end of the vertex list. It is up to the plugin to keep track of the indeces where vertices are being added (if the plugin needs to).

The vertices are not shuffled about, they stay in the same order in which the plugin passes them in.

MRY_WIREFRAME_BUILDING.fnAddNormals

The function MRY_WIREFRAME_BUILDING.fnAddNormals is a member function of the MRY_WIREFRAME_BUILDING struct that adds one or more normals to the wireframe.

long WINAPI fnAddNormals(long hWireframeID, long nNumNormals, MRY_VECTOR *pvNormals);

Parameters

hWireframeID	contains Morays handle of the wireframe being built.
nNumNormals	the number of normals that are to be added to the normals list.
pvNormals	A pointer to an array of MRY_VECTORs that contain the normals.

Return Values

MRY_SUCCESS	if the normals were appended to the list.
MRY_ERR_NULL_POINTER	if hWireframeID was NULL.
MRY_ERR_INTERNAL_ERROR	if something went very wrong.
MRY_ERR_WIRE_TOO_MANY_NORMALS	if more normals were passed in than were specified in the call to fnAllocateMemory.

Remarks

The normals are appended to the end of the normals list. It is up to the plugin to keep track of the indeces where normals are being added (if the plugin needs to).

The normals are copied from pvNormals, no memory is grabbed from the plugin. They are not shuffled about, so they stay in the same order in which the plugin passes them in.

MRY_WIREFRAME_BUILDING.fnAddNormal

The function MRY_WIREFRAME_BUILDING.fnAddNormal is a member function of the MRY_WIREFRAME_BUILDING struct that adds a normal to the wireframe.

long WINAPI fnAddNormal(long hWireframeID, double dNX, double dNY, double dNZ);

Parameters

hWireframeID	contains Morays handle of the wireframe being built.
dNX, dNY, dNZ	The coordinates of the normal to be added.

Return Values

MRY_SUCCESS	if the normal was appended to the list.
MRY_ERR_NULL_POINTER	if hWireframeID was NULL.
MRY_ERR_INTERNAL_ERROR	if something went very wrong.
MRY_ERR_WIRE_TOO_MANY_NORMALS	if more normals were passed in than were specified in the call to fnAllocateMemory.

Remarks

The normal is appended to the end of the normals list. It is up to the plugin to keep track of the indeces where normals are being added (if the plugin needs to).

The normals are not shuffled about, so they stay in the same order in which the plugin passes them in.

MRY_WIREFRAME_BUILDING.fnAddUVCoords

The function MRY_WIREFRAME_BUILDING.fnAddUVCoords is a member function of the MRY_WIREFRAME_BUILDING struct that adds one or more UV coordinates to the wireframe.

long WINAPI fnAddUVCoords)(long hWireframeID, long nNumUVCoords, MRY_VECTOR *pvUVCoords);

Parameters

hWireframeID	contains Morays handle of the wireframe being built.
nNumUVCoords	the number of UV coordinates that are to be added to the UV coordinates list.
pvUVCoords	A pointer to an array of MRY_VECTORs that contain the UV coordinates.

Return Values

MRY_SUCCESS	if the UV coordinates were appended to the list.
MRY_ERR_NULL_POINTER	if hWireframeID was NULL.
MRY_ERR_INTERNAL_ERROR	if something went very wrong.
MRY_ERR_WIRE_TOO_MANY_UVCOORDS	if more UV coordinates were passed in than were specified in the call to fnAllocateMemory.

Remarks

The UV coordinates are appended to the end of the UV coordinates list. It is up to the plugin to keep track of the indeces where UV coordinates are being added (if the plugin needs to).

The UV coordinates are copied from pvUVCoords, no memory is grabbed from the plugin. They are not shuffled about, so they stay in the same order in which the plugin passes them in.

MRY_WIREFRAME_BUILDING.fnAddUVCoord

The function MRY_WIREFRAME_BUILDING.fnAddUVCoord is a member function of the MRY_WIREFRAME_BUILDING struct that adds a UV coordinate to the wireframe.

long WINAPI fnAddUVCoord(long hWireframeID, double dUVX, double dUVY, double dUVZ);

Parameters

hWireframeID	contains Morays handle of the wireframe being built.
dUVX, dUVY, dUVZ	The coordinates of the UV coordinate to be added.

Return Values

MRY_SUCCESS	if the UV coordinate was appended to the list.
MRY_ERR_NULL_POINTER	if hWireframeID was NULL.
MRY_ERR_INTERNAL_ERROR	if something went very wrong.
MRY_ERR_WIRE_TOO_MANY_NORMALS	if more UV coordinates were added than were specified in the call to fnAllocateMemory.

Remarks

The UV coordinate is appended to the end of the UV coordinates list. It is up to the plugin to keep track of the indeces where UV coordinate are being added (if the plugin needs to).

The UV coordinates are not shuffled about, so they stay in the same order in which the plugin passes them in.

MRY_WIREFRAME_BUILDING.fnAddEdges

The function MRY_WIREFRAME_BUILDING.fnAddEdges is a member function of the MRY_WIREFRAME_BUILDING struct that adds one or more edges to the wireframe.

long WINAPI fnAddEdges(long hWireframeID, long nNumEdges, int *pnEdges);

Parameters

hWireframeID	contains Morays handle of the wireframe being built.
nNumEdges	the number of edges that are to be added to the edge list.
pnEdges	A pointer to an array of pairs of ints that contain start and end index of the vertices that define the edges.

Return Values

MRY_SUCCESS	if the edges were appended to the list.
MRY_ERR_NULL_POINTER	if hWireframeID was NULL.
MRY_ERR_INTERNAL_ERROR	if something went very wrong.
MRY_ERR_WIRE_TOO_MANY_UVCOORDS	if more edges were passed in than were specified in the call to fnAllocateMemory.

Remarks

The edges are appended to the end of the edge list. pnEdges must point to an array of int pairs, the first int defining the index of the vertex that defines the start of the edge. The second in defines the index of the vertex that defines the end of the edge.

The edges are copied from pnEdges, no memory is grabbed from the plugin. They are not shuffled about, so they stay in the same order in which the plugin passes them in.

MRY_WIREFRAME_BUILDING.fnAddEdge

The function MRY_WIREFRAME_BUILDING.fnAddEdge is a member function of the MRY_WIREFRAME_BUILDING struct that adds one or more edges to the wireframe.

long WINAPI fnAddEdge(long hWireframeID, int nVertex1, int nVertex2);

Parameters

hWireframeID	contains Morays handle of the wireframe being built.
nVertex1, nVertex2	the indeces of the vertices that make up the edge to be added to the edge list.

Return Values

MRY_SUCCESS	if the edge was appended to the list.
MRY_ERR_NULL_POINTER	if hWireframeID was NULL.
MRY_ERR_INTERNAL_ERROR	if something went very wrong.
MRY_ERR_WIRE_TOO_MANY_UVCOORDS	if more edges were passed in than were specified in the call to fnAllocateMemory.

Remarks

The edge is appended to the end of the edge list.

The edges are not shuffled about, so they stay in the same order in which the plugin passes them in.

MRY_WIREFRAME_BUILDING.fnAddTriangle

The function MRY_WIREFRAME_BUILDING.fnAddTriangle is a member function of the MRY_WIREFRAME_BUILDING struct that adds one triangle to the wireframe.

long WINAPI fnAddTriangle)(long hWireframeID, int nVertIndex1, int nVertIndex2, int nVertIndex3, long *hTriangleID);

Parameters

hWireframeID	contains Morays handle of the wireframe being built.
nVertIndex1	contains the index into the vertex list that defines the first vertex of the triangle.
nVertIndex2	contains the index into the vertex list that defines the second vertex of the triangle.
nVertIndex3	contains the index into the vertex list that defines the third vertex of the triangle.
hTriangleID	A pointer to a long that will receive the handle of the created triangle.

Return Values

MRY_SUCCESS	if the triangle was appended to the list.
MRY_ERR_NULL_POINTER	if hWireframeID was NULL.
MRY_ERR_INTERNAL_ERROR	if something went very wrong.
MRY_ERR_OUT_OF_MEMORY	if memory for triangles could not be allocated (will not occur if fnAllocateMemory was called)..

Remarks

Note: You can use the fnAddFace function instead.

Moray will create a triangle using the indeces passed and will return a handle to that triangle in hTriangleID. The plugin should then use the functions fnSetTriangleNormal and fnSetTriangleUVCoords to set the normals and the UV coordinates of the triangle.

MRY_WIREFRAME_BUILDING.fnAddQuad

The function MRY_WIREFRAME_BUILDING.fnAddQuad is a member function of the MRY_WIREFRAME_BUILDING struct that adds one quad to the wireframe.

long WINAPI fnAddQuad(long hWireframeID, int nVertIndex1, int nVertIndex2, int nVertIndex3, int nVertIndex4, long *hQuadID);

Parameters

hWireframeID	contains Morays handle of the wireframe being built.
nVertIndex1	contains the zero-based index into the vertex list that defines the first vertex of the quad.
nVertIndex2	contains the zero-based index into the vertex list that defines the second vertex of the quad.
nVertIndex3	contains the zero-based index into the vertex list that defines the third vertex of the quad.
nVertIndex4	contains the zero-based index into the vertex list that defines the fourth vertex of the quad.
hQuadID	A pointer to a long that will receive a handle to the created quad.

Return Values

MRY_SUCCESS	if the quad was appended to the list.
MRY_ERR_NULL_POINTER	if hObj was NULL.
MRY_ERR_INTERNAL_ERROR	if something went very wrong.
MRY_ERR_OUT_OF_MEMORY	if memory for quads could not be allocated (will not occur if fnAllocateMemory was called).

Remarks

Note: You can use the fnAddFace function instead.

Moray will create a quad using the indeces passed and will return a handle to that quad in hQuadID. The plugin should then use the functions fnSetQuadNormal and fnSetQuadUVCoords to set the normals and the UV coordinates of the quad.

MRY_WIREFRAME_BUILDING.fnSetTriangleNormals

The function MRY_WIREFRAME_BUILDING.fnSetTriangleNormals is a member function of the MRY_WIREFRAME_BUILDING struct that sets the normals of a triangle that was added to the wireframe.

long WINAPI fnSetTriangleNormals(long hTriangleID, int nNormIndex1, int nNormIndex2, int nNormIndex3);

Parameters

hTriangleID	contains the handle to a triangle returned by the fnAddTriangle function.
nNormIndex1	contains the zero-based index into the normal list that defines the normal at the first vertex of the triangle.
nNormIndex2	contains the zero-based index into the normal list that defines the normal at the second vertex of the triangle.
nNormIndex3	contains the zero-based index into the normal list that defines the normal at the third vertex of the triangle.

Return Values

MRY_SUCCESS	if the normals were set.
MRY_ERR_NULL_POINTER	if hTriangleID is NULL.

Remarks

The indeces are not checked. Therefore the indeces of the normals can be passed to this triangle before they are created with the fnAddNormals function. Of course, the plugin does need to make sure that when the wireframe is done, all indeces are valid.

MRY_WIREFRAME_BUILDING.fnSetQuadNormals

The function MRY_WIREFRAME_BUILDING.fnSetQuadNormals is a member function of the MRY_WIREFRAME_BUILDING struct that sets the normals of a quad that was added to the wireframe.

long WINAPI fnSetQuadNormals(long hQuadID, int nNormIndex1, int nNormIndex2, int nNormIndex3, int nNormIndex4);

Parameters

hQuadID	contains the handle to a quad returned by the fnAddQuad function.
nNormIndex1	contains the zero-based index into the normal list that defines the normal at the first vertex of the quad.
nNormIndex2	contains the zero-based index into the normal list that defines the normal at the second vertex of the quad.
nNormIndex3	contains the zero-based index into the normal list that defines the normal at the third vertex of the quad.
nNormIndex4	contains the zero-based index into the normal list that defines the normal at the fourth vertex of the quad.

Return Values

MRY_SUCCESS	if the normals were set.
MRY_ERR_NULL_POINTER	if hQuadID is NULL.

Remarks

The indeces are not checked. Therefore the indeces of the normals can be passed to this quad before they are created with the fnAddNormals function. Of course, the plugin does need to make sure that when the wireframe is done, all indeces are valid.

MRY_WIREFRAME_BUILDING.fnSetTriangleUVCoords

The function MRY_WIREFRAME_BUILDING.fnSetTriangleUVCoords is a member function of the MRY_WIREFRAME_BUILDING struct that sets the UV coordinates of the vertices of a triangle that was added to the wireframe.

long WINAPI fnSetTriangleUVCoords(long hTriangleID, int nUVIndex1, int nUVIndex2, int nUVIndex3);

Parameters

hTriangleID	contains the handle to a triangle returned by the fnAddTriangle function.
nNormIndex1	contains the zero-based index into the UV coordinates list that defines the UV coordinate at the first vertex of the triangle.
nNormIndex2	contains the zero-based index into the UV coordinates list that defines the UV coordinate at the second vertex of the triangle.
nNormIndex3	contains the zero-based index into the UV coordinates list that defines the UV coordinate at the third vertex of the triangle.

Return Values

MRY_SUCCESS	if the UV coordinates were set.
MRY_ERR_NULL_POINTER	if hTriangleID is NULL.

Remarks

The indeces are not checked. Therefore the indeces of the UV coordinates can be passed to this triangle before they are created with the fnAddUVCoords function. Of course, the plugin does need to make sure that when the wireframe is done, all indeces are valid.

MRY_WIREFRAME_BUILDING.fnSetQuadUVCoords

The function MRY_WIREFRAME_BUILDING.fnSetQuadUVCoords is a member function of the MRY_WIREFRAME_BUILDING struct that sets the UV coordinates of the vertices of a quad that was added to the wireframe.

long WINAPI fnSetQuadUVCoords(long hQuadID, int nUVIndex1, int nUVIndex2, int nUVIndex3, int nUVIndex4);

Parameters

hQuadID	contains the handle to a quad returned by the fnAddQuad function.
nUVIndex1	contains the zero-based index into the UV coordinates list that defines the UV coordinate at the first vertex of the quad.
nUVIndex2	contains the zero-based index into the UV coordinates list that defines the UV coordinate at the second vertex of the quad.
nUVIndex3	contains the zero-based index into the UV coordinates list that defines the UV coordinate at the third vertex of the quad.
nUVIndex4	contains the zero-based index into the UV coordinates list that defines the UV coordinate at the fourth vertex of the quad.

Return Values

MRY_SUCCESS	if the UV coordinates were set.
MRY_ERR_NULL_POINTER	if hQuadID is NULL.

Remarks

The indeces are not checked. Therefore the indeces of the UV coordinates can be passed to this quad before they are created with the fnAddUVCoords function. Of course, the plugin does need to make sure that when the wireframe is done, all indeces are valid.

MRY_WIREFRAME_BUILDING.fnSetTriangleMaterial

The function MRY_WIREFRAME_BUILDING.fnSetTriangleMaterial is a member function of the MRY_WIREFRAME_BUILDING struct that sets the material of a triangle of a wireframe.

long WINAPI fnSetTriangleMaterial(long hPoly, int nMaterialIndex);

Parameters

hPoly	contains the handle of the triangle returned in the last parameter in the call to the fnAddTriangle function.
nMaterialIndex	contains the index of the material to be used for this triangle. The materials are defined by calling functions in the mesh part of the MRY_OBJ_SPECIFIC struct (retrieved by GetAttributes).

Return Values

MRY_SUCCESS

always.

Remarks

The index is not checked. It is up the plugin to make sure that the mesh object has the correct list of materials.

See Also

MRY_WIREFRAME_BUILDING.fnSetQuadMaterial

The function MRY_WIREFRAME_BUILDING.fnSetQuadMaterial is a member function of the MRY_WIREFRAME_BUILDING struct that sets the material of a quad of a wireframe.

long WINAPI fnSetQuadMaterial(long hPoly, int nMaterialIndex);

Parameters

hPoly	contains the handle of the quad returned in the last parameter in the call to the fnAddQuad function.
nMaterialIndex	contains the index of the material to be used for this quad. The materials are defined by calling functions in the mesh part of the MRY_OBJ_SPECIFIC struct (retrieved by GetAttributes).

Return Values

MRY_SUCCESS

always.

Remarks

The index is not checked. It is up the plugin to make sure that the mesh object has the correct list of materials.

See Also

MRY_WIREFRAME_BUILDING.fnAddMeshTriangle

The function MRY_WIREFRAME_BUILDING.fnAddMeshTriangle is a member function of the MRY_WIREFRAME_BUILDING struct that adds a complete triangle to the wireframe of a plugin object.

long WINAPI fnAddMeshTriangle(long hObj, LPMRY_OBJ_TRIANGLE_EXT pTri);

Parameters

hObj	contains Morays handle of the plugin object being built.
pTri	contains a pointer to a MRY_OBJ_TRIANGLE_EXT struct containing the triangle definition.

Return Values

MRY_SUCCESS	if the triangle was added.
MRY_ERR_VERSION_NOT_SUPPORTED	if the nVersion member is incompatible with Moray.

Remarks

This function is the second way (as described under MRY_WIREFRAME_BUILDING) of building a wireframe for a plugin object. Moray extracts all the data from the struct and creates the corresponding lists.

Note: this member of the MRY_WIREFRAME_BUILDING struct is only valid if the object being built is a plugin object!

See MRY_OBJ_TRIANGLE_EXT for more details.

MRY_WIREFRAME_BUILDING.fnAddMeshQuad

The function MRY_WIREFRAME_BUILDING.fnAddMeshQuad is a member function of the MRY_WIREFRAME_BUILDING struct that adds a complete quad to the wireframe of a plugin object.

long WINAPI fnAddMeshQuad(long hObj, LPMRY_OBJ_QUAD_EXT pQuad);

Parameters

hObj	contains Morays handle of the plugin object being built.
pTri	contains a pointer to a MRY_OBJ_QUAD_EXT struct containing the quad definition.

Return Values

MRY_SUCCESS	if the quad was added.
MRY_ERR_VERSION_NOT_SUPPORTED	if the nVersion member is incompatible with Moray.

Remarks

MRY_WIREFRAME_BUILDING.fnGetVertex

The function MRY_WIREFRAME_BUILDING.fnGetVertex is a member function of the MRY_WIREFRAME_BUILDING struct and fills a MRY_VECTOR struct with the coordinates of a vertex.

long WINAPI fnGetVertex(long hWireframe, int nIndex, LPMRY_VECTOR v);

Parameters

hWireframe	contains the handle of the wireframe that is being queried.
nIndex	contains the zero-based index of the vertex to retrieve.
v	contains a pointer to the vector that should receive the coordinates of the vector.

Return Values

MRY_SUCCESS	if the structure was successfully filled.
MRY_ERR_NULL_POINTER	if hWireframe is NULL.
MRY_ERR_INDEX_OUT_OF_RANGE	if nIndex is out of range (less than zero or larger than the number of vertices present).
MRY_ERR_WIRE_NO_VERTICES	if the wireframe does not have any vertices.

Remarks

Valid indeces go up to, but excluding the value that was returned in the nNumVertices parameter of the the call to fnGetWireInfo member of the MRY_WIREFRAME_BUILDING struct.

See Also

MRY_WIREFRAME_BUILDING.fnGetNormal

The function MRY_WIREFRAME_BUILDING.fnGetNormal is a member function of the MRY_WIREFRAME_BUILDING struct and fills a MRY_VECTOR struct with the coordinates of a normal.

long WINAPI fnGetNormal(long hWireframe, int nIndex, LPMRY_VECTOR n);

Parameters

hWireframe	contains the handle of the wireframe that is being queried.
nIndex	contains the zero-based index of the normal to retrieve.
n	contains a pointer to the vector that should receive the coordinates of the normal.

Return Values

MRY_SUCCESS	if the structure was successfully filled.
MRY_ERR_NULL_POINTER	if hWireframe is NULL.
MRY_ERR_INDEX_OUT_OF_RANGE	if nIndex is out of range (less than zero or larger than the number of normals present).
MRY_ERR_WIRE_NO_NORMALS	if the wireframe does not have any normals.

Remarks

Valid indeces go up to, but excluding the value that was returned in the pnNumNormals parameter of the the call to fnGetWireInfo member of the MRY_WIREFRAME_BUILDING struct.

See Also

MRY_WIREFRAME_BUILDING.fnGetUVCoord

The function MRY_WIREFRAME_BUILDING.fnGetUVCoord is a member function of the MRY_WIREFRAME_BUILDING struct and fills a MRY_VECTOR struct with the U and V values of a UV coordinate.

long WINAPI fnGetUVCoord(long hWireframe, int nIndex, LPMRY_VECTOR uv);

Parameters

hWireframe	contains the handle of the wireframe that is being queried.
nIndex	contains the zero-based index of the UV Coordinate to retrieve.
uv	contains a pointer to the vector that should receive the values of the UV coordinate.

Return Values

MRY_SUCCESS	if the structure was successfully filled.
MRY_ERR_NULL_POINTER	if hWireframe is NULL.
MRY_ERR_INDEX_OUT_OF_RANGE	if nIndex is out of range (less than zero or larger than the number of UV coordinates present).
MRY_ERR_WIRE_NO_UVCOORDS	if the wireframe does not have any UV coordinates.

Remarks

Valid indeces go up to, but excluding the value that was returned in the pnNumUVCoords parameter of the the call to fnGetWireInfo member of the MRY_WIREFRAME_BUILDING struct.

See Also

MRY_WIREFRAME_BUILDING.fnGetEdge

The function MRY_WIREFRAME_BUILDING.fnGetEdge is a member function of the MRY_WIREFRAME_BUILDING struct and fills a MRY_VECTOR struct with the coordinates of a vertex.

long WINAPI fnGetEdge(long hWireframe, int nIndex, long* plVert1, long* plVert2);

Parameters

hWireframe	contains the handle of the wireframe that is being queried.
nIndex	contains the zero-based index of the edge to retrieve.
plVert1, plVert2	contain pointers to the long that should receive the indeces of the vertices that make up the edge.

Return Values

MRY_SUCCESS	if the structure was successfully filled.
MRY_ERR_NULL_POINTER	if hWireframe is NULL.
MRY_ERR_INDEX_OUT_OF_RANGE	if nIndex is out of range (less than zero or larger than the number of edges present).
MRY_ERR_WIRE_NO_EDGES	if the wireframe does not have any edges.

Remarks

Valid indeces go up to, but excluding the value that was returned in the pnNumEdges parameter of the the call to fnGetWireInfo member of the MRY_WIREFRAME_BUILDING struct.

See Also

MRY_WIREFRAME_BUILDING.fnGetTriangle

The function MRY_WIREFRAME_BUILDING.fnGetTriangle is a member function of the MRY_WIREFRAME_BUILDING struct and fills a MRY_MESH_TRIANGLE_EXT struct with the data of a triangle.

long WINAPI fnGetTriangle(long hWireframe, int nIndex, LPMRY_MSH_TRIANGLE_EXT pTri);

Parameters

hWireframe	contains the handle of the wireframe that is being queried.
nIndex	contains the zero-based index of the vertex to retrieve.
pTri	contains a pointer to MRY_MESH_TRIANGLE_EXT struct that should receive the triangle data.

Return Values

MRY_SUCCESS	if the structure was successfully filled.
MRY_ERR_NULL_POINTER	if hWireframe is NULL.
MRY_ERR_INDEX_OUT_OF_RANGE	if nIndex is out of range (less than zero or larger than the number of triangles present).
MRY_ERR_WIRE_NO_TRIANGLES	if the wireframe does not have any triangles.

Remarks

Note: Please use the fnGetFace function instead.

Valid indeces go up to, but excluding the value that was returned in the pnNumTriangles parameter of the the call to fnGetWireInfo member of the MRY_WIREFRAME_BUILDING struct.

See Also

MRY_WIREFRAME_BUILDING.fnGetQuad

The function MRY_WIREFRAME_BUILDING.fnGetQuad is a member function of the MRY_WIREFRAME_BUILDING struct and fills a MRY_MESH_QUAD_EXT struct with the data of a quad.

long WINAPI fnGetQuad(long hWireframe, int nIndex, LPMRY_MSH_QUAD_EXT pQuad);

Parameters

hWireframe	contains the handle of the wireframe that is being queried.
nIndex	contains the zero-based index of the quad to retrieve.
pTri	contains a pointer to MRY_MESH_QUAD_EXT struct that should receive the quad data.

Return Values

MRY_SUCCESS	if the structure was successfully filled.
MRY_ERR_NULL_POINTER	if hWireframe is NULL.
MRY_ERR_INDEX_OUT_OF_RANGE	if nIndex is out of range (less than zero or larger than the number of quads present).
MRY_ERR_WIRE_NO_QUADS	if the wireframe does not have any quads.

Remarks

Note: Please use the fnGetFace function instead.

Valid indeces go up to, but excluding the value that was returned in the pnNumQuads parameter of the the call to fnGetWireInfo member of the MRY_WIREFRAME_BUILDING struct.

See Also

MRY_WIREFRAME_BUILDING.fnModifyVertex

The function MRY_WIREFRAME_BUILDING.fnModifyVertex is a member function of the MRY_WIREFRAME_BUILDING struct and modifies the coordinates of a vertex.

long WINAPI fnModifyVertex(long hWireframeID, int nIndex, double dX, double dY, double dZ);

Parameters

hWireframeID	contains the handle of the wireframe that is being modified
nIndex	contains the zero-based index of the vertex to modify.
dX, dY, dZ	contains the coordinates that the vertex should be set to.

Return Values

MRY_SUCCESS	if the structure was successfully filled.
MRY_ERR_NULL_POINTER	if hWireframeID is NULL.
MRY_ERR_INDEX_OUT_OF_RANGE	if nIndex is out of range (less than zero or larger than the number of vertices present).

Remarks

Valid indeces go up to, but excluding the value that was returned in the pnNumVertices parameter of the the call to fnGetWireInfo member of the MRY_WIREFRAME_BUILDING struct.

See Also

MRY_WIREFRAME_BUILDING.fnModifyNormal

The function MRY_WIREFRAME_BUILDING.fnModifyNormal is a member function of the MRY_WIREFRAME_BUILDING struct and modifies the coordinates of a normal.

long WINAPI fnModifyNormal(long hWireframeID, int nIndex, double dNX, double dNY, double dNZ);

Parameters

hWireframeID	contains the handle of the wireframe that is being modified
nIndex	contains the zero-based index of the normal to modify.
dNX, dNY, dNZ	contains the coordinates that the normal should be set to.

Return Values

MRY_SUCCESS	if the structure was successfully filled.
MRY_ERR_NULL_POINTER	if hWireframeID is NULL.
MRY_ERR_INDEX_OUT_OF_RANGE	if nIndex is out of range (less than zero or larger than the number of normal present).

Remarks

Valid indeces go up to, but excluding the value that was returned in the pnNumNormals parameter of the the call to fnGetWireInfo member of the MRY_WIREFRAME_BUILDING struct.

See Also

MRY_WIREFRAME_BUILDING.fnModifyUVCoord

The function MRY_WIREFRAME_BUILDING.fnModifyUVCoord is a member function of the MRY_WIREFRAME_BUILDING struct and modifies the values of a UV coordinates.

long WINAPI fnModifyUVCoord(long hWireframeID, int nIndex, double dUVX, double dUVY, double dUVZ);

Parameters

hWireframeID	contains the handle of the wireframe that is being modified
nIndex	contains the zero-based index of the UV coordinate to modify.
dX, dY, dZ	contains the values that the UV coordinate should be set to.

Return Values

MRY_SUCCESS	if the structure was successfully filled.
MRY_ERR_NULL_POINTER	if hWireframeID is NULL.
MRY_ERR_INDEX_OUT_OF_RANGE	if nIndex is out of range (less than zero or larger than the number of UV coordinate present).

Remarks

Valid indeces go up to, but excluding the value that was returned in the pnNumUVCoords parameter of the the call to fnGetWireInfo member of the MRY_WIREFRAME_BUILDING struct.

See Also

MRY_WIREFRAME_BUILDING,

MRY_WIREFRAME_BUILDING.fnModifyEdge

The function MRY_WIREFRAME_BUILDING.fnModifyEdge is a member function of the MRY_WIREFRAME_BUILDING struct and modifies an edge.

long WINAPI fnModifyEdge(long hWireframeID, int nIndex, long lNewStart, long lNewEnd);

Parameters

hWireframeID	contains the handle of the wireframe that is being modified
nIndex	contains the zero-based index of the edge to modify.
lNewStart, lNewEnd	contains the indeces of the vertices that define the edge.

Return Values

MRY_SUCCESS	if the structure was successfully filled.
MRY_ERR_NULL_POINTER	if hWireframeID is NULL.
MRY_ERR_INDEX_OUT_OF_RANGE	if nIndex is out of range (less than zero or larger than the number of edges present).

Remarks

Valid indeces go up to, but excluding the value that was returned in the pnNumEdges parameter of the the call to fnGetWireFaceInfo member of the MRY_WIREFRAME_BUILDING struct.

See Also

MRY_WIREFRAME_BUILDING,

MRY_WIREFRAME_BUILDING.fnModifyTriangle

The function MRY_WIREFRAME_BUILDING.fnModifyTriangle is a member function of the MRY_WIREFRAME_BUILDING struct and modifies a triangle.

long WINAPI fnModifyTriangle(long hWireframeID, int nIndex, LPMRY_MSH_TRIANGLE_EXT pTri);

Parameters

hWireframeID	contains the handle of the wireframe that is being modified
nIndex	contains the zero-based index of the triangle to modify.
pTri	contains a pointer to a MRY_MSH_TRIANGLE_EXT struct that contains the new triangle definition.

Return Values

MRY_SUCCESS	if the structure was successfully filled.
MRY_ERR_NULL_POINTER	if hWireframeID is NULL.
MRY_ERR_INDEX_OUT_OF_RANGE	if nIndex is out of range (less than zero or larger than the number of vertices present).
MRY_ERR_WIRE_NO_TRIANGLES	if the wireframe does not have any triangles.

Remarks

Note: Please use the fnModifyFace function instead.

Valid indeces go up to, but excluding the value that was returned in the pnNumTriangles parameter of the the call to fnGetWireInfo member of the MRY_WIREFRAME_BUILDING struct.

See Also

MRY_WIREFRAME_BUILDING.fnModifyQuad

The function MRY_WIREFRAME_BUILDING.fnModifyQuad is a member function of the MRY_WIREFRAME_BUILDING struct and modifies a quad.

long WINAPI fnModifyQuad(long hWireframeID, int nIndex, LPMRY_MSH_QUAD_EXT pQuad);

Parameters

hWireframeID	contains the handle of the wireframe that is being modified
nIndex	contains the zero-based index of the quad to modify.
pQuad	contains a pointer to a MRY_MSH_QUAD_EXT struct that contains the new quad definition.

Return Values

MRY_SUCCESS	if the structure was successfully filled.
MRY_ERR_NULL_POINTER	if hWireframeID is NULL.
MRY_ERR_INDEX_OUT_OF_RANGE	if nIndex is out of range (less than zero or larger than the number of vertices present).
MRY_ERR_WIRE_NO_QUADS	if the wireframe does not have any quads.

Remarks

Note: Please use the fnModifyFace function instead.

Valid indeces go up to, but excluding the value that was returned in the pnNumQuads parameter of the the call to fnGetWireInfo member of the MRY_WIREFRAME_BUILDING struct.

See Also

MRY_WIREFRAME_BUILDING.fnGetWireFaceInfo

The function MRY_WIREFRAME_BUILDING.fnGetWireFaceInfo is a member function of the MRY_WIREFRAME_BUILDING struct and retrieves info about the wireframe.

long WINAPI fnGetWireFaceInfo(long hWireFrameID, long *pnNumVertices, long *pnNumNormals, long *pnNumEdges, long *pnNumUVCoords, long *pnNumFaces);

Parameters

hWireframeID	contains the handle of the wireframe that is being modified
pnNumVertices	contains a pointer to where the number of vertices should be written
pnNumNormals	contains a pointer to where the number of normals should be written
pnNumEdges	contains a pointer to where the number of edges should be written
pnNumUVCoords	contains a pointer to where the number of UV coordinates should be written
pnNumFaces	contains a pointer to where the number of faces should be written

Return Values

MRY_SUCCESS	if the structure was successfully filled.
MRY_ERR_NULL_POINTER	if hWireFrameID is NULL.

Remarks

If any of the pointers are NULL, the information will not be written.

See Also

MRY_WIREFRAME_BUILDING, MRY_MSH_FACE

MRY_WIREFRAME_BUILDING.fnGetFace

The function MRY_WIREFRAME_BUILDING.fnGetFace is a member function of the MRY_WIREFRAME_BUILDING struct and retrieves the information associated with a face.

long WINAPI fnGetFace(long hWireFrameID, int nIndex, LPMRY_MSH_FACE pMeshFace);

Parameters

hWireframeID	contains the handle of the wireframe that is being queried
nIndex	contains the zero-based index of the vertex to retrieve.
pMeshFace	contains a pointer to MRY_MSH_FACE struct that should receive the face data.

Return Values

MRY_SUCCESS	if the structure was successfully filled.
MRY_ERR_NULL_POINTER	if hWireframe or pMeshFace is NULL.
MRY_ERR_WIRE_NO_FACES	if the wireframe has no faces.
MRY_ERR_INDEX_OUT_OF_RANGE	if nIndex is out of range (less than zero or larger or equal to the number of faces present).

MRY_WIREFRAME_BUILDING.fnAddFace

The function MRY_WIREFRAME_BUILDING.fnAddFace is a member function of the MRY_WIREFRAME_BUILDING struct that adds one face to the wireframe.

long WINAPI fnAddFace(long hWireFrameID, LPMRY_MSH_FACE pMeshFace, long *hFaceID);

Parameters

hWireframeID	contains Morays handle of the wireframe being built.
pMeshFace	contains a pointer to MRY_MSH_FACE struct that should contains the data of the new face.
hFaceID	A pointer to a long that will receive a handle to the created face (see Remarks).

Return Values

MRY_SUCCESS	if the face was appended to the list.
MRY_ERR_NULL_POINTER	if hWireframeID was NULL.
MRY_ERR_OUT_OF_MEMORY	if memory for faces could not be allocated (will not occur if fnAllocateMemory was called).

Remarks

Moray will create a face using data in the MRY_MSH_FACE struct. If hFaceID is not NULL, Moray will return a handle to that face in that variable. (The index of the new face is the number of faces before the call.)

To create a triangle instead of a quad, simply pass -1 as the fourth index. Note that the plugin can still use the functions fnSetQuadNormals (or fnSetTriangleNormals) and fnSetQuadUVCoords (or fnSetTriangleUVCoords) to set the normals and the UV coordinates of the face after creating a face like this. However, this call can be used to set everything at once. The vertices, normals and UV coordinates do not need to exist when you call this function (they do need to be created before the first attempt to draw the object!).

See Also

MRY_WIREFRAME_BUILDING.fnModifyFace

The function MRY_WIREFRAME_BUILDING.fnModifyFace is a member function of the MRY_WIREFRAME_BUILDING struct and modifies a face.

long WINAPI fnModifyFace(long hWireFrameID, int nIndex, LPMRY_MSH_FACE pMeshFace);

Parameters

hWireframeID	contains the handle of the wireframe that is being modified
nIndex	contains the zero-based index of the face to modify.
pMeshFace	contains a pointer to MRY_MSH_FACE struct that contains the new face data.

Return Values

MRY_SUCCESS	if the structure was successfully transferred.
MRY_ERR_NULL_POINTER	if either hWireFrameID or pMeshFace are NULL.
MRY_ERR_WIRE_NO_FACES	if no faces are present in the wireframe (see Remarks).
MRY_ERR_INDEX_OUT_OF_RANGE	if nIndex is out of range (less than zero or larger or equal to the number of faces present).
MRY_ERR_WIRE_ONLY_TRIS_AND_QUADS	if the nNumVertices member of the MRY_MSH_FACE struct is not 3 or 4.

See Also

MRY_WIREFRAME_BUILDING, MRY_MSH_FACE

MRY_WIREFRAME_BUILDING.fnGenerateNormals

The function MRY_WIREFRAME_BUILDING.fnGenerateNormals is a member function of the MRY_WIREFRAME_BUILDING struct and generates normals.

long WINAPI fnGenerateNormals(long hWireFrameID, double dThreshold);

Parameters

hWireframeID	contains the handle of the wireframe whose normals should be generated.
dThreshold	is a reserved variable. Pass 0.0.

Return Values

MRY_SUCCESS	if the normals were generated.
MRY_ERR_NULL_POINTER	if hWireFrameID is NULL.

Remarks

This function generates normals for the mesh such that each face is flat-shaded. Currently existing normals are disarded.

Later Moray versions may use the dThreshold value to do automatic smoothing.

See Also

MRY_WIREFRAME_BUILDING.fnGenerateEdges

The function MRY_WIREFRAME_BUILDING.fnGenerateEdges is a member function of the MRY_WIREFRAME_BUILDING struct and generates edges.

long WINAPI fnGenerateEdges(long hWireFrameID);

Parameters

hWireframeID

contains the handle of the wireframe whose edges should be generated.

Return Values

MRY_SUCCESS	if the edges were generated.
MRY_ERR_NULL_POINTER	if hWireFrameID is NULL.

Remarks

This function generates edges for the mesh. If you do not have an optimized edge representation, this function can create an edge structure that contains each edge only once (even though it may be shared by two faces).

See Also

GetControlInfo, MRY_MENU_COMMAND

MRY_TEXTURE_DATA

struct MRY_TEXTURE_DATA;

The struct MRY_TEXTURE_DATA is used by the Scene Interface GetAttributes function to retrieve texture-specific information about a texture. A pointer to this structure is used in the MRY_OBJ_ATTRIBUTES structure.

The MRY_TEXTURE_DATA struct has the following members:

nSize - the size of the struct
nVersion - the version of the struct.
nType - the type of texture node the struct is filled with. See MRY_TEX_CREATE_PARAMS for a list of valid values. This corresponds to the nodes in the Texture Editor.
nNumSubItems - the number of child items this texture node has.

The rest is a union of structs that hold information according to the nType member.

Material:
- bMesh2Format - determines whether this material will be used by a mesh2 object. When this setting is on, a material does not export the "material { }" wrapper of a texture. This is required for mesh2 objects.
SolidColor, QuickColor, AmbientColor, ReflectionColor, AbsorptionColor, EmissionColor, ScatteringColor:
- dRed - the red component of the color.
- dGreen - the green component of the color.
- dBlue - the blue component of the color.
- dFilter - the filter component of the color.
- dTransmit - the transmit component of the color.
BitmapModifiers:
- achFilename - the filename of the bitmap.
- nFileType - the file type for this image. Possible values are:
  - MRY_TEX_FILETYPE_GIF, MRY_TEX_FILETYPE_TGA, MRY_TEX_FILETYPE_IFF, MRY_TEX_FILETYPE_PPM, MRY_TEX_FILETYPE_PGM, MRY_TEX_FILETYPE_PNG, MRY_TEX_FILETYPE_SYS.
- nMapType - the mapping type. Possible values are:
  - MRY_TEX_MAPTYPE_PLANAR, MRY_TEX_MAPTYPE_SPHERICAL, MRY_TEX_MAPTYPE_CYLINDRICAL, MRY_TEX_MAPTYPE_TORUSDONUT.
- bOnce - flag whether the image should be applied once only.
- bUseInterpolation - flag whether to use an interpolation method.
- nInterpolation - the type of interpolation to use. Possible values are:
  - MRY_TEX_INTERPOLATIONTYPE_PIXELIZED, MRY_TEX_INTERPOLATIONTYPE_BILINEAR, MRY_TEX_INTERPOLATIONTYPE_NORMALIZEDDISTANCE.
- bFilterAll - flag whether all colors are to be filtered.
- dFilterAllPercentage - the percentage that all colors are to be filtered by (only valid if bFilterAll is non-zero).
- nFilterCount - the number of filter entries that are used.
- adFilter[] - an array of the filter values. The position in the array indicates the index to be filtered, the filter value to be used is the value at that position. A value of MRY_TEX_MAX_FILTER_ENTRY_NOTUSED indicates that the entry is not used.
- bTransmitAll - flag whether all colors are to be transmitted.
- dTransmitAllPercentage - the percentage that all colors are to be transmitted by (only valid if bTransmitAll is non-zero).
- nTransmitCount - the number of transmit entries that are used.
- adTransmit[] - an array of the transmit values. The position in the array indicates the index to be transmitted, the transmit value to be used is the value at that position. A value of MRY_TEX_MAX_TRANSMIT_ENTRY_NOTUSED indicates that the entry is not used.
- bBumpmapUseIndex - this flag indicates that the index (not the color) should be used in calculations. This field is only valid for a normalbumpmap.
BlockPattern:
- nType - the type of block pattern. Possible values are:
  - MRY_TEX_BLOCKPATTERN_CHECKER, MRY_TEX_BLOCKPATTERN_HEXAGON, MRY_TEX_BLOCKPATTERN_BRICK.
  The following fields are only valid when nType is MRY_TEX_BLOCKPATTERN_BRICK.
- bUseBrickSizeVector - flag to indicate whether the scalar dBrickSize is valid (zero), or whether the dBrickSizeVector. members are valid (non-zero).
- dBrickSize - the scalar bricksize. Valid if bUseBrickSizeVector is zero.
- dBrickSizeVectorX - the X component of the vector bricksize. Valid if bUseBrickSizeVector is non-zero.
- dBrickSizeVectorY - the Y component of the vector bricksize. Valid if bUseBrickSizeVector is non-zero.
- dBrickSizeVectorZ - the Z component of the vector bricksize. Valid if bUseBrickSizeVector is non-zero.
- dMortar - the mortar value of the brick pattern.
Comment:
- achText - a tring containing the comment of the texture.
Finish:
- dAmbient - see POV-Ray documentation.
- dDiffuse - see POV-Ray documentation.
- dBrilliance - see POV-Ray documentation.
- dPhong - see POV-Ray documentation.
- dPhongSize - see POV-Ray documentation.
- dSpecular - see POV-Ray documentation.
- dRoughness - see POV-Ray documentation.
- bUseMetallic - flag to indicate whether metallic was selected.
- dMetallic - see POV-Ray documentation.
- bUseReflection - flag to indicate whether reflection was selected.
- dReflection - see POV-Ray documentation.
- bUseIrid - flag to indicate whether iridescense was enabled.
- dIridAmount - see POV-Ray documentation.
- dIridThickness - see POV-Ray documentation.
- dIridTurbulenceX - see POV-Ray documentation.
- dIridTurbulenceY - see POV-Ray documentation.
- dIridTurbulenceZ - see POV-Ray documentation.
- dCrand - see POV-Ray documentation.
Halo:
- htTyp - the type of the halo. See POV-Ray documentation. Possible values are:
  - MRY_TEX_HALO_TYPE_ATTENUATING, MRY_TEX_HALO_TYPE_EMITTING, MRY_TEX_HALO_TYPE_GLOWING, MRY_TEX_HALO_TYPE_DUST.
- dtTyp - the density type. See POV-Ray documentation. Possible values are:
  - MRY_TEX_HALO_DENSITYTYPE_CONSTANT, MRY_TEX_HALO_DENSITYTYPE_LINEAR, MRY_TEX_HALO_DENSITYTYPE_CUBIC, MRY_TEX_HALO_DENSITYTYPE_POLY.
- dDensityMaxValue - see POV-Ray documentation.
- dDensityExponent - see POV-Ray documentation.
- dmtTyp - the density map type. See POV-Ray documentation. Possible values are:
  - MRY_TEX_HALO_DENSITYMAPTYPE_PLANAR, MRY_TEX_HALO_DENSITYMAPTYPE_SPHERICAL, MRY_TEX_HALO_DENSITYMAPTYPE_CYLINDRICAL, MRY_TEX_HALO_DENSITYMAPTYPE_BOX.
- dutTyp - the dust type. See POV-Ray documentation. Possible values are:
  - MRY_TEX_HALO_DUSTYPE_ISOTROPIC, MRY_TEX_HALO_DUSTYPE_MIEHAZY, MRY_TEX_HALO_DUSTYPE_MIEMURKY, MRY_TEX_HALO_DUSTYPE_RAYLEIGH, MRY_TEX_HALO_DUSTYPE_HENYEYGREENSTEIN.
- dEccentricity - see POV-Ray documentation.
- dSamples - see POV-Ray documentation.
- nAALevel - see POV-Ray documentation.
- dAAThreshold - see POV-Ray documentation.
- dJitter - see POV-Ray documentation.
- nColormapEntries - the number of colormap entries in this node. Only valid if nType is MRY_TEX_HALO.
- aColormapEntry[] - an array of colormap entries (MRY_TEX_COLORMAP_ENTRY). Note that the first entry must be positioned at 0.0 and the last one at 1.0 and that the entries must be positioned sequentially in ascending order.
Interior:
- dIOR - see POV-Ray documentation.
- bUseCaustics - flag to determine whether to use the caustics value.
- dCaustics - see POV-Ray documentation.
- bUseFade - flag to determine whether to use the fading values.
- dFadeDistance - see POV-Ray documentation.
- dFadePower - see POV-Ray documentation.
Media:
- nIntervals - see POV-Ray documentation.
- nSamplesMin - see POV-Ray documentation.
- nSamplesMax - see POV-Ray documentation.
- dConfidence - see POV-Ray documentation.
- dVariance - see POV-Ray documentation.
- dRatio - see POV-Ray documentation.
- bUseScattering - flag to determine whether to use the scattering values.
- nScatteringType - see POV-Ray documentation.
- dScatteringEccentricity - see POV-Ray documentation.
- bUseScatteringExtinction - flag to determine whether to use the extinction value.
- dScatteringExtinction - see POV-Ray documentation.
NoiseModifiers:
- bUseTurbVector - flag to indicate whether to use the vector turbulence.
- dTurb - the scale turbulence. Only valid if bUseTurbVector is zero.
- dTurbX - the vector turbulence. Only valid if bUseTurbVector is non-zero.
- dTurbY - the vector turbulence. Only valid if bUseTurbVector is non-zero.
- dTurbZ - the vector turbulence. Only valid if bUseTurbVector is non-zero.
- nOctaves - see POV-Ray documentation.
- dOmega - see POV-Ray documentation.
- dLambda - see POV-Ray documentation.
- dFrequency - see POV-Ray documentation.
- dPhase - see POV-Ray documentation.
- nWaveType - see POV-Ray documentation. Possible values are:
  - MRY_TEX_WAVETYPE_RAMP, MRY_TEX_WAVETYPE_TRIANGLE, MRY_TEX_WAVETYPE_SINE, MRY_TEX_WAVETYPE_SCALLOP.
MapEntry:
- dNum - the position of this entry.
NoisePattern:
- npType - the type of noise pattern.
- dAgateTurbulence - the turbulence for the agate pattern.
- dGradientX - the gradient vector for the gradient pattern.
- dGradientY - the gradient vector for the gradient pattern.
- dGradientZ - the gradient vector for the gradient pattern.
- nMandelIterations - the number of iterations through the mandel pattern.
- dQuiltedControl0 - the control0 value of the quilted pattern.
- dQuiltedControl1 - the control1 value of the quilted pattern.
- nSpiralNumberOfArms - the number of arms for the spiral1 and spiral2 patterns.
- dBumpAmount - the bump amount.
- achDF3Filename - the filename of the density file for a densityfile pattern.
- nDF3Interpolation - the type of interpolation of a densityfile pattern.
- nColormapEntries - the number of colormap entries in this node. Only valid if nType is MRY_TEX_COLORMAPNOISEPATTERN.
- aColormapEntry[] - an array of colormap entries (MRY_TEX_COLORMAP_ENTRY). Note that the first entry must be positioned at 0.0 and the last one at 1.0 and that the entries must be positioned sequentially in ascending order.
BumpSize:
- dAmount - the bumpsize.
SlopeMap:
- nCount - the number of valid entries in the array. These are positioned sequentially in the array beginning at index 0.
- aEntry[n].dValue - the value of the the nth item of the slopemap.
- aEntry[n].dHeight - the height of the the nth item of the slopemap.
- aEntry[n].dSlope - the slope of the the nth item of the slopemap.
PolyrayDef:
- achText - the Polyray definition of the texture if the user entered one.
Transforms:
- dScaleX - the scale components of a transformation node.
- dScaleY - the scale components of a transformation node.
- dScaleZ - the scale components of a transformation node.
- dRotX - the rotation components of a transformation node.
- dRotY - the rotation components of a transformation node.
- dRotZ - the rotation components of a transformation node.
- dTransX - the translation components of a transformation node.
- dTransY - the translation components of a transformation node.
- dTransZ - the translation components of a transformation node.
Warp:
- nType - the type of the Warp. The possible values are:
  - MRY_TEX_WARP_TYPE_BLACKHOLE, MRY_TEX_WARP_TYPE_REPEAT, MRY_TEX_WARP_TYPE_TURBULENCE.
- dbhCenterX - valid for black hole. See POV-Ray documentation.
- dbhCenterY - valid for black hole. See POV-Ray documentation.
- dbhCenterZ - valid for black hole. See POV-Ray documentation.
- dbhRadius - valid for black hole. See POV-Ray documentation.
- dbhFallOff - valid for black hole. See POV-Ray documentation.
- dbhStrength - valid for black hole. See POV-Ray documentation.
- dbhRepeatX - valid for black hole. See POV-Ray documentation.
- dbhRepeatY - valid for black hole. See POV-Ray documentation.
- dbhRepeatZ - valid for black hole. See POV-Ray documentation.
- dbhTurbulenceX - valid for black hole. See POV-Ray documentation.
- dbhTurbulenceY - valid for black hole. See POV-Ray documentation.
- dbhTurbulenceZ - valid for black hole. See POV-Ray documentation.
- bbhInverse - valid for black hole. See POV-Ray documentation.
- drRepeatX - valid for repeat warp. See POV-Ray documentation.
- drRepeatY - valid for repeat warp. See POV-Ray documentation.
- drRepeatZ - valid for repeat warp. See POV-Ray documentation.
- drOffsetX - valid for repeat warp. See POV-Ray documentation.
- drOffsetY - valid for repeat warp. See POV-Ray documentation.
- drOffsetZ - valid for repeat warp. See POV-Ray documentation.
- drFlipX - valid for repeat warp. See POV-Ray documentation.
- drFlipY - valid for repeat warp. See POV-Ray documentation.
- drFlipZ - valid for repeat warp. See POV-Ray documentation.
- dtTurbulenceX - valid for turbulence warp. See POV-Ray documentation.
- dtTurbulenceY - valid for turbulence warp. See POV-Ray documentation.
- dtTurbulenceZ - valid for turbulence warp. See POV-Ray documentation.
- ntOctaves - valid for turbulence warp. See POV-Ray documentation.
- dtOmega - valid for turbulence warp. See POV-Ray documentation.
- dtLambda - valid for turbulence warp. See POV-Ray documentation.

MRY_TEX_COLORMAP_ENTRY

struct MRY_TEX_COLORMAP_ENTRY;

The struct MRY_TEX_COLORMAP_ENTRY is used by the Scene Interface GetAttributes function to retrieve colormap information from a texture node.

The MRY_TEX_COLORMAP_ENTRY struct has the following members:

dPosition - the position of this entry in the colormap. Valid ranges are 0.0 to 1.0.
dRed - the red value of the colormap entry.
dGreen - the green value of the colormap entry.
dBlue - the blue value of the colormap entry.
dFilter - the filter value of the colormap entry.
dTransmit - the transmit value of the colormap entry.

MRY_TEX_CREATE_PARAMS

struct MRY_TEX_CREATE_PARAMS;

The struct MRY_TEX_CREATE_PARAMS is used by the Scene Interface CreateObject function to inform Moray what type of texture node to create.

The MRY_TEX_CREATE_PARAMS struct has the following members:

nType - determines what type of texture node to create.
Valid values are currently:
- MRY_TEX_MATERIAL - a material. This is the topmost node of all textures.
- MRY_TEX_STANDARDTEXTURE - see below.
- MRY_TEX_TEXTUREMAPNOISEPATTERN - see below.
- MRY_TEX_MATERIALMAP - see below.
- MRY_TEX_LAYEREDTEXTURE - see below.
- MRY_TEX_BLOCKPATTERNTEXTURE - see below.
- MRY_TEX_PIGMENT - see below.
- MRY_TEX_SOLIDCOLOR - see below.
- MRY_TEX_BLOCKPATTERNSOLIDCOLOR - see below.
- MRY_TEX_BLOCKPATTERNPIGMENT - see below.
- MRY_TEX_BLOCKPATTERNNORMAL - see below.
- MRY_TEX_COLORMAPNOISEPATTERN - see below.
- MRY_TEX_PIGMENTMAPNOISEPATTERN - see below.
- MRY_TEX_NORMALMAPNOISEPATTERN - see below.
- MRY_TEX_NORMALNOISEPATTERN - see below.
- MRY_TEX_IMAGEMAP - see below.
- MRY_TEX_BUMPMAP - see below.
- MRY_TEX_NORMALBUMPSIZE - see below.
- MRY_TEX_NORMAL - see below.
- MRY_TEX_FINISH - see below.
- MRY_TEX_AMBIENTCOLOR- see below.
- MRY_TEX_REFLECTIONCOLOR - see below.
- MRY_TEX_HALO - not allowed. See below.
- MRY_TEX_WARP - see below.
- MRY_TEX_TRANSFORMS - see below.
- MRY_TEX_NOISEMODIFIERS - see below.
- MRY_TEX_BITMAPMODIFIERS - see below.
- MRY_TEX_QUICKCOLOR - see below.
- MRY_TEX_MAPENTRY - see below.
- MRY_TEX_SLOPEMAP - see below.
- MRY_TEX_COMMENT - see below.
- MRY_TEX_THUMBNAIL - see below.
- MRY_TEX_POLYRAYDEF - see below.
- MRY_TEX_INTERIOR - see below.
- MRY_TEX_MEDIA - see below.
- MRY_TEX_DENSITY - see below.
- MRY_TEX_DENSITYNOISEPATTERN - see below.
- MRY_TEX_BLOCKPATTERNDENSITY - see below.
- MRY_TEX_DENSITYMAPNOISEPATTERN - see below.
- MRY_TEX_ABSORPTIONCOLOR - see below.
- MRY_TEX_EMISSIONCOLOR - see below.
- MRY_TEX_SCATTERINGCOLOR - see below.
hParentID - the handle of the parent that the new texture node should be attached to.
achTextureName[] - the name of the new texture node. See below.;

The types in the nType parameters correspond exactly to the nodes in the Texture Editor. It is recommended that you become familiar with the nodes and their relationships (which nodes can be added to which nodes how many times) before you attempt to create textures from a plugin.

You do not need to name any of the texture nodes except material. Material nodes MUST be named.

Halos are no longer supported and cannot be created from a plugin.

See Also

CreateObject

MRY_CONTROL_INFO

struct MRY_CONTROL_INFO;

The struct MRY_CONTROL_INFO is used by the Object Interface GetControlInfo function to retrieve information about a control associated with a plugin object.

The MRY_CONTROL_INFO struct has the following members:

nVersion - the version of this struct. Set this to MRY_CONTROL_INFO_VERSION before calling GetControlInfo.
nType - determines what type of control this ID should become.
Valid values are currently:
- MRY_CTRL_EDITSPIN - the control is an edit box for a floating point value with a spinner at its right edge.
- MRY_CTRL_SLIDER - the control is a horizontal slider for integer values.
- MRY_CTRL_SLIDEREDITSPIN - the control is a horizontal slider with an edit box and spinner for floating point values.
editspin.dValue - the current floating point value of the spinner.
editspin.dMin - the minimum value of the spinner.
editspin.dMax - the maximum value of the spinner.
editspin.nPrecision - the precision (number of decimal places) of the spinner.
editspin.dScreenRange - the range that should be covered if the mouse cursor moves the height of the screen.
editspin.bForceRange - flag to enforce the range. If this flag is TRUE the value will be clipped to the min/max range.
slider.nValue - the current integer value of the slider.
slider.nRange - the range of the slider.
slider.nMin - the minimum value of the slider.
slider.nMajorStart - the value where major tick marks should be displayed.
slider.nMajorDivisions - the number of units to skip for the next major tick mark.
slider.nMinorStart - the value where minor tick marks should start at.
slider.nMinorDivisions - the number of units to skip for the next minor tick mark.
slidereditspin.dValue - the current floating point value of the control.
slidereditspin.dMin - the minimum value of the control.
slidereditspin.dMax - the maximum value of the control.
slidereditspin.nPrecision - the precision (number of decimal places) of the control.
slidereditspin.dScreenRange - the range that should be covered if the mouse cursor moves the height of the screen.
slidereditspin.dMajorStart - the value where major tick marks should be displayed.
slidereditspin.dMajorDivisions - the number of units to skip for the next major tick mark.
slidereditspin.dMinorStart - the value where minor tick marks should start at.
slidereditspin.dMinorDivisions - the number of units to skip for the next minor tick mark.

See Also

MRY_MENU_COMMAND

struct MRY_MENU_COMMAND;

The struct MRY_MENU_COMMAND is used by the Menu Interface GetItemInfoEx function to allow the plugin to define a menu item with an optional hotkey, or to define a hotkey only.

The MRY_MENU_COMMAND struct has the following members:

nVersion - the version of this struct. Set this to MRY_MENU_COMMAND_VERSION.
nID - the ID of the menu item/command that should be passed to ItemSelected when the command is invoked.
nFlags - should be set to zero (the item will be added to the Plugins submenu) or one of the following values:
- MRY_MNU_ADD_TO_EDIT - if the menu item should be added to the Edit menu.
- MRY_MNU_ADD_TO_VIEW - if the menu item should be added to the View menu.
- MRY_MNU_ADD_TO_SCENE - if the menu item should be added to the Scene menu.
- MRY_MNU_ADD_TO_RENDER - if the menu item should be added to the Render menu.
- MRY_MNU_ADD_TO_PLUGINS - if the menu item should be added to the Plugins menu (default).
- MRY_MNU_ADD_TO_TOOLS - if the menu item should be added to the Tools menu.
- MRY_MNU_ADD_TO_HELP - if the menu item should be added to the Help menu.
in addition one of the following flags can be combined with the flags above:
- MRY_MNU_POPUP - if you want to add a whole menu. In this case, nID should contain the HMENU of the menu.
- MRY_MNU_SEPARATOR - if the menu item is a seperator.
- MRY_MNU_NEW_SUBMENU - if it's going to be a new submenu.
- MRY_MNU_DISABLED - if the item should be disabled to begin with.
- MRY_MNU_COMMAND_ONLY - if only a hotkey should be added and no menu item.
achItemText - the text that the menu item should display on the menu.
achItemName - an internal command name for this item.
nPrimaryHotkey - the key (without modifiers) for this primary hotkey (optional).
nPrimaryHotkeyMod - the modifier for this hotkey (combination of MRY_MNU_KEYMOD_CTRL, MRY_MNU_KEYMOD_ALT, MRY_MNU_KEYMOD_SHIFT).
nSecondaryHotkey - the key (without modifiers) for this primary hotkey (optional).
nSecondaryHotkeyMod - the modifier for this hotkey (combination of MRY_MNU_KEYMOD_CTRL, MRY_MNU_KEYMOD_ALT, MRY_MNU_KEYMOD_SHIFT).

See Also

GetItemInfo, GetItemInfoEx

MRY_MNU_ITEMSTATE

struct MRY_MNU_ITEMSTATE;

The struct MRY_MNU_ITEMSTATE is used by the Menu Interface GetItemState function to set the states of a menu item that is associated with the plugin.

The MRY_MNU_ITEMSTATE struct has the following members:

bEnabled - determines whether the menu item should be displayed in its enabled (TRUE) or disabled (FALSE) state.
bChecked - determines whether the menu item should be checked (TRUE) or unchecked (FALSE).
achNewText - contains the text to be associated with the menu item. If you do not wish to change the text, leave this field as it is.

See Also

GetItemState

MRY_VECTOR

struct MRY_VECTOR;

The struct MRY_VECTOR is used when a three-dimensional vector is required.

The MRY_VECTOR struct has the following members:

dX - the X-component of the vector.
dY - the Y-component of the vector.
dZ - the Z-component of the vector.

MRY_MSH_TRIANGLE

struct MRY_MSH_TRIANGLE;

The struct MRY_MSH_TRIANGLE is used by the function returned in the fnGetTriangle pointer of the MRY_OBJ_ATTRIBUTES struct to retrieve and set triangles of a triangle mesh object.

The MRY_MSH_TRIANGLE struct has the following members:

vP1 - the MRY_VECTOR coordinate of the first vertex of the triangle.
vP2 - the MRY_VECTOR coordinate of the second vertex of the triangle.
vP3 - the MRY_VECTOR coordinate of the third vertex of the triangle.

MRY_MSH_TRIANGLE_INDECES

struct MRY_MSH_TRIANGLE_INDECES;

The struct MRY_MSH_TRIANGLE_INDECES is used by the function returned in the fnGetTriangleIndeces pointer of the MRY_OBJ_ATTRIBUTES struct to retrieve and set the indeces of the vertices of a triangle of a triangle mesh object.

The MRY_MSH_TRIANGLE_INDECES struct has the following members:

nP1 - the index of the first vertex of the triangle.
nP2 - the index of the second vertex of the triangle.
nP3 - the index of the third vertex of the triangle.

See Also

MRY_OBJ_SPECIFIC, MRY_MSH_TRIANGLE

MRY_SWEEP_NODE

struct MRY_SWEEP_NODE;

The struct MRY_SWEEP_NODE is used by the function returned in the fnGetSweepNode pointer of the MRY_OBJ_ATTRIBUTES struct to retrieve and set a node of a sweep.

The MRY_SWEEP_NODE struct has the following members:

dX - the X-coordinate of the position of the node.
dY - the Y-coordinate of the position of the node.
nFlags - a combination of the following flags:
- MRY_SWP_NODE_MARKED - indicates that the node is marked (selected) in the extended editor.
- MRY_SWP_NODE_ONLINE - the sweeps outline passed through this node. This flag is only useful for glyph curves.

See Also

MRY_BLOB_COMPONENT

struct MRY_BLOB_COMPONENT;

The struct MRY_BLOB_COMPONENT is used by the function returned in the fnGetComponent pointer of the MRY_OBJ_ATTRIBUTES struct to retrieve and set the components of a blob.

The MRY_BLOB_COMPONENT struct has the following members:

nType - determines the type of the component. This can be one of the following values:
- MRY_BLB_SPHERICAL - the component is a spherical component. The members in the spherical union are valid.
- MRY_BLB_CYLINDRICAL - the component is a cylindrical component. The members in the cylindrical union are valid.
dStrength - the strength of the component.
spherical.vPos - a MRY_VECTOR that determines the position of a spherical component.
spherical.dRadius - the radius of the spherical component.
cylindrical.vPos1 - a MRY_VECTOR that determines the position of one end of a cylindrical component.
cylindrical.vPos2 - a MRY_VECTOR that determines the position of the other end of a cylindrical component.
cylindrical.dRadius - the radius of the cylindrical component.

See Also

MRY_BEZIER_PATCH, MRY_OBJ_SPECIFIC

MRY_BEZIER_CTRLPOINT

struct MRY_BEZIER_CTRLPOINT;

The struct MRY_BEZIER_CTRLPOINT is used by the function returned in the fnGetCtrlPoint pointer of the MRY_OBJ_ATTRIBUTES struct to retrieve and set the control points of a bezier patch.

The MRY_BEZIER_CTRLPOINT struct has the following members:

vPos - a MRY_VECTOR that determines the coordinate of the control point.
bMidPoint a boolean flag that determines whether this control point is a non-selectable control point. The position of non-selectable control points are calculated as the midway point between two other control points (the next two struct members).
nLeftDepend - the index of the first control point that this control point depends on. Only valid if bMidPoint is non-zero.
nRightDepend - the index of the second control point that this control point depends on. Only valid if bMidPoint is non-zero.

See Also

MRY_BEZIER_PATCH

struct MRY_BEZIER_PATCH;

The struct MRY_BEZIER_PATCH is used by the function returned in the fnGetPatch pointer of the MRY_OBJ_ATTRIBUTES struct to retrieve and set individual patches of a bezier patch object.

The MRY_BEZIER_PATCH struct has the following members:

anIndeces[4][4] - the 4x4 matrix of indeces to the coordinates that make up this patch.

See Also

MRY_BEZIER_CTRLPOINT, MRY_OBJ_SPECIFIC

MRY_VERTEXEDGE

struct MRY_VERTEXEDGE;

The struct MRY_VERTEXEDGE is used by the fnAddVertexEdge function passed to the BuildLazyWireframe function to add a wireframe edge to a plugin object.

The MRY_VERTEXEDGE struct has the following members:

v1 - a MRY_VECTOR that determines the coordinate of the first point.
v2 - a MRY_VECTOR that determines the coordinate of the secondpoint.

See Also

BuildLazyWireframe

MRY_POINTS2D

struct MRY_POINTS2D;

The struct MRY_POINTS2D is used as parameters by the functions fnGetScreenCoord, fnDrawPolyLine2D and fnSetMultiplePixels2D of the MRY_SCN_VIEWINFO structure to draw 2D pixels.

The MRY_POINTS2D struct has the following members:

nX - the X-coordinate (horizontal) of the point.
nY - the Y-coordinate (vertical) of the point.
lColor - the color of the point. It is a 32-bit unsigned integer where the highest 8-bits are a color index (only relevant when running in 256-color mode), followed by the red, green, blue components (or in hex 0xIIRRGGBB). It's best to use RGB values with the index set to 0. For example, Red would be 0x00FF0000, Yellow would be 0x00FFFF00, etc.

See Also

MRY_SCN_VIEWINFO

MRY_VIEW_BITMAP

struct MRY_VIEW_BITMAP;

The struct MRY_VIEW_BITMAP is used as parameters by the function fnGetBitmapBits2D of the MRY_SCN_VIEWINFO structure to gain access to the pixels of the bitmap of the view.

The MRY_VIEW_BITMAP struct has the following members:

nVersion - the version of this struct. Set this to MRY_VIEW_BITMAP_VERSION before calling the fnGetBitmapBits2D member function of the MRY_SCN_VIEWINFO structure.
nWidth - the width of the bitmap. Valid coordinates go from 0 to nWidth-1.
nHeight - the height of the bitmap. Valid coordinates go from 0 to nHeight-1.
nPitch - the number of bytes on one scanline. Use this value to advance one line in Y.
nBitsPerPixel - the number of bits per pixel.
nFlags - flags associated with the bitmap. Currently always zero.
pBits - a pointer to the raw pixel data. This will be set to point to the memory that Moray is using for the view.

Not supported in Moray V3.5 and later.

You can use this function to gain low-level access to the pixels of a view. For higher-level access, please use one of the other functions available in MRY_SCN_VIEWINFO.
See the SAMPLE plugin for source code to use this function. It writes out a TGA image of the view.

See Also

MRY_SCN_VIEWINFO

struct MRY_SCN_VIEWINFO;

The struct MRY_SCN_VIEWINFO is used by the GetViewInfo function to return information about one of the four viewports.

The MRY_SCN_VIEWINFO struct has the following members:

nVersion - the version of this struct. Set this to MRY_SCN_VIEWINFO_VERSION before calling GetViewInfo.
nXPos (read-only) - the x position (in pixels) of the viewport relative to the client area available for viewports.
nXPos (read-only) - the y position (in pixels) of the viewport relative to the client area available for viewports.
nWidth (read-only) - the width (in pixels) of the viewport. Note that this size is always the non-maximized state of the viewport. If the viewport is maximized (nFlags has the MRY_SCN_VIEW_MAXIMIZED bit set) the size is nViewportWidth x nViewportHeight.
nHeight (read-only) - the height (in pixels) of the viewport. Note that this size is always the non-maximized state of the viewport. If the viewport is maximized (nFlags has the MRY_SCN_VIEW_MAXIMIZED bit set) the size is nViewportWidth x nViewportHeight.
nType - the type of viewport.
Valid values are:
- MRY_SCN_VIEW_XY - The view is a Top view, i.e. the horizontal axis is the X-axis and the vertical axis is the Y-Axis.
- MRY_SCN_VIEW_XZ - The view is a Front view, i.e. the horizontal axis is the X-axis and the vertical axis is the Z-Axis.
- MRY_SCN_VIEW_YZ - The view is a Side view, i.e. the horizontal axis is the Y-axis and the vertical axis is the Z-Axis.
- MRY_SCN_VIEW_XYZ - The view is a 3D (camera) view.
nFlags - determines certain states of the view.
This can be a combination of the following:
- MRY_SCN_VIEW_MAXIMIZED - the view is maximized (the other viewports are hidden and disabled).
- MRY_SCN_VIEW_DISABLED - the view is disabled.
- MRY_SCN_VIEW_GRID_VISIBLE - the grid of the view is enabled (visible).
- MRY_SCN_VIEW_HAS_BACKDROP - the view currently has a backdrop.
- MRY_SCN_VIEW_USING_OPENGL - the view is currently in OpenGL mode. This is always on in Moray V3.5 and later (nVersion>106).
dViewX1 - the X-coordinate of the top-left corner of the viewport. Only valid for top and front views.
dViewY1 - the Y-coordinate of the top-left corner of the viewport. Only valid for top and side views.
dViewZ1 - the Z-coordinate of the top-left corner of the viewport. Only valid for front and side views.
dViewDx - the width in world units of the viewport. Only valid for top and front views.
dViewDy - the width in world units of the viewport. Only valid for side views.
dViewDz - not used.
hCamera - the handle of the camera whose view this viewport is displaying. Only valid for 3D views.
hWnd - (read-only) the HWND for the viewport. Note that the viewport is not a child of the frame window (see GetConfigVar), but of the view window.
nViewportWidth - (read-only) the width of the entire area that the four viewports can take up.
nViewportHeight - (read-only) the height of the entire area that the four viewports can take up.
hView - the handle of the view. This needs to be passed to the function listed below.
hOpenGLContext (read only)- the handle of the OpenGL context (of type HGLRC). This field is only valid if the view is using OpenGL (see nFlags above).
nRenderMode - the render mode of view. This field is only valid if the view is using OpenGL (see nFlags above). The possible values are:
- MRY_SCN_VIEW_OPENGL_SOLID - the view is rendering in solid mode (polygons without textures).
- MRY_SCN_VIEW_OPENGL_WIREFRAME - the view is is rendering in wireframe mode (all edges are drawn).
- MRY_SCN_VIEW_OPENGL_HIDDEN_LINES - the view is rendering in wireframe mode (edges of backfacing polygons are not drawn).
- MRY_SCN_VIEW_OPENGL_ANTIALIASED_LINES - the view is rendering in antialiased wireframe mode (all edges are drawn).
- MRY_SCN_VIEW_OPENGL_TEXTURED - the view is rendering in textured mode (polyongs with textures).
- MRY_SCN_VIEW_OPENGL_POINTS - the view is rendering points only.
The rest of the structure contains pointer to functions that are described in more detail below.

There are two sets of functions:

functions that are available to give you low-level access to the views bitmap display (only for Moray V3.3 and earlier). The plugin can draw lines, pixels and rectangles and can gain really low-level access to the raw pixel data. Since the bitmap is buffered, the drawing should either take place at special times (see the RedrawEvent function for details) or you should call RedrawScene to generate a redraw of the scene and then paint in response to the fnRedrawEvent function.
functions are available to work with coordinate systems and to determine zoom level.

Here is a summary of the bitmap functions contained in the MRY_SCN_VIEWINFO struct:
NOTE: the following functions are not available in Moray V3.5 and will return MRY_ERR_NOT_SUPPORTED if called. In earlier versions of Moray they are only available if the view is not in OpenGL mode.

fnDrawLine2D - a function to draw a line in a view with a certain color.
fnSetPixel2D - a function to set a single pixel in a view with a certain color.
fnSetMultiplePixels2D - a function to set multiple pixels at once in a view.
fnDrawPolyLine2D - a function that can be used to draw a connected polyline in the view.
fnFillBlock2D - a function to draw a filled rectangle.
fnGetBitmapBits2D - a function to gain low-level access to the raw pixels of the view.

Here is a summary of the other functions contained in the MRY_SCN_VIEWINFO struct:
NOTE: the following functions are still available in Moray V3.5.

fnGetWorldCoord - a function to convert a pixel coordinate to the world coordinates of the view.
fnGetScreenCoord - a function to convert world coordinates to the pixel coordinates of the view.
fnZoomToFit - a function to zoom a view to either an object or to the scene.
fnWriteString - a function to write text in an OpenGL view.
fnSnapWorldCoord - a function to snap coordinates.

fnWriteString is only available in V1.08 of the struct and later. fnSnapWorldCoord is only available in V1.09 of the struct and later.

See Also

GetViewInfo, RedrawScene, RedrawEvent

MRY_SCN_VIEWINFO.fnDrawLine2D

The function MRY_SCN_VIEWINFO.fnDrawLine2D is a member function of the MRY_SCN_VIEWINFO struct and draws a line in a view with a certain color.

long WINAPI fnDrawLine2D(long hView, int nX1, int nY1, int nX2, int nY2, long lColor);

Parameters

hView	contains the handle of the view in which to draw the line.
nX1, nX2, nY1, nY2	are the pixel coordinates of the line to draw.
lColor	contains the color of the pixel. Colors are in the form 0x00RRGGBB.

Return Values

MRY_ERR_NOT_SUPPORTED	is you are running under Moray V3.5 and later.
MRY_SUCCESS	if the line was drawn without being clipped.
MRY_ERR_CLIPPED	if the line was clipped.
MRY_ERR_INVALID_HANDLE	if hView is not a valid handle to a view.
MRY_ERR_NULL_POINTER	if hView is NULL.
MRY_ERR_INTERNAL_ERROR	if Moray is in an unstable state.

Remarks

The line is drawn in pixel coordinates. The line is clipped before being drawn (only the visible part of the line is drawn). Check the nWidth and nHeight members of the MRY_SCN_VIEWINFO structure to get the size of the view.

NOTE: this function will fail in Moray V3.5. In earlier versions it only works if the view is not in OpenGL mode.

See Also

MRY_SCN_VIEWINFO.fnSetPixel2D

The function MRY_SCN_VIEWINFO.fnSetPixel2D is a member function of the MRY_SCN_VIEWINFO struct and sets a pixel in a view to a certain color.

long WINAPI fnSetPixel2D(long hView, int nX, int nY, long lColor);

Parameters

hView	contains the handle of the view in which to set the pixel.
nX, nY	are the coordinates of the pixel to set.
lColor	contains the color of the pixel. Colors are in the form 0x00RRGGBB.

Return Values

MRY_ERR_NOT_SUPPORTED	is you are running under Moray V3.5 and later.
MRY_SUCCESS	if the pixel was successfully set.
MRY_ERR_CLIPPED	if the pixel was outside the views coordinates.
MRY_ERR_INVALID_HANDLE	if hView is not a valid handle to a view.
MRY_ERR_NULL_POINTER	if hView is NULL.
MRY_ERR_INTERNAL_ERROR	if Moray is in an unstable state.

Remarks

The coordinates are pixel coordinates. The pixel is checked to be on the bitmap. Check the nWidth and nHeight members of the MRY_SCN_VIEWINFO structure to get the size of the view.

NOTE: this function will fail in Moray V3.5. In earlier versions it only works if the view is not in OpenGL mode.

See Also

MRY_SCN_VIEWINFO.fnSetMultiplePixels2D

The function MRY_SCN_VIEWINFO.fnSetMultiplePixels2D is a member function of the MRY_SCN_VIEWINFO struct and sets a pixel in a view to a certain color.

long WINAPI fnSetMultiplePixels2D(long hView, LPMRY_POINTS2D aPoints, int nNumPoints, int nOffsetX, int nOffsetY);

Parameters

hView	contains the handle of the view in which to set the pixels.
aPoints	is a pointer to an array of MRY_POINTS2D which are the pixels to set.
nNumPoints	contains the number of pixels to paint. Make sure that aPoints points to enough pixels.
nOffsetX	contains an horizontal offset that is added to the pixels in the aPoints struct.
nOffsetY	contains an vertical offset that is added to the pixels in the aPoints struct.

Return Values

MRY_ERR_NOT_SUPPORTED	is you are running under Moray V3.5 and later.
MRY_SUCCESS	if the pixels were all successfully set.
MRY_ERR_CLIPPED	if any of the pixels were outside the views coordinates.
MRY_ERR_INVALID_HANDLE	if hView is not a valid handle to a view.
MRY_ERR_NULL_POINTER	if hView is NULL.
MRY_ERR_VALUE_OUT_OF_RANGE	if you attempted to pass less than 1 point.
MRY_ERR_INTERNAL_ERROR	if Moray is in an unstable state.

Remarks

The coordinates are pixel coordinates. The pixels are checked to be on the bitmap and not painted if they are off. The routine does not abort if a pixel is off the bitmap. Check the nWidth and nHeight members of the MRY_SCN_VIEWINFO structure to get the size of the view.

NOTE: this function will fail in Moray V3.5. In earlier versions it only works if the view is not in OpenGL mode.

See Also

MRY_SCN_VIEWINFO.fnDrawPolyLine2D

The function MRY_SCN_VIEWINFO.fnDrawPolyLine2D is a member function of the MRY_SCN_VIEWINFO struct and draws connected lines (a polyline) in a view.

long WINAPI fnDrawPolyLine2D(long hView, LPMRY_POINTS2D aPoints, int nNumPoints, int nOffsetX, int nOffsetY);

Parameters

hView	contains the handle of the view in which to draw the polyline.
aPoints	is a pointer to an array of MRY_POINTS2D which contain the coordinates of the polyline.
nNumPoints	contains the number of points in the polyline. Make sure that aPoints points to enough coordinates.
nOffsetX	contains an horizontal offset that is added to the polyline in the aPoints struct.
nOffsetY	contains an vertical offset that is added to the polyline in the aPoints struct.

Return Values

MRY_ERR_NOT_SUPPORTED	is you are running under Moray V3.5 and later.
MRY_SUCCESS	if all the lines were successfully drawn with no clipping involved.
MRY_ERR_CLIPPED	if part(s) of the polyline were clipped.
MRY_ERR_INVALID_HANDLE	if hView is not a valid handle to a view.
MRY_ERR_NULL_POINTER	if hView is NULL.
MRY_ERR_VALUE_OUT_OF_RANGE	if you attempted to pass less than 1 point.
MRY_ERR_INTERNAL_ERROR	if Moray is in an unstable state.

Remarks

The coordinates are pixel coordinates. The color of the line is taken from the starting pixel coordinate of each segment. The function draws a line from aPoints[0] to aPoints[1] in the color defined in aPoints[0]. The next line is drawn from aPoints[1] to aPoints[2] in the color defined in aPoints[1], etc. The lines are clipped before being drawn (only the visible parts of the lines are drawn). Check the nWidth and nHeight members of the MRY_SCN_VIEWINFO structure to get the size of the view.

NOTE: this function will fail in Moray V3.5. In earlier versions it only works if the view is not in OpenGL mode.

See Also

MRY_SCN_VIEWINFO.fnFillBlock2D

The function MRY_SCN_VIEWINFO.fnFillBlock2D is a member function of the MRY_SCN_VIEWINFO struct and fills a rectangle of a view with a certain color.

long WINAPI fnFillBlock2D(long hView, LPMRY_POINTS2D aPoints, int nNumPoints, int nOffsetX, int nOffsetY);

Parameters

hView	contains the handle of the view in which to fill the rectangle.
nX1, nX2, nY1, nY2	are the pixel coordinates of rectangle to fill.
lColor	contains the color of the rectangle. Colors are in the form 0x00RRGGBB.

Return Values

MRY_ERR_NOT_SUPPORTED	is you are running under Moray V3.5 and later.
MRY_SUCCESS	if the rectangle was filled without being clipped.
MRY_ERR_CLIPPED	if the rectangle was clipped.
MRY_ERR_INVALID_HANDLE	if hView is not a valid handle to a view.
MRY_ERR_NULL_POINTER	if hView is NULL.
MRY_ERR_INTERNAL_ERROR	if Moray is in an unstable state.

Remarks

The rectangle is filled in pixel coordinates. The rectangle is clipped before being drawn (only the visible part of the rectangle is filled). Check the nWidth and nHeight members of the MRY_SCN_VIEWINFO structure to get the size of the view.

NOTE: this function will fail in Moray V3.5. In earlier versions it only works if the view is not in OpenGL mode.

See Also

MRY_SCN_VIEWINFO.fnGetBitmapBits2D

The function MRY_SCN_VIEWINFO.fnGetBitmapBits2D is a member function of the MRY_SCN_VIEWINFO struct and fills a struct with information about the views raw bitmap data.

long WINAPI fnGetBitmapBits2D(long hView, LPMRY_VIEW_BITMAP pViewBitmap);

Parameters

hView	contains the handle of the view whose bitmap is to be queried.
pViewBitmap	contains a pointer to a MRY_VIEW_BITMAP structure that is to receive the bitmap data of the view.

Return Values

MRY_ERR_NOT_SUPPORTED	is you are running under Moray V3.5 and later.
MRY_SUCCESS	if the structure pointed to by pViewBitmap was successfully initialized.
MRY_ERR_VERSION_NOT_SUPPORTED	if nVersion member of the MRY_VIEW_BITMAP indicates that Moray cannot support the struct.
MRY_ERR_INVALID_HANDLE	if hView is not a valid handle to a view.
MRY_ERR_NULL_POINTER	if hView is NULL.
MRY_ERR_INTERNAL_ERROR	if Moray is in an unstable state.

Remarks

A plugin can use the information returned to directly draw into the views bitmap. Note that the plugin is responsible for ensuring no memory overwrites occur. The bitmap is buffered, so once

NOTE: this function will fail in Moray V3.5. In earlier versions it only works if the view is not in OpenGL mode.

MRY_SCN_VIEWINFO.fnGetWorldCoord

The function MRY_SCN_VIEWINFO.fnGetWorldCoord is a member function of the MRY_SCN_VIEWINFO struct and can be used to determine to what world position a certain pixel corresponds.

long WINAPI fnGetWorldCoord(long hView, int nX, int nY, LPMRY_VECTOR pWorldPos);

Parameters

hView	contains the handle of the view in which to determine the coordinates.
nX, nY	are the coordinates of the pixel whose world coordinate is to be determined.
pWorldPos	contains a pointer to a MRY_VECTOR structure that is to receive the world coordinates of the pixel.

Return Values

MRY_SUCCESS	if the structure pointed to by pWorldPos was successfully set.
MRY_ERR_INVALID_HANDLE	if hView is not a valid handle to a view.
MRY_ERR_NULL_POINTER	if hView is NULL.

Remarks

The pixel coordinates need not be inside the view bitmap. The world coordinates are stored in the vector according to the type of view being queried. If it is a XY-View (see the nType variable of the MRY_SCN_VIEWINFO struct) the dX and dY variables are set and dZ is set to zero. Correspondingly, the dX and dZ variables are set and dY is set to zero for XZ-views and the dY and dZ variables are set and dX is set to zero for YZ-views. For XYZ-views (camera views) the function does not return valid coordinates.

MRY_SCN_VIEWINFO.fnSnapWorldCoord

The function MRY_SCN_VIEWINFO.fnSnapWorldCoord is a member function of the MRY_SCN_VIEWINFO struct that can be used to snap world coordinates

long WINAPI fnSnapWorldCoord(long hView, LPMRY_VECTOR pPoint, int nFlags);

Parameters

hView	contains the handle of a view.
pPoint	contains a pointer to the vector to be snapped.
nFlags	contains flags that determine the type of snapping.

Return Values

MRY_SUCCESS	if the coordinate was snapped.
MRY_ERR_INVALID_HANDLE	if hView is not a valid handle to a view.
MRY_ERR_NULL_POINTER	if hView is NULL.

Remarks

This function snaps a world coordinate according to the snap settings in Moray and the flags passed. Although you need to pass a valid hView, the snapping values are global to all views, so it doesn't matter which view you pass.
The nFlags parameter can contain the following values:

MRY_SCN_VIEW_SNAP_SCALE - the coordinate is snapped as if it were a scale value.
MRY_SCN_VIEW_SNAP_ROT - the coordinate is snapped as if it were a rotation value.
MRY_SCN_VIEW_SNAP_TRANS - the coordinate is snapped as if it were a translation value.
MRY_SCN_VIEW_SNAP_DELTA_MAJOR_AXIS - the coordinate is snapped to a major axis. This is useful for snapping delta coordinates. It sets the shortest two values of the axis to zero.
MRY_SCN_VIEW_SNAP_FORCE - this forces snapping. By default (i.e. without this flag), snapping only takes place if enabled in the right-click menu of the view.

Note that the scale, rot and translation flags are mutually exclusive. Only one of them will be applied, even if more than one is specified.

Available in V1.09 of the struct and later.

See Also

MRY_SCN_VIEWINFO.fnGetScreenCoord

The function MRY_SCN_VIEWINFO.fnGetScreenCoord is a member function of the MRY_SCN_VIEWINFO struct and can be used to determine to what pixel coordinate a world position corresponds.

long WINAPI fnGetScreenCoord(long hView, LPMRY_VECTOR pWorldPos, LPMRY_POINTS2D pPoint);

Parameters

hView	contains the handle of the view in which to determine the pixel coordinates.
pWorldPos	contains a pointer to a MRY_VECTOR structure that contains the world coordinate.
pPoint	contains a pointer to a MRY_POINTS2D structure that is to receive the pixel coordinates.

Return Values

MRY_SUCCESS	if the point was successfully converted. Always returned for 2D views. Returned for 3D views if the pixel is inside the view.
MRY_ERR_VALUE_OUT_OF_RANGE	is returned for 3D views if the value in pPoint is outside the visible view.
MRY_ERR_INVALID_HANDLE	if hView is not a valid handle to a view.
MRY_ERR_NULL_POINTER	if hView is NULL.

Remarks

For 2D-views the pixel coordinates are always returned.
For 3D-views, Moray attempts to find the real-world coordinate in the Z=0 plane and returns the pixel coordinate if possible. If the user clicked somewhere where the coordinate could not be determined (for example when the camera faces up away from the Z=0 plane), the function returns the MRY_ERR_VALUE_OUT_OF_RANGE value and the contents of pPoint are zero.

MRY_SCN_VIEWINFO.fnZoomToFit

The function MRY_SCN_VIEWINFO.fnZoomToFit is a member function of the MRY_SCN_VIEWINFO struct that can be used to zoom the view to the scene or to an object.

long WINAPI fnZoomToFit(long hView, long hObjID);

Parameters

hView	contains the handle of the view to be zoomed.
hObjID	contains a handle to the object to which to zoom the view. If it is NULL, the view is zoomed to the scene.

Return Values

MRY_SUCCESS	if the view was zoomed.
MRY_ERR_NOT_VALID_OBJECT	if hObjID is not NULL and not a valid object.
MRY_ERR_INVALID_HANDLE	if hView is not a valid handle to a view.
MRY_ERR_NULL_POINTER	if hView is NULL.
MRY_ERR_INTERNAL_ERROR	if Moray is in an unstable state.

Remarks

To zoom to an object pass its handle in hObjID. If the object has no wireframe representation the zoom may fail (without notice).
To zoom to the entire scene pass a NULL handle in hObjID.
The view is automatically redrawn.

See Also

MRY_SCN_VIEWINFO.fnWriteString

The function MRY_SCN_VIEWINFO.fnWriteString is a member function of the MRY_SCN_VIEWINFO struct that can be used to write text to the view.

long WINAPI fnWriteString(long hView, const char *achBuf, long nColor, MRY_VECTOR *vPos);

Parameters

hView	contains the handle of the view to be written to.
achBuf	contains the string to be written.
nColor	contains the color of the text (in the form 0x00RRGGBB).
vPos	contains the position of the text in the view (in real world coordinates).

Return Values

MRY_SUCCESS	if the strign was written.
MRY_ERR_INVALID_HANDLE	if hView is not a valid handle to a view.
MRY_ERR_NULL_POINTER	if hView is NULL.

Remarks

Note that this function only works when a redraw is actually taking place. It will not work when no rendering is taking place. Its primary use is for outputting text that is related to an object from that objects rendering code.

Available in V1.08 of the struct and later.

See Also