Löschst du den ZBuffer auch nach jedem Frame?
Ist die Orientierung deiner Polygone OK (CCW vs. CC)?

Ziemlich witzig...
Aber das mit dem Singen sollte er lassen 😉 😁

Das Berechnen der Vertexnormalen läuft meist in drei Schritten ab:

1. Berechne die Oberflächennormale eines Dreiecks (nicht mit Vertexnormale verwechseln) und speichere sie in einer Liste. (Simples Kreuzprodukt)
2. Durchlaufe alle Vertices und addiere alle Dreiecksnormalen der anliegenden Dreicke, die sich den aktuellen Vertex teilen.
3. Alle Vertexnormalen normieren.

Den 2. und 3. Punkt brauchst du nur wenn es Gouraud Shading sein soll. Bei Flatshading reicht Punkt 1.

Die deluxe Variante:

http://www.codeproject.com/csharp/PrettyGoodSplashScreen.asp

Wenn du einen Funktionszeiger als Paramter für eine andere Funktion übergeben willst (Callback-Funktion), dann musst du einen Delegaten nutzen.
Wie sowas aussieht kannst du hier sehen:
http://www.dotnet247.com/247reference/msgs/55/276613.aspx

Im 2.0 Framework gibt es sogar die Möglichkeit einen nativen Function-Pointer direkt in einen Delegaten umzuwandeln.

Für void* schreibt man IntPtr wenn es safe Code sein soll.
Wenn du deinen Code als unsafe markierst, kannst du auch ganz normal Pointer nehmen.

Wichtig ist nur, dass die Funktionen wenn sie mit nem C++ Compiler kompiliert wurden, als extern "C" deklariert werden. (Stichwort: Name Mangling)

tvar, app und Andere kannst du natürlich nicht nutzen. Du musst schon die Datentypen des CTS nehmen 😉

Außerdem solltest du auch auf den richtigen Namen für die Funktion achten. In deinem Code unten heißt die Funktion die du lädst "VSetVariable". In deinem C#-Code schreibst du aber nur "SetVariable". (EntryPoint benutzen)

DllImport noch mal kurz erklärt:
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vccore/html/vcwlkSysimportAttributeTutorial.asp

Frag doch einfach die Koogel 🙂

http://www.infosun.fmi.uni-passau.de/br/lehrstuhl/Kurse/sep_ws0405/samples/pflichtenheft.pdf

Setz mal den CooperativeLevel von Exclusive auf Normal.

Golem? Du meinst wohl Gnome 😁

Der Initiator von Mono heißt Miguel de Icaza. Er arbeitet bei Ximian (entwickeln vorallem Software für Linux: Ximian Evolution ...).
Früher hat er Gnome ins Leben gerufen, weil es damals noch keinen echten freien Desktop für Linux gab und die Qt-Bibliotheken von Trolltech noch unter einer kommerziellen Lizenz verteilt wurden.

Er meint sicherlich Tutorials als Artikel wie z.B auf Codeproject.
Die jetzigen Tutorials sind ja eigentlich nichts weiter als Forumseinträge.

Was meinst du speziell für eine Welt?

Es kommt ganz darauf an, was du machen willst. Je nach Anwendungsgebiet wählt man sich eine spezielle Beschleunigungsstruktur um das Rendering zu optimieren.

Typische Beispiele:

• Weite offene Landschaften: Quadtree oder Octree
• Indoor/Gebäude: Portal-Engine, BSP-Trees
• Weltraumballerspiel: Bounding-Volumes
• ...

Schick's doch einfach an die Leute vom Product feedback:

http://lab.msdn.microsoft.com/productfeedback/

Die freuen sich wenn sie mal was zu tun bekommen 😁

Wenn ich das richtig verstehe, willst du sehr große Dezimalzahlen mit Hilfe von int Vektoren darstellen. Leider gibt es in C# keine BigInteger. Aber es gibt da Alternativen:

http://www.codeproject.com/csharp/BigInteger.asp

Die Klasse nutzt intern einen int Vektor wie du ihn beschreibst (in Polynomdarstellung).
Die Operatoren wurden überladen und können ganz intuitiv wie normale Integer nutzen werden.

Die Fakultät lässt sich dann rekursiv berechnen:
Pseudocode:

BigInt fak(BinInt i)
{
   if(x>1)
      return fak(i-1)*i;
   else
      return 1;
}

oder Iterativ:

BigInt fak(BigInt i)
{
   BigInt f = 1;
   for(BigInt c = 2; c <= i; c++)
     f = f * c;
    return f;
}

Iteratives Verfahren sollte aber etwas schneller und ressourcenschonender sein. Kann aber trotzdem sehr lange dauern. Wenn dir das nicht schnell genug geht dann probiers mit den numerischen Verfahren.

Original von Pulpapex
Vitalgeist-Theorie,

ist damit die Theorie gemeint, dass es in Wirklichkeit nichts Gegenständliches, kein Universum usw. gibt und dass sich die Welt stattdessen in dem einzigen, existierenden Bewusstsein, einem selbst, abspielt?

So einen habe ich vor paar Jahren im Heise-Forum erlebt.

// Edit: abgehobene Vorstellung, aber lässt sich nur schwer widerlegen oder?

Hört sich ziemlich strange an.
Vorallem wenn man glaubt, das man nur selbst wirklich existiert und alles andere nur ein Produkt des eigenen Geistes ist. Ich würde das mal damit wiederlegen, dass ja jeder Mensch offensichtlich ein eigenes Bewusstsein besitzt. Ich kann mir jedenfalls nicht vorstellen, Milliarden von Individuen nur durch die eigene Imagination zu "erzeugen".
Und wenn doch, würde das bedeuten, dass ich hier gerade Selbstgespräche führe 😉

Äther? Es gibt doch die Loop-Quantengravitations-Theorie.
Viele Physiker, die die Stringtheorie ablehnen verfechten diese.
Das Problem ist nur, dass sie ein ätherähnliches absolutes Bezugssystem (Spin-Netzwerk) vorraussetzt, welches ja nach Einstein nicht existieren kann.

Muss cdr recht geben.

Schon die Wahrnehmungspsychologie lehrt, dass man nicht unbedingt das wahrnimmt was "wirklich" da ist, sondern das die Wahrnehmenung von der eigenen Erwarungshaltung, somit subjektiv, geprägt ist.
Optische Tauschungen sind ein schönes Beispiel dafür:

http://www.panoptikum.net/optischetaeuschungen/

Hier kann man man natürlich auch gleich die Frage anschließen : Was ist eigentlich Realität ... wirklich das was ich wahrnehme? 😉

In 2D funktioniert das Skalarprodukt. Dieses Produkt ist ein Maß für den Winkel zwischen zwei Vektoren.
Das Vektorprodukt führt aus dem 2D-Raum in den 3D-Raum. Ist also bei 2D Vektoren immer (0,0,-1) oder (0,0,1) (Damit also nicht im R^2 abgeschlossen).

Application.ProcessMessages kann schon Einfluss auf die Berechnung haben. Lass es mal weg und probier es noch mal, oder schreib an der gleichen Stelle im C# Programm Application.DoEvents() 😉

Um das heraus zu finden müsstes du schon den Quelltext posten 😉
Ich find es aber schon merkwürdig, wenn es so große Unterschide in der Laufzeit gibt. Der Delphi Compiler erzeugt eigentlich sehr guten Code.

Das hier hat echt nicht geholfen:

http://www.icsharpcode.net/OpenSource/SD/Forum/topic.asp?TOPIC_ID=7142

Ich kenne den Fehler.
Wenn ich mich recht entsinne, hatte ich mit XP-AntiSpy das Windows Scripting deaktiviert. Du musst es wieder reaktivieren und dann neu installieren.

Haha, sehr lustig 😉

Alternativ könntest du auch ne Xml-Datei schreiben (XmlWriter) und dann mit nem XML Stylesheet in HTML transformieren. Hätte den Vorteil das dein Log nicht an ein bestimmtes Format gebunden ist.

Ist zwar eigentlich ein C# Forum, aber na ja 😉
Es gibt auf SF eine Lib mit der man USB-Ports ansprechen kann. Vielleicht hilft dir das etwas weiter:
http://sourceforge.net/projects/libusb-win32/
Dafür gibt es übrigens auch einen .NET Wrapper.

Der Xml-basierende Ansatz macht dieses System sehr flexibel aber auch relativ wartungsaufwändig.
Es gibt auf SF Tools wie WixEdit, die das Generieren und Editieren solcher Dateien vereinfachen:
http://wixedit.sourceforge.net/
Ist aber noch in einem sehr frühem Entwicklungsstadium.

Ich selbst verwende Inno Setup sehr gerne. Die Installationsskripte sind schnell geschrieben und es erlaubt die Einbindung einer einfachen, zu Pascal ähnlichen, Skriptsprache:

http://www.jrsoftware.org/isinfo.php

Zumindest "neue Beiträge anzeigen" steht in der Kopfleiste. Allerding könnte man die anderen Links durchaus etwas "offensichtlicher anbringen". Ich fand das anfänglich auch etwas gewöhnungsbedürftig 🙂

Ein kleiner Tipp noch,

man sollte sich gut überlegen, ob man Einstellungsdaten noch in der Registry abspeichert. (Wegen der fragmentierung/vermüllung und den Inkonsistenzen die damit zusammenhängen). Ergo ist der "ApplicationData"-Order sinnvoller um Einstellungsdaten zu speichern. Den kann man über dies auch besser sichern - wenn es mal nötig sein sollte - als die Registryeinträge.

Danke dir auch,

hab das jetzt mit einigen Anbauten hingekriegt. Ist zwar nicht sehr elegant aber es reicht erst mal. Wird Zeit das sich Microsoft da was einfallen lässt.

Danke VizOne,

da ich auch nach langem Suchen keine elegante Lösung dafür gefunden habe, konnte ich mir schon denken das es nicht geht. Eigentlich schade, dass man Generics eingeführt hat, ohne an solche (eigentlich recht wichtigen) Dinge zu denken.

Ein ähnliches Problem tritt zu Beispiel auch beim casten auf:
Ist x ein generischer Typ dann kann man ihn nicht einfach nach int, float, double casten. Hier wäre es auch nicht schlecht, wenn man x als arithmetischen Typ kennzeichnen könnte, den man in einen anderen konvertieren kann.

Hallo,

wie kann ich in einer generische Klasse den Plus-Operator fehlerfrei überladen:

public struct Vector3<T>
{
	public T x;
	public T y;
	public T z;
	
	public Vector3(T _x, T _y, T _z)
	{
		x = _x;
		y = _y;
		z = _z;
	}
	
	public static Vector3<T> operator + (Vector3<T> l, Vector3<T> r)
	{
    	return new Vector3<T>(l.x+r.x, l.y+r.y, l.z+r.z); // Fehler
	}
}

Bei diesem Konstrukt bekommt man die Fehlermeldung, dass der Operator + nicht auf Operaten vom Typ T anwendet werden kann.
Gibt es da irgeneinen Constrain, mit dem man bestimmen kann, dass es sich bei T um einen numerischen Typ handelt?

Danke schon mal.

Schau mal hier in deiner Frameworkinstallation:

C:\Programme\Microsoft.NET\SDK\v1.1\Tool Developers Guide\Samples\clisp

Die Dateien Lexer.cs und Parser.cs demonstrieren die typische Vorgehensweise ganz gut.

In der Compilertechnik gibt es ja da eine ganz typische Vorgehensweise. Dein Text wird erst in einem Scanner (manchmal auch Tokenizer oder Lexer genannt) in einzelne Tokens zerlegt.
Hast du - mal als Beispiel - eine C-Funfktion die so aussieht:

float func(float f)
{
  return f*f;
}

dann zerlegt der Lexer sie in eine Tokenliste die wie folgt aussieht:

float
func
(
float
f
)
{
return
f
\*
f
;
}

Der Scanner ist meist nichts weiter als ein endlicher Automat der Whitespaces überspringt und die eingelesenen Symbole einer Tokenliste hinzufügt.

Erst nach diesem Schritt wird erst "richtig" geparst.

Ne Daten lassen sich nicht aus der Registry lesen.
Alles was Windowsspezifisch ist, wird natürlich nicht auf anderen Plattformen unterstützt.
Auch bei WindowsForms kannst du nicht alles machen: Zwar haben die von Mono nach eigenen Angaben etwa 94% von WinForms portiert, aber es gibt da viele Funktionen die noch nicht bzw. nie unter Linux laufen werden. Das sind z.b. Methoden die Betriebssystemspezifische Handles von Bitmaps bzw. Fenstern ermitteln. Wenn du also für beides entwickeln willst, musst du aufpassen das du keine Windows typische Funktionalität nutzt. Im Zweifelsfall immer mit beiden Frameworks testen.

Für die Grafik kanst du auch TAO benutzen:
www.taoframework.com
Die bieten dort Wrapper für die OpenGL Biblotheken an. OpenGL dürfte sich schon mit wesentlich einfacheren Grafikkarten zufrieden geben (3D Beschleunigung natürlich vorrausgesetzt) als DirectX.

Wenn du trotzdem was selbst programmieren willst, kommst du wahrscheinlich nicht um Optimierungsalgorithmen wie A* und Co. herum. A* ist aber bei sehr vielen Knoten nicht gerade effizient. Es gab mal vor kurzem einen Artikel in der C't über einen Ameisenalgrithmus.
Er basiert auf den Autoorganisationsmechanismen von Ameisenkolonien. Der Algorithmus simmuliert die Pheromonabgabe von Ameisen und ermittelt so den kürzesten Weg zwischen einem oder mehreren Knoten.

C't Softlink: 0505204

Mit der Formel 2^(3-1)=4 wollte ich andeuten, wie man von der zu setzenden Bitposition auf die jeweilige Dezimalzahl kommst, die diese Bitposition repräsentiert.

Allgemein: z = 2^(bitpos-1)

Wenn du das mit "port and not z" (löschen) bzw. "port or z" (setzen) nicht verstehst, dann notier dir mal ein beliebiges Bitfield. Dieses Feld und deine Maske z (siehe oben) verknüpfst du dann bitweise mit den oben genannten Operatoren.

Du kannst mit dem symbolischem Namen LPT1 und der CreateFile Funktion die parallele Schnittstelle öffnen. Das sieht dann so aus:

http://www.buha.info/board/archive/index.php/t-26544.html

Die WinAPI Funktionen lassen sich ja über Interop einbauen.
Du kannst auch mal mit der FileStream Klasse probieren LPT1 zu öffnen.
Da die Klasse intern auch CreateFile nutzt, sollte das eigentlich auch gehen.

Noch was zum setzen der Bits:
Du kannst die bitweisen logischen Operatoren(and,or,not) nutzen, um Bits zu setzen bzw. zu löschen.
Beispiel:
Das 4. Bit löschen: port = port and not 8; ( 2^(4-1)=8 )
Das 3. Bit setzen: port = port or 4; ( 2^(3-1)=4 )

Probier mal das: \x000ab

Windows und Dos verwenden unterschiedliche Zeichensätze, deswegen werden die NFOs nicht korrekt angezeigt.
Im Dos Texteditor kannst du die Alt-Taste festhalten, dann den ASCII-Code im Num-Pad eintippen (Alt-Taste wieder loslassen). Schon erscheint das Sonderzeichen im Editor.

Sonst gibt's da nichts weiter.
Du benutzt ihn wenn du bestimmte Aufgaben nach FIFO-Prinzip im Hintergrund laufen lassen willst.
Hast du dir etwa was bestimmtes erhofft ?(

Hätte ja sein können, da herbivore ja eigentlich Pflanzenfresser bedeutet 😉 Ich kenn den Begriff nur aus der Biologie 😉

Du kannst dir diesen Threadpool als eine Warteschlange für Threads vorstellen. Die Threads werden da im FIFO-Prinzip eingehängt. Der Thread, den du als erstes eingefügt hast, wird auch als Erster bearbeitet. Alle weiteren Threads warten bis ihre jeweiligen Vorgänger abgearbeitet wurden.

Auf Codeproject gab's mal ne ThreadPool Klasse mit erweiterter Funktionalität.

Zum Sinn: Manchmal kann so was bei einem einfachen Server nützlich sein. Der nimmt Anfragen entgegen und erzeugt dann für jeden Client einen Thread, diese werden dann in einen ThreadPool eingeordnet. (Der Cassini Webserver macht das z.B. so)

P.S.: @herbivore: Mal ne kleine Frage: Bist du Vegetarier ?( 😁

In .NET ist ein Int immer ein Int mit 32 bit Breite. Das ist ja gerade der Witz an .NET. Das Laufzeitsystem garantiert dir immer eine einheitliche Größe.

Der einzigste Datentyp der sich wirklich ändert ist IntPtr. Der ist auf Windows 64 auch tatsächlich 64 bit breit.

Gleitkommaoperationen musst du auch nicht ändern.
Auf 64bit Windowssystemen werden float und double aber nicht mehr auf der alten x87 Einheit berechnet, sondern nutzen SSE standardmäßig für Gleitkommaoperationen.

Wenn du also nur mit "safe" Code arbeitest, ändert sich für dich nichts.

Im 2.0 Framework wurde die Console Klasse erweitert. Es ist da möglich den Cursor frei zu positionieren und den Consolebuffer zu manipulieren.
Damit könntest du eigentlich ein einfaches Fenstersystem auf Textmodusbasis schreiben (Maussupport wird es natürlich nicht geben).
Die Sonderzeichen für Rahmen und Buttons kannst du aus der Windows Zeichentabelle nehmen.

Ich versuche auch das Singleton Pattern so weit wie möglich zu vermeiden. Oft kann sich dieses Pattern als sehr unflexibel erweisen. Willst du z.B. deine Software nachträglich von SDI nach MDI erweitern, steht dir das Singleton-Pattern im Wege.

Beim MVC-Pattern wird die Interaktion meist über ein Observer Pattern geregelt.
Ändert man z.B. einen Wert in deiner Dokumenten-Klasse (die Daten) dann benachrichtigt die sie alle Ansichten (Fenster), dass sich etwas geändert hat und zwingt sie zur Aktualisieren.

Softwaretechnisch wird das meist so umgesetzt:
http://csis.pace.edu/~bergin/mvc/mvcgui.html

In C# kann man für Observer/Observable Events nehmen.

Meist ist der exzessive Einsatz von globalen Variablen über Singletons ein Zeichen für ein nicht gerade gelungenes Software Design.

In vielen Systemen wird ein MVC-Pattern genutzt um Ansicht und interne Datenrepräsentation strikt voneinander zu trennen.

So was ähnliches könntest du auch machen: Schreib ne Klasse die internen Daten deines Programms speichert. Alle Deine Forms enthalten dann eine Referenz auf dieses Objekt. Wenn das Form geschlossen wird, werden alle Steuerelemente ausgelesen und in dieser Klasse gespeichert. Machst du dann ein zweites Form auf, können die Daten wieder aus der Datenklasse gelesen und aktualisiert werden.

Die Trennung hat noch weitere Vorteile: Serialisierung der Daten Objekte ist absolut problemlos. Auch können die Informationen für andere Ausgabearten verwendet werden. Es ist auch möglich mehrere Datenobjekte gleichzeitig im Speicher zu halten und dann dynamisch zu wechseln (interessant für MDI-Anwendungen)

Wie du schon gesagt hast, musst du, wenn du die GPL Software nutzt, dein Programm auch unter GPL stellen. Mit allen Konsequenzen: Quellcode muss für jeden einsehbar sein. Auch dürfen keine Copyrights der Autoren gelöscht werden und deine Änderungen musst du dokumentiert.

Die GPL kannst du hier noch mal durchlesen:
http://www.gnu.org/licenses/gpl.txt
Es gibt auch ne deutsche Variante (ist aber Rechtlich nicht abgesichert!)
http://www.gnu.de/gpl-ger.html

Die "schwache" Variante der GPL, die LGPL erlaubt darüber hinaus auch das Binden mit proprietären Programmen.

Also ich hab gehört das #Develop 2.0 frühstens releast werden soll, wenn die Betaphase des .NET Frameworks 2.0 beendet ist. Die Entwickler haben soweit ich weiß schon einen 2.0 Branch in ihrem Subversion Repository. Es wird wohl ne menge interessante Dinge im 2.x Zweig geben. Endlich einen integrierten Debugger, vielleicht Version Control Integration und Refactoring. Bin auch schon gespannt. #D 2.0 wird aber nur mit dem 2.0 Framework laufen.

Das #Dev so super buggy sein soll kann ich auch nicht betätigen. Es gibt zwar ein paar Performanceprobleme und Ungereimtheiten aber sonst ist die IDE nicht schlecht. Ich habe damit auch schon nen Raytracer geschrieben. Knapp 10000 Zeilen Code. Ging wunderbar.

http://www.csharp-board.de/ wurde ja jetzt verseucht.
Man kann sich da KaZa (Wer's glaubt wird seelig) herunteladen.
Solchen Leuten sollte man echt mal das Handwerk legen.

Ich seh gerade: Vielleicht etwas unglücklich Ausgedrückt mit "dem statischen Linken". Module sind immer abhängig von einer anderen Assembly und nicht selbstständig lauffähig. In etwa so, als ob man einen Teil eines Programms nur in eine ander Datei auslagert. Der Code von Modulen wird aber nicht in die Assembly integriert, wie beim statischem Linken von C++.
Das VS es nicht unterstützt (auch #Develop) ist wohl nicht so schlimm, da in 99.99% aller Fälle eine normale Assembly wohl eh die bessere und flexiblere Wahl ist.