Is there a general method for finding out, to the byte, how much memory is
consumed by a given instance of an object?

I'm in the process of designing a scientific simulation program (to simulate
planetary formation, tectonics, etc).  To simulate an earth-sized planet
with any nice degree of resolution takes an astonishing number of objects.
For instance, tiling the earth with triangles of size 50 kilometers just to
do a reasonable tectonic simulation takes almost 440,000 triangles.  That's
not bad, but subsequent refinements down to 1 km blow that number up to
something like 1.7x10^9 triangles (or maybe only 6x10^8 if I ignore
everything that's underwater).

Clearly, in this type of application, every byte of memory must be carefully
considered; even a single extra byte of padding somewhere in a data
structure can end up costing you hundreds of MB of memory.  I need to decide
whether to implement these triangles and their vertices as managed C#
objects (much easier for me), or as unmanaged C++ objects (in order to
tightly control memory so the model fits into RAM).

In the unmanaged C++ world, I know exactly how to count the bytes my classes
will take up.  In the managed C# world, with the overhead that the framework
imposes in order to be able to move objects around, do garbage collection,
etc., I have no idea.  If I define:

class WorldPoint {
 public float x,y,z;        // in C++ this costs 12 bytes
}

class WorldTriangle {
 WorldPoint *vertices[3];    // in C++, this costs 12 bytes, too, in the
form of pointers.
}

In C++, if I build 1 WorldTriangle, I've used 12 bytes for pointers to the
vertices, and 36 bytes for the vertex objects themselves.  In C#, How much
memory have I really used?