Wie hoch ist die Präzision von Highspoaks in GLSL ES 2.0 (für iPhone / iPod touch / iPad)?

Ich habe einen shader, der im Idealfall braucht 28 bits der Mantisse, kann ich zwar weniger und die Leistung beeinträchtigen. Wie kann ich ermitteln, was die Präzision der 'HP' ist in OpenGL ES? Es ist wahrscheinlich eine FP24, mit 16-bit (Mantisse, aber ich kann nicht herausfinden, für sicher oder wie zu Fragen, OpenGL. Irgendwelche Ideen?

InformationsquelleAutor der Frage gonzojive | 2010-12-10

  1. 10

    Du willst GetShaderPrecisionFormat Abfrage der Reichweite und Präzision der shader-Typen

    int range[2], precision;
glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER, GL_HIGH_FLOAT, range, &precision);

    geben Sie die Reichweite und Präzision highp float.

    InformationsquelleAutor der Antwort Chris Dodd

  2. 28

    Aus der OpenGL ES Shading Language reference:

    • highp - 16-bit, floating-point-Bereich:
      -2^62 auf 2^62, integer Wertebereich: -2^16 bis 2^16
    • mediump - 10-bit, floating
      Punkt-Bereich: -2^14 bis 2^14, integer
      Wertebereich: -2^10 bis 2^10
    • lowp - 8 bit,
      floating-point-Bereich: -2 bis 2,
      integer Wertebereich: -2^8 bis 2^8

    InformationsquelleAutor der Antwort Brad Larson

  3. 13

    In meinen Tests auf meiner Linie teure Spielzeug:

    Für beide ints und floats, die Genauigkeiten und reicht über fragment-und vertex-Shader sind die gleichen.

    Also werde ich nicht alle Kombinationen erschöpfend.

    Beachten Sie auch, dass die Genauigkeit von int-Werten definiert ist, immer 0.

    PowerVR SGX543MP3 (iPhone 5):

    • Schwimmt
      • Niedrig gezielt: precision = 8, range = 0 auf 0 (Nicht sicher, aber ich denke, das bedeutet, dass wir nicht erwarten können, dass ein lowp tatsächlich in der Lage sein zu repräsentieren, einen Wert erreichen genau 2 oder -2 ich weiß wirklich nicht, von eine großartige Möglichkeit, um dies zu testen, noch sollten wir über-beschäftigen uns mit diesen Einschränkungen, verwenden Sie einfach mediump wenn dies jemals ein Thema sein)
      • Medium: precision = 10, Bereich = 15 15 (erfüllt die Anforderungen)
      • Hoch: Präzision = 23, Bereich = 127 bis 127 (übersteigt spec)
    • Ints
      • Niedrig gezielt: range = 23 von 23 (übersteigt spec)
      • Medium: Reichweite = 23 von 23 (übersteigt spec)
      • High: range = 23 von 23 (übersteigt spec)

    A7 & PowerVR G6430 (iPad Air):

    • Schwimmt
      • Niedrig gezielt: precision = 10, Bereich = 15 15 (übersteigt spec)
      • Medium: precision = 10, Bereich = 15 15 (erfüllt die Anforderungen)
      • Hoch: Präzision = 23, Bereich = 127 bis 127 (übersteigt ES 2.0 Spezifikation, entspricht der 3.0 spec)
    • Ints
      • Low: Reichweite = 15 bis 14 (übersteigt spec)
      • Medium: Reichweite = 15 bis 14 (übersteigt ES 2.0 Spezifikation, entspricht ES-3.0-spec)
      • Hoch: Bereich = 31-30 (übersteigt ES 2.0 Spezifikation, entspricht ES-3.0-spec)

    A8 & PowerVR GX6450 (iPhone 6 Plus):

    • Schwimmt
      • Niedrig gezielt: precision = 10, Bereich = 15 15 (übersteigt spec)
      • Medium: precision = 10, Bereich = 15 15 (erfüllt die Anforderungen)
      • Hoch: Präzision = 23, Bereich = 127 bis 127 (übersteigt ES 2.0 Spezifikation, entspricht der 3.0 spec)
    • Ints
      • Low: Reichweite = 15 bis 14 (übersteigt spec)
      • Medium: Reichweite = 15 bis 14 (übersteigt ES 2.0 Spezifikation, entspricht ES-3.0-spec)
      • Hoch: Bereich = 31-30 (übersteigt ES 2.0 Spezifikation, entspricht ES-3.0-spec)

    Hier ist ein Beispiel, wie Sie vielleicht die Abfrage der Werte. 

    int range[2], precision;
glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER, GL_HIGH_FLOAT, range, &precision);
NSLog(@"Fragment shader high precision float range: %d %d precision: %d", range[0], range[1], precision);
glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER, GL_MEDIUM_FLOAT, range, &precision);
NSLog(@"Fragment shader medium precision float range: %d %d precision: %d", range[0], range[1], precision);
glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER, GL_LOW_FLOAT, range, &precision);
NSLog(@"Fragment shader low precision float range: %d %d precision: %d", range[0], range[1], precision);

glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER, GL_HIGH_INT, range, &precision);
NSLog(@"Fragment shader high precision int range: %d %d precision: %d", range[0], range[1], precision);
glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER, GL_MEDIUM_INT, range, &precision);
NSLog(@"Fragment shader medium precision int range: %d %d precision: %d", range[0], range[1], precision);
glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER, GL_LOW_INT, range, &precision);
NSLog(@"Fragment shader low precision int range: %d %d precision: %d", range[0], range[1], precision);

glGetShaderPrecisionFormat(GL_VERTEX_SHADER, GL_HIGH_FLOAT, range, &precision);
NSLog(@"Vertex shader high precision float range: %d %d precision: %d", range[0], range[1], precision);
glGetShaderPrecisionFormat(GL_VERTEX_SHADER, GL_MEDIUM_FLOAT, range, &precision);
NSLog(@"Vertex shader medium precision float range: %d %d precision: %d", range[0], range[1], precision);
glGetShaderPrecisionFormat(GL_VERTEX_SHADER, GL_LOW_FLOAT, range, &precision);
NSLog(@"Vertex shader low precision float range: %d %d precision: %d", range[0], range[1], precision);

glGetShaderPrecisionFormat(GL_VERTEX_SHADER, GL_HIGH_INT, range, &precision);
NSLog(@"Vertex shader high precision int range: %d %d precision: %d", range[0], range[1], precision);
glGetShaderPrecisionFormat(GL_VERTEX_SHADER, GL_MEDIUM_INT, range, &precision);
NSLog(@"Vertex shader medium precision int range: %d %d precision: %d", range[0], range[1], precision);
glGetShaderPrecisionFormat(GL_VERTEX_SHADER, GL_LOW_INT, range, &precision);
NSLog(@"Vertex shader low precision int range: %d %d precision: %d", range[0], range[1], precision);

    Es ist mir nicht klar, noch, ob Sie erwarten können spürbare performance-Verbesserungen durch die Wahl einer niedrigeren Genauigkeit Typ (Auch auf einige Handys, die sind jetzt 3 Jahre alt).

    Es ist klar, dass der trend in Richtung Konvergenz mit desktop-hardware, wie es kann gesehen werden, dass die neuere GPU ' s haben, vollständig eliminiert die 8-bit-Typen und recycling für die mediump für lowp.

    InformationsquelleAutor der Antwort Steven Lu

Schreibe einen Kommentar