Laden...
U
Benutzerbeschreibung
Konto auf Wunsch des Benutzers gesperrt

Forenbeiträge von userid11997 Ingesamt 400 Beiträge

09.02.2012 - 18:29 Uhr

Alles klar, dann mach doch folgendes:

  1. Den Renderer (also deine methode, in der du blending und so setzt) ganz am ANFANG deiner Darstellungsschleife aufrufen, da du sonst erst auf Texturen zugreifst und diese dann erst verfpgbar machst.

  2. Wenn du einen Alphawert setzt, überschreibst du die Farbe deiner Textur und diese wird wiederum sichtbar. Verwende statdessen Color3f

  3. Etwas grundlegendes über OpenGL "OpenGL ist eine Zustandmaschine, dass heißt, dass ein gesetzter Zustand bis zu dessen Aufhebung aktiv bleibt".
    Du musst lediglich ein mal vor dem Aufruf von Gl.Begin eine Textur binden, die dann auf die in Gl.Begin definierte Struktur angewendet wird. Um eine Textur wieder zu "entladen" verwende einfach Gl.glBindTexture(Gl.GL_TEXTURE_2D, 0);

Warum setzt du hier mehrmals die Farbe?
Tue ich nicht, jeder Vertext bekommt eine Farbe verpasst.

Dann solltest du keine Texturen verwenden oder eben die Farbe auf 3 Komponenten reduzieren.

09.02.2012 - 14:50 Uhr

Verushc doch einfach mal statt zwei TYPINSTANZEN die WERTE für den Construktor anzugeben. Was vermutlich passiert ist folgendes, du übergibst 2 dem Activator zwei Typinstanzen mit typeof(), dieser such dann nach einem passenden Constructor mit den Parametern Type,Type und das schlägt dann fehl.

09.02.2012 - 14:42 Uhr

Moin,

nur eine kurze Frage:
Wenn ich einen Satz Shader habe, der beispielsweise ein Partikelsystem darstellt und mit jedem Frame die Partikel in Größe, Farbe und Position verändert, werden die Variablen, wenn ich sie innerhalb meiner Main setze, bei jedem Durchlauf der Pipelin wieder zurückgesetzt oder bleiben diese auf dem Wert des letzten durchlaufs stehen?

Wenn ja, ist dies bei allen Typen so oder nur bei Uniforms?

09.02.2012 - 14:34 Uhr

Schau dir bitte die Fragen in deinem Quellcode einmal an und versuche diese zu beantworten.


private static void DrawImmediateModeVertex(Vector pos, Color color, Point uvs)
        {
            //Wird hier ein Alphawert gesetzt?, wen ja welcher?
            Gl.glColor4f(color.Red, color.Green, color.Blue, color.Alpha);
            Gl.glTexCoord2f(uvs.X, uvs.Y);
            Gl.glVertex3d(pos.X, pos.Y, pos.Z);
        }

        public void DrawSprite(Sprite sprite)
        {
            Gl.glBegin(Gl.GL_TRIANGLE_STRIP);
            {
                for (var i = 0; i < sprite.VertexAmount; i++)
                {
                    //Warum bindest du hier mehrmals dieselbe Textur?
                    Gl.glBindTexture(Gl.GL_TEXTURE_2D, sprite.Texture.TextureId);
                    DrawImmediateModeVertex(sprite.VertexPositions[i],
                    //Warum setzt du hier mehrmals die Farbe?
                        sprite.VertexColors[i], sprite.VertexUVs[i]);
                }
            }
            Gl.glEnd();
        }

Wann und wo rufst du Renderer auf?
Ich nehme mal an, dass du Renderer auch vor dem laden deiner Texturen aufrufst?

Vor allem bei mir funktionierts einwandfrei. Das Logo in der Mitte und der Text sind jeweils texturierte Quads.

08.02.2012 - 18:41 Uhr

Verwende einfach folgendes um eine 32bpp Alphachaneltextur zu laden

var bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
                                             ImageLockMode.ReadOnly, PixelFormat.Format32bppRgb);

            Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGBA8, bitmap.Width, bitmap.Height, 0, Gl.GL_BGRA, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);

Dann aber die Belndfunction nicht vergessen (sowohl beim erzeugen, als auch beim rendern)

GL.Enable(Blend);
                    GL.BlendFunc(SrcAlpha, OneMinusSrcAlpha);

Da zwar der Alphakanal gesetzt ist, der aber den alpha nicht verwendet. Hier wird dann der alphasource zum blenden verwendet.

08.02.2012 - 14:51 Uhr

Einfach wie in Texture Mapping die Bitmapdaten laden, den Pointer an OGL und wieder freigeben.

Wenn die Darstellung fehlschläg, bist du sicher, dass deine Texturkoordinaten richtig sind?
Ansonsten kanns nurnoch n Parameterfehler in der Methode sein.

08.02.2012 - 10:41 Uhr

Am besten lädst du dir die Textur selber. Da das ja nur in seltenen fällen mehr als ein 4 Zeiler ist und das in jedem Tutorial irgendwannd rann kommt, würd ich das lieber so machen.

Was ist denn genau die Fehlermeldung?

06.02.2012 - 11:54 Uhr

Moin,

ich habe mir überlegt einen flexiblen ErrorManager zu schreiben. Dazu möchte ich sowas machen wie


ErrorManager.Begin(SektionID);

//critical Code
...
ErrorManager.Log("some log message");

ErrorManager.End(SektionID);

Gibt es da eine Möglichkeit fehler abzufangen, die auf den Try-Catch-Block verzichtet?

19.01.2012 - 18:42 Uhr

Du könntest es dem NN etwas einfacher machen, schließlich lernt ein Mensch auch nur durch Erfolg und Misserfolg. Du könntest also ein paar einfachere testformeln erzeugen, die du dein NN solange machen lässt bis esdas richtige Ergebnis ausspukt.
Um sich das merken zu können bräuchte dein NN ein Gedächtnis, in das es positive (also erfolgreiche) Ergebnisse ablegt um es dann mit anderen Aufgaben assoziieren zu können.

16.01.2012 - 21:58 Uhr

Kurz gesagt, alles was dem Anwender/Entwickler der Engine interessiert. Dazu zählt sicherlich die Menge des VRam zu entwicklungs/initialisierungs Zeiten für die größe der Modelle und die Detailtiefe von Texturen/Texturlevels, oder eben die Temperatur oder der Akkustatus (gehört jetzt nicht zur GH) im Spiel oder in der Anwendung, dass die Anwendung Crashes bereits vorhersagen und entsprechend reagieren kann.

Bisweilen beschränkt auf den Windows-Treiber, Linux und Mac kommt später.

15.01.2012 - 15:56 Uhr

Klar, OpenCl haben wir natürlich implementiert, das Problem ist nur, wenn die Grafikhardware kein OpenCl unterstützt, weil einfach zu alt, gibts natürlich auch keine Informationen dazu. Auf meinem System wird beispielsweise die HD 2400 XT nicht unterstützt und ich erhalte lediglich einen CPU Context.

14.01.2012 - 23:14 Uhr

was ist mit Intel?

12.01.2012 - 11:14 Uhr

Moin,

ich schaue gerade, ob es nicht einen API-Call gibt, der mir Information meiner Grafikhardware wie Temperatur, VRAM-Größe etc. ausgibt und zwar unabhängig von Hersteller und Modell. Das Ganze soll in OpenGL bzw. Win-API als Teil des Windows-Treibers für unsere Engine geschehen, DX ist also absolut garkeine Option.

29.12.2011 - 21:42 Uhr

Zur Entwicklung des 3D Zeichenprogramms Depict suchen wir Entwickler in C#/C++ mit erfahrung in GUI und 3D Programmierung (OpenGl).

Das Programm soll dazu dienen mit Modellbibliotheken 3D Scene zu erzeugen und mit den üblichen Grafikbearbeitungsoptionen wie Ebenen, Filter etc. diese Scene zu modifizieren. Dies kann beispielsweise für Wallpaper von Spielen oder Bildergeschichten nützlich sein.

02.12.2011 - 21:33 Uhr

und noch einer weils so schön aussieht

02.12.2011 - 21:30 Uhr

Zur Anregung der Phanatsie noch ein Screenshot von einer Testscene.

30.11.2011 - 22:14 Uhr

Da tut sich zum release nicht viel zwischen dem Delegaten und dem Invoke. Das Problem bei delegate.CreateDelegate ist der verlangte Typ, der wiederum ein Delegate mit exakt definiertem Typ sein muss, der eben nicht genau bekannt ist.

28.11.2011 - 17:58 Uhr

Moin,

ich hab mir mal die ganzen Post zu Reflection angesehen, darunter auch ein Blogpost, der zeigen sollte, wie man aus einem Objekt MethodInfo einen delegatentypen erhalten kann, wenn der Typ nicht bekannt ist. Die Ansätze in allen Ehren, aber meine Tests mit diesem Quellcode

using System;
using System.Reflection;
using System.Text;
using System.Diagnostics;

public class Test
{
    public delegate W Func<T, V, W>(T arg, V val);
    public delegate int IndexOFDelegate(char c);


    static void Main()
    {

        MethodInfo indexOf = typeof(string).GetMethod("IndexOf", new Type[] { typeof(char) });
        IndexOFDelegate indexOfDelegate = (IndexOFDelegate)Delegate.CreateDelegate(typeof(IndexOFDelegate), "Hallo" ,typeof(string).GetMethod("IndexOf", new Type[] { typeof(char) }));

        MethodInfo getByteCount = typeof(Encoding).GetMethod("GetByteCount", new Type[] { typeof(string) });

        Func<string, object, object> indexOfFunc = MagicMethod<string>(indexOf);

        Func<Encoding, object, object> getByteCountFunc = MagicMethod<Encoding>(getByteCount);

        Stopwatch sw = new Stopwatch();
        sw.Start();
            indexOf.Invoke("Hello", new object[] { 'e' });
        sw.Stop();

        Console.WriteLine("Invoked MethodInfo " + sw.Elapsed.TotalMilliseconds.ToString());
        sw.Reset();
        sw.Start();
            indexOfFunc("Hello", 'e');
        sw.Stop();

        Console.WriteLine("Created Delegate " + sw.Elapsed.TotalMilliseconds.ToString());

        sw.Reset();
        sw.Start();
            indexOfDelegate('e');
        sw.Stop();

        Console.WriteLine("Declared Delegate " + sw.Elapsed.TotalMilliseconds.ToString());
        Console.ReadKey();

    }

    static Func<T, object, object> MagicMethod<T>(MethodInfo method) where T : class
    {

        // First fetch the generic form

        MethodInfo genericHelper = typeof(Test).GetMethod("MagicMethodHelper",

            BindingFlags.Static | BindingFlags.NonPublic);

        // Now supply the type arguments

        MethodInfo constructedHelper = genericHelper.MakeGenericMethod

            (typeof(T), method.GetParameters()[0].ParameterType, method.ReturnType);

        // Now call it. The null argument is because it's a static method.

        object ret = constructedHelper.Invoke(null, new object[] { method });

        // Cast the result to the right kind of delegate and return it

        return (Func<T, object, object>)ret;

    }

    static Func<TTarget, object, object> MagicMethodHelper<TTarget, TParam, TReturn>(MethodInfo method)

        where TTarget : class
    {

        // Convert the slow MethodInfo into a fast, strongly typed, open delegate

        Func<TTarget, TParam, TReturn> func = (Func<TTarget, TParam, TReturn>)Delegate.CreateDelegate

            (typeof(Func<TTarget, TParam, TReturn>), method);

        // Now create a more weakly typed delegate which will call the strongly typed one

        Func<TTarget, object, object> ret = delegate(TTarget target, object param) { return func(target, (TParam)param); };

        return ret;

    }

}

haben angehängtes Ergebnis auf einer 32b XP-Maschine unter 2.0 geliefert, wobei ich mich dann doch fragen muss, was sich die ganzen Programmierer über die schlechte Performance von MethodInfo.Invoke() beschweren.


Gibt es denn noch irgendeine andere Möglichkeit unter 2.0 zur Laufzeit einen delegaten aus einem MethodInfo-Objekt zu erzeugen, dass an die Geschwindigkeit eines zur Buildzeit definierten delegaten herankommt?

EDIT: Eventuell indem man einen Methodenpointer in einen delegaten castet?

26.11.2011 - 23:52 Uhr

Moin,

wenn ich ein Projekt habe, dass mit verschieden gekapselten Komponenten arbeitet, gibt es da eine Möglichkeit mehrfach verwendete Funktionen so auszulagern, dass ich diese nicht explizit in jede Komponente einbauen muss, aber dennoch jede Komponente sozusagen "stand alone" verwenden kann?

24.11.2011 - 23:07 Uhr

Wie gesagt, da ich im momment im Spielebereich mit beidem zu tun habe und unser Prof natürlich größe Stücke auf C++ hält, bin ich im Momment etwas nachdenklich. Mit der Performance von unserem Script (was nahezu wenn nicht sogar exakt an die geschwindigkeit von C# heran kommt) bin ich relativ zufrieden, was die OpenGL basierte Grafik angeht, bin ich mir nicht sicher. Klar, die 8000fps von javas slick sind schon beeindruckend und die 6000 von ATIs performancetest sind auch nicht zu verachten, obwohl ich natürlich weiß, dass es mit der Bildwiederholrate des Monitors absolut nicht zu machen ist, jedoch sind das erstmal beeindruckende zahlen. Da kann das OnPaint Ereignis von einem C# Form nicht mithalten, geschweigedenn mit dem renderloop in einer while(true) schleife, welcher öfter in c++ beispielen auftaucht. Unser Code ist noch kein Stück optimiert, jedoch sind uns bei Funktionen, die Daten über die Cpu an die Grafikkarte senden die Hände gebunden, da wir weder das direkt tun können, noch mal eben n par Register herumschieben können.

Wobei ich glaube, dass die Branche natürlich c++ und DirectX geprägt ist und sich das so schnell auch nicht ändern wird aber dem sei mal so dahin gestellt.

Ist eine Funktion mit unsafe eigentlich grundsätzlich schneller?

24.11.2011 - 22:48 Uhr

Tja, .Net ist wohl schon luxus 😜

24.11.2011 - 17:21 Uhr

Aber da du ja schon P/Invoke ansprichst (Unmanaged Code in C# nutzen),

Naja ich meinte eigentlich so unsafe codeblocks wo man eben auch pointer nutzen kann aber gut.

BtW: Kann ich mit Visual Studio eigentlich auch Nicht-.NET-Bezogene C++ programme schreiben?

24.11.2011 - 17:03 Uhr

Moin,

gibt es eigentlich ein natives c++ gegenstück zu den Funktionen von System.Reflection oder etwas ähnliches?

24.11.2011 - 17:01 Uhr

Moin,

ich frage mich gerade wie es denn so um die Performance von C# bestellt ist, da es ja immer wieder etliche Personen gibt, die behaupten es wäre einfach keine echte Sprache weil es zu langsam ist.

Daher, was kann man denn alles aus seiner Anwendung herauskitzeln (an geschwindigkeit gegenüber nativem c++) und wo sind die grenzen?

Es ist ja möglich c++ code in eine c# anwendung zu integrieren (beispielsweise bei der Bildverarbeitung), ist das auch mit inline-assembler möglich oder irgendwie möglich zu machen?

01.11.2011 - 12:23 Uhr

Villeicht ist dein PC einfach so ausgelastet, dass der Server einen Timeout verursacht, weil er nicht schnell genug antwortet?

01.11.2011 - 10:50 Uhr

Ist die Verbindung durch irgendeinen Grund villeicht so langsam, dass eine der beiden Seiten dann einfach sagt ok, ich hab jetzt keine lust mehr. Wie sendest du die Anfrage genau?

26.10.2011 - 20:56 Uhr

Hallo,

leider war der Ansturm an Bewerbern nicht so groß, wie wir es erhofft hatten. Deswegen nochmals der Aufruf:

Wir suchen immernoch Mitarbeiter für die oben genannten Bereiche, gerne auch Schüler und Studenten mit etwas Erfahrung, nur zuverlässig müßen sie sein.

18.10.2011 - 20:40 Uhr

Um meine Frage nochmal zu wiederholen

Weiß jemand, wie das große Engines wie die Unreal- oder Source-Engine machen?

15.10.2011 - 23:36 Uhr

Also du meinst wir "adden" jeweils eine routine für jedes erdenkliche Licht in der Scene zu unserem Shaderprogramm und aktivieren nur diejenigen (per id oder wie auch immer), die überhaupt gerade auf das Objekt angewendet werden könnten?

Wenn jetzt noch Wassereffekte oder so sachen wie Feuer etc. hinzukommen, muss ich die dann auch in mein mit den Lichtroutinen beklekkertes Programm hinzufügen?

Weiß jemand, wie das große Engines wie die Unreal- oder Source-Engine machen?

10.10.2011 - 02:01 Uhr

Moin,

habe gerade meinen Grafiktreiber aktualisiert und mal aus neugier eins meiner OpenGL-Programme aufgerufen. Ich musste feststellen, dass die Scene, bestehend aus einem VertexArray in einer Displayliste, nicht mehr bzw. nicht immer angezeigt wird.
Je nachdem wie ich die Kamera drehe, verschwindet das Modell oder wird halt wieder angezeigt.

Das Programm wirft mir jedoch keinerlei Exceptions.

Jemand ne Ahnung woran das liegen kann?

Nachtrag:

Das Problem bezieht sich wirklich nur auf die Konstelation VertexArray->Displaylist, bei meinen anderen Testprogrammen, die mit Displaylisten arbeiten, läuft alles wunderbar.

09.10.2011 - 17:51 Uhr

Wie gesagt, sämtliche Lösungsansätze hier im Forum haben eben nur auf dem Desktop ÜBER den Icons funktioniert. Ich würde gerne wenn es sich vermeiden ließe, auf DirectX verzichten, gibt es nicht noch andere Möglichkeiten?

08.10.2011 - 23:23 Uhr

Moin,

ich suche schon seid ner ganzen eile nach einer Möglichkeit um wirklich auf den Desktop-HINTERGRUND zu zeichnen. Alles was ich bislang gefunden habe, auch hier im Forum, zeichnet immer nur über die Icons.

Ich würd mir gerne einen interaktiven Desktophintergrund bauen, mit der Endscene aus dem zweiten Portal teil (die beiden Computerkerne)

01.10.2011 - 22:49 Uhr

Das ist ganz normales glBegin, glEnd in der onPaint-Methode des Forms, ohne irgendwelche speziellen Pipelinopperationen.

01.10.2011 - 00:27 Uhr

Moin,

es geht darum, dass wir gerade versuchen einen Shader zu schreiben, der eine bzw mehrere Lichtquellen darzustellen. Leider ist das Licht sehr schwach bzw bewegt sich mit, trotz Matrix-Sicherung.

Kann uns jemand ganz einfach erklären, wie man grundsätzlich an sowas herangeht bzw. uns bei dem Shader helfen?

Wie verhält es sich, wenn wir nun mehrere Lichtquellen an verschiedenen sich teilweise ändernden Orten mit unterschiedlichen Stärken und Farben verwenden wollen?

Ist es überhaupt richtig nur einen Shader (Fragment, Geometry, Vertex) zu verwenden oder wie müssen wir das Verwenden mehrerer Shader pro Zeichendurchgang realisieren?

07.09.2011 - 22:19 Uhr

Hallo,

erstmal danke für eure hilfe. Was ich ausgeben möchte, ist erstmal ei Hobbyprojekt um Spielfiguren zu "drucken". Wenn das dann laufen sollte, wirds dann wohl eine Ebene
nach oben gestuft auf Kommerz.

Was mir auch noch eingefallen ist, ist die Programmierung eines Lego RCX Moduls mit C++ und kommunikation über Infrarot, das Ding auseinander zu bauen ist aber auch wegen der Stromversorgung eher suboptimal.

Was ist eigentlich besser, das Fräseverfahren oder das tatsächliche Drucken mittels granulat und einem Lasersrahl?

07.09.2011 - 14:56 Uhr

Moin,

ich überlege gerade mir einen 3D Drucker bzw. eine 3D Fräse zu bauen. Welche vorraussetzungen müssen gegeben sein, um so ein Gerät mit einem C# Programm zu bedienen (z.b. einen Motor an/aus zu schalten oder Sensoreingaben abzurufen)?

Welche Vorraussetzungen müssen in der Maschine selbst gegeben sein (Microprozessor, Assemblerprogramm) und welche Vorraussetzungen braucht das C# Programm als Basis (C/C++ oder Assembler Treiber)?

30.08.2011 - 10:17 Uhr

Was ich gerade bei solchen Programmen für Mobielgeräte gut finde, ist die
Funktion, dass man bei Eingabe eines falschen Passworts einen Satz zufällig
generierte Passwörter angezeigt werden. Das ist gerade dann gut, wenn jemand
unbedingt die Paswörter haben will.

16.07.2011 - 01:04 Uhr

Ich hab mir jetzt mal folgendes überlegt: Auf basis unserer Alchemie-Engine definiere ich zuerst einen Satz von Eigenschaften mit vorgabewerten. Das sieht dann in etwa so aus:


playerCarriesItemX = false;
npcCariesItemX = false;
npcIsDead = false;

Und definiere dann einen Satz von kombinationen, die die jeweiligen Pfade darstellen. In etwa so:


--Step1

playerCarriesItemX = "itemX"; #player_picksItemEvent
npcCariesItemX = "itemX"; #npc_picksItemEvent

--Step2

npcIsDead = "true"; #playerCarriesItemX


Wobei die Definition hinter dem # auf Ereignisse bzw. Eigenschaften zugreift. Es gibt zwei Arten vin Knoten, die abfragenden Knoten und die definierenden Knoten.

Abfragende Knoten greifen auf die Eigenschaften zu, während definierende Knoten die Eigenschaften jeweils invertieren (true -> false und umgekehrt)

Die Zeitlinie kombiniert jetzt jeweils auf basis der in den Eigenschaften definierten Tokens der jeweiligen Tiefe (Step) und prüft die Ergebnisse und erzeugt somit einen Pfad, der die Zeitknoten definiert. Ein Ereignis, welches einen Alternativpfad erzeugt, verändert jetzt eine Eigenschaft und in der nächsten Tiefenstufe wird wiederum der aktuellen Knoten Eigenschaften geprüft und das Resultat als neuen Wegknoten gesetzt.

11.07.2011 - 23:26 Uhr

Nutzt mir aber nichts, da es nicht funktioniert. Sowohl das installieren der Version auf dem Server, als auch das Kompilieren mit bestimmter Prozessorarchitektur lüppt net.

11.07.2011 - 12:51 Uhr

Hallo,

ich habe eine Anwendung auf einem XP-System (32bit) erstellt und diese auf einen Server 2008 Container (64bit) übertragen. Nun erhalte ich immer die Fehlermeldung, dass die Bibliothek System.Data.SQLite oder eine abhängigkeit nicht geladen werden konnte, obwohl sich diese im selben Verzeichnis befindet.

Gibts da eine Lösung, die kein installieren von VS auf dem Serversystem und Neukompilierung vorsieht?

04.07.2011 - 17:14 Uhr

Moin,

Als Teil des Project Universe entwickeln wir, ein kleines Team aus ganz Deutschland ein SDK mit einigen Zusatzprogrammen. Dazu suchen wir zur Zeit ein paar kompetente und zuverlässige helfende Hände für
die Bereiche:

  • Programmierung in C++/C# und OpenGL

  • Programmierung in C++/C# Schwerpunkt Netzwerk

  • Programmierung in C++/C# Schwerpunkt GUI

  • Allgemeine Programmierung in C#

  • Leveldesign

  • Modelldesign

  • Sound und Audio

  • Webdesign

  • Mono-Integration

und noch viele weitere Bereiche unseres SDKs. Die Aufgaben beziehen sich dabei auf Programmteile, weiterentwicklung aber auch komplett neuen Komponenten unseres Werkes. Das SDK soll als einfache Platform für Neueinsteiger aber auch fortgeschrittene Erschaffer von Spielwelten dienen, die ihre Kreationen über das Community-Netzwerk mit einer vielzahl von Benutzern kostenlos teilen können.

Das SDK soll dem Anwender so viel Arbeit wie möglich abnehmen, dadurch das
Entwickeln sehr einfach gestalten, aber auch die Möglichkeit keinesfalls
einschränken.

Neben vielen Dienstprogrammen und scriptbasierten Schnittstellen kann
natürlich auch über ein Visual Studio Projekt auf das SDK zurückgegriffen
werden.

Für weitere Informationen und/oder Bewerbungen bitte eine PN oder Email an mich richten.

Oder direkt an universeprojekt@googlemail.com

28.06.2011 - 09:38 Uhr

Hallo,

Das Ganze soll später für den Einsatz in Spielen Optimiert werden, was ebend ann dazu eingesetzt werden kann, um anhand einer Zeitachse zu bestimmen, ob bestimmte Aktionen des Spielers den Verlauf zu späteren Zeitpunkten beeinflussen.
Mit NextStep() wird dann schrittweise die Zeitstufe erhöht.

Dabei existieren eine bestimmte Anzahl Hauptereignisknoten, wie es abgelaufen wäre, wenn der Spieler den Pfad nicht durch irgendeine Aktion vverändert hätte.
Diese werden potenzielle erstmal nicht entfernt, es wird lediglich über eine Bedingung (Bedingungsscript) entschieden, ob ein Pfad besucht werden kann.

Beispielsweise


Der Spieler entfernt einen Gegenstand X aus einem Raum Y, der später von einem NPC besucht wird. Der NPC findet den Gegenstand nun nicht mehr vor und verlässt den Raum ohne diesen. Durch den fehlenden Gegenstand wird der NPC in einer Falle gefangen, kann sich nicht befreien und stirbt.
Der NPC hätte aber, hätte er den Gegenstand gehabt entkommen können und wäre später wieder auf den Spieler getroffen, um diesen beim Bosskampf zu unterstützen
etc..

Die Ereignisknoten sind zumindest teilweise vorgegeben, die Kernfrage ist nun, wie entschieden wird, welche Alternativwege bzw. sogar Alternativknoten durch diese eine Aktion in den einzelnen Zeitstufen erzeugt werden.

Den Startknoten bildet dabei immer der aktuelle Hauptereignisknoten (das entfernen von Gegenstand X)

24.06.2011 - 07:29 Uhr

Hallo,

mal ne blöde Frage aber wo bekomme ich so ein Steuerelement her, wie es bei den Eigenschaften im Designer von VS verwendet wird?

22.06.2011 - 21:59 Uhr

Hallo,

ich möchte ein Konstrukt erstellen, dass mir eine Zeitlinie definiert, in der bespilsweise das entfernen von Objekt A in X Abschnitten weiter Einfluss auf Person B nimmt. Allerdings kann ich mi da noch nicht so ganz vorstellen, wie man das realisieren kann.

Eine Möglichkeit wäre ein Baum, aber wie definier ich das Ende, bzw den Anfang und wie kann ich die alternativwege "berechnen" , wenn ich Objekt A entnehme, schlägt der Pfad von Person B auf einen anderen um etc.

Und für die, die jetzt wieder aufklärend tätig sein wollen, ja ich kenne mich mit der Defiition von Zeit im allgemeinen aus.

21.06.2011 - 14:44 Uhr

Hallo,

ich hab heute mal ein Shaderprogramm (mal wieder auf einem Poolrechner) ausprobiert, dass aber nichts getan hat. Bei einer Prüfung von glGetProgram ergab, dass das Programm wohl Invalid war.

Da es sich um ein Beispiel handelte, kann ich mir nicht vorstellen, dass das Programm an sich falsch war.

Weiß jemand woran das ligen kann?
Eventuell am Treiber?

10.06.2011 - 18:57 Uhr

OK, habs getestet und mit dem reduzierten Puffer hats geklappt.
Mein Performancecounter hat auch keine Packete verschludert oder vermatscht.

(übers Netzwerk an meinen Server in Düsseldorf und wieder zurück)

10.06.2011 - 18:08 Uhr

sofern Du TCP und nicht UDP

Ne, Ne, ist schon TCP.

Wenn Du die Größe der einzelnen Pakete kennst, kannst Du das ggf. mit einer entsprechenden Puffergröße beim Lesen steuern, allerdings nur bei einem stabilen, schnellen Netzwerk.

Du meinst also, wenn ich Packete mit 8byte versende, sollte ich einen Puffer von 8Byte größe verwenden, um zu gewährleisten, dass die Daten alle einzeln ankommen?
Ist denn dabei auch gewährleistet, dass auch wirklich die gesendeten 8byte im Puffer sind und nicht etwa 2 teile von 2 verschiedenen sendungen?

Und auch da würde ich an Deiner Stelle auf jeden Fall noch auswerten, wieviele Bytes tatsächlich emfangen wurden!

Wie meinst du denn das? Ich erhalte ja über die empfangsmethode ein Array, welches immer genauso groß ist, wie die bei cTCPConnection.Client.EndReceive(result) erhaltenen Elemente in meinem Puffer

10.06.2011 - 17:10 Uhr

ja aber gibts da nichts internes, dass das verhinert?

Ich mein die Packete werden ja auf layerebene auch nummeriert. Kann ich dem result nicht sagen, dass es nur warten soll bis ein sendesatz komplett ist (also bis packete 1, 2 und 3/3 da sind)?

10.06.2011 - 16:40 Uhr

Moin,

ich hab n Problem mit einer Socketbasierten TCP/IP Client-Server Anwendung. Und zwar sende ich zum Performancetest etwa 10000 Anfragen a 8 byte in einer for-Schleife und einem seperaten Thread. Nun habe ich aber das Problem eines zu potenten Servers, dass heißt, dass teilweise mehrere Antworten auf einmal in ein und demselben Result zurückkommen und teilweise auch abgeschnitten werden, wenn der Puffer voll ist.

Gibt es eine Möglichkeit, dass die Anfragen so zurück kommen, wie ich sie gesendet habe? Das Senden langsamer zu machen ist dabei aber keine Option.

Unser Code sieht 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;
                }
            }
        }

Kann ich da eventuell was über das Socketflagg machen?

07.06.2011 - 08:56 Uhr

Hast du zufällig irgendwelche schwammigen relativen pfade zu irgendwelchen Dateien in deinem Programm?

Application.Startuppath,
Envirpoment.CurrentDirectory
und natürlich "../Datei.endung"

können jenachdem wer wo was startetd sehr unterschiedlich sein. Hast du das mal geprüft?

Hast du daran gedacht eventuelle Biondungen an verwendete Assemblies zu prüfen, ob diese auch beim Start geladen werden können?