Laden...
H
hauptmann myCSharp.de - Member
Schüler Österreich/Kärnten Dabei seit 19.07.2003 704 Beiträge
Benutzerbeschreibung

Forenbeiträge von hauptmann Ingesamt 704 Beiträge

15.07.2004 - 18:11 Uhr

Hi!

vielleicht gibts hier ein paar CSler,UTler oder BFler oder auch C&Cler. Naja, vielleicht könnten wir ja, bei genügend Interesse, einen myC# Clan machen.

Wie würdet ihr das finden 😁

15.07.2004 - 17:57 Uhr

naja, eigentlich hab ich nichts verbrochen. Ich kann ja den Geist Modus mal abschalten bei mir. Aber wayne?

15.07.2004 - 17:47 Uhr

Gegenfrage: Was bringt es mir nicht? 😁

15.07.2004 - 17:33 Uhr

Hi!

soetwas ist nicht erlaubt. Bezeichner dürfen nicht mit einer Zahl anfangen Du müsstest das so schreiben:


enum MyEnum
{
   Grad10
}

15.07.2004 - 17:27 Uhr

Original von golohaas.de

  • C# bietet ein Exception-Handling mit try / catch / finally

C++ unterstützt ebenfalls Exeption Handling. Sogar (Win32)C hat das schon unterstützt: try,catch,finally und leave.

15.07.2004 - 17:20 Uhr

Hi!

auch von mir ein Hallo, aber hätte das nicht besser da rein gepasst?
wat wer bist du den?

15.07.2004 - 17:19 Uhr

Hi!

solche Anmeldeprobleme mit dem IE sind bekannt. Wir hoffen das beim nächsten Forenupdate diese Probleme beseitigt werden.

14.07.2004 - 18:36 Uhr

Original von Chief Brodie
das wird nicht gehen, es sei denn, die junx von apache erweitern ihren server um asp.net.

http://apacheworld.org/modmono/ 😉

13.07.2004 - 20:11 Uhr

BitDefender läuft auf dem Windows 2003 Server auch ohne Probleme....

09.07.2004 - 16:29 Uhr

Hier mal eine Liste von kostenlosen Anbietern:
Wer ASP.net einfach nur mal im Internet ausprobieren will, findet hier ein kostenloses ASP.net Hosting Angebot. Man bekommt 20MB Webspace,10MB SQL Speicherplatz. Allerdings dürfen normale Dateien nur 100kb groß sein....
Aber zum ausprobieren ist der ganz gut.

Bei Discount ASP gibt es ASP.net Webspace mit ganz ordentlichen Feautures für 3 Monate zum Testen. Danach muss man zahlen.

Bei ASPWebHosting kann man das Angebot 30 Tage lang kostenlos nutzen(just4testing halt)

Bei Free ASP Host gibt es ebenfalls freien ASP.net Webspace. Nur man sollte das kleingedruckte lesen: You must already have or register your own domain name. Domain Registration @ $29.95

Bei Dev Biz Host gibt es einen 30 Tage Trial Account.

Und dann noch Innerhost. Jedoch muss man da einen bereits exestierenden Account besitzen.

CFM Ressources bietet ebenfalls einen Free ASP.net Account an.

Brinkster bietet ebenfalls ein Gratis ASP.net Angebot, jedoch mit einigen Einschränkungen bezgl. des Traffics(500mb pro Monat, 15mb pro Tag)

09.07.2004 - 16:07 Uhr

Hi!

Weil C++ lange vor Dingen wie des Erfolgs des Internet,XML etc. erfunden wurde. Ergo ist es recht schwierig eine Ordentliche Integration dieser Dinge in C++ zu machen. Außerdem enthält C# viele nützliche Helfer, die das RAD(Rapid Application Development) enorm fördern. Schon allein dadruch hat C# eine große Daseinsberechtigung.

08.07.2004 - 16:53 Uhr

Hi!

nein, das geht afaik nicht. Mach dochs einfach mit einem Installer, der das Framework automatisch installiert

29.06.2004 - 19:30 Uhr

Original von hauptmann

Original von Xqgene
.NET Framework != .NET Framework SDK

schon. Aber normalerweise sollte man mit dem normalen Framework auch C# Dinge kompiliert bekommen. Beim 1.1 Runtime ist der C# Compiler dabei....

Es ist ledeglich das Framework 1.0 mit welchem Programm soll ich da versuchen eine .cs Datei zu kompilieren?

such mal nach dem Programm csc.exe

29.06.2004 - 19:30 Uhr

Original von Xqgene
.NET Framework != .NET Framework SDK

schon. Aber normalerweise sollte man mit dem normalen Framework auch C# Dinge kompiliert bekommen. Beim 1.1 Runtime ist der C# Compiler dabei....

27.06.2004 - 18:03 Uhr

Original von sirtk
niemand eine Idee?

anscheinend nicht... oder vielleicht auch mal länger als einen Tag warten?

Bitter unterlasse in Zukunft das "pushen" von Beiträgen. Danke.

27.06.2004 - 15:45 Uhr

Hier handelt es sich wohl eher um eine Frage über die Entwicklungsumgebung als über ASP.net d.h. ** Verschoben nach Entwicklungsumgebungen**

21.06.2004 - 16:31 Uhr

also ich vertrau weiterhin auf SuSE(hab so 6 Versionen von denen zu Hause)

SuSE 9.1 hab ich übrigens auch schon. (auf DVD)

19.06.2004 - 21:39 Uhr

Original von Jdan

in C# wurden die Pointer "entfernt". stattdessen rennt jetzt alles über die referenzen!

naja, entfernt kann man nicht sagen. Sie wurden deaktiviert. Man kann immer noch mit Pointer arbeiten:



// compile with /unsafe option
		static void Main(string[] args)
		{
			unsafe
			{
				int a = 4;
				int* i;
				i = &a;
			
				Console.WriteLine("Inhalt von (Pointer)i: {0}",*i);
				Console.WriteLine("Inhalt von (Variable)a: {0}",a);

				*i = 10;
				Console.WriteLine("Inhalt von (Pointer)i: {0}",*i);
				Console.WriteLine("Inhalt von (Variable)a: {0}",a);

			}
			Console.ReadLine();
			
		}

Sind natürlich total unschön und sowas sollte unter C# eigentlich nicht mehr genutzt werden. Ist halt nur relevant, wenn man irgendwelche Sachen über P\Invoke einbinden will.

16.06.2004 - 12:49 Uhr

hast du auch die neuesten Patches für dein Windows?

13.06.2004 - 11:51 Uhr

ich denke England oder Frankreich wird gewinnen. Naja, mal sehen 😁

11.06.2004 - 11:29 Uhr

Original von GhstEsl
Also der Fehler kommt immernoch, kann es sein, dass es dran liegt das ich [STAThread] löschen muss, damit ich das programm starten kann? weil wenn ich [STAThread] stehtn lasse, dann kommt folgender fehler:

Attribute 'STAThread' is not valid on this declaration type. It is valid on 'method' declarations only.

Wo hast du das [STAThread] Attribut hingetan? Du musst es vor eine Funktion tun.

11.06.2004 - 11:16 Uhr

Hast du eine Referenz auf das Assembly System.Windows.Forms.dll gesetzt? Denn in diesem Assembly liegt der Namespace System.Windows

09.06.2004 - 20:00 Uhr

joa. Keine Ahnung ob ich da kommen kann. Weil ich hab von 10. Juli bis 11. September Sommerferien und im Oktober so wie es aussieht schlechte Chancen auf Ferien oder so 😁

naja, mal sehen.

09.06.2004 - 17:53 Uhr

Original von Code-Hacker

Closed-Ereignis?Dann ist die Form doch schon geschlossen

ach ja, stimmt. Dann habe ich das mit dem Closing Ereignis verwechselt. So gehts auch:


this.Closing += new System.ComponentModel.CancelEventHandler(this.Form1_Closing);
...
....
private void Form1_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
	e.Cancel = true;
}

09.06.2004 - 16:52 Uhr

du könntest das Closing Ereignis abfangen....

09.06.2004 - 16:07 Uhr

maxE meint wohl die Klasse Microsoft.DirectX.Direct3D.Sprite(Achtung: Die ist im Assembly Microsoft.DirectX.Direct3DX).

Mit der kannst du das machen, das maxE vorgeschlagen hat.

05.06.2004 - 22:52 Uhr

ok hat sich erledigt. Hab jetzt Windows 2000 installiert. Jetzt funktionierts 😁

05.06.2004 - 22:21 Uhr

Bevor du mit der Klasse arbeiten kannst musst du sie zuerst instanzieren.



using FTPCom;

...
....
private FTPCom.FTPC ftpc;

public void DeinKonstruktor()
{
   ftpc = new FTPC(); // Konstruktor
   
}

im Zip ist eh ein Sample File drin, sihe dir das mal an....

05.06.2004 - 21:33 Uhr

probier mal Babylon aus. Das ist afaik das beste. Kostet aber auch.

Falls du Vokabel brauchst lohnt sich ein Blick auf [url=dict.leo.org[/url]Leo [/url]. Das ist eines der umfangreichsten Wörterbücher im Internet

05.06.2004 - 21:28 Uhr

lol 😁

05.06.2004 - 17:22 Uhr

Hi!

Ich habe die 356 Tage Trial Version des Windows 2003 Servers installiert und auch VS.net 03.
So, jetzt will ich es starten, aber immer kommt ein eine Meldung: Key Expired.
Auch eine Neuinstallation des Studios half nichts.

Vorallem ist es komisch, da es 1. ein originaler Key und 2. es vor ein paar Tagen noch gegangen ist .

Ich werde vielleicht mal Windows 2003 neuinstallieren. Vielleicht bringts ja was

04.06.2004 - 17:27 Uhr

Ja also ich kann wahrscheinlich kommen, kommt halt auf den Termin drauf an 8)

03.06.2004 - 16:43 Uhr

Hallo André,

** Beitrag verschoben nach Windows Forms**

27.05.2004 - 15:48 Uhr

@Code-Hacker:
ja,ok. der link ist ein wenig irrefürhend.
Aber es ist schon wahrscheinlich, dass wenn ein c als Endung ist, da auch zum Großteil c Code drin steht.
Außerdem ist die Wahrscheinlich, dass der Großteil von Windows in C geschrieben wurde, sehr hoch. Aber egal. Who cares? 😉

26.05.2004 - 18:30 Uhr

Also WinXP ist komplett in C geschrieben:
http://www.sysinternals.com/ntw2k/info/xpsrctree.shtml

Jedoch werden Höher Schichten wie etwa DirectX sicher zum Großteil in C++ implementiert sein

24.05.2004 - 19:22 Uhr

Original von Didii
habe jetzt doch Gründe dagegen!!!
mein Projektleiter meinte, GPL iste keine so gute idee!
weiß zwar ned genau warum, aber wahrscheinlich weil die Software verkauft wird.
Weiß wirklich niemand was unter c# direkt????

*verzweifel*

auf der Website steht:

Bottom line In plain English this means you can use this library in commercial closed-source applications.

d.h. du solltest also keine Probleme mit closed-source/komerz. Software haben.....

24.05.2004 - 16:37 Uhr

jo, ich habs mir schon am Samstag runtergeladen und das Spiel ist wirklich toll 👍
mal sehen wie lange ich brauchen werde, um es durchzuspielen 😁

20.05.2004 - 17:33 Uhr

So, weiter gehts mit den....

** Renderstates **

Was ist ein Renderstate? Nun, ein Renderstate beschreibt, wie Direct3D unsere Dreiecke zeichnen soll. Es gibt sehr viele verschiedene Renderstates, daher kann ich jetzt nicht auf alle eingehen(abgesehen davon, könnten wir viele Renderstates mit unserem bisherigen Wissen ohnehin nicht verstehen). Daher will ich mal das grundlegende Konzept der RSs zeigen, damit wir später keine Probleme haben.
Also zuerst mal, beeinflusst ein Renderstate wie ein Dreieck gezeichnet wird. Ein einfacher Renderstate wäre z.B. der FillMode. Der sagt Direct3D, ob unser Dreieck, entweder solid(was der Standard Wert ist und mit dem haben wir auch in den bisherigen Anwendungen gearbeitet), ob nur die Eckpunkte oder nur die Linien gezeichnet werden sollen. Wir können disen RS vor dem Rendern unseres Dreiecks einsetzen:


....
m_Device.RenderState.FillMode = FillMode.WireFrame;

			m_Device.SetStreamSource(0,m_VertexBuffer,0);
			m_Device.DrawPrimitives(PrimitiveType.TriangleStrip,0,1);
....

Mit dem WireFrame Modus werden von unserem Dreieck nur die Linien gezeichnet. Daneben gibt es noch FillMode.Solid, der der Standardwert ist. Und dann gibts noch FillMode.Point, der nur die Eckpunkte zeichnet.(Bemerkung: Wenn wir den DrawPrimitive Aufruf auf m_Device.DrawPrimitives(PrimitiveType.PointList,0,3); abändern, hätte wir den selben Effekt wir mit dem Renderstate FillMode auf Point. )

Natürlich gibt es noch viel mehr RSs als nur FillMode, daher will ich hier noch ein paar vorstellen.

Der nächste ist DitherEnable. Beim Dithering wird da, wo mehrere verschiedene Farben aufeinandertreffen, ein Mittelwert aus diesen berechnet und dieser dann eingesetzt. Auf heutigen Grafikkarten macht es fast keinen Unterschied, ob Dithering eingeschalter ist oder nicht, daher schalten wir es ein:


m_Device.RenderState.DitherEnable = true;

Und noch einer ist das Culling. Das Culling entscheided, welche Objekte sichtbar sind und deshalb gezeichnet werden und welche nicht sichtbar sind und nicht gezeichnet werden.
Direct3D unterstüztt bereits von Haus aus 2 einfache Arten von Culling, die in unseren Beispielanwendungen vollkommen ausreichen werden. Bei Spielen/Grafikdemos würde man natürlich zum Standard Culling noch sein eigenes implementieren.
Direct3D bietet uns das clockwise(CW) culling und das counterclockwise(CCW) culling. Wenn wir unsere Vertices im Uhrzeigersinn anordnen, brauchen wir CCW culling, damit die "unsichtbaren" Vertices wegfallen, wenn unsere Vertices gegen der Uhrzeigersinn angeordnet sind, müssen CW culling verwenden.
Der Standard Wert dieses RS ist CCW. Natürlich können wir das Culling auch komplett abschalten:


m_Device.RenderState.CullMode = Cull.CounterClockwise; // Standard. Unser Dreieck aus dem vorigen Beispiel würde gezeichnet werden
m_Device.RenderState.CullMode = Cull.Clockwise; // CW Culling. Um unser Dreieck jetzt zu zeichnen müssten wir die Elemente 0 und 2 austauschen
m_Device.RenderState.CullMode = Cull.None; // Alles wird gezeichnet. Es ist egal wie wir unsere Vertices anordnen

Gut, das waren mal 3 Renderstate, wir werden jedoch im Laufe des Tutorials noch viele mehr kennen lernen...

19.05.2004 - 18:35 Uhr

gehts auf english auch?
Wenn ja, dann hast du so ein Glossar bereits bei dir installiert: Start -> Programme -> .net Framework v1.1 -> Dokumentation

Da ist alles wichtige zu .net/C# drin, jedoch größtenteils auf Englisch, es gibt aber auch Artiekl auf Deutsch

17.05.2004 - 18:44 Uhr

** Rendern von Dreiecken **

Gut, weiter gehts. Dieses Kapitel wird viele grundlegende Dinge beinhalten, also gut aufpassen. Zunächst wollen wir einmal sehen, wie ein Dreieck aufgebaut ist: Ein Dreieck besteht aus 3 Eckpunkten,die miteinander verbunden werden. Und für jedes Dreieck, dass wir zeichnen wollen, müssen wir diese 3 Eckpunkte definieren. Aber wie müssen wir diese 3 Eckpunkte definieren, damit DirectX sie zeichnen kann? Nun, dass ist relativ einfach: Für Direct3D ist der Bildschirm nichts weiter als ein Koordinatensystem. Wir müssen nur die Koordinaten für die einzelnen Eckpunkte an Direct3D schicken und Direct3D zeichnet uns dann ein Dreieck. Wie ist dieses Koordinatensystem nun aufgebaut? Ich denke mal, dass jeder weis, was ein (karthesisches)Koordinatensystem ist. Für Direct3D exestieren 3 Achsen. Die x Achse, die y Achse und die z Achse. Die x Achse verläuft auf der horizontalen, die y auf der vertikalen. Die z Achse geht in den Bildschirm hinein. Da wir ja jetzt erstmal nur 2D Objekte rendern wollen, brauchen wir uns darum nicht zu kümmern. Zu sagen bleibt hierzu eigentlich nur noch, dass die englische Bezeichnung für Eckpunkt Vertex lautet, im Plural Vertices.
Um solche Vertices zu speichern, bietet uns Direct3D eine ganze Reihe von Strukturen. Diese sind alle im Namespace Microsoft.DirectX.Direct3D.CustomVertex zusammengefasst. In diesem Namespace sind ziemlich viele unterschiedliche Strukturen zum Speichern von Vertices, für uns ist jedoch nur die Struktur CustomVertex.TransformedColored (erstmal) interessant. Das Transformed bedeutet das wir 2D Koordinaten angeben wollen und das Color das wir jeden Eckpunkt eine Farbe zuweisen wollen. Wenn wir jetzt jeden Eckpunkt eine eigene Farbe zuweisen, wird der unmittelbare Bereich zu diesem Eckpunkt mit der Farbe gefärbt. An den Übergängen zwischen den einzelnen Farben, werden die Farben interpoliert. Beim interpolieren wird einfach ein Mittelwert zwischen den einzelnen Farben berechnet und dadurch kommt ein Farbverlauf zwischen den Farben zustande.
Jetzt müssen wir noch wissen, wie wir die Vertices speichern. Dazu müssen wir zunächst mal ein Array von CustomVertex.TransformedColored erstellen und mit unseren Daten befüllen. Dazu fügen wir unserer Klasse aus dem 1. Kapitel eine weitere private Variable verts hinzu:


private CustomVertex.TransformedColored[] verts;

Nun, diese Vertices liegen jetzt aber im Hauptspeicher(dem RAM). Wenn wir nun unser Dreieck rendern wollen, muss Direct3D diese erst über den AG Port(bzw. PCI Port) zur Grafikkarte transportieren. Bei ein paar Vertices, wird sich das sicher nicht bemerkbar machen, aber wenn wir jetzt mehrere tausend Vertices haben? Deshalb wäre es ja von Vorteil, wenn die Vertices direkt auf dem Speicher der Grafikkarte liegen würden.(Video RAM) Der Vorteil des Video RAM ist, dass er eine extrem kurze Zugriffszeit hat und das wir nicht bei jedem Rendervorgang, die Daten über den AG Port transportieren müssen. Ein Nachteil ist jedoch, dass der Video RAM von der Größe her relativ begrenzt ist und teuer ist. Aber darum müssen wir uns nicht kümmern. Also wir speichern wir jetzt unsere Vertices im Video RAM? Ganz einfach: Mit einem VertexBuffer. Ein VertexBuffer ist nichts anderes als ein Speicherbereich im Video RAM, der unsere Vertices hält. Ein VertexBuffer wird durch die Klasse Direct3D.VertexBuffer repräsentiert.


private VertexBuffer m_VertexBuffer;

Nun müssen wir unserer Vertices noch definieren und nebenbei den VertexBuffer mit diesen Daten befüllen. Zuerst definieren wir die Vertices:


verts = new CustomVertex.TransformedColored[3];

			verts[0].X=150;verts[0].Y=50;verts[0].Z=0.5f; verts[0].Rhw=1;verts[0].Color = Color.Yellow.ToArgb();
			verts[1].X=250;verts[1].Y=250;verts[1].Z=0.5f; verts[1].Rhw=1;verts[1].Color = Color.Bisque.ToArgb();
			verts[2].X=50;verts[2].Y=250;verts[2].Z=0.5f; verts[2].Rhw=1; ;verts[2].Color = Color.White.ToArgb();

Wir sehen also, dass wir jedem Vertex eine X Koordinate, eine Y Koordinate, eine Z Koordinate und eine Farbe zuweisen. Wie gesagt, müssen wir uns eigentlich nicht um die Z Koordinate kümmern, jedoch habe ich sie auf 0.5 gesetzt, da ein 0.0 bei manchen(älteren) Grafikkarten zu Problemen führen könnte.
Nun erstellen wir den VertexBuffer und zwar mit den folgenden Konstruktor:

public VertexBuffer(
Type typeVertexType,
int numVerts,
Device device,
Usage usage,
VertexFormats vertexFormat,
Pool pool
);

Der erste Parameter bestimmt, welchen VertexType wir für unseren VertexBuffer verwenden wollen. Hier setzen wir einfach typeof(CustomVertex.TransformedColored) ein.
Der zweite Parameter bestimmt die Anzahl der Vertices, die wir in unserem VertexBuffer speichern wollen. Da wir nur ein Dreieck speichern wollen, setzen wir hier eine 3 ein.
Der vierte Parameter bestimmt das Device, in welchem Kontext der VertexBuffer erstellt werden soll: m_Device.
Der fünfte Parameter bietet uns einen Satz von Konstanten an, die bestimmen, wie der VertexBuffer intern aufgebaut ist. Hier setzen wir Usage.WriteOnly ein, das besagt, das wir nur in den VertexBuffer schreiben wollen, ihn jedoch nicht auslesen(das kann zu kleineren Performancegewinnen führen)
Der vorletze Parameter ist das VertexFormat: CustomVertex.TransformedColored.Format
Der letzte Parameter bestimmt schließlich, wo wir unseren VertexBuffer speichern wollen. Hier können wir Pool.Default einsetzen, was besagt, dass Direct3D die Vertices einfach in den Video RAM plaziert. Pool.Managed übergibt die Kontrolle des VertexBuffers an den Grafikkartentreiber. Der kann dann z.B., wenn der Platz auf dem Video RAM knapp wird, unsere Vertices wieder in den RAM verschieben. Pool.SystemMemory besagt schlieslich, dass wir unsere Vertices im System RAM plazieren wollen, was die Vorteile eines VertexBuffers jedoch wieder zunichte macht.
In der Praxis sieht das nun so aus:


m_VertexBuffer = new VertexBuffer(typeof(CustomVertex.TransformedColored), 3, m_Device, Usage.WriteOnly, CustomVertex.TransformedColored.Format, Pool.Default);

Nun müssen wir unsere Vertices noch in den VertexBuffer hineinschreiben. Dazu müssen wir ihn zuerst sperren(locken), um sicherzustellen, dass während unseres Schreibvorgangs niemand anders auf den Buffer zugreift. Dann schreiben wir unsere Daten in den VertexBuffer und schlieslich entsperren wir ihne wieder(unlocken).Das ganze sieht so aus:


GraphicsStream stream = m_VertexBuffer.Lock(0,0,0);
			
			stream.Write(verts);
			m_VertexBuffer.Unlock();

Der Code bedarf eigentlich keiner großartigen Erklärungen, außer das die Parameter von Lock angeben, dass wir den ganzen VertexBuffer sperren wollen.
Nun kommen wir zum rendern.
Bevor wir unser Dreieck renden können, müssen wir unserem Device noch sagen, in welchem Format(CustomVertex.xxx) unsere Vertices gespeichert sind:


m_Device.VertexFormat = CustomVertex.TransformedColored.Format;

Jetzt haben wir zwei Möglichkeiten. Entweder wir rendern direkt aus dem SystemMemory heraus(unser Array verts liegt ja immer noch da drinnen) oder wir rendern vom VertexBuffer heraus. Ich zeig zuerst mal die Variante aus dem Systemmory, dazu nutzen wir die Funktion Device.


public void DrawUserPrimitives(
    PrimitiveType primitiveType,
    int primitiveCount,
    object vertexStreamZeroData
);

Der erste Parameter bestimmt den Primitive Type. Hier können wir entweder Punkte, Linien oder Dreiecke einsetzen.(Ein Primitiv ist nichts anderes als ein Punkt,Linie oder Dreieck) Wir setzen natürlich PrimitiveType.TriangleStrip ein. Es gibt mehrere Varianten von jedem Primitiv, TriangleSrip besagt, das wir, falls wir evtl. mehrere Dreiecke haben, die Dreiecke in einem Band miteinander verbunden gerendert werden.
Der nächste Parameter bestimmt die Anzahl der Primitive, die gezeichnet werden soll. Wir können unser verts Array z.B. mit 6 Elementen befüllen, um dann zwei Dreiecke zu zeichnen. Da wir aber nur ein Dreieck zeichnen wollen, setzen wir hier eine 1 ein.
Der letze Parameter bestimmt nun das Array, in dem unsere Vertices liegen: verts
Also hier der Code:


m_Device.DrawUserPrimitives(PrimitiveType.TriangleStrip,1,verts);

Nun kommen wir zur Methode mit den VertexBuffer. Bevor wir aus einem VertexBuffer heraus rendern können, müssen wir unserem Device sagen, aus welchem wir überhaupt rendern wollen(ja, wir können mehrere VertexBuffer haben...). Dazu nutzen wir die Funktion Device.SetStreamSource


m_Device.SetStreamSource(0,m_VertexBuffer,0);

Der erste Parameter bestimmt welchen Kanal(Vertex Stream) wir nutzen wollen. Einfach 0 einsetzen, denn das ist der 1. Vertex Kanal, auf dem die Vertices fließen.
Der zweite Parameter bestimmt jenden VertexBuffer, von dem die Daten kommen sollen.
Der letzte Parameter gibt den Offset vom Beginn des Streams bis zu den ersten Vertex Daten an. Hier setzen wir einfach wieder 0 ein.
Nun steht uns nichts mehr im Wege, aus dem VertexBuffer zu rendern. Und das machen wir via Device.DrawPrimitives.


m_Device.DrawPrimitives(PrimitiveType.TriangleStrip,0,1);

Die Parameter unterscheiden sich nicht allzu sehr von den Parametern von DrawUserPrimitives, bis auf 2., der den Start Vertex angibt, also den Vertex, ab dem gerendert werden soll(einfach 0). Der Letzte gibt wieder an, wie viele Primitive wir zeichnen wollen.

Dieses Kapitel war jetzt schon länger als das vorangehende. Zum Schluss nochmal der gesamte Code, wie immer gibts auch die Visual Studio .net 2003 Projektdateien zum Download:


using System;
using System.Drawing;
using System.Windows.Forms;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

namespace MDXTutorial02
{
	
	public class MDXSampleApp : System.Windows.Forms.Form
	{
		private Device m_Device;
		private VertexBuffer m_VertexBuffer;
		private CustomVertex.TransformedColored[] verts;
		

		// ctor
		// do nothing...
		public MDXSampleApp()
		{
		}

		// dtor
		~MDXSampleApp()
		{
		}

		public void InitGfx()
		{
			try
			{
				this.ClientSize = new Size(800,600);
				this.Text = "Direct3D Tutorial 2: Rendering colored Vertices";

				this.KeyPress += new KeyPressEventHandler(OnKeyPress);

				PresentParameters pp = new PresentParameters();

				pp.Windowed = true;
				pp.SwapEffect = SwapEffect.Copy;
				
				
				m_Device = new Device(Manager.Adapters.Default.Adapter,DeviceType.Hardware,this,CreateFlags.	HardwareVertexProcessing,
					pp);
				CreateVertexBuffer();

				
				
			
			}
			catch(DirectXException e)
			{
				MessageBox.Show(e.Message);
				
			}
		}

		private void CreateVertexBuffer()
		{
		
			verts = new CustomVertex.TransformedColored[3];

			verts[0].X=150;verts[0].Y=50;verts[0].Z=0.5f; verts[0].Rhw=1;verts[0].Color = Color.Yellow.ToArgb();
			verts[1].X=250;verts[1].Y=250;verts[1].Z=0.5f; verts[1].Rhw=1;verts[1].Color = Color.Bisque.ToArgb();
			verts[2].X=50;verts[2].Y=250;verts[2].Z=0.5f; verts[2].Rhw=1; ;verts[2].Color = Color.White.ToArgb();

			m_VertexBuffer = new VertexBuffer(typeof(CustomVertex.TransformedColored), 3, m_Device, Usage.WriteOnly, CustomVertex.TransformedColored.Format, Pool.Default);

			GraphicsStream stream = m_VertexBuffer.Lock(0,0,0);
			
			stream.Write(verts);
			m_VertexBuffer.Unlock();
		}

	
		public void Render()
		{
			

			m_Device.Clear(ClearFlags.Target ,Color.Blue,0.0f,0);
			
			m_Device.BeginScene();
			
			m_Device.VertexFormat = CustomVertex.TransformedColored.Format;

			m_Device.SetStreamSource(0,m_VertexBuffer,0);
			m_Device.DrawPrimitives(PrimitiveType.TriangleStrip,0,1);
		    //m_Device.DrawUserPrimitives(PrimitiveType.TriangleStrip,1,verts);
			
			m_Device.EndScene();
			m_Device.Present();

		}

		public void Shutdown()
		{
			m_Device.Dispose();
		}

		

	
		/// <summary>
		/// Der Haupteinstiegspunkt für die Anwendung.
		/// </summary>
		[STAThread]
		static void Main() 
		{
			MDXSampleApp example = new MDXSampleApp();
			example.InitGfx();
			example.Show();

			while(example.Created)
			{
				example.Render();
				Application.DoEvents();
			}
			example.Shutdown();

		}

		private void OnKeyPress(object sender, KeyPressEventArgs e)
		{
			if((int)e.KeyChar == (int)Keys.Escape)	
				this.Close();
			
		}
	}
}

14.05.2004 - 15:24 Uhr

Original von Code-Hacker

Wie das mit diesem intregrierten Assembler funktioniert weiß ich nicht, habe mich nie näher mit der Sprache beschäftigt. Aber wie du sagtest, so glaube ich auch das man sie nicht braucht. Wäre imho eher mal etwas für die Freizeit, aber wenn ich Assembler brauche programmiere ich Assembler und wenn ich C oder C+ brauche dann dies.

würde ich nicht so sagen. Der integrierte Assembler von C++(Unter VC++ 7.1 den Assemblercode einfach in einen _asm{ } Block schreiben) ist doch recht nützlich.

So muss man nicht einen extra Assembler aufrufen, wenn mal man Assemblermodule in C++ einbinden will.

13.05.2004 - 15:57 Uhr

Original von Code-Hacker

Kennt jemand von euch C--? Das ist C mit einem integrierten Assembler. Damit wurde sogar bereits ein OS entwickelt. Einfach bei google nach C-- suchen und ihr solltet fündig werden.

mit C/C++ kann man ja schon von Haus aus direkt Assembler Code schreiben...
Dazu braucht man ja kein neues C

btw: bei Google hab ich nur Links zu C gefunden, wenn ich C-- eingebe....

11.05.2004 - 18:18 Uhr

** Verschoben nach Netzwerkprogrammierung **

Sieh dir mal die Klasse System.Net.WebClient an...

10.05.2004 - 16:09 Uhr

gut. Habs jetzt rausgehauen. Hoffe es passt so...

10.05.2004 - 15:54 Uhr

Original von r00t
gehst du auch auf surfaces ein?

lass dich mal überachen 😁
im nächsten Teil geht es um 2D Zeichenoperationen(bevor wir zum 3D kommen...)

EDIT: am Wochenende wird es weitergehen. Vorraussichtlicher Termin ist entweder Samstag/Sonntag(unter der Woche hab ich keine Zeit was zu schreiben sry)

10.05.2004 - 15:08 Uhr

bin 89 geboren und gehe noch zu Schule....
also nichts aufregendes 😉

10.05.2004 - 15:07 Uhr

Original von r00t
super idee danke 😉

vielleicht kann ich ja was dazu lernen g

wieivele parts planst du?

danke.

ich denke mal das ich die Basics mache und dann entscheide, ob ich dann noch mehr mache oder nicht.
Der nächste Teil kommt entweder heute oder morgen...

09.05.2004 - 17:12 Uhr

Ab sofort ist die neueste Version des Tutorials hier zu erreichen.

Hi!

weil hier immer wieder mal nach DirectX Tutorials gefragt wird, hab ich einfach mich mal dazu entschlossen eins zu schreiben. Um das hier zu verstehen braucht man keine besondere Erfahrung mit C#. Aber man sollte schon sicher mit C# umgehen können und auch mit WindowsForms sollte man schon ein wenig gearbeitet haben. Feedback etc. sind natürlich erwünscht. Der Sourcecode dieses Tutorials ist am Schluss als Zip angehängt.

** DirectX: Eine Einführung **

DirectX wurde 1995 erstmals von Microsoft unter dem Namen The Games SDK(oder so...) vorgestellt. Davor war(zu DOS Zeiten) musste man umständlich auf Assembler zurückgreifen, wenn man irgendwas mit Grafik machen wollte. DirectX vereinfachte dies extrem und wurde von Version zu Version immer weiter entwickelt und auch immer besser. Derzeit stehen wir bei Version DirectX 9. DirectX ist eigentlich eine Sammlung von mehreren APIs. Diese sind DirectInput um Daten von Tastaturen,Mäuse,Joysticks etc. zu empfangen und verarbeiten, DirectSound/Music um Sounds/Musik zu spielen, DirectPlay um Netzwerkprogramme wie Multiplayer Spiele zu schreiben, DirectShow um Videos abzuspielen und zu guter Letzt Direct3D um auf dem Bildschirm zu zeichnen. Daneben gibt es noch DirectDraw, mit dem man ausschließlich 2D Objekte zeichnen kann(mit Direct3D kann man sowohl 3D als auch 2D Objekte zeichnen) und DirectSetup, ein Setup Generationsprogramm spez. für DirectX Applikationen.
Dieses Tutorial befasst sich also nicht mit dem gesamten DirectX Multimedia Packet, sondern "nur" mit Direct3D. Es muss natürlich gesagt werden, dass jeder Unterbereich von DirectX schon allein ziemlich groß ist. So, nun wollen wir mal sehen, welche Möglichkeiten uns Direct3D bietet. Ebenso werden die nächsten Kapitel ziemlich Theorie beinhalten, mit nur relativ wenig Code. Aber durchhalten. Wir werden bald zu unseren ersten Zeichenoperationen kommen...

** Direct3D: A closer look **

Voll DirectX 9 kompatibel.
Damit wird seit längerer Zeit von vielen Grafikkartenherstellern geworben. Die Grafikkartenhersteller meinen damit natürlich Direct3D.(DirectInput auf der Grafikkarte? ^^) Aber was macht Direct3D eigentlich genau? Direct3D bietet uns die Möglichkeit auf dem Bildschirm Objekte zu zeichnen. Denkt einfach mal an ein Spiel wie Far Cry. Der ganze tolle Dschungel dort wird mit Direct3D gezeichnet.(achja, wir haben noch einen langen Weg vor uns, bis wir sowas wie Far Cry machen können). Aber wie sind diese Objekte jetzt aufgebaut? Die Antwort ist einfach: Aus Dreiecken. Denn aus Dreiecken kann man jedes beliebige Objekt zusammenstellen. Nehmt einfach einen Zettel und malt ein Rechteck drauf. Wie ihr vielleicht sehen könnt, besteht ein Rechteck aus zwei sich gegenüberliegenen rechtwinkeligen Dreiecken. Eine solche Aufteilung in Dreiecken lässt sich praktisch bei jedem Objekt machen. D.h. wir können also Dreiecke mit Direct3D zeichen.(man kann aber auch Punkte und Linien zeichnen, aber am öftesten verwendet man Dreieckte). Aber Direct3D kann noch mehr. Es kann diese Dreiecke nun texturieren. Normalerweise kann man einem Dreieck nur eine Farbe zuweisen(blau,gelb,rot....), aber das ist natürlich langweilig. Deshalb erfand man eine Technik namens Texturieren. D.h. das man einfach ein Bild über das Dreieck legt. Damit sehen Objekte viel realitätsnäher aus. Desweiteren kann man mit Direct3D auch Licht erzeugen.(Lights) Das ist allerdings ziemlich komplex, daher werden wir das erst später besprechen. Zum Schluss kann Direct3D Dreiecke noch verschieben,vergrößern und verkleinern. Aber das werden wir auch noch später genauer kennen lernen.
so, jetzt haben wir uns mal einen groben Überblick über Direct3D verschafft. Jetzt können wir näher auf die einzelnen Bereiche eingehen. Zuerst sehen wir mal, wie wir Direct3D dazu bringen, dass es uns erlaubt irgendwas zu zeichnen.

** Direct3D: Erste Schritte **

Überlegen wir uns erstmal, was wir in diesem Kapitel erreichen wollen. Wir wollen ganz einfach ein Fenster erzeugen, das Blau(oder in irgendeiner anderen Farbe) gefärbt ist. Das ist sozusagen das "Hello World" von DirectX.
Was braucht man dazu? Ich sage mal ganz einfach, dass man mit einer IDE arbeiten sollte. Warum? Weil es das Leben vereinfacht. Ich selbst nutze VS.net 2003. Als nächstes braucht man halt die Standardtools, um mit C# zu programmieren. Zu guter Letzt braucht man noch das so genannte DirectX SDK. Das beinhaltet alles, was man braucht um mit DirectX zu programmieren. Nachdem das SDK installiert wurde, können wir weitermachen.(irgendwie logisch...).
Zunächst referenzieren wir auf folgende DLLs: System.dll,System.Drawing.dll,System.Windows.Forms.dll,Microsoft.DirectX.dll,Microsoft.DirectX.Direct3D.dll Microsoft.DirectX.Direct3DX.dll.
Nun binden wir folgende Namespaces ein, die eigentlich selbsterklärend sind:


using System;
using System.Drawing;
using System.Windows.Forms;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

Für unsere erste DirectX Anwendung brauchen wir nur eine einzige Membervariable. Das DirectX Device(Microsoft.DirectX.Direct3D.Device m_Device). Ein Device ist die elementare Grundverbindung zwischen unserer Anwendung und Direct3D. Mit einem Device können wir alle oben genannten Dinge machen. Nun implementieren wir eine Funktion InitGfx(), die uns das Device erstellt.
Die ersten Zeilen dieser Funktion sollten kein Problem darstellen:


public void InitGfx()
{
	try
	{
		this.ClientSize = new Size(1024,768);
		this.Text = "Direct3D Tutorial 1";

		this.KeyPress += new KeyPressEventHandler(OnKeyPress);

Nun kommen wir zum interessanten Teil: Die PresentParameter. Diese werden wir später zum erstellen des Devices benötige. Zuerst mal der Code:


PresentParameters pp = new PresentParameters();

pp.Windowed = true;
pp.SwapEffect = SwapEffect.Copy;

Die PresentParamter(Präsentations Parameter) bestimmen also wie sich das Device grundlegend verhalten soll.(es gibt noch mehr, aber in unserem Fall reichen diese aus). Für unsere Applikation brauchen wir zunächst nur diese beiden Parameter. Der erste Paramter zeigt an, das wir eine Fensteranwendung haben wollen. Der Zweite gibt an, wie wir die Bilder auf den Bildschirm bringen wollen. Copy bedeutet einfach, dass wir immer den gesamten Bildschirm neuzeichnen wollen.
Nun geht daran, das Device zu erstellen:


m_Device = new Device(Manager.Adapters.Default.Adapter,DeviceType.Hardware,this,CreateFlags.HardwareVertexProcessing,
										pp);

ok. Gehen wir Parameter für Parameter durch:
Manager.Adapters.Default.Adapter: Gibt an, auf welchem Adapter(=Bildschirm) wir zeichnen wollen. Normalerweise haben die meisten Systeme einen Bildschirm. Und diesen Bildschirm repräsentiert Manager.Adapters.Default.Adapter.
DeviceType.Hardware: Das bedeutet, das für alle möglichen Operationen von Direct3D die Grafikhardware verwendet wird. Man kann auch bestimmen, das das die CPU(Software) machen soll, was aber ziemlich langsam ist.
this: Zeigt einfach an, das das Devie einfach dieses Fenster zum zeichnen verwenden soll.
CreateFlags.HardwareVertexProcessing: Besagt ebenfalls grundsätzlich das selbe wie DeviceType.Hardware, aber ist trotzdem ein wenig anders, außerdem gibts da noch ein paar andere Paramter, die aber für uns(derzeit) nicht interessant sind. Ich werde später noch genauer darauf eingehen.
pp: Zeigt auf die ausgefüllte PresentParameters Struktur.

Und jetzt noch der Abschluss der Funktion:


}
			catch(DirectXException e)
			{
				MessageBox.Show(e.Message);
			}
		}

Gut. Nun kommen wir zum Zeichnen. Das wird als Rendern bezeichnet. Deshalb implementieren wir einfach mal eine Funktion namens Render.


public void Render()
		{
			m_Device.Clear(ClearFlags.Target ,Color.Blue,0.0f,0);
			m_Device.BeginScene();
                             // rendern
			m_Device.EndScene();
			m_Device.Present();

		}

Der erste Funktionsaufruf ist nicht sonderlich interessant(derzeit...) und besagt, dass das Fenster(Target) mit einem blauen Hintergrund gerendert werden soll.
Danach kommen wir zum eigentlichen rendern. Das rendern geschieht immer zwischen einem BeginScene und einem EndScene. Doch das werden wir später auch noch genauer besprechen. Das Present veranlsst Direct3D nun, alles auch wirkich zu rendern.
Nun brauchen wir noch eine Funktion, die Direct3D herunterfährt und noch die Main Funktion. Schließlich implementieren wir noch die OnKeyPress Funktion...


public void Shutdown()
		{
			m_Device.Dispose();
		}

		

	
		/// <summary>
		/// Der Haupteinstiegspunkt für die Anwendung.
		/// </summary>
		[STAThread]
		static void Main() 
		{
			MDXSampleApp example = new MDXSampleApp();
			example.InitGfx();
			example.Show();

			while(example.Created)
			{
				example.Render();
				Application.DoEvents();
			}
			example.Shutdown();

		}

		private void OnKeyPress(object sender, KeyPressEventArgs e)
		{
			if((int)e.KeyChar == (int)Keys.Escape)	
				this.Close();
		}

Hier jetzt der gesamte Source: (insgesamt rund 100 Zeilen)


using System;
using System.Drawing;
using System.Windows.Forms;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

namespace MDXTutorial01
{
	/// <summary>
	/// Zusammenfassung für Form1.
	/// </summary>
	public class MDXSampleApp : System.Windows.Forms.Form
	{
		private Device m_Device;


		// ctor
		// do nothing...
		public MDXSampleApp()
		{
			
		}

		// dtor
		// shutdown D3D
		 ~MDXSampleApp()
		{
			
			 
		}

		public void InitGfx()
		{
			try
			{
				this.ClientSize = new Size(1024,768);
				this.Text = "Direct3D Tutorial 1";

				this.KeyPress += new KeyPressEventHandler(OnKeyPress);

				PresentParameters pp = new PresentParameters();

				pp.Windowed = true;
				pp.SwapEffect = SwapEffect.Copy;
				
				m_Device = new Device(Manager.Adapters.Default.Adapter,DeviceType.Hardware,this,CreateFlags.HardwareVertexProcessing,
										pp);

			}
			catch(DirectXException e)
			{
				MessageBox.Show(e.Message);
			}
		}
		public void Render()
		{
			m_Device.Clear(ClearFlags.Target ,Color.Blue,0.0f,0);
			m_Device.BeginScene();
			m_Device.EndScene();
			m_Device.Present();

		}

		public void Shutdown()
		{
			m_Device.Dispose();
		}

		

	
		/// <summary>
		/// Der Haupteinstiegspunkt für die Anwendung.
		/// </summary>
		[STAThread]
		static void Main() 
		{
			MDXSampleApp example = new MDXSampleApp();
			example.InitGfx();
			example.Show();

			while(example.Created)
			{
				example.Render();
				Application.DoEvents();
			}
			example.Shutdown();

		}

		private void OnKeyPress(object sender, KeyPressEventArgs e)
		{
			if((int)e.KeyChar == (int)Keys.Escape)	
				this.Close();
		}
	}
}

So, das wars. Im nächsten Teil werden wir genauer aufs Rendern und auch auf den Fullscreen Modus zum sprechen kommen.

06.05.2004 - 18:16 Uhr

Hi!

mal sehen obs was taugt. Mir haben die frühen Versionen von #Develop schon sehr gut gefallen. Ist schlanker als das VS.net und lädt auch schneller

06.05.2004 - 14:44 Uhr

Ich programmiere C,C++,C#,Assembler und PHP.

@Franknstein
Ja, es gibt noch mehr Fachinformatiker hier, bin nämlich auch einer ;o)

mich kann man zwar streng genommen nicht als Fachinformatiker bezeichnen, aber ich bin für die nächsten 5 Jahre schon auf der folgenden Schule aufgenommen, die sich auf Programmieren spez. hat.(Zweig EDV und Organisation)
http://www.htl-vil.ac.at/

Ich geh derzeit zwar noch auf ein Gymnasium(oh, wie ich diese Schule hasse), aber ich hab schon ne fixe Zusage für das nächste Schuljahr 😉