[C#] OpenGl problem

Übersicht Andere Programmiersprachen Allgemein

Neue Antwort erstellen

 

PhillipK

Betreff: [C#] OpenGl problem

BeitragFr, März 08, 2013 6:37
Antworten mit Zitat
Benutzer-Profile anzeigen
huhu Community!

Erstmal vorweg: Ich war mir unsicher, ob das nicht eventuell nach Andere Dialekte -> Basic-Fremdes gehört.
Mich macht der punkt stutzig, das ich ja noch garnichts geschrieben habe *grins* Kein code, garnichts, nur "smalltalk" wirds hier eben.

Ich dachte mir, da im rahmen des Umgestaltens vom Portal auch BasicFremdes seinen platz findet, könnte ich mal mit c# anfangen zu lernen.
Allerdings tue ich nichts lieber, wie erstmal snippets zusammenstellen, bzw diverse Teilprobleme zu erarbeiten und wieder zu verwerfen, immer wieder.
Über kurz oder lang wird es darauf hinauslaufen, das ich auch mal etwas sehen möchte, was nicht in ein Gui gezwängt ist - also brauche ich, da ich ganz vernarrt bin, opengl Smile

Angeschaut habe ich mir bisher SharpGL und muss sagen.. ich bin entsetzt!
Eine simple routine welche 100x100 quads auf dem Bildschirm ausgibt... < 2 fps ?
Blitzmax rennt bei meiner maschine mit pur OpenGL mit > 1000fps - also ein himmelweiter unterschied.
Kann mir dies jemand erklären? Liegt es in der eigenheit von SharpGL oder ist Blitzmax einfach cooler, wenn man OpenGL haben will? Very Happy

Kennt jemand eventuell eine Bessere umsetzung von OpenGL in c# ? .. Alles was ich bisher gefunden habe, besagt, das SharpGL einfach der schnellste OpenGL wrapper für c# sein soll :-/


Mein problem:
Über kurz oder lang werde auch ich mal sowas wie eine ausbildung machen. Grobe richtung ist klar, und da wird mir sicher java oder c# begegnen. Da ich java zumindest in den grundzügen schon beherrsche, wollte ich meinen horizont erweitern. Aber ohne openGL macht das lernen keinen spass :3

DAK

BeitragFr, März 08, 2013 8:21
Antworten mit Zitat
Benutzer-Profile anzeigen
Ich habe selbst weder C# noch SharpGL verwendet, nur Java mit LWJGL.
Mal ohne deinen Code zu sehen kann ich mir nicht vorstellen, dass C# plus was als der schnellste GL-Wrapper gehandelt wird, so extrem weit langsamer ist, als BM. Ich wage mal zu behaupten, das es was mit deinem Code hat, aber ohne Code kann man nix beurteilen. Hast du einen Test Case?
(Vor Allem weil auch BlitzMax nicht OpenGL pur, also direkt verwendet, sondern auch einen Wrapper verwendet, so viel ich weiß)
Gewinner der 6. und der 68. BlitzCodeCompo
 

PhillipK

BeitragFr, März 08, 2013 9:34
Antworten mit Zitat
Benutzer-Profile anzeigen
Bwah, code zu posten, den man nur zur hälfte versteht, ist immer so peinlich ...
Also:
Version 1. Direkt von SharpGL als "standartprojekt":
MainWindow.xaml
Code: [AUSKLAPPEN]
<Window x:Class="SharpGLWPFApplication1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="SharpGL WPF Application" Height="768" Width="1024"
        xmlns:sharpGL="clr-namespace:SharpGL.WPF;assembly=SharpGL.WPF">
    <Grid>

        <!-- The OpenGL control provides a OpenGL drawing surface. -->
        <sharpGL:OpenGLControl
        OpenGLDraw="openGLControl_OpenGLDraw"
        OpenGLInitialized="openGLControl_OpenGLInitialized"
        DrawFPS="True"
        FrameRate="10000"
        Resized="openGLControl_Resized" />

    </Grid>
</Window>

-> Bringt das Fenster ins spiel und fügt den SharpGL context ein. OGLDraw, OGLInit und Resized verweist die entsprechenden Events auf Funktionen innerhalb des folgenden codes:

MainWindow.xaml.cs
Code: [AUSKLAPPEN]
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using SharpGL.SceneGraph;
using SharpGL;

namespace SharpGLWPFApplication1
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    ///
   
    public partial class MainWindow : Window
    {

        float rotatePyramid = 0;
        float rquad = 0;

        /// <summary>
        /// Initializes a new instance of the <see cref="MainWindow"/> class.
        /// </summary>
        public MainWindow()
        {
            InitializeComponent();

        }

        /// <summary>
        /// Handles the OpenGLDraw event of the openGLControl1 control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="args">The <see cref="SharpGL.SceneGraph.OpenGLEventArgs"/> instance containing the event data.</param>
        private void openGLControl_OpenGLDraw(object sender, OpenGLEventArgs args)
        {
            //  Get the OpenGL instance that's been passed to us.
            OpenGL gl = args.OpenGL;

            //  Clear the color and depth buffers.
            gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);

            //  Reset the modelview matrix.
            gl.LoadIdentity();

            //  Move the geometry into a fairly central position.
            gl.Translate(-1.5f, 0.0f, -6.0f);

            //  Draw a pyramid. First, rotate the modelview matrix.
            gl.Rotate(rotatePyramid, 0.0f, 1.0f, 0.0f);

            //  Start drawing triangles.
            gl.Begin(OpenGL.GL_TRIANGLES);

            gl.Color(1.0f, 0.0f, 0.0f);
            gl.Vertex(0.0f, 1.0f, 0.0f);
            gl.Color(0.0f, 1.0f, 0.0f);
            gl.Vertex(-1.0f, -1.0f, 1.0f);
            gl.Color(0.0f, 0.0f, 1.0f);
            gl.Vertex(1.0f, -1.0f, 1.0f);

            gl.Color(1.0f, 0.0f, 0.0f);
            gl.Vertex(0.0f, 1.0f, 0.0f);
            gl.Color(0.0f, 0.0f, 1.0f);
            gl.Vertex(1.0f, -1.0f, 1.0f);
            gl.Color(0.0f, 1.0f, 0.0f);
            gl.Vertex(1.0f, -1.0f, -1.0f);

            gl.Color(1.0f, 0.0f, 0.0f);
            gl.Vertex(0.0f, 1.0f, 0.0f);
            gl.Color(0.0f, 1.0f, 0.0f);
            gl.Vertex(1.0f, -1.0f, -1.0f);
            gl.Color(0.0f, 0.0f, 1.0f);
            gl.Vertex(-1.0f, -1.0f, -1.0f);

            gl.Color(1.0f, 0.0f, 0.0f);
            gl.Vertex(0.0f, 1.0f, 0.0f);
            gl.Color(0.0f, 0.0f, 1.0f);
            gl.Vertex(-1.0f, -1.0f, -1.0f);
            gl.Color(0.0f, 1.0f, 0.0f);
            gl.Vertex(-1.0f, -1.0f, 1.0f);

            gl.End();

            //  Reset the modelview.
            gl.LoadIdentity();

            //  Move into a more central position.
            gl.Translate(1.5f, 0.0f, -7.0f);

            //  Rotate the cube.
            gl.Rotate(rquad, 1.0f, 1.0f, 1.0f);

            //  Provide the cube colors and geometry.
            gl.Begin(OpenGL.GL_QUADS);

            gl.Color(0.0f, 1.0f, 0.0f);
            gl.Vertex(1.0f, 1.0f, -1.0f);
            gl.Vertex(-1.0f, 1.0f, -1.0f);
            gl.Vertex(-1.0f, 1.0f, 1.0f);
            gl.Vertex(1.0f, 1.0f, 1.0f);

            gl.Color(1.0f, 0.5f, 0.0f);
            gl.Vertex(1.0f, -1.0f, 1.0f);
            gl.Vertex(-1.0f, -1.0f, 1.0f);
            gl.Vertex(-1.0f, -1.0f, -1.0f);
            gl.Vertex(1.0f, -1.0f, -1.0f);

            gl.Color(1.0f, 0.0f, 0.0f);
            gl.Vertex(1.0f, 1.0f, 1.0f);
            gl.Vertex(-1.0f, 1.0f, 1.0f);
            gl.Vertex(-1.0f, -1.0f, 1.0f);
            gl.Vertex(1.0f, -1.0f, 1.0f);

            gl.Color(1.0f, 1.0f, 0.0f);
            gl.Vertex(1.0f, -1.0f, -1.0f);
            gl.Vertex(-1.0f, -1.0f, -1.0f);
            gl.Vertex(-1.0f, 1.0f, -1.0f);
            gl.Vertex(1.0f, 1.0f, -1.0f);

            gl.Color(0.0f, 0.0f, 1.0f);
            gl.Vertex(-1.0f, 1.0f, 1.0f);
            gl.Vertex(-1.0f, 1.0f, -1.0f);
            gl.Vertex(-1.0f, -1.0f, -1.0f);
            gl.Vertex(-1.0f, -1.0f, 1.0f);

            gl.Color(1.0f, 0.0f, 1.0f);
            gl.Vertex(1.0f, 1.0f, -1.0f);
            gl.Vertex(1.0f, 1.0f, 1.0f);
            gl.Vertex(1.0f, -1.0f, 1.0f);
            gl.Vertex(1.0f, -1.0f, -1.0f);

            gl.End();

            //  Flush OpenGL.
            gl.Flush();

            //  Rotate the geometry a bit.
            rotatePyramid += 3.0f;
            rquad -= 3.0f;
           
        }

        /// <summary>
        /// Handles the OpenGLInitialized event of the openGLControl1 control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="args">The <see cref="SharpGL.SceneGraph.OpenGLEventArgs"/> instance containing the event data.</param>
        private void openGLControl_OpenGLInitialized(object sender, OpenGLEventArgs args)
        {


            //  Enable the OpenGL depth testing functionality.
            args.OpenGL.Enable(OpenGL.GL_DEPTH_TEST);
        }

        /// <summary>
        /// Handles the Resized event of the openGLControl1 control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="args">The <see cref="SharpGL.SceneGraph.OpenGLEventArgs"/> instance containing the event data.</param>
        private void openGLControl_Resized(object sender, OpenGLEventArgs args)
        {

            // Get the OpenGL instance.
            OpenGL gl = args.OpenGL;

            // Load and clear the projection matrix.
            gl.MatrixMode(OpenGL.GL_PROJECTION);
            gl.LoadIdentity();

            // Perform a perspective transformation
            gl.Perspective(45.0f, (float)gl.RenderContextProvider.Width /
                (float)gl.RenderContextProvider.Height,
                0.1f, 100.0f);

            // Load the modelview.
            gl.MatrixMode(OpenGL.GL_MODELVIEW);
        }

        /// <summary>
        /// The current rotation.
        /// </summary>
        private float rotation = 0.0f;
    }
}


Zugegeben, nicht ganz der Standartcode, aber die selbe logik.
Leider finde ich die Wikiseite nichtmehr, die diesen simplen "startcode" ausführlich erklärt hat. Fakt ist aber: Ausgabe ist die selbe wie auf dem angebotenen Screenshot, nur das bei mir keine 1100 fps angezeigt werden, sondern eben nur ~200 (schwankend).
Und damit nicht genug, der wert ist auchnoch verfälscht.

Nach ewig vielem rumgeteste, bin ich soweit zu sagen, das es nicht an SharpGL liegt, sondern an einer einstellung im programm / bei mir / keine ahnung, denn:

Beispiel.exe zu SharpGL haben schlechte performance
EigenerCode.exe mit SharpGL hat schlechte performance

Es gibt spürbare ruckler alle 2-3 sekunden (doppelte rendertime etwa)

Uuund: Debugprints mit millisecs lassen vermuten, das der DrawAufruf nur alle 10ms kommt (beim ruckler 20ms) - wobei ich hier noch nicht sagen kann, obs an der Consolenausgabe liegt. Ich arbeite jedenfalls noch dran.

Gestern war ich bereit, das ganze direkt wieder hinzuschmeißen.. Heute bin ich überaus motiviert. Leider fehlen mir ein paar "grundlagen" um das richtige zu googlen *grummel*
Ich suche jedenfalls weiter nach einem versteckten timer oder nicht gesetzen einstellugnen, denn ich habe das gefühl das die programme absichtlich gedrosselt sind :3


PS:
Ich beschreibe noch flott, was da zu sehen sein sollte:
2 Grundformen, pyramide und quad, aus simplen primitiven zusammengesetzt, perspektivisch.
diese drehen sich Wink
Pic:
user posted image

Unerklärlich für mich. Ich bin zwar kein totaler trottel, aber scheinbar doch zu blöde.
Es FÜHLT sich so an, als würde tatsächlich gewartet werden, bis das DrawEvent geschickt wird:
~9.5ms warten, draw, ein paar mal. Bis ein draw aufruf ganz knapp nen tick verpasst hat und die 20ms entstehen.

Ich suche mal weiter nach dem gemeinen timer oder den Threadoptionen, die ich umstellen kann, auch wenn sie vielleicht garnicht existieren^^

Jolinah

BeitragFr, März 08, 2013 10:05
Antworten mit Zitat
Benutzer-Profile anzeigen
Was passiert, wenn du das FrameRate="10000" weglässt im XAML? Denn so wie ich das verstanden habe dient das mehr dazu die Framerate zu limitieren, nicht umgekehrt (da es einen Timer erstellt). Ich habe zumindest ein anderes Beispiel im Netz gefunden, wo das weggelassen wurde und ca. 1200 FPS erreicht wurden.
 

PhillipK

BeitragFr, März 08, 2013 10:44
Antworten mit Zitat
Benutzer-Profile anzeigen
Bleibt gleich schlecht.

Habe grade nochmal das "default projekt" ausgepackt (Datei ->Neues PRojekt -> SharpGL WPF Dings)
Dort die zeilen drawfps, rendercontext und framerate komplett entnommen und getestet ->schön unsauber, hakeliges drehen der pyramide.
Fps so um ~ 300 rum.
Beim maximieren ist der effekt noch weiter ausgeprägt und langsamer. Fps ~ 60.

Habe den fehler mal weiter analysiert - die millisecs() methode war doof. Habe nen anderes getestet, welche mir tatsächlich pro 1ms einen anderen wert geliefert hat - die andere lieferte nur alle 10ms einen veränderten wert.
Das ist auch genau die zeit, die das drawing wohl braucht. Ich vermute also, das SharpGL dem selbem problem unterliegt oO Vielleicht war diese ms sache früher mal "anders" ?

Jedenfalls versuche ich mir grade eine blitzmax übliche programmstruktur zu bauen.

Init

schleife->
update
Drawing
<-schleife
Mal sehen ob ich das schaffe (und ob SharpGL das mitmacht *grins*)

aMul

Sieger des Minimalist Compo 01/13

BeitragFr, März 08, 2013 10:45
Antworten mit Zitat
Benutzer-Profile anzeigen
Ich hab alles nur überflogen geb ich zu, aber:
Du benutzt Immediate Mode zum anzeigen. Das ist so ungefähr die langsamste Art mit OpenGL etwas zu rendern.

Zugegeben sollten deine paar Dreiecke da allerdings immer noch hunderte oder Tausende von FPS kriegen.
Was für eine Grafikkarte hast du?
Hast du mal geschaut ob die GPU zu 100% ausgelastet ist(Ich glaub das Tool GPUz kann das, benutzte selbst den herstellerspezifischen MSI Afterburner).

Mein eigenes Spiel(Panic Pong, schau im WIP Thread) läuft in C# mit OpenTK(OpenGL wrapper) auf bis zu 3000 FPS, und das ist das GANZE Spiel, mit etwa einem dutzend Draw-Calls und Tausenden von Polygonen pro Frame.

Die beste Methode um in OpenGL zu rendern sind VertexBuffers, und evtl. IndexBuffers. Um die zu benutzen brauchst du aber ein relativ gutes Verständnis von der Grafik-Pipeline, und musst evtl. deine eigenen Shader schreiben.

Aber wenn du von Grund auf aufbauen willst kommst du da nicht drum herum.
Ich bin gerade selbst dabei eine Grafik-Engine in C# zu schreiben, da ich anderer Leute Code nicht mag. Mr. Green

Und noch auf deine Frage was man empfehlen kann:
Ich kenn jetzt nur OpenTK, komme damit aber super zurecht. Es setzt OpenGL praktisch 1:1 um, bisher nichts gefunden was nicht drin ist. Hat auch Support für OpenAL, Maus, Keyboard und Controller Input und so.
Nicht 100% sicher wie gut es auf Mac und Linux in Mono läuft, aber ich hab es laufen sehen.
Ein Nachteil ist, dass es niemanden gibt der gerade offiziell daran entwickelt. Ein paar Members der Community versuchen zwar etwas zu tun, aber keiner hat wirklich Überblick oder einen Plan oder so.

Trotzdem benutze ich es, da wie gesagt alles was ich bisher machen wollte super funktioniert hat, und auch mit SEHR guter Performance.

EDIT:
Btw, sollte das hier nicht in "Basic-Fremdes"? Smile
Panic Pong - ultimate action mashup of Pong and Breakout <= aktives Spiele-Projekt, Downloads mit vielen bunten Farben!
advASCIIdraw - the advanced ASCII art program <= aktives nicht-Spiele-Projekt, must-have für ASCII/roguelike/dungeon-crawler fans!
Alter BB-Kram: ThroughTheAsteroidBelt - mit Quelltext! | RGB-Palette in 32²-Textur / Farbige Beleuchtung mit Dot3 | Stereoskopie in Blitz3D | Teleport-Animation Screensaver
 

PhillipK

BeitragFr, März 08, 2013 11:30
Antworten mit Zitat
Benutzer-Profile anzeigen
Hehe, ja eigentlich sollte das (mittlerweile) in Basic-Fremdes.
Ich war nur unsicher, weil ich anfangs nur ne frage hatte und keinen code - wo kommt sowas nun rein oO (der beschreibungstext verweißt auf "nicht in basic geschriebenes" - ich hatte aber nichts geschrieben hrhr)

An der grafikkarte wirds nicht liegen - Geforce GTX 550 Ti. (skyrim in full hd, hmm lecker)

Einen vergleichbaren code kann ich, selbst mit immidiate mode, in OpenGL + Blitzmax auch mit ~3000fps rennen lassen.

Ich konnte den fehler weiter isolieren und vermute mittlerweile, das er in der art der FPS bremse liegt. Diese scheint fehlerhaft zu sein, vielleicht .Net abhängig, ka ? Smile (seit den tutorials sind ja auch schon wieder 2-3 jahre ins land gegangen)
Mein vorhaben momentan ist, ein window selbst zu erschaffen und weg vom defaultcode zu gehen. dieser zwingt mich quasie, die eventschleife zu nutzen und alles was bei ist, find ich äusserst uncool.
Aber naja, wie das mit anfängern so ist, das braucht seine zeit.

(zumal Visual studio ständig fehler verursacht. Habe ich was falsch gemacht und kein fenster erscheint, rennt dei exe trotzdem weiter. Killem im taskmanager gibt VS die kontrolle zurück, aber die exe läuft weiter -.- Bis irgendwann die performance absackt und das proggen unmöglich ist. yay!)

BladeRunner

Moderator

BeitragFr, März 08, 2013 17:00
Antworten mit Zitat
Benutzer-Profile anzeigen
Ist doch richtig, weiss gar nicht was Du hast ... Wink
Zu Diensten, Bürger.
Intel T2300, 2.5GB DDR 533, Mobility Radeon X1600 Win XP Home SP3
Intel T8400, 4GB DDR3, Nvidia GF9700M GTS Win 7/64
B3D BMax MaxGUI

Stolzer Gewinner des BAC#48, #52 & #92
 

PhillipK

BeitragSo, März 10, 2013 12:45
Antworten mit Zitat
Benutzer-Profile anzeigen
Falls es mal wen intressiert...

Ich konnte mittlerweile den Fehler lokalisieren.
Wie bereits festgestellt, gibt es durch DateTime (oder wie auch immer das heißt..) diverse Milliseconds funktionen. N bissl rechnen und man hat nen Millisecs() wert wie zb unter BlitzMax - ABER:

Ein blick in SharpGL source ließ meine befürchtung bestätigen. Es nutzt eine MS funktion, welche (mittlerweile?) nur alle 10ms sich ändert - die FPS limitierung wird schlichtweg schlampig berechnet.
Zwar konnte ich den fehler umgehen, indem ich ohne Events gearbeitet habe, aber mein wissen reicht einfach nicht aus, um das wirklich alles sauber zu kapseln - vielerlei begriffe waren mir ein rätsel.
Immerhin hat meine schlampige umsetzung des Zeichnens die > 2000fps geschafft, die ich angedacht hatte ^^

Ausserdem konnte ich nur sehr schlampig einen (von mir sehr geachteten) mainloop einführen - Application.Run(openglform) hat mirn derben strich durch die rechnung gemacht *grins*


Wie auch immer. Sollte es einen C# anfänger geben, der auch gerne Grafische ausgaben via OpenGL haben möchte, dem rate ich zu OpenTK. Vollste kontrolle und die möglichkeit, die opengl befehle FAST wie in blitzmax zu verwenden.
Ausserdem finde ich allerlei Tutorials, Codesnippets und anreize per google.. Macht echt spass, so ne neue Syntax zu lernen Smile


(aMul: Ich bastel auch grade eine kleine Grafiklib, ein paar standartbefehle die ich in Blitzmax geliebt habe. Wenn du nichts dagegen hast, werde ich dich ab und an mal anhaun, wenn ich nach ner woche rumprobieren noch nicht weiterkomme *grins*)

Gruß, Phillip

Noobody

BeitragSo, März 10, 2013 12:49
Antworten mit Zitat
Benutzer-Profile anzeigen
Die "klassischen" Timerfunktionen hatten auf Windows schon immer nur ~10ms grosse Auflösung, ich finde es darum seltsam, dass sich dieses Framework darauf verlässt (vor allem, da es ja anscheinend mal funktioniert hat). Siehe auch hier.
Man is the best computer we can put aboard a spacecraft ... and the only one that can be mass produced with unskilled labor. -- Wernher von Braun
 

PhillipK

BeitragSo, März 10, 2013 13:21
Antworten mit Zitat
Benutzer-Profile anzeigen
Tja, damit kann ich mich erst auseinandersetzen, wenn ich mehr weiß *grins*
Zugegeben, wenn man von blitzmax kommt und geringe java erfahrung hat, gehts extremst einfach.. Aber alles kapier ich noch nicht ganz Very Happy

Was ich jedenfalls mit gewissheit sagen kann:

1) Diverse Exen welche die Samples zeigen, funktionieren ebenso schlecht wie Standartcode den man generieren lassen kann Sad
2) Bei einem umbasteln des Eventsystems zu drawaufrufen kann man eine extrem hohe fps erzielen. alle verfügbaren einstellungen um das event-system zu verschnellern kamen auf max. 200 fps. -> Eigene draws auf 2000+ (cool, der faktor 10 wieder hehe)

:>

DAK

BeitragSo, März 10, 2013 16:10
Antworten mit Zitat
Benutzer-Profile anzeigen
Wegen den 10ms-Timern:
Nenn mir mal eine wirkliche Anwendung (außer Benchmarks), bei der mehr als 100 fps Sinn machen. Die meisten Bildschirme zeigen eh nicht mehr als 60 an.
Gewinner der 6. und der 68. BlitzCodeCompo
 

PhillipK

BeitragSo, März 10, 2013 16:31
Antworten mit Zitat
Benutzer-Profile anzeigen
Na eben die Benchmarks oÔ

Es kann doch nicht sein, das man umwege gehen muss, um die performance des neusten codes zu testen.
Simpler FPS vergleich zeigt immer, wieviel noch drin ist.
Wenns vorher 1000 warn und nach dem neucode nurnoch 200 isses halt mist.
Aber wenn man nichtmal diese 200 normal sehen kann...
Wer programmiert, gibt sich halt nicht gerne mit kontrollverlust ab Smile
 

feider

ehemals "Decelion"

BeitragSo, März 10, 2013 16:42
Antworten mit Zitat
Benutzer-Profile anzeigen
Ich würde dir zudem empfehlen, nicht direkt auf OpenGL-Ebene zu arbeiten. Es mag schnell sein, aber etwas lauffähiges hinzubekommen ist ein wahrer krampf. Schiebe noch eine abstraktionsschicht dazwischen und nutze eine 3D-Engine für die ersten Schritte oder auch weiterhin.
 

PhillipK

BeitragSo, März 10, 2013 16:50
Antworten mit Zitat
Benutzer-Profile anzeigen
In blitzmax kann ich garnichtmehr ohne opengl arbeiten ^^

Is schon ein wenig hintergrundwissen vorhanden, ich krieg das schon hin Smile

DAK

BeitragSo, März 10, 2013 19:50
Antworten mit Zitat
Benutzer-Profile anzeigen
Hmm, den Geschwindigkeitstest von Code solltest du eigentlich auch viel besser hin kriegen als mit FPS. Da checkst du einfach die Uhrzeit in Nanosekunden oder Millisekunden (je nach Laufzeit des Codes) vor dem zu testenden Codesegment und vergleichst ihn mit der Zeit danach. Dadurch kriegst du raus, wie lang genau das zu testende Codesegment braucht, ohne andere Codeteile berücksichtigen zu müssen.

Einfach nach folgendem Pseudocode:

Code: [AUSKLAPPEN]
time = getTimeNamos();
...
totalTime = getTimeNanos()-time


Ist wesentlich besser für reines Performancetesten.

Wenn es dir zu schnell ist, es jedes Frame zu updaten, sammle die Werte für 100 Frames oder so, und gib den Durchschnitt aus.

Code: [AUSKLAPPEN]
time = getTimeNamos();
...
totalTime = totalTime*.99 + (getTimeNanos()-time)*.01
Gewinner der 6. und der 68. BlitzCodeCompo

aMul

Sieger des Minimalist Compo 01/13

BeitragMo, März 11, 2013 12:20
Antworten mit Zitat
Benutzer-Profile anzeigen
feider hat Folgendes geschrieben:
Ich würde dir zudem empfehlen, nicht direkt auf OpenGL-Ebene zu arbeiten. Es mag schnell sein, aber etwas lauffähiges hinzubekommen ist ein wahrer krampf. Schiebe noch eine abstraktionsschicht dazwischen und nutze eine 3D-Engine für die ersten Schritte oder auch weiterhin.

Dem will ich wiedersprechen. Natürlich, wenn man sich aufs Gameplay konzentieren will kann das ein guter Weg sein. Aber Leute wie ich, denen wichtig ist zu verstehen wie Sachen funktionieren, und die gerne das Maximum an Performance rausholen können durchaus direkt auf OpenGL arbeiten.
Natürlich schreibt man sich dann seine eigene "Abstraktionschicht", aber das ist auch nicht wirklich schwer, wenn man genug von der Rendering-Pipeline versteht. Zugegeben sind die Tutorials die man online findet teilweise sehr konfus, aber OpenGL ansich ist nicht komplizierter als andere Frameworks, in meiner Erfahrung.
Wenn einem die low-level Programmierung Spaß macht, hat man sich da schnell eingearbeitet.

Teil Beweis, teils Werbung: Mr. Green
Ich hab mein Spiel Panic Pong über Weihnachten komplett nach C# und OpenTK umgesetzt. Hat ein paar Wochen gedauert ja, aber ich studier nebenher ja auch noch und so, und hatte vorher noch nie was mit OpenGL gemacht.

@PhillipK:
Klar, lass mich wissen wenn du ne Frage oder was anderes zu bereden hast!
Am einfachsten kriegst du mich in Skype, aber alles andere kommt auch irgendwie an.
Hätte Spaß daran zu vergleichen wie wir gewisse Sachen umgesetzt haben. Smile
Panic Pong - ultimate action mashup of Pong and Breakout <= aktives Spiele-Projekt, Downloads mit vielen bunten Farben!
advASCIIdraw - the advanced ASCII art program <= aktives nicht-Spiele-Projekt, must-have für ASCII/roguelike/dungeon-crawler fans!
Alter BB-Kram: ThroughTheAsteroidBelt - mit Quelltext! | RGB-Palette in 32²-Textur / Farbige Beleuchtung mit Dot3 | Stereoskopie in Blitz3D | Teleport-Animation Screensaver
 

PhillipK

BeitragFr, März 15, 2013 8:25
Antworten mit Zitat
Benutzer-Profile anzeigen
Ich kann auch noch nicht wirklich verstehen, warum ich nicht direkt auf OpenGL eben arbeiten sollte.

Klar es ist umständlich und frustrierend, wenn man anfängt, aber nach kurzer zeit hat man den bogen raus.
Ich wrappe eh jeden fitzel wo ich "glXXXXX" schreiben müsste direkt in eine passende funktion Razz

So hab ich schon eine minimale 2d grafik lib, nen platzhalter mesh, nen VBO objekt, nen fbo Objekt, nen Texturverwalter... eben alles, was eigentlich arbeit ist, auf simple befehle vereinfacht. Und dennoch komplett zu 100% von mir verwaltet (und vor allem kenne ich die interne auflösung Smile )

Zugegeben, grade das VBO ding war tricky. Ich bräuchte noch 5 weitere hände, um an den fingern abzählen zu können, wie oft sich mein Grafikkartentreiber verabschiedet hat, weil ich mit den Pointern gemurkst hab. Aber hey, DAS PRÄGT. Daraus lernt man *grins*


@DAK:
Boa. Warum hab ich nicht an Nanos gedacht?
Najut, Millisekunden möchte ich nicht nehmen, ist "zu gering aufgelöst" wenns wirklich flott ist. Und selbst 1000 durchläufe + durchschnittszeit sind mir nicht genau genug.

Was mir an den FPS gefällt : Man merkt einfach direkt, wenn da murx is. Aber schlampig ist es trotzdem, da habt ihr recht.

@aMul:
Werde drauf zurückkommen *grins* Zusammen mit AnniXa is unserere codesammlung in den letzten tagen stark gestiegen. Wäre wirklich intressant zu sehen, wie 2 c# neulinge dinge lösen *grins*
(schickst mir deinen skypenamen per pn? Smile )

Neue Antwort erstellen


Übersicht Andere Programmiersprachen Allgemein

Gehe zu:

Powered by phpBB © 2001 - 2006, phpBB Group