Jaka jest precyzja highplay w GLSL ES 2.0 (Dla iPhone/iPod touch/iPad)?

From the OpenGL ES Shading Language reference:

• highp - 16-bitowy, zmiennoprzecinkowy zakres: -2^62 do 2^62, zakres liczb całkowitych: -2^16 do 2^16
• mediump - 10 bitowy, pływający zakres punktowy: -2^14 do 2^14, liczba całkowita zakres: -2^10 do 2^10
• lowp - 8 bit, zakres zmiennoprzecinkowy: -2 do 2, zakres liczb całkowitych: -2^8 do 2^8

W moich testach na mojej linii drogich zabawek:

Zarówno dla ints, jak i float, precyzje i zakresy dla shaderów fragmentów i wierzchołków są takie same.

Nie będę więc wymieniał wyczerpująco wszystkich kombinacji.

Zauważ również, że precyzja ints jest zdefiniowana jako zawsze 0.

PowerVR SGX543MP3 (iPhone 5):

• pływaki
  • Low: precision = 8, range = 0 to 0 (nie jestem pewien, ale myślę, że oznacza to, że nie możemy oczekiwać lowp, aby w rzeczywistości być w stanie reprezentować wartość osiągającą dokładnie 2 lub -2, naprawdę nie znam dobrego sposobu, aby to przetestować, ani nie powinniśmy nadmiernie martwić się o te ograniczenia, po prostu użyj mediump kiedy to może być kiedykolwiek problemem) {]}
  • Medium: precyzja = 10, Zakres = 15 do 15 (spełnia spec)
  • High: precision = 23, range = 127 to 127 (exceeds spec)
• Ints
  • Low: range = 23 to 23 (exceeds spec)
  • Medium: range = 23 to 23
  • High: range = 23 to 23 (exceeds spec)

A7 & PowerVR G6430 (iPad Air):

• pływaki
  • Low: precision = 10, range = 15 to 15 (exceeds spec)
  • Medium: precyzja = 10, Zakres = 15 do 15 (spełnia spec)
  • wysoki: precyzja = 23, zakres = 127 do 127 (przekracza ES 2.0 spec, spełnia 3.0 spec)
• Ints
  • Low: range = 15 to 14 (exceeds spec)
  • Medium: zakres = 15 do 14 (przekracza ES 2.0 spec, spełnia ES 3.0 spec)
  • High: range = 31 do 30 (przekracza ES 2.0 spec, spełnia ES 3.0 spec)

A8 & PowerVR GX6450 (iPhone 6 Plus):

• pływaki
  • Low: precision = 10, range = 15 to 15 (exceeds spec)
  • Medium: precyzja = 10, Zakres = 15 do 15 (spełnia spec)
  • High: precision = 23, range = 127 to 127 (przekracza ES 2.0 spec, spełnia 3.0 spec)
• Ints
  • niski: zakres = 15 do 14 (przekracza spec)
  • Medium: zakres = 15 do 14 (przekracza ES 2.0 spec, spełnia ES 3.0 spec)
  • High: range = 31 do 30 (przekracza ES 2.0 spec, spełnia ES 3.0 spec)

Oto przykład, jak można odpytywać wartości.

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);

Nie jest dla mnie jeszcze jasne, czy można oczekiwać wymiernej poprawy wydajności, wybierając typ o niższej precyzji (nawet w niektórych telefonach które mają już 3 lata).

Jest oczywiste, że trend zmierza w kierunku konwergencji ze sprzętem komputerowym, ponieważ widać, że najnowsze GPU całkowicie wyeliminowały typy 8 bitów i recyklingują mediump dla lowp.