sigonasr2/jmonkeyengine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #277 from zzuegg/master

Browse Source 
Added GL_MAX_VERTEX_UNIFORM_COMPONENTS
This commit is contained in:
Kirill Vainer 2015-06-20 13:42:37 -04:00
commit 37c572434c
3 changed files with 162 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
jme3-core/src/main/java/com/jme3/renderer/Limits.java
View File

@ -75,4 +75,6 @@ public enum Limits {
ColorTextureSamples, ColorTextureSamples,
DepthTextureSamples, DepthTextureSamples,
VertexUniformVectors,
} }

2
jme3-core/src/main/java/com/jme3/renderer/opengl/GL.java
View File

@ -100,6 +100,8 @@ public interface GL {
public static final int GL_MAX_TEXTURE_SIZE = 0xD33; public static final int GL_MAX_TEXTURE_SIZE = 0xD33;
public static final int GL_MAX_VERTEX_ATTRIBS = 0x8869; public static final int GL_MAX_VERTEX_ATTRIBS = 0x8869;
public static final int GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C; public static final int GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C;
public static final int GL_MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A;
public static final int GL_MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB;
public static final int GL_MIRRORED_REPEAT = 0x8370; public static final int GL_MIRRORED_REPEAT = 0x8370;
public static final int GL_NEAREST = 0x2600; public static final int GL_NEAREST = 0x2600;
public static final int GL_NEAREST_MIPMAP_LINEAR = 0x2702; public static final int GL_NEAREST_MIPMAP_LINEAR = 0x2702;

312
jme3-core/src/main/java/com/jme3/renderer/opengl/GLRenderer.java
View File

@ -73,7 +73,7 @@ public class GLRenderer implements Renderer {
private static final Logger logger = Logger.getLogger(GLRenderer.class.getName()); private static final Logger logger = Logger.getLogger(GLRenderer.class.getName());
private static final boolean VALIDATE_SHADER = false; private static final boolean VALIDATE_SHADER = false;
private static final Pattern GLVERSION_PATTERN = Pattern.compile(".*?(\\d+)\\.(\\d+).*"); private static final Pattern GLVERSION_PATTERN = Pattern.compile(".*?(\\d+)\\.(\\d+).*");
private final ByteBuffer nameBuf = BufferUtils.createByteBuffer(250); private final ByteBuffer nameBuf = BufferUtils.createByteBuffer(250);
private final StringBuilder stringBuf = new StringBuilder(250); private final StringBuilder stringBuf = new StringBuilder(250);
private final IntBuffer intBuf1 = BufferUtils.createIntBuffer(1); private final IntBuffer intBuf1 = BufferUtils.createIntBuffer(1);
@ -83,7 +83,7 @@ public class GLRenderer implements Renderer {
private final NativeObjectManager objManager = new NativeObjectManager(); private final NativeObjectManager objManager = new NativeObjectManager();
private final EnumSet<Caps> caps = EnumSet.noneOf(Caps.class); private final EnumSet<Caps> caps = EnumSet.noneOf(Caps.class);
private final EnumMap<Limits, Integer> limits = new EnumMap<Limits, Integer>(Limits.class); private final EnumMap<Limits, Integer> limits = new EnumMap<Limits, Integer>(Limits.class);
private FrameBuffer mainFbOverride = null; private FrameBuffer mainFbOverride = null;
private final Statistics statistics = new Statistics(); private final Statistics statistics = new Statistics();
private int vpX, vpY, vpW, vpH; private int vpX, vpY, vpW, vpH;
@ -98,7 +98,7 @@ public class GLRenderer implements Renderer {
private final GLExt glext; private final GLExt glext;
private final GLFbo glfbo; private final GLFbo glfbo;
private final TextureUtil texUtil; private final TextureUtil texUtil;
public GLRenderer(GL gl, GLExt glext, GLFbo glfbo) { public GLRenderer(GL gl, GLExt glext, GLFbo glfbo) {
this.gl = gl; this.gl = gl;
this.gl2 = gl instanceof GL2 ? (GL2)gl : null; this.gl2 = gl instanceof GL2 ? (GL2)gl : null;
@ -118,7 +118,7 @@ public class GLRenderer implements Renderer {
public EnumSet<Caps> getCaps() { public EnumSet<Caps> getCaps() {
return caps; return caps;
} }
// Not making public yet ... // Not making public yet ...
public EnumMap<Limits, Integer> getLimits() { public EnumMap<Limits, Integer> getLimits() {
return limits; return limits;
@ -140,7 +140,7 @@ public class GLRenderer implements Renderer {
} }
return extensionSet; return extensionSet;
} }
public static int extractVersion(String version) { public static int extractVersion(String version) {
Matcher m = GLVERSION_PATTERN.matcher(version); Matcher m = GLVERSION_PATTERN.matcher(version);
if (m.matches()) { if (m.matches()) {
@ -160,17 +160,17 @@ public class GLRenderer implements Renderer {
private boolean hasExtension(String extensionName) { private boolean hasExtension(String extensionName) {
return extensions.contains(extensionName); return extensions.contains(extensionName);
} }
private void loadCapabilitiesES() { private void loadCapabilitiesES() {
caps.add(Caps.GLSL100); caps.add(Caps.GLSL100);
caps.add(Caps.OpenGLES20); caps.add(Caps.OpenGLES20);
// Important: Do not add OpenGL20 - that's the desktop capability! // Important: Do not add OpenGL20 - that's the desktop capability!
} }
private void loadCapabilitiesGL2() { private void loadCapabilitiesGL2() {
int oglVer = extractVersion(gl.glGetString(GL.GL_VERSION)); int oglVer = extractVersion(gl.glGetString(GL.GL_VERSION));
if (oglVer >= 200) { if (oglVer >= 200) {
caps.add(Caps.OpenGL20); caps.add(Caps.OpenGL20);
if (oglVer >= 210) { if (oglVer >= 210) {
@ -194,9 +194,9 @@ public class GLRenderer implements Renderer {
} }
} }
} }
int glslVer = extractVersion(gl.glGetString(GL.GL_SHADING_LANGUAGE_VERSION)); int glslVer = extractVersion(gl.glGetString(GL.GL_SHADING_LANGUAGE_VERSION));
switch (glslVer) { switch (glslVer) {
default: default:
if (glslVer < 400) { if (glslVer < 400) {
@ -222,34 +222,34 @@ public class GLRenderer implements Renderer {
caps.add(Caps.GLSL100); caps.add(Caps.GLSL100);
break; break;
} }
// Workaround, always assume we support GLSL100 & GLSL110 // Workaround, always assume we support GLSL100 & GLSL110
// Supporting OpenGL 2.0 means supporting GLSL 1.10. // Supporting OpenGL 2.0 means supporting GLSL 1.10.
caps.add(Caps.GLSL110); caps.add(Caps.GLSL110);
caps.add(Caps.GLSL100); caps.add(Caps.GLSL100);
// Fix issue in TestRenderToMemory when GL.GL_FRONT is the main // Fix issue in TestRenderToMemory when GL.GL_FRONT is the main
// buffer being used. // buffer being used.
context.initialDrawBuf = getInteger(GL2.GL_DRAW_BUFFER); context.initialDrawBuf = getInteger(GL2.GL_DRAW_BUFFER);
context.initialReadBuf = getInteger(GL2.GL_READ_BUFFER); context.initialReadBuf = getInteger(GL2.GL_READ_BUFFER);
// XXX: This has to be GL.GL_BACK for canvas on Mac // XXX: This has to be GL.GL_BACK for canvas on Mac
// Since initialDrawBuf is GL.GL_FRONT for pbuffer, gotta // Since initialDrawBuf is GL.GL_FRONT for pbuffer, gotta
// change this value later on ... // change this value later on ...
// initialDrawBuf = GL.GL_BACK; // initialDrawBuf = GL.GL_BACK;
// initialReadBuf = GL.GL_BACK; // initialReadBuf = GL.GL_BACK;
} }
private void loadCapabilitiesCommon() { private void loadCapabilitiesCommon() {
extensions = loadExtensions(); extensions = loadExtensions();
limits.put(Limits.VertexTextureUnits, getInteger(GL.GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS)); limits.put(Limits.VertexTextureUnits, getInteger(GL.GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS));
if (limits.get(Limits.VertexTextureUnits) > 0) { if (limits.get(Limits.VertexTextureUnits) > 0) {
caps.add(Caps.VertexTextureFetch); caps.add(Caps.VertexTextureFetch);
} }
limits.put(Limits.FragmentTextureUnits, getInteger(GL.GL_MAX_TEXTURE_IMAGE_UNITS)); limits.put(Limits.FragmentTextureUnits, getInteger(GL.GL_MAX_TEXTURE_IMAGE_UNITS));
// gl.glGetInteger(GL.GL_MAX_VERTEX_UNIFORM_COMPONENTS, intBuf16); // gl.glGetInteger(GL.GL_MAX_VERTEX_UNIFORM_COMPONENTS, intBuf16);
// vertexUniforms = intBuf16.get(0); // vertexUniforms = intBuf16.get(0);
// logger.log(Level.FINER, "Vertex Uniforms: {0}", vertexUniforms); // logger.log(Level.FINER, "Vertex Uniforms: {0}", vertexUniforms);
@ -257,62 +257,66 @@ public class GLRenderer implements Renderer {
// gl.glGetInteger(GL.GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, intBuf16); // gl.glGetInteger(GL.GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, intBuf16);
// fragUniforms = intBuf16.get(0); // fragUniforms = intBuf16.get(0);
// logger.log(Level.FINER, "Fragment Uniforms: {0}", fragUniforms); // logger.log(Level.FINER, "Fragment Uniforms: {0}", fragUniforms);
if (caps.contains(Caps.OpenGLES20)) {
limits.put(Limits.VertexUniformVectors, getInteger(GL.GL_MAX_VERTEX_UNIFORM_VECTORS));
} else {
limits.put(Limits.VertexUniformVectors, getInteger(GL.GL_MAX_VERTEX_UNIFORM_COMPONENTS) / 4);
}
limits.put(Limits.VertexAttributes, getInteger(GL.GL_MAX_VERTEX_ATTRIBS)); limits.put(Limits.VertexAttributes, getInteger(GL.GL_MAX_VERTEX_ATTRIBS));
limits.put(Limits.TextureSize, getInteger(GL.GL_MAX_TEXTURE_SIZE)); limits.put(Limits.TextureSize, getInteger(GL.GL_MAX_TEXTURE_SIZE));
limits.put(Limits.CubemapSize, getInteger(GL.GL_MAX_CUBE_MAP_TEXTURE_SIZE)); limits.put(Limits.CubemapSize, getInteger(GL.GL_MAX_CUBE_MAP_TEXTURE_SIZE));
if (hasExtension("GL_ARB_draw_instanced") && if (hasExtension("GL_ARB_draw_instanced") &&
hasExtension("GL_ARB_instanced_arrays")) { hasExtension("GL_ARB_instanced_arrays")) {
caps.add(Caps.MeshInstancing); caps.add(Caps.MeshInstancing);
} }
if (hasExtension("GL_OES_element_index_uint") || gl2 != null) { if (hasExtension("GL_OES_element_index_uint") || gl2 != null) {
caps.add(Caps.IntegerIndexBuffer); caps.add(Caps.IntegerIndexBuffer);
} }
if (hasExtension("GL_ARB_texture_buffer_object")) { if (hasExtension("GL_ARB_texture_buffer_object")) {
caps.add(Caps.TextureBuffer); caps.add(Caps.TextureBuffer);
} }
// == texture format extensions == // == texture format extensions ==
boolean hasFloatTexture; boolean hasFloatTexture;
hasFloatTexture = hasExtension("GL_OES_texture_half_float") && hasFloatTexture = hasExtension("GL_OES_texture_half_float") &&
hasExtension("GL_OES_texture_float"); hasExtension("GL_OES_texture_float");
if (!hasFloatTexture) { if (!hasFloatTexture) {
hasFloatTexture = hasExtension("GL_ARB_texture_float") && hasFloatTexture = hasExtension("GL_ARB_texture_float") &&
hasExtension("GL_ARB_half_float_pixel"); hasExtension("GL_ARB_half_float_pixel");
if (!hasFloatTexture) { if (!hasFloatTexture) {
hasFloatTexture = caps.contains(Caps.OpenGL30); hasFloatTexture = caps.contains(Caps.OpenGL30);
} }
} }
if (hasFloatTexture) { if (hasFloatTexture) {
caps.add(Caps.FloatTexture); caps.add(Caps.FloatTexture);
} }
if (hasExtension("GL_OES_depth_texture") || gl2 != null) { if (hasExtension("GL_OES_depth_texture") || gl2 != null) {
caps.add(Caps.DepthTexture); caps.add(Caps.DepthTexture);
// TODO: GL_OES_depth24 // TODO: GL_OES_depth24
} }
if (hasExtension("GL_OES_rgb8_rgba8") || if (hasExtension("GL_OES_rgb8_rgba8") ||
hasExtension("GL_ARM_rgba8") || hasExtension("GL_ARM_rgba8") ||
hasExtension("GL_EXT_texture_format_BGRA8888")) { hasExtension("GL_EXT_texture_format_BGRA8888")) {
caps.add(Caps.Rgba8); caps.add(Caps.Rgba8);
} }
if (caps.contains(Caps.OpenGL30) || hasExtension("GL_OES_packed_depth_stencil")) { if (caps.contains(Caps.OpenGL30) || hasExtension("GL_OES_packed_depth_stencil")) {
caps.add(Caps.PackedDepthStencilBuffer); caps.add(Caps.PackedDepthStencilBuffer);
} }
if (hasExtension("GL_ARB_color_buffer_float") && if (hasExtension("GL_ARB_color_buffer_float") &&
hasExtension("GL_ARB_half_float_pixel")) { hasExtension("GL_ARB_half_float_pixel")) {
// XXX: Require both 16 and 32 bit float support for FloatColorBuffer. // XXX: Require both 16 and 32 bit float support for FloatColorBuffer.
caps.add(Caps.FloatColorBuffer); caps.add(Caps.FloatColorBuffer);
} }
@ -321,44 +325,44 @@ public class GLRenderer implements Renderer {
caps.add(Caps.FloatDepthBuffer); caps.add(Caps.FloatDepthBuffer);
} }
if ((hasExtension("GL_EXT_packed_float") && hasFloatTexture) || if ((hasExtension("GL_EXT_packed_float") && hasFloatTexture) ||
caps.contains(Caps.OpenGL30)) { caps.contains(Caps.OpenGL30)) {
// Either OpenGL3 is available or both packed_float & half_float_pixel. // Either OpenGL3 is available or both packed_float & half_float_pixel.
caps.add(Caps.PackedFloatColorBuffer); caps.add(Caps.PackedFloatColorBuffer);
caps.add(Caps.PackedFloatTexture); caps.add(Caps.PackedFloatTexture);
} }
if (hasExtension("GL_EXT_texture_shared_exponent") || caps.contains(Caps.OpenGL30)) { if (hasExtension("GL_EXT_texture_shared_exponent") || caps.contains(Caps.OpenGL30)) {
caps.add(Caps.SharedExponentTexture); caps.add(Caps.SharedExponentTexture);
} }
if (hasExtension("GL_EXT_texture_compression_s3tc")) { if (hasExtension("GL_EXT_texture_compression_s3tc")) {
caps.add(Caps.TextureCompressionS3TC); caps.add(Caps.TextureCompressionS3TC);
} }
if (hasExtension("GL_ARB_ES3_compatibility")) { if (hasExtension("GL_ARB_ES3_compatibility")) {
caps.add(Caps.TextureCompressionETC2); caps.add(Caps.TextureCompressionETC2);
caps.add(Caps.TextureCompressionETC1); caps.add(Caps.TextureCompressionETC1);
} else if (hasExtension("GL_OES_compressed_ETC1_RGB8_texture")) { } else if (hasExtension("GL_OES_compressed_ETC1_RGB8_texture")) {
caps.add(Caps.TextureCompressionETC1); caps.add(Caps.TextureCompressionETC1);
} }
// == end texture format extensions == // == end texture format extensions ==
if (hasExtension("GL_ARB_vertex_array_object") || caps.contains(Caps.OpenGL30)) { if (hasExtension("GL_ARB_vertex_array_object") || caps.contains(Caps.OpenGL30)) {
caps.add(Caps.VertexBufferArray); caps.add(Caps.VertexBufferArray);
} }
if (hasExtension("GL_ARB_texture_non_power_of_two") || if (hasExtension("GL_ARB_texture_non_power_of_two") ||
hasExtension("GL_OES_texture_npot") || hasExtension("GL_OES_texture_npot") ||
caps.contains(Caps.OpenGL30)) { caps.contains(Caps.OpenGL30)) {
caps.add(Caps.NonPowerOfTwoTextures); caps.add(Caps.NonPowerOfTwoTextures);
} else { } else {
logger.log(Level.WARNING, "Your graphics card does not " logger.log(Level.WARNING, "Your graphics card does not "
+ "support non-power-of-2 textures. " + "support non-power-of-2 textures. "
+ "Some features might not work."); + "Some features might not work.");
} }
if (caps.contains(Caps.OpenGLES20)) { if (caps.contains(Caps.OpenGLES20)) {
// OpenGL ES 2 has some limited support for NPOT textures // OpenGL ES 2 has some limited support for NPOT textures
caps.add(Caps.PartialNonPowerOfTwoTextures); caps.add(Caps.PartialNonPowerOfTwoTextures);
@ -374,14 +378,14 @@ public class GLRenderer implements Renderer {
if (hasExtension("GL_EXT_framebuffer_object") || gl3 != null) { if (hasExtension("GL_EXT_framebuffer_object") || gl3 != null) {
caps.add(Caps.FrameBuffer); caps.add(Caps.FrameBuffer);
limits.put(Limits.RenderBufferSize, getInteger(GLFbo.GL_MAX_RENDERBUFFER_SIZE_EXT)); limits.put(Limits.RenderBufferSize, getInteger(GLFbo.GL_MAX_RENDERBUFFER_SIZE_EXT));
limits.put(Limits.FrameBufferAttachments, getInteger(GLFbo.GL_MAX_COLOR_ATTACHMENTS_EXT)); limits.put(Limits.FrameBufferAttachments, getInteger(GLFbo.GL_MAX_COLOR_ATTACHMENTS_EXT));
if (hasExtension("GL_EXT_framebuffer_blit")) { if (hasExtension("GL_EXT_framebuffer_blit")) {
caps.add(Caps.FrameBufferBlit); caps.add(Caps.FrameBufferBlit);
} }
if (hasExtension("GL_EXT_framebuffer_multisample")) { if (hasExtension("GL_EXT_framebuffer_multisample")) {
caps.add(Caps.FrameBufferMultisample); caps.add(Caps.FrameBufferMultisample);
limits.put(Limits.FrameBufferSamples, getInteger(GLExt.GL_MAX_SAMPLES_EXT)); limits.put(Limits.FrameBufferSamples, getInteger(GLExt.GL_MAX_SAMPLES_EXT));
@ -419,10 +423,10 @@ public class GLRenderer implements Renderer {
} }
caps.add(Caps.Multisample); caps.add(Caps.Multisample);
} }
// Supports sRGB pipeline. // Supports sRGB pipeline.
if ( (hasExtension("GL_ARB_framebuffer_sRGB") && hasExtension("GL_EXT_texture_sRGB")) if ( (hasExtension("GL_ARB_framebuffer_sRGB") && hasExtension("GL_EXT_texture_sRGB"))
|| caps.contains(Caps.OpenGL30) ) { || caps.contains(Caps.OpenGL30) ) {
caps.add(Caps.Srgb); caps.add(Caps.Srgb);
} }
@ -430,33 +434,33 @@ public class GLRenderer implements Renderer {
if (hasExtension("GL_ARB_seamless_cube_map") || caps.contains(Caps.OpenGL32)) { if (hasExtension("GL_ARB_seamless_cube_map") || caps.contains(Caps.OpenGL32)) {
caps.add(Caps.SeamlessCubemap); caps.add(Caps.SeamlessCubemap);
} }
if (caps.contains(Caps.OpenGL32) && !hasExtension("GL_ARB_compatibility")) { if (caps.contains(Caps.OpenGL32) && !hasExtension("GL_ARB_compatibility")) {
caps.add(Caps.CoreProfile); caps.add(Caps.CoreProfile);
} }
if (hasExtension("GL_ARB_get_program_binary")) { if (hasExtension("GL_ARB_get_program_binary")) {
int binaryFormats = getInteger(GLExt.GL_NUM_PROGRAM_BINARY_FORMATS); int binaryFormats = getInteger(GLExt.GL_NUM_PROGRAM_BINARY_FORMATS);
if (binaryFormats > 0) { if (binaryFormats > 0) {
caps.add(Caps.BinaryShader); caps.add(Caps.BinaryShader);
} }
} }
// Print context information // Print context information
logger.log(Level.INFO, "OpenGL Renderer Information\n" + logger.log(Level.INFO, "OpenGL Renderer Information\n" +
" * Vendor: {0}\n" + " * Vendor: {0}\n" +
" * Renderer: {1}\n" + " * Renderer: {1}\n" +
" * OpenGL Version: {2}\n" + " * OpenGL Version: {2}\n" +
" * GLSL Version: {3}\n" + " * GLSL Version: {3}\n" +
" * Profile: {4}", " * Profile: {4}",
new Object[]{ new Object[]{
gl.glGetString(GL.GL_VENDOR), gl.glGetString(GL.GL_VENDOR),
gl.glGetString(GL.GL_RENDERER), gl.glGetString(GL.GL_RENDERER),
gl.glGetString(GL.GL_VERSION), gl.glGetString(GL.GL_VERSION),
gl.glGetString(GL.GL_SHADING_LANGUAGE_VERSION), gl.glGetString(GL.GL_SHADING_LANGUAGE_VERSION),
caps.contains(Caps.CoreProfile) ? "Core" : "Compatibility" caps.contains(Caps.CoreProfile) ? "Core" : "Compatibility"
}); });
// Print capabilities (if fine logging is enabled) // Print capabilities (if fine logging is enabled)
if (logger.isLoggable(Level.FINE)) { if (logger.isLoggable(Level.FINE)) {
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@ -467,10 +471,10 @@ public class GLRenderer implements Renderer {
} }
logger.log(Level.FINE, sb.toString()); logger.log(Level.FINE, sb.toString());
} }
texUtil.initialize(caps); texUtil.initialize(caps);
} }
private void loadCapabilities() { private void loadCapabilities() {
if (gl2 != null) { if (gl2 != null) {
loadCapabilitiesGL2(); loadCapabilitiesGL2();
@ -479,31 +483,31 @@ public class GLRenderer implements Renderer {
} }
loadCapabilitiesCommon(); loadCapabilitiesCommon();
} }
private int getInteger(int en) { private int getInteger(int en) {
intBuf16.clear(); intBuf16.clear();
gl.glGetInteger(en, intBuf16); gl.glGetInteger(en, intBuf16);
return intBuf16.get(0); return intBuf16.get(0);
} }
private boolean getBoolean(int en) { private boolean getBoolean(int en) {
gl.glGetBoolean(en, nameBuf); gl.glGetBoolean(en, nameBuf);
return nameBuf.get(0) != (byte)0; return nameBuf.get(0) != (byte)0;
} }
@SuppressWarnings("fallthrough") @SuppressWarnings("fallthrough")
public void initialize() { public void initialize() {
loadCapabilities(); loadCapabilities();
// Initialize default state.. // Initialize default state..
gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, 1); gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, 1);
if (caps.contains(Caps.CoreProfile)) { if (caps.contains(Caps.CoreProfile)) {
// Core Profile requires VAO to be bound. // Core Profile requires VAO to be bound.
gl3.glGenVertexArrays(intBuf16); gl3.glGenVertexArrays(intBuf16);
int vaoId = intBuf16.get(0); int vaoId = intBuf16.get(0);
gl3.glBindVertexArray(vaoId); gl3.glBindVertexArray(vaoId);
} }
if (gl2 != null) { if (gl2 != null) {
gl2.glEnable(GL2.GL_VERTEX_PROGRAM_POINT_SIZE); gl2.glEnable(GL2.GL_VERTEX_PROGRAM_POINT_SIZE);
if (!caps.contains(Caps.CoreProfile)) { if (!caps.contains(Caps.CoreProfile)) {
@ -536,8 +540,8 @@ public class GLRenderer implements Renderer {
} }
/*********************************************************************\ /*********************************************************************\
|* Render State *| |* Render State *|
\*********************************************************************/ \*********************************************************************/
public void setDepthRange(float start, float end) { public void setDepthRange(float start, float end) {
gl.glDepthRange(start, end); gl.glDepthRange(start, end);
} }
@ -602,7 +606,7 @@ public class GLRenderer implements Renderer {
} }
if (state.isDepthTest() && !context.depthTestEnabled) { if (state.isDepthTest() && !context.depthTestEnabled) {
gl.glEnable(GL.GL_DEPTH_TEST); gl.glEnable(GL.GL_DEPTH_TEST);
gl.glDepthFunc(convertTestFunction(context.depthFunc)); gl.glDepthFunc(convertTestFunction(context.depthFunc));
context.depthTestEnabled = true; context.depthTestEnabled = true;
} else if (!state.isDepthTest() && context.depthTestEnabled) { } else if (!state.isDepthTest() && context.depthTestEnabled) {
@ -714,7 +718,7 @@ public class GLRenderer implements Renderer {
case Color: case Color:
case Screen: case Screen:
gl.glBlendFunc(GL.GL_ONE, GL.GL_ONE_MINUS_SRC_COLOR); gl.glBlendFunc(GL.GL_ONE, GL.GL_ONE_MINUS_SRC_COLOR);
break; break;
case Exclusion: case Exclusion:
gl.glBlendFunc(GL.GL_ONE_MINUS_DST_COLOR, GL.GL_ONE_MINUS_SRC_COLOR); gl.glBlendFunc(GL.GL_ONE_MINUS_DST_COLOR, GL.GL_ONE_MINUS_SRC_COLOR);
break; break;
@ -815,8 +819,8 @@ public class GLRenderer implements Renderer {
} }
/*********************************************************************\ /*********************************************************************\
|* Camera and World transforms *| |* Camera and World transforms *|
\*********************************************************************/ \*********************************************************************/
public void setViewPort(int x, int y, int w, int h) { public void setViewPort(int x, int y, int w, int h) {
if (x != vpX || vpY != y || vpW != w || vpH != h) { if (x != vpX || vpY != y || vpW != w || vpH != h) {
gl.glViewport(x, y, w, h); gl.glViewport(x, y, w, h);
@ -859,8 +863,8 @@ public class GLRenderer implements Renderer {
} }
/*********************************************************************\ /*********************************************************************\
|* Shaders *| |* Shaders *|
\*********************************************************************/ \*********************************************************************/
protected void updateUniformLocation(Shader shader, Uniform uniform) { protected void updateUniformLocation(Shader shader, Uniform uniform) {
int loc = gl.glGetUniformLocation(shader.getId(), uniform.getName()); int loc = gl.glGetUniformLocation(shader.getId(), uniform.getName());
if (loc < 0) { if (loc < 0) {
@ -1040,12 +1044,12 @@ public class GLRenderer implements Renderer {
boolean gles2 = caps.contains(Caps.OpenGLES20); boolean gles2 = caps.contains(Caps.OpenGLES20);
String language = source.getLanguage(); String language = source.getLanguage();
if (gles2 && !language.equals("GLSL100")) { if (gles2 && !language.equals("GLSL100")) {
throw new RendererException("This shader cannot run in OpenGL ES 2. " throw new RendererException("This shader cannot run in OpenGL ES 2. "
+ "Only GLSL 1.00 shaders are supported."); + "Only GLSL 1.00 shaders are supported.");
} }
// Upload shader source. // Upload shader source.
// Merge the defines and source code. // Merge the defines and source code.
stringBuf.setLength(0); stringBuf.setLength(0);
@ -1072,14 +1076,14 @@ public class GLRenderer implements Renderer {
} }
} }
} }
if (linearizeSrgbImages) { if (linearizeSrgbImages) {
stringBuf.append("#define SRGB 1\n"); stringBuf.append("#define SRGB 1\n");
} }
stringBuf.append(source.getDefines()); stringBuf.append(source.getDefines());
stringBuf.append(source.getSource()); stringBuf.append(source.getSource());
intBuf1.clear(); intBuf1.clear();
intBuf1.put(0, stringBuf.length()); intBuf1.put(0, stringBuf.length());
gl.glShaderSource(id, new String[]{ stringBuf.toString() }, intBuf1); gl.glShaderSource(id, new String[]{ stringBuf.toString() }, intBuf1);
@ -1137,7 +1141,7 @@ public class GLRenderer implements Renderer {
// If using GLSL 1.5, we bind the outputs for the user // If using GLSL 1.5, we bind the outputs for the user
// For versions 3.3 and up, user should use layout qualifiers instead. // For versions 3.3 and up, user should use layout qualifiers instead.
boolean bindFragDataRequired = false; boolean bindFragDataRequired = false;
for (ShaderSource source : shader.getSources()) { for (ShaderSource source : shader.getSources()) {
if (source.isUpdateNeeded()) { if (source.isUpdateNeeded()) {
updateShaderSourceData(source); updateShaderSourceData(source);
@ -1246,8 +1250,8 @@ public class GLRenderer implements Renderer {
} }
/*********************************************************************\ /*********************************************************************\
|* Framebuffers *| |* Framebuffers *|
\*********************************************************************/ \*********************************************************************/
public void copyFrameBuffer(FrameBuffer src, FrameBuffer dst) { public void copyFrameBuffer(FrameBuffer src, FrameBuffer dst) {
copyFrameBuffer(src, dst, true); copyFrameBuffer(src, dst, true);
} }
@ -1402,7 +1406,7 @@ public class GLRenderer implements Renderer {
} else if (attachmentSlot < 0 || attachmentSlot >= 16) { } else if (attachmentSlot < 0 || attachmentSlot >= 16) {
throw new UnsupportedOperationException("Invalid FBO attachment slot: " + attachmentSlot); throw new UnsupportedOperationException("Invalid FBO attachment slot: " + attachmentSlot);
} }
return GLFbo.GL_COLOR_ATTACHMENT0_EXT + attachmentSlot; return GLFbo.GL_COLOR_ATTACHMENT0_EXT + attachmentSlot;
} }
@ -1412,7 +1416,7 @@ public class GLRenderer implements Renderer {
if (image.isUpdateNeeded()) { if (image.isUpdateNeeded()) {
// Check NPOT requirements // Check NPOT requirements
checkNonPowerOfTwo(tex); checkNonPowerOfTwo(tex);
updateTexImageData(image, tex.getType(), 0, false); updateTexImageData(image, tex.getType(), 0, false);
// NOTE: For depth textures, sets nearest/no-mips mode // NOTE: For depth textures, sets nearest/no-mips mode
@ -1476,7 +1480,7 @@ public class GLRenderer implements Renderer {
} }
checkFrameBufferError(); checkFrameBufferError();
fb.clearUpdateNeeded(); fb.clearUpdateNeeded();
} }
@ -1569,7 +1573,7 @@ public class GLRenderer implements Renderer {
// update viewport to reflect framebuffer's resolution // update viewport to reflect framebuffer's resolution
setViewPort(0, 0, fb.getWidth(), fb.getHeight()); setViewPort(0, 0, fb.getWidth(), fb.getHeight());
if (context.boundFBO != fb.getId()) { if (context.boundFBO != fb.getId()) {
glfbo.glBindFramebufferEXT(GLFbo.GL_FRAMEBUFFER_EXT, fb.getId()); glfbo.glBindFramebufferEXT(GLFbo.GL_FRAMEBUFFER_EXT, fb.getId());
statistics.onFrameBufferUse(fb, true); statistics.onFrameBufferUse(fb, true);
@ -1640,7 +1644,7 @@ public class GLRenderer implements Renderer {
public void readFrameBuffer(FrameBuffer fb, ByteBuffer byteBuf) { public void readFrameBuffer(FrameBuffer fb, ByteBuffer byteBuf) {
readFrameBufferWithGLFormat(fb, byteBuf, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE); readFrameBufferWithGLFormat(fb, byteBuf, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE);
} }
private void readFrameBufferWithGLFormat(FrameBuffer fb, ByteBuffer byteBuf, int glFormat, int dataType) { private void readFrameBufferWithGLFormat(FrameBuffer fb, ByteBuffer byteBuf, int glFormat, int dataType) {
if (fb != null) { if (fb != null) {
RenderBuffer rb = fb.getColorBuffer(); RenderBuffer rb = fb.getColorBuffer();
@ -1662,8 +1666,8 @@ public class GLRenderer implements Renderer {
gl.glReadPixels(vpX, vpY, vpW, vpH, glFormat, dataType, byteBuf); gl.glReadPixels(vpX, vpY, vpW, vpH, glFormat, dataType, byteBuf);
} }
public void readFrameBufferWithFormat(FrameBuffer fb, ByteBuffer byteBuf, Image.Format format) { public void readFrameBufferWithFormat(FrameBuffer fb, ByteBuffer byteBuf, Image.Format format) {
GLImageFormat glFormat = texUtil.getImageFormatWithError(format, false); GLImageFormat glFormat = texUtil.getImageFormatWithError(format, false);
readFrameBufferWithGLFormat(fb, byteBuf, glFormat.format, glFormat.dataType); readFrameBufferWithGLFormat(fb, byteBuf, glFormat.format, glFormat.dataType);
} }
@ -1696,14 +1700,14 @@ public class GLRenderer implements Renderer {
} }
/*********************************************************************\ /*********************************************************************\
|* Textures *| |* Textures *|
\*********************************************************************/ \*********************************************************************/
private int convertTextureType(Texture.Type type, int samples, int face) { private int convertTextureType(Texture.Type type, int samples, int face) {
if (samples > 1 && !caps.contains(Caps.TextureMultisample)) { if (samples > 1 && !caps.contains(Caps.TextureMultisample)) {
throw new RendererException("Multisample textures are not supported" + throw new RendererException("Multisample textures are not supported" +
" by the video hardware."); " by the video hardware.");
} }
switch (type) { switch (type) {
case TwoDimensional: case TwoDimensional:
if (samples > 1) { if (samples > 1) {
@ -1723,8 +1727,8 @@ public class GLRenderer implements Renderer {
} }
case ThreeDimensional: case ThreeDimensional:
if (!caps.contains(Caps.OpenGL20)) { if (!caps.contains(Caps.OpenGL20)) {
throw new RendererException("3D textures are not supported" + throw new RendererException("3D textures are not supported" +
" by the video hardware."); " by the video hardware.");
} }
return GL2.GL_TEXTURE_3D; return GL2.GL_TEXTURE_3D;
case CubeMap: case CubeMap:
@ -1807,11 +1811,11 @@ public class GLRenderer implements Renderer {
int target = convertTextureType(tex.getType(), image != null ? image.getMultiSamples() : 1, -1); int target = convertTextureType(tex.getType(), image != null ? image.getMultiSamples() : 1, -1);
boolean haveMips = true; boolean haveMips = true;
if (image != null) { if (image != null) {
haveMips = image.isGeneratedMipmapsRequired() || image.hasMipmaps(); haveMips = image.isGeneratedMipmapsRequired() || image.hasMipmaps();
} }
// filter things // filter things
if (image.getLastTextureState().magFilter != tex.getMagFilter()) { if (image.getLastTextureState().magFilter != tex.getMagFilter()) {
int magFilter = convertMagFilter(tex.getMagFilter()); int magFilter = convertMagFilter(tex.getMagFilter());
@ -1834,7 +1838,7 @@ public class GLRenderer implements Renderer {
context.seamlessCubemap = false; context.seamlessCubemap = false;
} }
} }
if (tex.getAnisotropicFilter() > 1) { if (tex.getAnisotropicFilter() > 1) {
if (caps.contains(Caps.TextureFilterAnisotropic)) { if (caps.contains(Caps.TextureFilterAnisotropic)) {
gl.glTexParameterf(target, gl.glTexParameterf(target,
@ -1871,15 +1875,15 @@ public class GLRenderer implements Renderer {
// R to Texture compare mode // R to Texture compare mode
if (tex.getShadowCompareMode() != Texture.ShadowCompareMode.Off) { if (tex.getShadowCompareMode() != Texture.ShadowCompareMode.Off) {
gl2.glTexParameteri(target, GL2.GL_TEXTURE_COMPARE_MODE, GL2.GL_COMPARE_R_TO_TEXTURE); gl2.glTexParameteri(target, GL2.GL_TEXTURE_COMPARE_MODE, GL2.GL_COMPARE_R_TO_TEXTURE);
gl2.glTexParameteri(target, GL2.GL_DEPTH_TEXTURE_MODE, GL2.GL_INTENSITY); gl2.glTexParameteri(target, GL2.GL_DEPTH_TEXTURE_MODE, GL2.GL_INTENSITY);
if (tex.getShadowCompareMode() == Texture.ShadowCompareMode.GreaterOrEqual) { if (tex.getShadowCompareMode() == Texture.ShadowCompareMode.GreaterOrEqual) {
gl2.glTexParameteri(target, GL2.GL_TEXTURE_COMPARE_FUNC, GL.GL_GEQUAL); gl2.glTexParameteri(target, GL2.GL_TEXTURE_COMPARE_FUNC, GL.GL_GEQUAL);
} else { } else {
gl2.glTexParameteri(target, GL2.GL_TEXTURE_COMPARE_FUNC, GL.GL_LEQUAL); gl2.glTexParameteri(target, GL2.GL_TEXTURE_COMPARE_FUNC, GL.GL_LEQUAL);
} }
}else{ }else{
//restoring default value //restoring default value
gl2.glTexParameteri(target, GL2.GL_TEXTURE_COMPARE_MODE, GL.GL_NONE); gl2.glTexParameteri(target, GL2.GL_TEXTURE_COMPARE_MODE, GL.GL_NONE);
} }
tex.compareModeUpdated(); tex.compareModeUpdated();
} }
@ -1891,7 +1895,7 @@ public class GLRenderer implements Renderer {
* Textures with power-of-2 dimensions are supported on all hardware, however * Textures with power-of-2 dimensions are supported on all hardware, however
* non-power-of-2 textures may or may not be supported depending on which * non-power-of-2 textures may or may not be supported depending on which
* texturing features are used. * texturing features are used.
* *
* @param tex The texture to validate. * @param tex The texture to validate.
* @throws RendererException If the texture is not supported by the hardware * @throws RendererException If the texture is not supported by the hardware
*/ */
@ -1900,23 +1904,23 @@ public class GLRenderer implements Renderer {
// Texture is power-of-2, safe to use. // Texture is power-of-2, safe to use.
return; return;
} }
if (caps.contains(Caps.NonPowerOfTwoTextures)) { if (caps.contains(Caps.NonPowerOfTwoTextures)) {
// Texture is NPOT but it is supported by video hardware. // Texture is NPOT but it is supported by video hardware.
return; return;
} }
// Maybe we have some / partial support for NPOT? // Maybe we have some / partial support for NPOT?
if (!caps.contains(Caps.PartialNonPowerOfTwoTextures)) { if (!caps.contains(Caps.PartialNonPowerOfTwoTextures)) {
// Cannot use any type of NPOT texture (uncommon) // Cannot use any type of NPOT texture (uncommon)
throw new RendererException("non-power-of-2 textures are not " throw new RendererException("non-power-of-2 textures are not "
+ "supported by the video hardware"); + "supported by the video hardware");
} }
// Partial NPOT supported.. // Partial NPOT supported..
if (tex.getMinFilter().usesMipMapLevels()) { if (tex.getMinFilter().usesMipMapLevels()) {
throw new RendererException("non-power-of-2 textures with mip-maps " throw new RendererException("non-power-of-2 textures with mip-maps "
+ "are not supported by the video hardware"); + "are not supported by the video hardware");
} }
switch (tex.getType()) { switch (tex.getType()) {
@ -1924,7 +1928,7 @@ public class GLRenderer implements Renderer {
case ThreeDimensional: case ThreeDimensional:
if (tex.getWrap(WrapAxis.R) != Texture.WrapMode.EdgeClamp) { if (tex.getWrap(WrapAxis.R) != Texture.WrapMode.EdgeClamp) {
throw new RendererException("repeating non-power-of-2 textures " throw new RendererException("repeating non-power-of-2 textures "
+ "are not supported by the video hardware"); + "are not supported by the video hardware");
} }
// fallthrough intentional!!! // fallthrough intentional!!!
case TwoDimensionalArray: case TwoDimensionalArray:
@ -1932,17 +1936,17 @@ public class GLRenderer implements Renderer {
if (tex.getWrap(WrapAxis.S) != Texture.WrapMode.EdgeClamp if (tex.getWrap(WrapAxis.S) != Texture.WrapMode.EdgeClamp
|| tex.getWrap(WrapAxis.T) != Texture.WrapMode.EdgeClamp) { || tex.getWrap(WrapAxis.T) != Texture.WrapMode.EdgeClamp) {
throw new RendererException("repeating non-power-of-2 textures " throw new RendererException("repeating non-power-of-2 textures "
+ "are not supported by the video hardware"); + "are not supported by the video hardware");
} }
break; break;
default: default:
throw new UnsupportedOperationException("unrecongized texture type"); throw new UnsupportedOperationException("unrecongized texture type");
} }
} }
/** /**
* Uploads the given image to the GL driver. * Uploads the given image to the GL driver.
* *
* @param img The image to upload * @param img The image to upload
* @param type How the data in the image argument should be interpreted. * @param type How the data in the image argument should be interpreted.
* @param unit The texture slot to be used to upload the image, not important * @param unit The texture slot to be used to upload the image, not important
@ -1968,7 +1972,7 @@ public class GLRenderer implements Renderer {
gl.glActiveTexture(GL.GL_TEXTURE0 + unit); gl.glActiveTexture(GL.GL_TEXTURE0 + unit);
context.boundTextureUnit = unit; context.boundTextureUnit = unit;
} }
gl.glBindTexture(target, texId); gl.glBindTexture(target, texId);
context.boundTextures[unit] = img; context.boundTextures[unit] = img;
@ -2011,12 +2015,12 @@ public class GLRenderer implements Renderer {
throw new RendererException("Multisample textures are not supported by the video hardware"); throw new RendererException("Multisample textures are not supported by the video hardware");
} }
} }
// Check if graphics card doesn't support depth textures // Check if graphics card doesn't support depth textures
if (img.getFormat().isDepthFormat() && !caps.contains(Caps.DepthTexture)) { if (img.getFormat().isDepthFormat() && !caps.contains(Caps.DepthTexture)) {
throw new RendererException("Depth textures are not supported by the video hardware"); throw new RendererException("Depth textures are not supported by the video hardware");
} }
if (target == GL.GL_TEXTURE_CUBE_MAP) { if (target == GL.GL_TEXTURE_CUBE_MAP) {
// Check max texture size before upload // Check max texture size before upload
int cubeSize = limits.get(Limits.CubemapSize); int cubeSize = limits.get(Limits.CubemapSize);
@ -2053,12 +2057,12 @@ public class GLRenderer implements Renderer {
if (!caps.contains(Caps.TextureArray)) { if (!caps.contains(Caps.TextureArray)) {
throw new RendererException("Texture arrays not supported by graphics hardware"); throw new RendererException("Texture arrays not supported by graphics hardware");
} }
List<ByteBuffer> data = imageForUpload.getData(); List<ByteBuffer> data = imageForUpload.getData();
// -1 index specifies prepare data for 2D Array // -1 index specifies prepare data for 2D Array
texUtil.uploadTexture(imageForUpload, target, -1, linearizeSrgbImages); texUtil.uploadTexture(imageForUpload, target, -1, linearizeSrgbImages);
for (int i = 0; i < data.size(); i++) { for (int i = 0; i < data.size(); i++) {
// upload each slice of 2D array in turn // upload each slice of 2D array in turn
// this time with the appropriate index // this time with the appropriate index
@ -2087,21 +2091,21 @@ public class GLRenderer implements Renderer {
if (image.isUpdateNeeded() || (image.isGeneratedMipmapsRequired() && !image.isMipmapsGenerated())) { if (image.isUpdateNeeded() || (image.isGeneratedMipmapsRequired() && !image.isMipmapsGenerated())) {
// Check NPOT requirements // Check NPOT requirements
boolean scaleToPot = false; boolean scaleToPot = false;
try { try {
checkNonPowerOfTwo(tex); checkNonPowerOfTwo(tex);
} catch (RendererException ex) { } catch (RendererException ex) {
if (logger.isLoggable(Level.WARNING)) { if (logger.isLoggable(Level.WARNING)) {
int nextWidth = FastMath.nearestPowerOfTwo(tex.getImage().getWidth()); int nextWidth = FastMath.nearestPowerOfTwo(tex.getImage().getWidth());
int nextHeight = FastMath.nearestPowerOfTwo(tex.getImage().getHeight()); int nextHeight = FastMath.nearestPowerOfTwo(tex.getImage().getHeight());
logger.log(Level.WARNING, logger.log(Level.WARNING,
"Non-power-of-2 textures are not supported! Scaling texture '" + tex.getName() + "Non-power-of-2 textures are not supported! Scaling texture '" + tex.getName() +
"' of size " + tex.getImage().getWidth() + "x" + tex.getImage().getHeight() + "' of size " + tex.getImage().getWidth() + "x" + tex.getImage().getHeight() +
" to " + nextWidth + "x" + nextHeight); " to " + nextWidth + "x" + nextHeight);
} }
scaleToPot = true; scaleToPot = true;
} }
updateTexImageData(image, tex.getType(), unit, scaleToPot); updateTexImageData(image, tex.getType(), unit, scaleToPot);
} }
@ -2147,8 +2151,8 @@ public class GLRenderer implements Renderer {
} }
/*********************************************************************\ /*********************************************************************\
|* Vertex Buffers and Attributes *| |* Vertex Buffers and Attributes *|
\*********************************************************************/ \*********************************************************************/
private int convertUsage(Usage usage) { private int convertUsage(Usage usage) {
switch (usage) { switch (usage) {
case Static: case Static:
@ -2222,7 +2226,7 @@ public class GLRenderer implements Renderer {
//statistics.onVertexBufferUse(vb, false); //statistics.onVertexBufferUse(vb, false);
} }
} }
int usage = convertUsage(vb.getUsage()); int usage = convertUsage(vb.getUsage());
vb.getData().rewind(); vb.getData().rewind();
@ -2283,7 +2287,7 @@ public class GLRenderer implements Renderer {
if (context.boundShaderProgram <= 0) { if (context.boundShaderProgram <= 0) {
throw new IllegalStateException("Cannot render mesh without shader bound"); throw new IllegalStateException("Cannot render mesh without shader bound");
} }
Attribute attrib = context.boundShader.getAttribute(vb.getBufferType()); Attribute attrib = context.boundShader.getAttribute(vb.getBufferType());
int loc = attrib.getLocation(); int loc = attrib.getLocation();
if (loc == -1) { if (loc == -1) {
@ -2413,7 +2417,7 @@ public class GLRenderer implements Renderer {
// What is this? // What is this?
throw new RendererException("Unexpected format for index buffer: " + indexBuf.getFormat()); throw new RendererException("Unexpected format for index buffer: " + indexBuf.getFormat());
} }
if (indexBuf.isUpdateNeeded()) { if (indexBuf.isUpdateNeeded()) {
updateBufferData(indexBuf); updateBufferData(indexBuf);
} }
@ -2487,8 +2491,8 @@ public class GLRenderer implements Renderer {
} }
/*********************************************************************\ /*********************************************************************\
|* Render Calls *| |* Render Calls *|
\*********************************************************************/ \*********************************************************************/
public int convertElementMode(Mesh.Mode mode) { public int convertElementMode(Mesh.Mode mode) {
switch (mode) { switch (mode) {
case Points: case Points:
@ -2530,7 +2534,7 @@ public class GLRenderer implements Renderer {
if (interleavedData != null && interleavedData.isUpdateNeeded()) { if (interleavedData != null && interleavedData.isUpdateNeeded()) {
updateBufferData(interleavedData); updateBufferData(interleavedData);
} }
if (instanceData != null) { if (instanceData != null) {
setVertexAttrib(instanceData, null); setVertexAttrib(instanceData, null);
} }
@ -2580,11 +2584,11 @@ public class GLRenderer implements Renderer {
} }
private void renderMeshDefault(Mesh mesh, int lod, int count, VertexBuffer[] instanceData) { private void renderMeshDefault(Mesh mesh, int lod, int count, VertexBuffer[] instanceData) {
// Here while count is still passed in. Can be removed when/if // Here while count is still passed in. Can be removed when/if
// the method is collapsed again. -pspeed // the method is collapsed again. -pspeed
count = Math.max(mesh.getInstanceCount(), count); count = Math.max(mesh.getInstanceCount(), count);
VertexBuffer interleavedData = mesh.getBuffer(Type.InterleavedData); VertexBuffer interleavedData = mesh.getBuffer(Type.InterleavedData);
if (interleavedData != null && interleavedData.isUpdateNeeded()) { if (interleavedData != null && interleavedData.isUpdateNeeded()) {
updateBufferData(interleavedData); updateBufferData(interleavedData);
@ -2602,7 +2606,7 @@ public class GLRenderer implements Renderer {
setVertexAttrib(vb, null); setVertexAttrib(vb, null);
} }
} }
for (VertexBuffer vb : mesh.getBufferList().getArray()) { for (VertexBuffer vb : mesh.getBufferList().getArray()) {
if (vb.getBufferType() == Type.InterleavedData if (vb.getBufferType() == Type.InterleavedData
|| vb.getUsage() == Usage.CpuOnly // ignore cpu-only buffers || vb.getUsage() == Usage.CpuOnly // ignore cpu-only buffers
@ -2637,7 +2641,7 @@ public class GLRenderer implements Renderer {
gl.glLineWidth(mesh.getLineWidth()); gl.glLineWidth(mesh.getLineWidth());
context.lineWidth = mesh.getLineWidth(); context.lineWidth = mesh.getLineWidth();
} }
if (gl4 != null && mesh.getMode().equals(Mode.Patch)) { if (gl4 != null && mesh.getMode().equals(Mode.Patch)) {
gl4.glPatchParameter(mesh.getPatchVertexCount()); gl4.glPatchParameter(mesh.getPatchVertexCount());
} }
@ -2653,12 +2657,12 @@ public class GLRenderer implements Renderer {
// Gamma correction // Gamma correction
if (!caps.contains(Caps.Srgb) && enableSrgb) { if (!caps.contains(Caps.Srgb) && enableSrgb) {
// Not supported, sorry. // Not supported, sorry.
logger.warning("sRGB framebuffer is not supported " + logger.warning("sRGB framebuffer is not supported " +
"by video hardware, but was requested."); "by video hardware, but was requested.");
return; return;
} }
setFrameBuffer(null); setFrameBuffer(null);
if (enableSrgb) { if (enableSrgb) {