[Projekt]Grafik-Engine

Der neue Code fürs Rendern ist nun komplett fertig und ich bin mehr als zufrieden.
Die Szene die ich vorher mit ca. 180fps gerendert habe, läuft nun mit dem neuen Code bei 2000-2200fps :D Das ist also nochmal deutlich mehr als die angepeilten gut 300% Steigerung bzw. den zuletzt 600%!

Es folgen nun auch bald mal bewegte Bilder ;)
 
Ja die Frage ging wohl wirklich etwas unter^^
Bloß, wie meinst du das denn genau mit der Struktur? Bin mir gerade nicht sicher was du da hören willst :ugly:
 
Krasses Projekt, sieht für einen allein verdammt gut aus (die vielen Features).
Mich würde mal interessieren, wie man den Code für die Kollisionsabfrage schreibt.
 
Krasses Projekt, sieht für einen allein verdammt gut aus (die vielen Features).
Mich würde mal interessieren, wie man den Code für die Kollisionsabfrage schreibt.
Lässt sich einrichten :D

Code:
bool CheckInsidePoly(float x1, float y1, float x2, float y2, float x3, float y3, float px, float py)
{
    float check = ((x2 - x1) * (py - y1)) - ((px - x1) * (y2 - y1));
    if (check > 0.0) {
        check = ((x3 - x2) * (py - y2)) - ((px - x2) * (y3 - y2));
        if (check > 0.0) {
            check = ((x1 - x3) * (py - y3)) - ((px - x3) * (y1 - y3));
            if (check > 0.0)
                return true;
        };
    };

    check = ((x2 - x1) * (py - y1)) - ((px - x1) * (y2 - y1));
    if (-check > 0.0) {
        check = ((x3 - x2) * (py - y2)) - ((px - x2) * (y3 - y2));
        if (-check > 0.0) {
            check = ((x1 - x3) * (py - y3)) - ((px - x3) * (y1 - y3));
            if (-check > 0.0)
                return true;
        };
    };
    return false;
};

void CheckCollision3D()
{
    ColCounter = 0;
    int i, j, k;
    bool Or1, Or2, Or3;
    float x1, x2, y1, y2, z1, z2; //Richtungsvektoren
    float ex, ey, ez; //Ebene
    float b, t;
    float x_fix, y_fix, z_fix;
    float uuu, vvv, www, uuu1, vvv1, www1, uuu2, vvv2, www2;
    double dist;

    for (i=0;i<Mapcounter;i++) {
        for (k=0;k<Objcounter;k++) {
            if (ObjectName[k] == MapInfoName[i])
                break;
        };

        for (j=0;j<VertexCounter[k];j++) {
            Or1 = CheckInsidePoly(Object[k][j][0][0]+MapInfo[i][0], Object[k][j][0][2]+MapInfo[i][2], Object[k][j][1][0]+MapInfo[i][0], Object[k][j][1][2]+MapInfo[i][2], Object[k][j][2][0]+MapInfo[i][0], Object[k][j][2][2]+MapInfo[i][2], Move_x, Move_z); //Y-Col
            Or2 = CheckInsidePoly(Object[k][j][0][1]+MapInfo[i][1], Object[k][j][0][2]+MapInfo[i][2], Object[k][j][1][1]+MapInfo[i][1], Object[k][j][1][2]+MapInfo[i][2], Object[k][j][2][1]+MapInfo[i][1], Object[k][j][2][2]+MapInfo[i][2], Move_y, Move_z); //X-Col

            //Aktuelles Polygone
            uuu = Collision[ColCounter][0] = Object[k][j][0][0]+MapInfo[i][0];
            vvv = Collision[ColCounter][1] = Object[k][j][0][1]+MapInfo[i][1];
            www = Collision[ColCounter][2] = Object[k][j][0][2]+MapInfo[i][2];
            uuu1 = Collision[ColCounter][3] = Object[k][j][1][0]+MapInfo[i][0];
            vvv1 = Collision[ColCounter][4] = Object[k][j][1][1]+MapInfo[i][1];
            www1 = Collision[ColCounter][5] = Object[k][j][1][2]+MapInfo[i][2];
            uuu2 = Collision[ColCounter][6] = Object[k][j][2][0]+MapInfo[i][0];
            vvv2 = Collision[ColCounter][7] = Object[k][j][2][1]+MapInfo[i][1];
            www2 = Collision[ColCounter][8] = Object[k][j][2][2]+MapInfo[i][2];

            x1 = uuu1 - uuu;
            x2 = uuu2 - uuu;
            y1 = vvv1 - vvv;
            y2 = vvv2 - vvv;
            z1 = www1 - www;
            z2 = www2 - www;

            //Ebene mit Kreuzprodukt
            ex = (y1 * z2) - (z1 * y2);
            ey = (z1 * x2) - (x1 * z2);
            ez = (x1 * y2) - (y1 * x2);

            if (Or1) {
                    ColCounter++;

                    b = ex * uuu + ey * vvv + ez * www;
                    t = (b - (Move_y * ey)) / ey;

                    final_x = Move_x;
                    final_y = Move_y + t;
                    final_z = Move_z;

                    y_fix = Move_y - final_y;
                    dist = sqrt(y_fix*y_fix);
                    if (dist < 1.5)
                        Move_y = Move_y_old;
            };

            if (Or2) {
                    ColCounter++;

                    b = ex * uuu + ey * vvv + ez * www;
                    t = (b - (Move_x * ex)) / ex;

                    final_x = Move_x + t;
                    final_y = Move_y;
                    final_z = Move_z;

                    x_fix = Move_x - final_x;
                    dist = sqrt(x_fix*x_fix);
                    if (dist < 1.5) {
                        Move_x = Move_x_old;
                    }
            };
        };
    };
};
Das ist definitiv keine Finalefassung des Codes, dass muss ich dazusagen.
Dieser ColCounter oder Collision[ColCounter][X] speichert nur ein paar Zwischeninfos für mich, damit ich mir grafisch ein paar Dinge ausgeben kann, die Teilweise fürs Verständnis hilfreich sind.

An sich zeigt der Code die Berechnung der Kollision für die X und Y Achse, die Z Achse funktioniert noch etwas anders und so ist der Code auch noch ein klein wenig frisiert, da ich einen Teil gerade überarbeite... Muss noch den Normalenvektor wo einbauen sonst funktioniert da was nicht... aber für einen groben Überblick reichts hoffentlich ;)

Also wie gesagt, später sieht das dann alles mal Ordentlich aus :ugly:
 
Ahja, hätte auch noch ein neues Bild (das komische Objekt was so schräg rumsteht kann mal ignoriert werden :ugly:)
New.jpg

Geht halt vorallem um die Reflektion :)
 
Ahoi!

Zurzeit gibts leider nicht so viel zu berichten. War jetzt zuletzt an der Schattenberechnung dran aber ich muss auch zugeben mich dort teilweise etwas verrannt zu haben. Sobald die Implementierung dann allerdings abgeschlossen ist folgt auch ein Video, wo mal alles ordentlich gezeigt wird.
 
Hi,

programmierst du die Shader eigentlich auch selber oder gibts vllt im Inet dazu vorgefertige Abschnitte? (Weil SO ein Profi bin ich dann nun auch wieder nicht, dass ich das könnte .... bzw. ich will ja auch mal bei mir ein bisschen vorankommen und um sowas könnte ich mich dann später nochmal kümmern)

Apropos Schatten: Machste auch was mit (SS)AO ?
 
Also ich programmiere die Shader schon selber allerdings hab ich da noch Luft nach oben.
Ich hatte mich vorher nicht gerade mit GLSL beschäftigt aber ich merk schon selber das es vorran geht. Erstmal die Basics verstehen und dann weitersehen... Shader programmieren ist zumindest keine Sache des unmöglichen :D

SSAO stand aktuell nicht auf der ToDo Liste aber an sowas hätte ich vllt. später gedacht (?!).
Hab mich dazu mal eingelesen und der algorithmus scheint auch garnicht sooo komplex zu sein... klingt also Umsetzbar. Aber damit beschäftige ich mich dann zu einem späteren Zeitpunkt.
 
Zur Kollision: in der Oberen Hälfte des Quellcodes schaust du, ob in einem Koprdinatensystem sich 2 Punkte berühren (Stichwort Pythagoras ), oder?
 
Ein Dreieck hat ja bekanntlich 3 Linien. A=>B | B=>C | C => A
Ich überprüfe halt, ob der Punkt wo man sich befindet 3mal innerhalb dieses 3 Linien liegt. Trifft dies 3mal zu, weiss ich in welchem Dreieck ich mich befindet.
 
Update zur späten Stunden (oder eher frühen?) :schief:
Die erste Version vom Shadow Mapping konnte ich nun vollenden.
Definitiv noch kein finaler Code aber für den Anfang funktionierts bis jetzt schonmal sehr gut.

Shadow.jpg

Es wird aufjedenfall noch an der Qualität geschraubt aber das kommt dann schon wieder in die Kategorie Feintuning :)
 
Und nochmal ein update.
4xMSAA (Multisample Anti-Aliasing) integriert... sieht wesentlich angenehmer aus ingame :)
MSAA.jpg
 
Mensch da schau ich mal ne Weile net hier rein und du kommst gleich mit MSAA und Schatten :D Da steckt ja doch ne Menge hinter wenn man das mal so betrachtet. Umso schändlicher ist immer dieses rumgemecker über Crysis :what:
 
Mensch da schau ich mal ne Weile net hier rein und du kommst gleich mit MSAA und Schatten :D Da steckt ja doch ne Menge hinter wenn man das mal so betrachtet. Umso schändlicher ist immer dieses rumgemecker über Crysis :what:

Naja manche Hersteller kann man aber wirklich nicht verstehen ...
Aber unabhängig davon ist das hier gebotene wirklich absolut spitze und ich werde es auf jeden Fall weiter beobachten :daumen:
 
Zurück