Finde ich aber gerade für unser Game-SDK recht vorteilhaft, da man für die Spiele z.b. Hacks und Cheats zumindest erschweren kann.

Das sind dann aber keine "unerklärliche undefinierte Fehler".

Das Fenster wird weiß, es erscheint ein ähnliches Fenster wie dem angehängten Bild und das im DEBUGMODE von VS, trotz gesetzter try-catch um die kritischen Stellen !!!

Dann Virtualisierung des Systems, bzw. ist es eventuell sogar nen Thin Client? Dann läuft dein Programm nicht mal auf der Hardware wo du vorsitzt

Nein ist es nicht. Es existiert ein Anmeldeprogramm, dass nach Anmeldung des "normalen" Benutzers ausgeführt wird. Darin werden Name und Password des Studenten abgefragt und dann die entsprechenden Netzlaufwerke auf den Rechner gemappt. Das war dann aber auch schon alles.

Man Arbeitet jedesmal mit dem angemeldeten Windows-Konto (also z.b. PoolRechnerXY)

Möglicherweise liegt's auch an der Größe des Grafikspeichers

Beträgt auf allen Rechnern 1GB, auf meinem Entwicklungsrechner zu hause sogar nur 512 MB

Ich würde da eher auf Treiberfehler bei den einem Rechner tippen

Glaube ich ehrlichgesagt nicht, da da auch riesige CAD-Programme für unsere Ingenieure drauf laufen und mit viel Glück schafft er sogar 3DS Max

ob dedizierte, onboard oder gar in der CPU integrierte GPU ist für das OS doch völlig transparent und belanglos. [...] Fehler gibts wenn man von der Grafikkarte nicht unterstützte Funktionen benutzen möchte, aber das ist wiederum völlig unabhängig davon wie die Grafikkarte verbaut ist.

Mag sein, bezüglich des Fehlers ist es aber Hardwarebezgen. Auf meinem Heimrechner klappt das Programm wunderbar, auf dem Laptop auch (beide mit Grafikkarte), nur bei den Unirechnern gibt es sobald ich eine bestimmte Funktion aufrufe immer einen Totalabsturz. Alle getesteten Rechner halten eine ATI Grafikkarte mit OpenGL 3.0 support. Zudem verwende ich KEINE speziellen Extensions, sondern nur Vertex Arrays in einer üblichen Renderingschleife.

Wie gesagt, auf den Rechnern mit Karte läuft es wunderbar.

So viel ich weiss steht da auch nur das Modell drin, was eine Recherche bei Gogle trotzdem nicht erspart.

Moin,

ich bekomme in bestimmten Teilen meiner Anwendung aber nur auf bestimmten Rechnern einen Fehler, der selbst den Debugmode sprengt, also mit der Standardkernelmeldung und dem berühmten "An Microsoft senden" Dialog das Programm unsanft beendet.

Gibts ne Möglichkeit da irgendwie herauszufinden, was genau da jetzt schief geht?

Moin,

gibts eigentlich ne Möglichkeit herauszufinden, ob es sich bei einer Grafikeinheit um eine Karte oder einen OnBoard Chip handelt, ohne jedes mal bei den Hertellern zu suchen?

Ich treste momentan ein zwei sachen auf verschiedenen zum Teil öffentlichen Rechnern. Zum Teil klappt das, zum Teil gibt es aber auch unerklärliche undefinierte Fehler, gerade bei den öffentlichen Rechnern, wobei ich dort vermute, dass das daran liegt dass dort einfache Grafikchips verbaut sind. Das ist jedoch allein durch die Specifikation nur mit Rechercheaufwand herauszufinden.

Moin,

ich habe oben genanntes Problem in meiner OpenGL Anwendung. Der C ode Sieht folgendermaßen aus:

aObj.BeginArray(CapabilitieFlag.VertexArray);
            aObj.BeginArray(CapabilitieFlag.TextureCoordArray);

            aObj.PushArray(0, sizeof(float) * 3, vertices);
            aObj.PushArray(1, sizeof(float) * 2, texCoords);
            
            obj.BeginList();
            aObj.PopArray(ArrayPopMode.DrawArrays, new object[]{BeginMode.TriangleStrip, 0, vertices.Length});
            obj.EndList();

            aObj.EndArray();
            aObj.EndArray();

Wobei die BeginMethoden jeweils glEnableClientState aufrufen (wie es in den Tutorials vorgegeben ist), Push jeweils ein übergebens Datenarray in ein float[]-Array umwandelt und daraus einen IntPtr-Pointer erzeugt und die Pop-Methode ruft dann in diesem Fall glDrawArrays mit den übergebenen Parametern auf.

Mit nur einem VertexArray klappt das Ganze wunderbar, sobald ich aber das TextureArray dazuschalte wirft mir die glDrawArrays Methode eine AccessViolationException.

BeginList und EndList erzeugen übrigens eine DisplayList, in die glDrawArrays reinzeichnen soll. Wie gesagt, ohne Texturkoordinaten klappt alles wunderbar, die brauche ich allerdings unbedingt.

Kann es daran liegen, dass die Texturkoordinaten falsch gelegt sind (also statt 0.0f - 1.0f bis X.Xf gehen), was ich mir allerdings nicht vorstellen kann?

Warum gibt es denn so eine Funktion nicht schon ab 2.0 schon Standardmässig, da man sowas ja doch gerade in Bibliotheken doch schon häufiger braucht?

Moin,

gibts ne Möglichkeit einen kombinierten Enumerationswert

ColorFlgas flag = ColorFlags.Red | ColorFlags.Blue;

zu Zerlegen, villeicht auch so, dass jeder verwendete Enumerationswert abgerufen werden kann?

Du stellst da eine merkwürdige Frage, denn im Endeffekt musst du das selbst wissen

Wenn ichs wüsste, hätte ich die Frage ja nicht gestellt 😜

Kennst du denn eine passable Antwort (mit einer Begründung!)?

ja kann es. Findet man in den Beispielen des DX-SDK ab Version 9c

Mit anderer Textur sieht das Ganze schon besser aus.
Bitte nicht an den Portalen stören.

Moin,

ich arbeite gerade an einem Editor für unser Spiel und habe mir daher die Frage gestellt: Wie Groß ist eigentlich die Abmessung einer solchen OpenWorld-Zelle in floating Points?

Ich möchte die Map gerne "in einem Stück" gießen, das bedeutet, dass ich die gesammte Map in Zellen zerteile und diese Zellen dann wiederum in 8 bis mehr weitere kleinere Zellen zerlege, sodass ich mit Hilfe von intelligentem Clipping immer nur 1- max 3 solcher kleinen Teilzellen rendern muss.

Wie groß sollten die Zellen für ein Rollenspiel (a la Oblivion etc.) in floating-Points ungefähr sein, wenn 1 Pixel meiner Heightmap 1.0f entsprechen?

Sind diese Abmessungen optimal oder welchen Faktor (Pixel zu OpenGL-Einheit) sollte ich stattdessen verwenden?

Danke für die Antwort. Sicherlich habe ich die Texturkoordinaten so berechnet, dass die obere linke Ecke die Koordinaten 0,0 und die untere rechte Ecke 1,1 hat und dazwischen eben (1.0f / size) * size.

Ich habe gerade allerdings gesehen, dass die Textur an der entsprechenden Stelle ebenfalls schon Streifig ist. Also liegt es an der schlechten Texturqualität an sich.

Ich betrachte das Ganze mal aus einem naiveren Blickwinkel, was ist denn, wenn du einfach die WinForm-Events für MouseClick, Move etc. dahernimmst und ainfach immer den Ursprung entsprechend verschiebst?

So nach dem Muster

glTranslate(MouseX,0,MouseY);

(OpenGL Quellcode)

Natürlich nicht direkt mit den Mauskoordinaten, da das viel zu empfindlich wäre.

Moin,

giebt es eine Möglichkeit die Texturgenauigkeit in OpenGL zu erhöhen, ohne die Größe der Textur zu verändern?

Wie auf dem Screenshot zu sehen "zieht" sich die Textur doch arg am unteren Gebirgsrand, sodass starke Verstreifung entsteht.

Die Map wird mit einer TriangleStrip gezeichnet und die Dreiecke haben jeweils einen Abstand von 1 floating-Einheiten. Das Gebiet an sich misst 256x und die Textur 512x

Wäre für jegliche Hilfe, die das Resultat optisch verbessern sehr dankbar.

Neue Version:

Fertiggestellter ScriptProzessor interpätiert binäres Assembly in eine ausführbare Strucktur

Erzeugen von Handles wurde gefixt

Bugreports ausdrücklich erwünscht

Ist der Launcher eine .NET-Assembly?
Dann solltest du über die Assembly.GetEntryAssembly-Methode (System.Reflection) rankommen.

Ich rufe die Anwendung mit Process.Create() auf, da gibts glaub ich keinen Verweis auf mein Assembly

Moin,

weiß jemand wie man den aufrufenden Prozess eines Assemnly ermittelt? Ich möchte gerne ein Programm schreiben, dass nur von einem Launcher gestartet werden kann, aber als eigenständiges ausführbares Assembly auf der Platte existieren soll.

Hallo,

ich hab mal ne Frage und zwar, funktioniert das nur mit "echten" Controls oder geht das auch mit selbst erstellten OpenGL Controls, die von einem Grafikkontext gerendert und durch Image und Font objekte erzeugt werden, aber nicht von System.Control abgeleitet sind?

Hallo,

am besten wäre wohl die Option es selbst zu machen. Schaut euch mal das OpenTK an, die haben soweit ich weiß auch beispiele für OpenGL in WPF anwendungen.

Wenn du ein natives (also C/C++) SDK findest, kannst du dir natürlich auch einen Wrapper für C# bauen.

Auch wenn ich es persöhnlich nicht mag, schau dir doch mal das DirectX SDK an, villeicht findest du da schon einen integrierten/drumherumgebauten loader für dein Dateiformat. DirectX bietet in der Hinsicht von Haus aus schon sehr viel, soweit ich weiß.

Gelöst mit nur einem Eingabevektor als Parameter.

Hier das Beispielprojekt. Für den Zerlegevorgang werden Tokens aus der Gruppe Compiler verwendet, für den Nachbearbeitungsvorgang Tokens aus der Gruppe PostCompiler.

Tokens mit der Eigenschaft NoParse werden beim Parservorgang zwar berücksichtigt, aber nicht aufgeführt.

Und hier ein Screenshot mit geöffnetem Call-To-Call Baum

Moin,

unser neuestes Projekt ist ein altes Projekt in neuer Verpackung. Dabei handelt es sich um eine art "Compiler", der eine beliebig definierte Scriptsprache in ein unter C# verwend- und manupulierbares Konstruckt umwandelt, das im gleichen oder einem anderen Thread ausgeführt werden kann.

Definition beliebig definierbare Scriptsprache

Unter dieser Definition, die ich hier verwende, versteht man zur Laufzeit interprätierten Programmcode, dessen Zusammensetzung in Syntax und Funktionsumfang vom Anwender definiert wird.

Funktionsumfang

Der Funktionsumfang beinhaltet neben der definierbaren Sprache auch einige Methoden zur Kompilierung in ein binäres Assembly, sowie zum laden eines geeigneten Assembly in die Laufzeitumgebung.

Umfang des Customising

Der Umfang des Customising ist sehr üppig gestrickt, was aber auch bedeutet, dass die Schnittstellen sehr Abstrackt gehalten sind. Die einzigen von der Komponente mitgelieferten Funktionen sind:
*Das Zerlegen des Klartextes anhand der Sprachdefinition *Lokalisieren von Funktionen in der verwendeten Funktionsbibliothek

Alle weitren Funktionen wie etwa das stufenweise Weiterzerlegen von Übereinstimmungen in der Spezifikation bleibt dem Anwender überlassen.

Definition von Sprache

Die Definition einer eigenen Sprache ist in zwei Bereiche geteilt. Zum einen der Bereich der Syntax:

Die Syntax der zugrunde liegenden Sprache wird mithilfe eines EBNF Musters nach ISO 14977 definiert.
Wir haben die Norm zusätzlich noch um folgende gültige Tags erweitert:
*-- (name) Definiert den Beginn oder das Ende einer Tokengruppe *#(definition),(definition) Definiert einen Satz von Eigenschaften für ein Token

Zum anderen der Bereich Funktionsumfang und Klassenstrucktur:

Die Methoden und Klassen werden in C# Quellcode als Assembly mit entsprechenden Flags definiert. Der Compiler greift auf die Flags zu und findet auf diese Weise im Script verwendete Methoden.

Mögliche Einsatzgebiete

Die Einsatzgebeiete des Projektes sind vielfältig gefächert. Es kann überall da eingesetzt werden, wo Scripts oder dynamische Programmteile verwendet werden sollen oder müssen.

Wir verwenden das Projekt z.B. als Basis für unser MMO und dort speziell für Mapscripts und Eigenschaften von Gegenständen und Zauber.

Aber welche Vorteile soll das haben?

Dies ist eine berechtigte Frage. Die Verwendung ist erstmal Aufwändig mit der definition einer eigenen Sprache und der Ergänzung wichtiger Interpeterteile und sicherlich gibt es für Sprachen wie Python, Lua etc. auch schon fertige und optimiertere Bibliotheken.

Unser Projekt kann aber mit einer sehr guten Performance, was oft bei größeren Scripten oder langsameren Rechnern ein Problem darstellen kann, aufwarten. Die Ausführungszeit unterscheidet sich nur unmerklich von echtem C# Programmcode.

Unser Projekt produziert zudem keine Laufzeitinterprätation anhand von Text, sondern eine Call-to-Call Strucktur, welche zu jedem beliebigen Zeitpunkt an jeder beliebigen Stelle betreten werden kann. Das heißt im Klartext, dass das Script z.B. beim Laden einer Map kompiliert wird und danach zu jedem beliebigen Zeitpunkt und beliebig oft ohne erneutes interprätieren ausgeführt werden kann.

Ein zusätzlicher Vorteil ist ausserdem ein voller reflektiver Zugriff auf nahezu alle Levels des Scripts und ein dadurch auch nach dem kompileren garantierten programatischen Modifikationsschema.

Eine daraus resultierende weitere Funktionsmöglichkeit ist z.B. einfache implementierung von Ereignisbehandlung anhand von Scripten (Spieler X wird mit Zauber Y gezielt, trägt aber Gegenstand Z mit Eigenschaft Q)

Im Testprojekt findet Ihr sowohl eine Definition einer simplen Sprache, die bislang nur den Befehl "print(parameter)" kennt, als auch ein Beispielprogramm welches Code anhand der Spezifikation "compiliert" (siehe Screenshots)

Auch mag am Anfang die atomare Opperationsstrucktur der Resultate etwas verwirrend sein, das Ganze hat aber durchaus seinen Sinn.

Wichtig

An der Importfunktion des ScriptProcessor wird mommentan noch gearbeitet.

Ich will KEIN gluLookAt, da sämtliche Scenenelemente von der Kamera abgeleitet werden, wodurch Scenenobjekte ebenfalls andere Scenenobjekte anvisieren können.

Wenn du dann immer noch Probleme damit hast, mußt du schon eine konkrete Frage stellen

Habe ich oben getan

Wenn ich jetzt nicht schon 6 Stunden rumgesucht und getestet hätte, hätte ich es hier nicht gepostet!

Moin,

ich versuche gerade einen Punkt als Ziel für meine Kamera zu definieren, sodass diese automatish auf diesen Punkt schaut, auch wenn ich sie neu positioniere.

Ich habe dazu 2 Methoden ausprobiert:

1. Berechnung mittels einfacher Geometrie: Hierzu habe ich ein Dreieck zwischen meinen beiden und einem Referenzpunkt berechnet (weiße linien).

Dann habe ich mittels Cosinus, Sinus und Tangens jeweils versucht den Winkel zu bekommen, was aber nicht geklappt hat (blaue linie)

2. Berechnung mittels Vektoren: Hierzu habe ich die Normalvektoren gebildet indem ich jeweils von meinem hilfsvektor und meinem eigentlichen zielvektor den Startvektor abgezogen habe und das ganze normalisiert habe. Laut diesem Tutorial sollte dann aus dem Punktprodukt der Cosinus des Winkels herauskommen. Klappt aber auch nicht.

Weiß jemand wie man einen Rotationsvektor berechnen kann, sodass die Kamera auf meinen Zielpunkt "zeigt"?

Moin,

ich arbeite gerade daran einen Compiler für einen beliebigen Sprachsatz zu entwerfen.
Die Syntax wird dabei durch ein in den Parser geladenes Pattern nach EBNF ISO-Norm vorgegeben und die eigentlichen Programmbefehle kommen aus einer dynamisch gebundenen DLL.

Nun habe ich einen Performancetest gemacht und bin für:

function();
if(b==1)
{
   i = 0;
   while(i<10)
   {
      function(1);
      add(i,1);
   }
}

mit einem Muster

--compiler

if = "if(" {(([{" "}] basic.comparsion) [({" "} (basic.logicalLink) {" "})])} ")" [{" "}] "{" [{" "}] {([{" "}] statement [{" "}])} [{" "}]"}";

while = "while(" {(([{" "}] basic.comparsion) [({" "} (basic.logicalLink) {" "})])} ")" [{" "}] "{" [{" "}] {([{" "}] statement [{" "}])} [{" "}]"}";

statement = ((basic.assignment|basic.function) ";") | (if|while);

whitespace = " ";

--basic

comparsion = (function|identifier|number|string) [{" "}] ("=="|"!="|">="|"<="|">"|"<") [{" "}] (function|identifier|number|string);

assignment = identifier [{" "}] "=" [{" "}] (function|identifier|number|string);

function = identifier [{" "}] "(" ({(identifier [","])|(number [","])|(string [","])}) ")";

identifier = char - numeral - " " { ( char - " "|numeral ) };

string = ("'" {char} "'")|('"' {char} '"');

number = ["-"] {numeral};

char = "a"|"b"|"c"|"d"|"e"|"f"|"g"|"h"|
       "i"|"j"|"k"|"l"|"m"|"n"|"o"|"p"|
       "q"|"r"|"s"|"t"|"u"|"v"|"w"|"x"|
       "y"|"z"|" "|numeral;

numeral = "0"|"1"|"2"|"3"|"4"|"5"|"6"|"7"|
          "8"|"9";

logicalLink = (([{" "}] "&&" [{" "}]) | ([{" "}] "||" [{" "}]));

auf etwa 4 ms für das Parsen anhand der Token in der Gruppe "compiler" gekommen.

Ist das verhältnismäßig gut oder eher noch verbesserungswürdig?

Moin,

also:
Der Tipp mit der Mono Migration war gut, bis auf die eh nicht verwendeten Dinge schmeist der mir zumindest mal keine Fehler.

Ich habes allerdings mal getestet und er mekkert, dass er System.Windows.Form nicht kennt.

Kann das an der Mono-Version liegen? Wenn ja, wie finde ich das raus?

Meine Bibliothek verwendet System.Reflection, sowie System.Runtime.InteroptService als verweis für DLL-Imports zum anzeigen des Windows-Arbeitspeichers, die aber unwichtig sind und nicht verwendet werden, also hauptsächlich System.Reflection

Ich kanns probieren, sobald mein Wetab wieder aus der Reperatur kommt.

Moin,

seid kurzem besitze ich ein Tablet der Marke WeTab, mit dem ich auch recht zufrieden bin. Jetzt wollte ich mal wissen, ob meine .NET Komponenten auf dem mit Linux Fedora betriebenen System auch laufen würden, wenn ich Bibliothekenabhänigkeiten zu meinen geschriebenen Bibliotheken habe.

Inwiwiet unterstützt Mono das Reflectionmodell mit dynamischer Laufzeitbindung von Assemblies und was ist mit nicht unterstützten Funktionen wie der DLL-Import von Windows-Bibliotheken, die zwar enthalten sind, die ich aber nicht (bzw. selten und dann eher auf Windoof Maschinen) verwende?

Kann ich die kompilierten Programme auch einfach per USB oder what ever auf mein Tab übertragen oder muss ich diese dort nochmals unter Mono kompilieren?

Moin,

aus Erfahrung weiss ich, dass es oft nicht Synchron läuft, was bedeutet, dass du, wenn du im Server das erste mal auf empfangen gehst im Client schon alles gesendet sein kann und im server das dann eben alles als eine Übertragung gehandelt wird.

Ich vermute mal die latenz ist bei deinem Server-Client-Modell nicht optimal.

Du kannst es wie bei großen Serversystemen so machen, dass du vom Server eine Bestätigung schickst:

-> client sendet benutzernamen
-> client wartet auf erhalten
<- Server sendet erhalten
-> client sendet password
-> client wartetd auf erhalten
<- server sendet erhalten
usw.

Die Empfangsmethode unseres Gameservers (komplett in C#) sieht z.b. so aus

private void ReciveData(IAsyncResult result)
        {
            if (server.Running)
            {
                if (!Avilable)
                    Avilable = true;

                int offset = 0;
                try
                {
                  offset = cTCPConnection.Client.EndReceive(result);
                }
                catch(SocketException e)
                { 
                    this.Avilable = false;
                    return;
                }
                catch (ObjectDisposedException e)
                {
                    this.Avilable = false;
                    return;
                }
                
                if (offset == 0)
                {
                    Avilable = false;
                    return;
                }

                if (!Subscribed)
                {
                    subscribed = true;
                    server.CastConnectionEvent(this);
                }

                List<byte> bytes = new List<byte>();
                bytes.AddRange(buffer);
                bytes.RemoveRange(offset, bytes.Count - offset);

                server.CastTransmissionEvent(bytes.ToArray(), this);

                try
                {
                  cTCPConnection.Client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, ReciveData, null);
                }
                catch(SocketException e)
                { 
                    this.Avilable = false; 
                }
                catch (ObjectDisposedException e)
                {
                    this.Avilable = false;
                }
            }
        }

Das bedeutet er wartet auf ein asynchrones Ergebnis also eine Übertragung, macht diese dem Programmierer über ein Event zugänglich und geht dann wieder in den Empfangszustand über.

Das Gleiche mache ich auch beim Client

private void ReciveData(IAsyncResult result)
        {
            if (active)
            {
                int offset = 0;
                try
                {
                  offset = server.Client.EndReceive(result);
                }
                catch(SocketException e)
                { 
                    this.Active = false;
                }
                catch (ObjectDisposedException e)
                {
                    this.Active = false;
                }
                
                if (offset == 0)
                {
                    Active = false;
                    try
                    {
                      server.GetStream().Close();
                    }
                    catch(Exception e)
                    {}
                    
                    return;
                }

                List<byte> bytes = new List<byte>();
                bytes.AddRange(buffer);
                bytes.RemoveRange(offset, bytes.Count - offset);

                if (TransmissionReceipt != null)
                {
                    Connection c = new Connection(this.Server, null);
                    TransmissionReceipt.Invoke(bytes.ToArray(), c);
                }
            }
            if(server != null && !closed)
            try
            {
              server.Client.BeginReceive(buffer,0,buffer.Length,SocketFlags.None,ReciveData,null);
            }
            catch (SocketException e)
            {
                this.Active = false;
            }
            catch (ObjectDisposedException e)
            {
                this.Active = false;
            }
        }

Zudem verwalten wir die Verbindungen, die die Empfangsmethode haben als seperate Klassenobjekte einer Verbindungsklasse, sodass der Server dammit nichts mehr zu tun hat, ausser die Verbindung anzunehmen und wieder abzuwählen.

Moin,

mal ne Frage:
Funktioniert es, dass ein Keyboardhook auf dem Hostsystem trotz Fokus auf eine Einheit eines WindowsVirtualPCs die Tastaureingaben empfängt?

Kein WPF verfügbar. Bitte um anderen Vorschlag

Moin,

gibt es eine Möglichkeit zu prüfen von welcher Tastatur eine Eingabe kommt, wenn man zwei Tastaturen (oder einen entsprechenden Handscanner) angeschlossen hat und die Tasten mit

1. onKey abfängt
2. keyboradHook abfängt

Habe jetzt mal ein paar Ansätze ausprobiert und denke, dass das so gehen sollte.
Das Ergebnis sieht schonmal ganz gut aus. Hat zwar immernoch eine auslastung von bis zu 50% beim verschieben, ruckelt aber nicht mehr, ist also quasi just in time.

Ich muss jetzt nurnoch das ganze so verpacken, dass ich nur noch eine Styleklasse auf mein Form ziehen muss.

Hat jemand eine Ahnung wie das mit dem Skinnen funktioniert?
Hier z.b. SkinCrafter hat auch Styles mit transparentem Fenster. Welche Methoden benötige ich um das nach zu machen?

EDIT: Nach etwas Recherche habe ich Ansätze gefunden, die aber jedesmal ein Form erzeugen, von dem ich erben muss. Die Skinbibliothek aus dem Forum habe ich nicht zum laufen bekommen und bin durch den Code auch nicht durchgestiegen. (Gegebenenfalls bitte helfen)

Gibt es nicht eine Möglichkeit einfach nur einen skin zu initialisieren wie etwa

Skin myskin = new Skin(this);
myskin.ApplySkin();

oder muss ich für die bestmögliche gestalterische Freiheit wirklich immer von einem entsprechenden Skinform erben?

Naja, das was ich gefunden habe ist alles mehr oder weniger unbefriedigend!
Die sache mit dem CopyFromScreen ist mit einer auslastung von 25 - 50% bei schnellen Bewegungen oder einer entsprechenden Größe zu langsam und das was es noch auf codeprojekt gab "PerPixelAlpha" erfüllt nicht den Zweck, da es zumindest bei mir, keine anderen Controls oder Drawings anzeigt.

Moin,

ich möchte meinen Fenstern und Controls einen selbst definierten Style geben. Dabei würde ich gerne wissen, wie ich ein Fenster transparent mache und dann mit einer halbtransparenten Grafik darauf zeichnen kann.
Vor allem sollte das Ganze noch performe sein, also nicht mehr als 4% der gesammtauslastung schlucken.

Um gleich vorweg ein paar Posts zu vermeiden: Ein Form mit dem transparencyKey unsichtbar zu machen, führt nur dazu, dass die transparente Grafik die verwendete Farbe annimmt!

Ich bin mir auch nicht sicher, ob einen Screenshot zu machen nicht zu viel Performance frisst, wenn das Form öfter versetzt bzw. neugezeichnet wird.

Das kommt letztendlich alles auf die präzision des Zeichners an.

Ich frage dich, wie lange benötigst du, um aus einzelnen Würfeln einen Menschen zu bauen und dann denke mal drüber nach, wie schnell es ginge diesen stattdessen zu zeichnen.

was möchtest du eigentlich erreichen?

Nun, sowas lässt sich vilerlei einsetzen, z.b. zum entwerfen und illustrieren von Bildern für z.b. Spielkarten, für Serienbilder wie sie etwa bei Comicstrips verwendet werden oder Zeichentrickfilme, zum entwerfen von Kleidung oder anderen Handwerksarbeiten.

Zudem ist es meiner Ansicht nach einfacher, ein 3D Modell zu zeichnen, als es aus Blöcken "zusammenzukneten" und vor allem dauert es für einen Leyen wie mich nicht so lang wie mit vergleichbaren Programmen.

Du musst es ja nicht verwenden aber ich finde sowas in Verbindung mit einem Grafiktablet sehr nützlich.

Ehrlich gesagt halte ich das ganze für ein Ding der Unmöglichkeit. Wie willst du einfach u. schnell aus einem Bild dass nur 2D-Informationen enthält ein 3D-Bild machen ...

Nein, es ist nicht möglich ein komplettes Modell aus nur einer Ansicht eines Bildes zu erstellen, aber folgendes Beispiel, dass dir meine Idee etwas näher bringt:

Du hast die Frontansicht eines Gesichtes und legst nun die Hightmap darauf. Du erhälsts dammit ein Modell, dass du im 3D raum bewegen kannst.

Nun drehst du das Bild, sodass du dein Gesicht von der Seite siehst. Da dein Gesicht nur die Front war, fehlt natürlich der Hinterkopf. Nun wechselst du aber wieder in den Zeichenmodus und zeichnest aus deiner aktuellen Perspektive den Kopf an dein Gesicht, legst wieder die Hightmap darauf und drehst das Modell etwas weiter.

Das machst du solange, bis du einmal rund bist und hast sommit die Komplette ansicht deines Modells. Der Vorteil daran ist, dass du zu keinem Zeitpunkt voirab festlegen musst, wie die nicht sichtbaren Bereiche deines Modells auszusehen haben, sondern kannst dies im Laufe deiner Zeichenarbeit festlegen.

Ebenso soll es möglich sein, die Zeichnung im nachhinein noch zu bearbeiten. Etwa die Ausprägung oder Linienführung des Gesichtes zu ändern etc..

Auch wenn das Ganze dann ein paar viele Polygone hat, kann ich mir durchaus vorstellen, das Modell später in ein anderes Format etwa 3DS-Max oder Cinema4D exportieren zu können, um es dann z.b. für ein Spiel weiter zu verarbeiten.

Also...

ich habe mir jetzt folgendes Überlegt:

Der Anwender hat die Möglichkeit in einem Modus zu Zeichnen und dann in einen Höhenmodus zu Wechseln, wo er auf das gzeichnete eine Art Hightmap legen kann. Dann gibt es noch den Betrachtungsmodus, indem der Anwender seine Zeichnung betrachten kann.

Ich bin mir allerdings noch nicht im Klaren, wie ich die Verformung berechne und vor allem, wenn ich die Zeichnung gedreht habe, wie ich dann die Punkte anhand der Drehung setzen soll

Ich wollte eigentlich keine Fremdsoftware extra für diesen Zweck verwenden. Und schon garnicht wo man 6 exakte Kopien des Bildes braucht, da bei mir auch leider die Bilder immer Unikat sind.

Ich hatte mir auch schon überlegt für jeden Pixel einen Vector zu generieren, sodass der Zeichner dann eine Verformung zu einem 3D Modell machen und dieses im Raum beliebig drehen kann. Wäre jedoch vom zeitlichen Aufwand her für den Anwender nicht gerade optimal.

Ansonsten ist mir bis dahin auch nichts brauchbares eingefallen.

Moin,

hab mir kürzlich ein Grafiktabelt gekauft um am Computer zu zeichnen. Dabei stellte sich mir die Frage, ob es nicht eine Möglichkeit gibt eine flache Zeichnung automatisch in ein 3D-Objekt extrudieren zu lassen, um sie dann aus verschiedenen Perspektiven als Bild speichern zu können.

So könnte man z.b. verschiedene Positionen von Charakteren ausprobieren, ohne stundenlang neue Blickwinkel zu zeichnen.

Hat jemand Anregung, Vorschläge oder Ansätze, wie man das bewerkstelligen könnte?