Thread Rating:
  • 0 Vote(s) - 0 Average
  • 1
  • 2
  • 3
  • 4
  • 5
A useful site
Here's some excellent simple tips on changing your work flow from OpenGLES2.0 to OpenGLES3.0

The key thing to consider is that there's not a huge amount changes on the client (main code) side, the bulk of the changes happen in the shader language itself.
There's a few new features you might want to send values to but its still a case of the client sending attributes, now called in values,  and uniforms and letting the shaders to their work.

That said there are rather a lot of nice things in OpenGLES3.0, heres a list I found on stackoverflow. Most of these relate to new data structures you can use, or extensions to exisiting structures, making your shaders far more flexible.  Most normal mortals won't use but a fraction of these new features but you may discover that something you are trying to do, but failed or found too slow, is now much more plausible.  
For me the biggest thing is VAO's and Instancing and multiple render targets. These make it very easy to populate and dress a scene with large numbers of the same model, with or without manipulation, as well as a far easier way to create shadow buffers and light effects.

  • OpenGL Shading Language ES 3.00

  • transform feedback 1 and 2 (with restrictions)

  • uniform buffer objects including block arrays

  • vertex array objects

  • sampler objects

  • sync objects and fences

  • pixel buffer objects

  • buffer subrange mapping

  • buffer object to buffer object copies 314

  • boolean occlusion queries, including conservative mode

  • instanced rendering, via shader variable and/or vertex attribute divisor

  • multiple render targets

  • 2D array and 3D textures

  • simplified texture storage specification

  • R and RG textures

  • texture swizzles

  • seamless cube maps

  • non-power-of-two textures with full wrap mode support and mipmapping

  • texture LOD clamps and mipmap level base offset and max clamp

  • at least 32 textures, at least 16 each for fragment and vertex shaders

  • 16-bit (with filtering) and 32-bit (without filtering) floating-point textures

  • 32-bit, 16-bit, and 8-bit signed and unsigned integer renderbuffers, textures, and vertex attributes

  • 8-bit sRGB textures and framebuffers (without mixed RGB/sRGB rendering)

  • 11/11/10 floating-point RGB textures

  • shared exponent RGB 9/9/9/5 textures

  • 10/10/10/2 unsigned normalized and unnormalized integer textures

  • 10/10/10/2 signed and unsigned normalized vertex attributes

  • 16-bit floating-point vertex attributes

  • 8-bit-per-component signed normalized textures

  • ETC2/EAC texture compression formats

  • sized internal texture formats with minimum precision guarantees

  • multisample renderbuffers

  • 8-bit unsigned normalized renderbuffers

  • depth textures and shadow comparison

  • 24-bit depth renderbuffers and textures

  • 24/8 depth/stencil renderbuffers and textures

  • 32-bit depth and 32F/8 depth/stencil renderbuffers and textures

  • stretch blits (with restrictions)

  • framebuffer invalidation hints

  • primitive restart with fixed index

  • unsigned integer element indices with at least 24 usable bits

  • draw command allowing specification of range of accessed elements

  • ability to attach any mipmap level to a framebuffer object

  • minimum/maximum blend equations

  • program binaries, including querying binaries from linked GLSL programs

  • mandatory online compiler

  • non-square and transposable uniform matrices

  • additional pixel store state

  • indexed extension string queries
Brian Beuken
Lecturer in Game Programming at Breda University of Applied Sciences.
Author of The Fundamentals of C/C++ Game Programming: Using Target-based Development on SBC's 


Forum Jump:

Users browsing this thread: 1 Guest(s)