That's all nice and applicable to 3D programming, but it's not really
relevant.  No matter how fancy your shaders are, and how powerful your GPU
is -- you will still need to manipulate matrices in your app.

Doing 3D in a managed language should not impose any undue / silly
penalties, especially when those penalties are easily avoidable (ref Matrix
foo).

Frans, I've seen enough of your posts on this list to think that you have a
fair share of clues about CLR.  But this post seems below your usual
quality.  You do, of course, realize the difference between reference and
value types in CLR, don't you?  Allocating reference types is *cheap*, but
it is far from *free*.

-- arlie


-----Original Message-----
From: Unmoderated discussion of advanced .NET topics.
[mailto:[EMAIL PROTECTED] On Behalf Of Frans Bouma
Sent: Monday, May 17, 2004 4:19 AM
To: [EMAIL PROTECTED]
Subject: Re: [ADVANCED-DOTNET] Large structures

> Taken
>
> But in this particular case, being heavy matrix opreations in 3d, this
> kills your performance.

        If you want performance, write a shader and do your matrix
manipulations on the GPU or call into a C++ matrix lib. I also don't really
see why classes would kill performance really. Admitted, in C++ I used
structs for coordinates and some own written math lib for working with those
structs, however a struct is a class in C++ anyway (they're synonyms, IIRC)
so why would:

public class Vertex3
{
        public float X;
        public float Y;
        public float Z;
}

        be slow in .NET? Graphic programming can only be done fast if you
parallellize operations by delegating the tasks to specialized units, often
a library written to do a given kind of operation really fast (optimized
math lib) or for example a DX helper lib, or better: a shader which does
manipulation of your data down the pipe in hardware. I don't think 3D vector
math in C# will be that performant over a C++ version.

        And in the end, if you insist doing the math in C#, you can of
course fall back to the good old days method when we all used assembler:
3 arrays of floats or a 3 dim. array of floats. Do your math in place and
convert it to an array of vertex objects to send it down the pipe to the
hardware. But if you ask me, see the .NET layer in a DX program which relies
heavily on graphics performance as a thin layer to keep the program
together, not the core application: the power is not in the .NET layer, it's
in the DX layer so don't try to do more in the .NET layer than absolutely
necessary.

> Purity is nice, but here we talk of criticals, too.

        if performance is critical, use the right objects in the layer-stack
to do the work :) So, I'd suggest to call into C++ math libs from C# and
pass on the result to DX, or better: write a shader. Much faster :)

                FB

===================================
This list is hosted by DevelopMentor®  http://www.develop.com
Some .NET courses you may be interested in:

NEW! Guerrilla ASP.NET, 17 May 2004, in Los Angeles
http://www.develop.com/courses/gaspdotnetls

View archives and manage your subscription(s) at http://discuss.develop.com

Reply via email to