Sorry your browser is not supported!

Quote: "So, if you uset SET MEMBlOCK BYTE memblocknum, 1
that would have no effect on the first float."

sync on
sync rate 60

` To explain what I mean we will create a memblock with 5 bytes
` first four is for the float and the last byte is for the byte.
make memblock 1,5

` Write in an example float
Write Memblock float 1,0,1.234

` Write in an example byte and make sure it doesn't overwrite
` the float in the first four bytes
Write Memblock byte 1,4,123

text 0,0,"Float: "+str$(Memblock Float(1,0))
text 0,20,"Byte: "+str$(Memblock Byte(1,4))
sync : sync
wait key

Quote: "a brief explanation of memblocks containing meshes. I guess you're using DBC, so I'll use that format.

After taking a quick look at the help files, it turns out I've never used the DBC memblock mesh commands anyway, so I'll just have to make it up as I go along.

Ok, the first 32 bytes in the memblock is the header, which contains:

(0) Number of vertices
(4) Byte offset to vertex data
(8) Number of normals
(12)Byte offset to normal data
(16)Number of faces
(20)Byte offset to face data
(24)Size of all face data
(28)Offset to texture coordinates

All these values are 4 bytes (dwords), that is how they are read and written. Having never used the commands before, I can't tell you if the byte offset is from zero or 32 or what, you can probably establish that from experimenting. The numbers in brackets are the positions in the memblock in which you write the data.

Now, the data after that is what you use to create your mesh. You can set any number of vertices, and link up three at a time to make a face. Each vertex in a face has a normal, but the vertices and normals are kept as separate data. The normal of the face is probably calculated based on the average normals of the vertices making up that face. Now, starting at position 32, you can input vertex data, as 4 byte floats. You input 3 floats per vertex, to hold the X, Y and Z positions of the vertex.

'n'th vertex:

(32+(n*12)+0) X position
(32+(n*12)+4) Y position
(32+(n*12)+8) Z position

You can input as many of these as you like, just make sure to put the appropriate offset in the header.

Now, you can create some normals to help light your mesh. A normal is basically a vector that points outwards from the surface of the mesh. (I hope you know what a normal is, that explanation was rubbish). You can set the X, Y and Z components of a normalised normal vector in the memblock.

'n'th normal:

(32+normal offset+(n*12)+0) X component
(32+normal offset+(n*12)+4) Y component
(32+normal offset+(n*12)+8) Z component

These are all 4 byte floats. Again you can add as many as you like, providing you set the correct offsets in the header.

Now, face data. Each face consists of three vertices, and three normals. Also a number of vertices used, but that should always be set to 3. Now, there is an inconsistency in the help files here. It says the face data should be 2 byte dwords. Now this should either be 4 byte dwords or 2 byte words, I'm not sure which, having never used the commands before. As such, the number in the expression for the memblock position to write to should be (n*14) or (n*28) appropriately. Likewise y should increment in steps of 2 or 4 respectively, like in the previous examples.

'n'th face:
(32+face offset+(n*x)+y) Number of vertices (always 3)
(32+face offset+(n*x)+y) Vertex index A
(32+face offset+(n*x)+y) Normal index A
(32+face offset+(n*x)+y) Vertex index B
(32+face offset+(n*x)+y) Normal index B
(32+face offset+(n*x)+y) Vertex index C
(32+face offset+(n*x)+y) Normal index C

You can define a face by putting the indexes (not the memblock positions) of three vertices, and three normals to use with these vertices.

Lastly, you can input texture data. Each vertex has a U and V value for it's texture coordinates. These come right at the end of the memblock, and are 4 byte floats.

'n'th vertex's texture coordinate:
(32+texture coordinate offset+(n*8)+0) U coordinate
(32+texture coordinate offset+(n*8)+4) V coordinate"