// + "renderer!");
versionStr = "";
}
- logger.info("GLES20.GL_SHADING_LANGUAGE_VERSION = "+versionStr);
+ logger.info("GLES20.GL_SHADING_LANGUAGE_VERSION = " + versionStr);
// Fix issue in TestRenderToMemory when GL_FRONT is the main
// buffer being used.
float version = 1;
try {
version = Float.parseFloat(versionStr);
- } catch(Exception ex) {
+ } catch (Exception ex) {
}
glslVer = (int) (version * 100);
*/
GLES20.glGetIntegerv(GLES20.GL_MAX_TEXTURE_SIZE, intBuf16);
maxTexSize = intBuf16.get(0);
- logger.log(Level.INFO, "Maximum Texture Resolution: {0}"+ maxTexSize);
+ logger.log(Level.INFO, "Maximum Texture Resolution: {0}" + maxTexSize);
GLES20.glGetIntegerv(GLES20.GL_MAX_CUBE_MAP_TEXTURE_SIZE, intBuf16);
maxCubeTexSize = intBuf16.get(0);
// checkGLError();
useVBO = false;
-
+
// NOTE: SDK_INT is only available since 1.6,
// but for jME3 it doesn't matter since android versions 1.5 and below
// are not supported.
- if (Build.VERSION.SDK_INT >= 9){
+ if (Build.VERSION.SDK_INT >= 9) {
useVBO = true;
}
// chekc Adreno200,205,220 bug
- if (GLES20.glGetString(GLES20.GL_RENDERER).indexOf("Adreno") >=0) {
+ if (GLES20.glGetString(GLES20.GL_RENDERER).indexOf("Adreno") >= 0) {
adreno_finish_bug = true;
}
logger.log(Level.INFO, "Caps: {0}", caps);
public void setClipRect(int x, int y, int width, int height) {
if (!context.clipRectEnabled) {
// if (verboseLogging) {
- logger.info("GLES20.glEnable(GLES20.GL_SCISSOR_TEST)");
+ logger.info("GLES20.glEnable(GLES20.GL_SCISSOR_TEST)");
// }
GLES20.glEnable(GLES20.GL_SCISSOR_TEST);
checkGLError();
logger.info("GLES20.glShaderSource(" + id + ")");
}
if (source.getType().equals(ShaderType.Vertex)
- && GLES20.glGetString(GLES20.GL_RENDERER).indexOf("PowerVR")>=0) {
+ && GLES20.glGetString(GLES20.GL_RENDERER).indexOf("PowerVR") >= 0) {
GLES20.glShaderSource(
id,
- source.getDefines()
+ source.getDefines()
+ source.getSource());
} else {
GLES20.glShaderSource(
logger.log(Level.FINE, "compile success: " + source.getName());
}
} else {
- logger.log(Level.WARNING, "Bad compile of:\n{0}{1}",
+ logger.log(Level.WARNING, "Bad compile of:\n{0}{1}",
new Object[]{source.getDefines(), source.getSource()});
if (infoLog != null) {
throw new RendererException("compile error in:" + source + " error:" + infoLog);
}
}
+ public void setShaderWithoutUpdateUniforms(Shader shader) {
+ if (verboseLogging) {
+ logger.info("setShader(" + shader + ")");
+ }
+
+ if (shader == null) {
+ if (context.boundShaderProgram > 0) {
+
+ if (verboseLogging) {
+ logger.info("GLES20.glUseProgram(0)");
+ }
+
+ GLES20.glUseProgram(0);
+
+ statistics.onShaderUse(null, true);
+ context.boundShaderProgram = 0;
+ boundShader = null;
+ }
+ } else {
+ if (shader.isUpdateNeeded()) {
+ updateShaderData(shader);
+ }
+
+ // NOTE: might want to check if any of the
+ // sources need an update?
+
+ if (!shader.isUsable()) {
+ logger.warning("shader is not usable.");
+ return;
+ }
+
+ assert shader.getId() > 0;
+
+ if (context.boundShaderProgram != shader.getId()) {
+ if (VALIDATE_SHADER) {
+ // check if shader can be used
+ // with current state
+ if (verboseLogging) {
+ logger.info("GLES20.glValidateProgram(" + shader.getId() + ")");
+ }
+
+ GLES20.glValidateProgram(shader.getId());
+
+ if (verboseLogging) {
+ logger.info("GLES20.glGetProgramiv(" + shader.getId() + ", GLES20.GL_VALIDATE_STATUS, buffer)");
+ }
+
+ GLES20.glGetProgramiv(shader.getId(), GLES20.GL_VALIDATE_STATUS, intBuf1);
+
+ boolean validateOK = intBuf1.get(0) == GLES20.GL_TRUE;
+
+ if (validateOK) {
+ logger.fine("shader validate success");
+ } else {
+ logger.warning("shader validate failure");
+ }
+ }
+
+ if (verboseLogging) {
+ logger.info("GLES20.glUseProgram(" + shader.getId() + ")");
+ }
+
+ GLES20.glUseProgram(shader.getId());
+
+ statistics.onShaderUse(shader, true);
+ context.boundShaderProgram = shader.getId();
+ boundShader = shader;
+ } else {
+ statistics.onShaderUse(shader, false);
+ }
+ }
+ }
+
public void deleteShaderSource(ShaderSource source) {
if (source.getId() < 0) {
logger.warning("Shader source is not uploaded to GPU, cannot delete.");
}
*/
- public void setMainFrameBufferOverride(FrameBuffer fb){
+ public void setMainFrameBufferOverride(FrameBuffer fb) {
}
-
+
public void setFrameBuffer(FrameBuffer fb) {
if (verboseLogging) {
logger.warning("setFrameBuffer is not supported.");
private void deleteRenderBuffer(FrameBuffer fb, RenderBuffer rb) {
logger.warning("deleteRenderBuffer is not supported.");
+ intBuf1.put(0, rb.getId());
+ GLES20.glDeleteRenderbuffers(1, intBuf1);
}
/*
private void deleteRenderBuffer(FrameBuffer fb, RenderBuffer rb){
public void deleteFrameBuffer(FrameBuffer fb) {
logger.warning("deleteFrameBuffer is not supported.");
+ if (fb.getId() != -1) {
+ if (context.boundFBO == fb.getId()) {
+ GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
+ context.boundFBO = 0;
+ }
+
+ if (fb.getDepthBuffer() != null) {
+ deleteRenderBuffer(fb, fb.getDepthBuffer());
+ }
+ if (fb.getColorBuffer() != null) {
+ deleteRenderBuffer(fb, fb.getColorBuffer());
+ }
+
+ intBuf1.put(0, fb.getId());
+ GLES20.glDeleteFramebuffers(1, intBuf1);
+ fb.resetObject();
+
+ statistics.onDeleteFrameBuffer();
+ }
}
/*
public void deleteFrameBuffer(FrameBuffer fb) {
// bind texture
int target = convertTextureType(type);
- if (context.boundTextureUnit != 0) {
- if (verboseLogging) {
- logger.info("GLES20.glActiveTexture(GLES20.GL_TEXTURE0)");
- }
-
- GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
- context.boundTextureUnit = 0;
+ if (context.boundTextureUnit != 0) {
+ if (verboseLogging) {
+ logger.info("GLES20.glActiveTexture(GLES20.GL_TEXTURE0)");
}
+
+ GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+ context.boundTextureUnit = 0;
+ }
if (context.boundTextures[0] != img) {
if (verboseLogging) {
}
Android22Workaround.glVertexAttribPointer(loc,
- vb.getNumComponents(),
- convertFormat(vb.getFormat()),
- vb.isNormalized(),
- vb.getStride(),
- vb.getOffset());
+ vb.getNumComponents(),
+ convertFormat(vb.getFormat()),
+ vb.isNormalized(),
+ vb.getStride(),
+ vb.getOffset());
attribs[loc] = vb;
}
}
ArrayList<VertexBuffer> buffersList = mesh.getBufferList();
- for (int i = 0; i < buffersList.size(); i++){
+ for (int i = 0; i < buffersList.size(); i++) {
VertexBuffer vb = buffersList.get(i);
-
+
if (vb.getBufferType() == Type.InterleavedData
|| vb.getUsage() == Usage.CpuOnly // ignore cpu-only buffers
|| vb.getBufferType() == Type.Index) {
logger.info("renderMeshVertexArray");
}
- // IntMap<VertexBuffer> buffers = mesh.getBuffers();
+ // IntMap<VertexBuffer> buffers = mesh.getBuffers();
IntMap<VertexBuffer> buffers = mesh.getBuffers();
IntMap.Entry<VertexBuffer> table[] = buffers.getTable();
for (IntMap.Entry<VertexBuffer> entry : table) {
drawTriangleList_Array(indices, mesh, count);
} else {
if (verboseLogging) {
- logger.log(Level.INFO, "GLES20.glDrawArrays({0}, {1}, {2})",
+ logger.log(Level.INFO, "GLES20.glDrawArrays({0}, {1}, {2})",
new Object[]{mesh.getMode(), 0, mesh.getVertexCount()});
}
private void renderMeshDefault(Mesh mesh, int lod, int count) {
if (verboseLogging) {
- logger.log(Level.INFO, "renderMeshDefault({0}, {1}, {2})",
+ logger.log(Level.INFO, "renderMeshDefault({0}, {1}, {2})",
new Object[]{mesh, lod, count});
}
VertexBuffer indices = null;
indices = mesh.getBuffer(Type.Index);// buffers.get(Type.Index.ordinal());
}
ArrayList<VertexBuffer> buffersList = mesh.getBufferList();
- for (int i = 0; i < buffersList.size(); i++){
+ for (int i = 0; i < buffersList.size(); i++) {
VertexBuffer vb = buffersList.get(i);
-
+
if (vb.getBufferType() == Type.InterleavedData
|| vb.getUsage() == Usage.CpuOnly // ignore cpu-only buffers
|| vb.getBufferType() == Type.Index) {
} else {
// throw new UnsupportedOperationException("Cannot render without index buffer");
if (verboseLogging) {
- logger.log(Level.INFO, "GLES20.glDrawArrays({0}, 0, {1})",
+ logger.log(Level.INFO, "GLES20.glDrawArrays({0}, 0, {1})",
new Object[]{convertElementMode(mesh.getMode()), mesh.getVertexCount()});
}
}
private void checkGLError() {
-
}
+
private void checkGLError2() {
int error;
while ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR) {
if (verboseLogging) {
logger.log(Level.INFO,
- "GLES20.glVertexAttribPointer(" +
- "location={0}, " +
- "numComponents={1}, " +
- "format={2}, " +
- "isNormalized={3}, " +
- "stride={4}, " +
- "data.capacity={5})",
- new Object[]{loc, vb.getNumComponents(),
- vb.getFormat(),
- vb.isNormalized(),
- vb.getStride(),
- avb.getData().capacity()});
+ "GLES20.glVertexAttribPointer("
+ + "location={0}, "
+ + "numComponents={1}, "
+ + "format={2}, "
+ + "isNormalized={3}, "
+ + "stride={4}, "
+ + "data.capacity={5})",
+ new Object[]{loc, vb.getNumComponents(),
+ vb.getFormat(),
+ vb.isNormalized(),
+ vb.getStride(),
+ avb.getData().capacity()});
}
boundShader = null;
lastFb = null;
}
+
public void resetBoundsTexture() {
context.boundTextures[0] = null;
if (context.boundTextureUnit != 0) {
context.boundTextureUnit = 0;
}
// GLES20.glDisable(GLES20.GL_TEXTURE_2D);
- GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
- // context.boundTextureUnit = -2;
+ GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+ // context.boundTextureUnit = -2;
// context.boundElementArrayVBO = -2;
// context.boundShaderProgram = -1;
// context.boundArrayVBO = -1;
+++ /dev/null
-package com.jme3.renderer.lwjgl;
-
-import com.jme3.light.SpotLight;
-import java.util.ArrayList;
-import com.jme3.light.PointLight;
-import com.jme3.math.Vector3f;
-import com.jme3.light.DirectionalLight;
-import com.jme3.light.Light;
-import org.lwjgl.opengl.GL14;
-import com.jme3.math.FastMath;
-import com.jme3.renderer.GL1Renderer;
-import com.jme3.shader.Shader;
-import com.jme3.shader.Shader.ShaderSource;
-import com.jme3.texture.FrameBuffer;
-import java.nio.ShortBuffer;
-import java.nio.Buffer;
-import com.jme3.scene.Mesh.Mode;
-import com.jme3.scene.VertexBuffer.Usage;
-import com.jme3.scene.VertexBuffer.Type;
-import com.jme3.util.IntMap.Entry;
-import com.jme3.util.IntMap;
-import com.jme3.scene.Mesh;
-import com.jme3.scene.VertexBuffer;
-import com.jme3.texture.Image;
-import com.jme3.texture.Texture.WrapAxis;
-import com.jme3.texture.Texture;
-import com.jme3.light.LightList;
-import com.jme3.material.FixedFuncBinding;
-import java.nio.FloatBuffer;
-import com.jme3.math.Matrix4f;
-import java.util.logging.Level;
-import com.jme3.material.RenderState;
-import com.jme3.math.ColorRGBA;
-import com.jme3.renderer.Caps;
-import com.jme3.util.NativeObjectManager;
-import com.jme3.renderer.RenderContext;
-import com.jme3.renderer.Statistics;
-import com.jme3.util.BufferUtils;
-import java.nio.ByteBuffer;
-import java.nio.IntBuffer;
-import java.util.EnumSet;
-import java.util.logging.Logger;
-import jme3tools.converters.MipMapGenerator;
-import org.lwjgl.opengl.GL12;
-import org.lwjgl.opengl.GLContext;
-
-import static org.lwjgl.opengl.GL11.*;
-
-public class LwjglGL1Renderer implements GL1Renderer {
-
- private static final Logger logger = Logger.getLogger(LwjglRenderer.class.getName());
- private final ByteBuffer nameBuf = BufferUtils.createByteBuffer(250);
- private final StringBuilder stringBuf = new StringBuilder(250);
- private final IntBuffer ib1 = BufferUtils.createIntBuffer(1);
- private final IntBuffer intBuf16 = BufferUtils.createIntBuffer(16);
- private final FloatBuffer fb16 = BufferUtils.createFloatBuffer(16);
- private final FloatBuffer fb4Null = BufferUtils.createFloatBuffer(4);
- private final RenderContext context = new RenderContext();
- private final NativeObjectManager objManager = new NativeObjectManager();
- private final EnumSet<Caps> caps = EnumSet.noneOf(Caps.class);
- private int maxTexSize;
- private int maxCubeTexSize;
- private int maxVertCount;
- private int maxTriCount;
- private int maxLights;
- private boolean gl12 = false;
- private final Statistics statistics = new Statistics();
- private int vpX, vpY, vpW, vpH;
- private int clipX, clipY, clipW, clipH;
-
- private Matrix4f worldMatrix = new Matrix4f();
- private Matrix4f viewMatrix = new Matrix4f();
-
- private ArrayList<Light> lightList = new ArrayList<Light>(8);
- private ColorRGBA materialAmbientColor = new ColorRGBA();
- private Vector3f tempVec = new Vector3f();
-
- protected void updateNameBuffer() {
- int len = stringBuf.length();
-
- nameBuf.position(0);
- nameBuf.limit(len);
- for (int i = 0; i < len; i++) {
- nameBuf.put((byte) stringBuf.charAt(i));
- }
-
- nameBuf.rewind();
- }
-
- public Statistics getStatistics() {
- return statistics;
- }
-
- public EnumSet<Caps> getCaps() {
- return caps;
- }
-
- public void initialize() {
- if (GLContext.getCapabilities().OpenGL12){
- gl12 = true;
- }
-
- // Default values for certain GL state.
- glShadeModel(GL_SMOOTH);
- glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
- glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
-
- // Enable rescaling/normaling of normal vectors.
- // Fixes lighting issues with scaled models.
- if (gl12){
- glEnable(GL12.GL_RESCALE_NORMAL);
- }else{
- glEnable(GL_NORMALIZE);
- }
-
- if (GLContext.getCapabilities().GL_ARB_texture_non_power_of_two) {
- caps.add(Caps.NonPowerOfTwoTextures);
- } else {
- logger.log(Level.WARNING, "Your graphics card does not "
- + "support non-power-of-2 textures. "
- + "Some features might not work.");
- }
-
- maxLights = glGetInteger(GL_MAX_LIGHTS);
-
- }
-
- public void invalidateState() {
- context.reset();
- }
-
- public void resetGLObjects() {
- logger.log(Level.INFO, "Reseting objects and invalidating state");
- objManager.resetObjects();
- statistics.clearMemory();
- invalidateState();
- }
-
- public void cleanup() {
- logger.log(Level.INFO, "Deleting objects and invalidating state");
- objManager.deleteAllObjects(this);
- statistics.clearMemory();
- invalidateState();
- }
-
- public void setDepthRange(float start, float end) {
- glDepthRange(start, end);
- }
-
- public void clearBuffers(boolean color, boolean depth, boolean stencil) {
- int bits = 0;
- if (color) {
- //See explanations of the depth below, we must enable color write to be able to clear the color buffer
- if (context.colorWriteEnabled == false) {
- glColorMask(true, true, true, true);
- context.colorWriteEnabled = true;
- }
- bits = GL_COLOR_BUFFER_BIT;
- }
- if (depth) {
-
- //glClear(GL_DEPTH_BUFFER_BIT) seems to not work when glDepthMask is false
- //here s some link on openl board
- //http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showflat&Number=257223
- //if depth clear is requested, we enable the depthMask
- if (context.depthWriteEnabled == false) {
- glDepthMask(true);
- context.depthWriteEnabled = true;
- }
- bits |= GL_DEPTH_BUFFER_BIT;
- }
- if (stencil) {
- bits |= GL_STENCIL_BUFFER_BIT;
- }
- if (bits != 0) {
- glClear(bits);
- }
- }
-
- public void setBackgroundColor(ColorRGBA color) {
- glClearColor(color.r, color.g, color.b, color.a);
- }
-
- private void setMaterialColor(int type, ColorRGBA color, ColorRGBA defaultColor) {
- if (color != null){
- fb16.put(color.r).put(color.g).put(color.b).put(color.a).flip();
- }else{
- fb16.put(defaultColor.r).put(defaultColor.g).put(defaultColor.b).put(defaultColor.a).flip();
- }
- glMaterial(GL_FRONT_AND_BACK, type, fb16);
- }
-
- /**
- * Applies fixed function bindings from the context to OpenGL
- */
- private void applyFixedFuncBindings(boolean forLighting){
- if (forLighting){
- glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, context.shininess);
- setMaterialColor(GL_AMBIENT, context.ambient, ColorRGBA.DarkGray);
- setMaterialColor(GL_DIFFUSE, context.diffuse, ColorRGBA.White);
- setMaterialColor(GL_SPECULAR, context.specular, ColorRGBA.Black);
-
- if (context.useVertexColor){
- glEnable(GL_COLOR_MATERIAL);
- }else{
- glDisable(GL_COLOR_MATERIAL);
- }
- }else{
- // Ignore other values as they have no effect when
- // GL_LIGHTING is disabled.
- ColorRGBA color = context.color;
- if (color != null){
- glColor4f(color.r, color.g, color.b, color.a);
- }else{
- glColor4f(1,1,1,1);
- }
- }
- }
-
- /**
- * Reset fixed function bindings to default values.
- */
- private void resetFixedFuncBindings(){
- context.color = null;
- context.ambient = null;
- context.diffuse = null;
- context.specular = null;
- context.shininess = 0;
- context.useVertexColor = false;
- }
-
- public void setFixedFuncBinding(FixedFuncBinding ffBinding, Object val) {
- switch (ffBinding) {
- case Color:
- context.color = (ColorRGBA) val;
- break;
- case MaterialAmbient:
- context.ambient = (ColorRGBA) val;
- break;
- case MaterialDiffuse:
- context.diffuse = (ColorRGBA) val;
- break;
- case MaterialSpecular:
- context.specular = (ColorRGBA) val;
- break;
- case MaterialShininess:
- context.shininess = (Float) val;
- break;
- case UseVertexColor:
- context.useVertexColor = (Boolean) val;
- break;
- }
- }
-
- public void applyRenderState(RenderState state) {
- if (state.isWireframe() && !context.wireframe) {
- glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
- context.wireframe = true;
- } else if (!state.isWireframe() && context.wireframe) {
- glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
- context.wireframe = false;
- }
-
- if (state.isDepthTest() && !context.depthTestEnabled) {
- glEnable(GL_DEPTH_TEST);
- glDepthFunc(GL_LEQUAL);
- context.depthTestEnabled = true;
- } else if (!state.isDepthTest() && context.depthTestEnabled) {
- glDisable(GL_DEPTH_TEST);
- context.depthTestEnabled = false;
- }
-
- if (state.isAlphaTest() && !context.alphaTestEnabled) {
- glEnable(GL_ALPHA_TEST);
- glAlphaFunc(GL_GREATER, state.getAlphaFallOff());
- context.alphaTestEnabled = true;
- } else if (!state.isAlphaTest() && context.alphaTestEnabled) {
- glDisable(GL_ALPHA_TEST);
- context.alphaTestEnabled = false;
- }
-
- if (state.isDepthWrite() && !context.depthWriteEnabled) {
- glDepthMask(true);
- context.depthWriteEnabled = true;
- } else if (!state.isDepthWrite() && context.depthWriteEnabled) {
- glDepthMask(false);
- context.depthWriteEnabled = false;
- }
-
- if (state.isColorWrite() && !context.colorWriteEnabled) {
- glColorMask(true, true, true, true);
- context.colorWriteEnabled = true;
- } else if (!state.isColorWrite() && context.colorWriteEnabled) {
- glColorMask(false, false, false, false);
- context.colorWriteEnabled = false;
- }
-
- if (state.isPointSprite()) {
- logger.log(Level.WARNING, "Point Sprite unsupported!");
- }
-
- if (state.isPolyOffset()) {
- if (!context.polyOffsetEnabled) {
- glEnable(GL_POLYGON_OFFSET_FILL);
- glPolygonOffset(state.getPolyOffsetFactor(),
- state.getPolyOffsetUnits());
- context.polyOffsetEnabled = true;
- context.polyOffsetFactor = state.getPolyOffsetFactor();
- context.polyOffsetUnits = state.getPolyOffsetUnits();
- } else {
- if (state.getPolyOffsetFactor() != context.polyOffsetFactor
- || state.getPolyOffsetUnits() != context.polyOffsetUnits) {
- glPolygonOffset(state.getPolyOffsetFactor(),
- state.getPolyOffsetUnits());
- context.polyOffsetFactor = state.getPolyOffsetFactor();
- context.polyOffsetUnits = state.getPolyOffsetUnits();
- }
- }
- } else {
- if (context.polyOffsetEnabled) {
- glDisable(GL_POLYGON_OFFSET_FILL);
- context.polyOffsetEnabled = false;
- context.polyOffsetFactor = 0;
- context.polyOffsetUnits = 0;
- }
- }
- if (state.getFaceCullMode() != context.cullMode) {
- if (state.getFaceCullMode() == RenderState.FaceCullMode.Off) {
- glDisable(GL_CULL_FACE);
- } else {
- glEnable(GL_CULL_FACE);
- }
-
- switch (state.getFaceCullMode()) {
- case Off:
- break;
- case Back:
- glCullFace(GL_BACK);
- break;
- case Front:
- glCullFace(GL_FRONT);
- break;
- case FrontAndBack:
- glCullFace(GL_FRONT_AND_BACK);
- break;
- default:
- throw new UnsupportedOperationException("Unrecognized face cull mode: "
- + state.getFaceCullMode());
- }
-
- context.cullMode = state.getFaceCullMode();
- }
-
- if (state.getBlendMode() != context.blendMode) {
- if (state.getBlendMode() == RenderState.BlendMode.Off) {
- glDisable(GL_BLEND);
- } else {
- glEnable(GL_BLEND);
- switch (state.getBlendMode()) {
- case Off:
- break;
- case Additive:
- glBlendFunc(GL_ONE, GL_ONE);
- break;
- case AlphaAdditive:
- glBlendFunc(GL_SRC_ALPHA, GL_ONE);
- break;
- case Color:
- glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR);
- break;
- case Alpha:
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- break;
- case PremultAlpha:
- glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
- break;
- case Modulate:
- glBlendFunc(GL_DST_COLOR, GL_ZERO);
- break;
- case ModulateX2:
- glBlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
- break;
- default:
- throw new UnsupportedOperationException("Unrecognized blend mode: "
- + state.getBlendMode());
- }
- }
-
- context.blendMode = state.getBlendMode();
- }
-
- if (state.isStencilTest()) {
- throw new UnsupportedOperationException("OpenGL 1.1 doesn't support two sided stencil operations.");
- }
-
- }
-
- public void setViewPort(int x, int y, int w, int h) {
- if (x != vpX || vpY != y || vpW != w || vpH != h) {
- glViewport(x, y, w, h);
- vpX = x;
- vpY = y;
- vpW = w;
- vpH = h;
- }
- }
-
- public void setClipRect(int x, int y, int width, int height) {
- if (!context.clipRectEnabled) {
- glEnable(GL_SCISSOR_TEST);
- context.clipRectEnabled = true;
- }
- if (clipX != x || clipY != y || clipW != width || clipH != height) {
- glScissor(x, y, width, height);
- clipX = x;
- clipY = y;
- clipW = width;
- clipH = height;
- }
- }
-
- public void clearClipRect() {
- if (context.clipRectEnabled) {
- glDisable(GL_SCISSOR_TEST);
- context.clipRectEnabled = false;
-
- clipX = 0;
- clipY = 0;
- clipW = 0;
- clipH = 0;
- }
- }
-
- public void onFrame() {
- objManager.deleteUnused(this);
-// statistics.clearFrame();
- }
-
- private FloatBuffer storeMatrix(Matrix4f matrix, FloatBuffer store) {
- store.clear();
- matrix.fillFloatBuffer(store, true);
- store.clear();
- return store;
- }
-
- private void setModelView(Matrix4f modelMatrix, Matrix4f viewMatrix){
- if (context.matrixMode != GL_MODELVIEW) {
- glMatrixMode(GL_MODELVIEW);
- context.matrixMode = GL_MODELVIEW;
- }
-
- glLoadMatrix(storeMatrix(viewMatrix, fb16));
- glMultMatrix(storeMatrix(modelMatrix, fb16));
- }
-
- private void setProjection(Matrix4f projMatrix){
- if (context.matrixMode != GL_PROJECTION) {
- glMatrixMode(GL_PROJECTION);
- context.matrixMode = GL_PROJECTION;
- }
-
- glLoadMatrix(storeMatrix(projMatrix, fb16));
- }
-
- public void setWorldMatrix(Matrix4f worldMatrix) {
- this.worldMatrix.set(worldMatrix);
- }
-
- public void setViewProjectionMatrices(Matrix4f viewMatrix, Matrix4f projMatrix) {
- this.viewMatrix.set(viewMatrix);
- setProjection(projMatrix);
- }
-
- public void setLighting(LightList list) {
- // XXX: This is abuse of setLighting() to
- // apply fixed function bindings
- // and do other book keeping.
- if (list == null || list.size() == 0){
- glDisable(GL_LIGHTING);
- applyFixedFuncBindings(false);
- setModelView(worldMatrix, viewMatrix);
- return;
- }
-
- // Number of lights set previously
- int numLightsSetPrev = lightList.size();
-
- // If more than maxLights are defined, they will be ignored.
- // The GL1 renderer is not permitted to crash due to a
- // GL1 limitation. It must render anything that the GL2 renderer
- // can render (even incorrectly).
- lightList.clear();
- materialAmbientColor.set(0, 0, 0, 0);
-
- for (int i = 0; i < list.size(); i++){
- Light l = list.get(i);
- if (l.getType() == Light.Type.Ambient){
- // Gather
- materialAmbientColor.addLocal(l.getColor());
- }else{
- // Add to list
- lightList.add(l);
-
- // Once maximum lights reached, exit loop.
- if (lightList.size() >= maxLights){
- break;
- }
- }
- }
-
- applyFixedFuncBindings(true);
-
- glEnable(GL_LIGHTING);
-
- fb16.clear();
- fb16.put(materialAmbientColor.r)
- .put(materialAmbientColor.g)
- .put(materialAmbientColor.b)
- .put(1).flip();
-
- glLightModel(GL_LIGHT_MODEL_AMBIENT, fb16);
-
- if (context.matrixMode != GL_MODELVIEW) {
- glMatrixMode(GL_MODELVIEW);
- context.matrixMode = GL_MODELVIEW;
- }
- // Lights are already in world space, so just convert
- // them to view space.
- glLoadMatrix(storeMatrix(viewMatrix, fb16));
-
- for (int i = 0; i < lightList.size(); i++){
- int glLightIndex = GL_LIGHT0 + i;
- Light light = lightList.get(i);
- Light.Type lightType = light.getType();
- ColorRGBA col = light.getColor();
- Vector3f pos;
-
- // Enable the light
- glEnable(glLightIndex);
-
- // OGL spec states default value for light ambient is black
- switch (lightType){
- case Directional:
- DirectionalLight dLight = (DirectionalLight) light;
-
- fb16.clear();
- fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip();
- glLight(glLightIndex, GL_DIFFUSE, fb16);
- glLight(glLightIndex, GL_SPECULAR, fb16);
-
- pos = tempVec.set(dLight.getDirection()).negateLocal().normalizeLocal();
- fb16.clear();
- fb16.put(pos.x).put(pos.y).put(pos.z).put(0.0f).flip();
- glLight(glLightIndex, GL_POSITION, fb16);
- glLightf(glLightIndex, GL_SPOT_CUTOFF, 180);
- break;
- case Point:
- PointLight pLight = (PointLight) light;
-
- fb16.clear();
- fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip();
- glLight(glLightIndex, GL_DIFFUSE, fb16);
- glLight(glLightIndex, GL_SPECULAR, fb16);
-
- pos = pLight.getPosition();
- fb16.clear();
- fb16.put(pos.x).put(pos.y).put(pos.z).put(1.0f).flip();
- glLight(glLightIndex, GL_POSITION, fb16);
- glLightf(glLightIndex, GL_SPOT_CUTOFF, 180);
-
- if (pLight.getRadius() > 0) {
- // Note: this doesn't follow the same attenuation model
- // as the one used in the lighting shader.
- glLightf(glLightIndex, GL_CONSTANT_ATTENUATION, 1);
- glLightf(glLightIndex, GL_LINEAR_ATTENUATION, pLight.getInvRadius() * 2);
- glLightf(glLightIndex, GL_QUADRATIC_ATTENUATION, pLight.getInvRadius() * pLight.getInvRadius());
- }else{
- glLightf(glLightIndex, GL_CONSTANT_ATTENUATION, 1);
- glLightf(glLightIndex, GL_LINEAR_ATTENUATION, 0);
- glLightf(glLightIndex, GL_QUADRATIC_ATTENUATION, 0);
- }
-
- break;
- case Spot:
- SpotLight sLight = (SpotLight) light;
-
- fb16.clear();
- fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip();
- glLight(glLightIndex, GL_DIFFUSE, fb16);
- glLight(glLightIndex, GL_SPECULAR, fb16);
-
- pos = sLight.getPosition();
- fb16.clear();
- fb16.put(pos.x).put(pos.y).put(pos.z).put(1.0f).flip();
- glLight(glLightIndex, GL_POSITION, fb16);
-
- Vector3f dir = sLight.getDirection();
- fb16.clear();
- fb16.put(dir.x).put(dir.y).put(dir.z).put(1.0f).flip();
- glLight(glLightIndex, GL_SPOT_DIRECTION, fb16);
-
- float outerAngleRad = sLight.getSpotOuterAngle();
- float innerAngleRad = sLight.getSpotInnerAngle();
- float spotCut = outerAngleRad * FastMath.RAD_TO_DEG;
- float spotExpo = 0.0f;
- if (outerAngleRad > 0) {
- spotExpo = (1.0f - (innerAngleRad / outerAngleRad)) * 128.0f;
- }
-
- glLightf(glLightIndex, GL_SPOT_CUTOFF, spotCut);
- glLightf(glLightIndex, GL_SPOT_EXPONENT, spotExpo);
-
- if (sLight.getSpotRange() > 0) {
- glLightf(glLightIndex, GL_LINEAR_ATTENUATION, sLight.getInvSpotRange());
- }else{
- glLightf(glLightIndex, GL_LINEAR_ATTENUATION, 0);
- }
-
- break;
- default:
- throw new UnsupportedOperationException(
- "Unrecognized light type: " + lightType);
- }
- }
-
- // Disable lights after the index
- for (int i = lightList.size(); i < numLightsSetPrev; i++){
- glDisable(GL_LIGHT0 + i);
- }
-
- // This will set view matrix as well.
- setModelView(worldMatrix, viewMatrix);
- }
-
- private int convertTextureType(Texture.Type type) {
- switch (type) {
- case TwoDimensional:
- return GL_TEXTURE_2D;
-// case ThreeDimensional:
-// return GL_TEXTURE_3D;
-// case CubeMap:
-// return GL_TEXTURE_CUBE_MAP;
- default:
- throw new UnsupportedOperationException("Unknown texture type: " + type);
- }
- }
-
- private int convertMagFilter(Texture.MagFilter filter) {
- switch (filter) {
- case Bilinear:
- return GL_LINEAR;
- case Nearest:
- return GL_NEAREST;
- default:
- throw new UnsupportedOperationException("Unknown mag filter: " + filter);
- }
- }
-
- private int convertMinFilter(Texture.MinFilter filter) {
- switch (filter) {
- case Trilinear:
- return GL_LINEAR_MIPMAP_LINEAR;
- case BilinearNearestMipMap:
- return GL_LINEAR_MIPMAP_NEAREST;
- case NearestLinearMipMap:
- return GL_NEAREST_MIPMAP_LINEAR;
- case NearestNearestMipMap:
- return GL_NEAREST_MIPMAP_NEAREST;
- case BilinearNoMipMaps:
- return GL_LINEAR;
- case NearestNoMipMaps:
- return GL_NEAREST;
- default:
- throw new UnsupportedOperationException("Unknown min filter: " + filter);
- }
- }
-
- private int convertWrapMode(Texture.WrapMode mode) {
- switch (mode) {
- case EdgeClamp:
- case Clamp:
- case BorderClamp:
- return GL_CLAMP;
- case Repeat:
- return GL_REPEAT;
- default:
- throw new UnsupportedOperationException("Unknown wrap mode: " + mode);
- }
- }
-
- private void setupTextureParams(Texture tex) {
- int target = convertTextureType(tex.getType());
-
- // filter things
- int minFilter = convertMinFilter(tex.getMinFilter());
- int magFilter = convertMagFilter(tex.getMagFilter());
- glTexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilter);
- glTexParameteri(target, GL_TEXTURE_MAG_FILTER, magFilter);
-
- // repeat modes
- switch (tex.getType()) {
-// case ThreeDimensional:
-// case CubeMap:
-// glTexParameteri(target, GL_TEXTURE_WRAP_R, convertWrapMode(tex.getWrap(WrapAxis.R)));
- case TwoDimensional:
- glTexParameteri(target, GL_TEXTURE_WRAP_T, convertWrapMode(tex.getWrap(WrapAxis.T)));
- // fall down here is intentional..
-// case OneDimensional:
- glTexParameteri(target, GL_TEXTURE_WRAP_S, convertWrapMode(tex.getWrap(WrapAxis.S)));
- break;
- default:
- throw new UnsupportedOperationException("Unknown texture type: " + tex.getType());
- }
- }
-
- public void updateTexImageData(Image img, Texture.Type type, boolean mips, int unit) {
- int texId = img.getId();
- if (texId == -1) {
- // create texture
- glGenTextures(ib1);
- texId = ib1.get(0);
- img.setId(texId);
- objManager.registerForCleanup(img);
-
- statistics.onNewTexture();
- }
-
- // bind texture
- int target = convertTextureType(type);
-// if (context.boundTextureUnit != unit) {
-// glActiveTexture(GL_TEXTURE0 + unit);
-// context.boundTextureUnit = unit;
-// }
- if (context.boundTextures[unit] != img) {
- glEnable(target);
- glBindTexture(target, texId);
- context.boundTextures[unit] = img;
-
- statistics.onTextureUse(img, true);
- }
-
- // Check sizes if graphics card doesn't support NPOT
- if (!GLContext.getCapabilities().GL_ARB_texture_non_power_of_two) {
- if (img.getWidth() != 0 && img.getHeight() != 0) {
- if (!FastMath.isPowerOfTwo(img.getWidth())
- || !FastMath.isPowerOfTwo(img.getHeight())) {
-
- // Resize texture to Power-of-2 size
- MipMapGenerator.resizeToPowerOf2(img);
-
- }
- }
- }
-
- if (!img.hasMipmaps() && mips) {
- // No pregenerated mips available,
- // generate from base level if required
-
- // Check if hardware mips are supported
- if (GLContext.getCapabilities().OpenGL14) {
- glTexParameteri(target, GL14.GL_GENERATE_MIPMAP, GL_TRUE);
- } else {
- MipMapGenerator.generateMipMaps(img);
- }
- } else {
- }
-
- /*
- if (target == GL_TEXTURE_CUBE_MAP) {
- List<ByteBuffer> data = img.getData();
- if (data.size() != 6) {
- logger.log(Level.WARNING, "Invalid texture: {0}\n"
- + "Cubemap textures must contain 6 data units.", img);
- return;
- }
- for (int i = 0; i < 6; i++) {
- TextureUtil.uploadTexture(img, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, i, 0, tdc);
- }
- } else if (target == EXTTextureArray.GL_TEXTURE_2D_ARRAY_EXT) {
- List<ByteBuffer> data = img.getData();
- // -1 index specifies prepare data for 2D Array
- TextureUtil.uploadTexture(img, target, -1, 0, tdc);
- for (int i = 0; i < data.size(); i++) {
- // upload each slice of 2D array in turn
- // this time with the appropriate index
- TextureUtil.uploadTexture(img, target, i, 0, tdc);
- }
- } else {*/
- TextureUtil.uploadTexture(img, target, 0, 0, false);
- //}
-
- img.clearUpdateNeeded();
- }
-
- public void setTexture(int unit, Texture tex) {
- if (unit != 0 || tex.getType() != Texture.Type.TwoDimensional) {
- //throw new UnsupportedOperationException();
- return;
- }
-
- Image image = tex.getImage();
- if (image.isUpdateNeeded()) {
- updateTexImageData(image, tex.getType(), tex.getMinFilter().usesMipMapLevels(), unit);
- }
-
- int texId = image.getId();
- assert texId != -1;
-
- Image[] textures = context.boundTextures;
-
- int type = convertTextureType(tex.getType());
-// if (!context.textureIndexList.moveToNew(unit)) {
-// if (context.boundTextureUnit != unit){
-// glActiveTexture(GL_TEXTURE0 + unit);
-// context.boundTextureUnit = unit;
-// }
-// glEnable(type);
-// }
-
-// if (context.boundTextureUnit != unit) {
-// glActiveTexture(GL_TEXTURE0 + unit);
-// context.boundTextureUnit = unit;
-// }
-
- if (textures[unit] != image) {
- glEnable(type);
- glBindTexture(type, texId);
- textures[unit] = image;
-
- statistics.onTextureUse(image, true);
- } else {
- statistics.onTextureUse(image, false);
- }
-
- setupTextureParams(tex);
- }
-
- private void clearTextureUnits() {
- Image[] textures = context.boundTextures;
- if (textures[0] != null) {
- glDisable(GL_TEXTURE_2D);
- textures[0] = null;
- }
- }
-
- public void deleteImage(Image image) {
- int texId = image.getId();
- if (texId != -1) {
- ib1.put(0, texId);
- ib1.position(0).limit(1);
- glDeleteTextures(ib1);
- image.resetObject();
- }
- }
-
- private int convertArrayType(VertexBuffer.Type type) {
- switch (type) {
- case Position:
- return GL_VERTEX_ARRAY;
- case Normal:
- return GL_NORMAL_ARRAY;
- case TexCoord:
- return GL_TEXTURE_COORD_ARRAY;
- case Color:
- return GL_COLOR_ARRAY;
- default:
- return -1; // unsupported
- }
- }
-
- private int convertVertexFormat(VertexBuffer.Format fmt) {
- switch (fmt) {
- case Byte:
- return GL_BYTE;
- case Float:
- return GL_FLOAT;
- case Int:
- return GL_INT;
- case Short:
- return GL_SHORT;
- case UnsignedByte:
- return GL_UNSIGNED_BYTE;
- case UnsignedInt:
- return GL_UNSIGNED_INT;
- case UnsignedShort:
- return GL_UNSIGNED_SHORT;
- default:
- throw new UnsupportedOperationException("Unrecognized vertex format: " + fmt);
- }
- }
-
- private int convertElementMode(Mesh.Mode mode) {
- switch (mode) {
- case Points:
- return GL_POINTS;
- case Lines:
- return GL_LINES;
- case LineLoop:
- return GL_LINE_LOOP;
- case LineStrip:
- return GL_LINE_STRIP;
- case Triangles:
- return GL_TRIANGLES;
- case TriangleFan:
- return GL_TRIANGLE_FAN;
- case TriangleStrip:
- return GL_TRIANGLE_STRIP;
- default:
- throw new UnsupportedOperationException("Unrecognized mesh mode: " + mode);
- }
- }
-
- public void drawTriangleArray(Mesh.Mode mode, int count, int vertCount) {
- if (count > 1) {
- throw new UnsupportedOperationException();
- }
-
- glDrawArrays(convertElementMode(mode), 0, vertCount);
- }
-
- public void setVertexAttrib(VertexBuffer vb, VertexBuffer idb) {
- int arrayType = convertArrayType(vb.getBufferType());
- if (arrayType == -1) {
- return; // unsupported
- }
- glEnableClientState(arrayType);
- context.boundAttribs[vb.getBufferType().ordinal()] = vb;
-
- if (vb.getBufferType() == Type.Normal) {
- // normalize if requested
- if (vb.isNormalized() && !context.normalizeEnabled) {
- glEnable(GL_NORMALIZE);
- context.normalizeEnabled = true;
- } else if (!vb.isNormalized() && context.normalizeEnabled) {
- glDisable(GL_NORMALIZE);
- context.normalizeEnabled = false;
- }
- }
-
- // NOTE: Use data from interleaved buffer if specified
- Buffer data = idb != null ? idb.getData() : vb.getData();
- int comps = vb.getNumComponents();
- int type = convertVertexFormat(vb.getFormat());
-
- data.rewind();
-
- switch (vb.getBufferType()) {
- case Position:
- if (!(data instanceof FloatBuffer)) {
- throw new UnsupportedOperationException();
- }
-
- glVertexPointer(comps, vb.getStride(), (FloatBuffer) data);
- break;
- case Normal:
- if (!(data instanceof FloatBuffer)) {
- throw new UnsupportedOperationException();
- }
-
- glNormalPointer(vb.getStride(), (FloatBuffer) data);
- break;
- case Color:
- if (data instanceof FloatBuffer) {
- glColorPointer(comps, vb.getStride(), (FloatBuffer) data);
- } else if (data instanceof ByteBuffer) {
- glColorPointer(comps, true, vb.getStride(), (ByteBuffer) data);
- } else {
- throw new UnsupportedOperationException();
- }
- break;
- case TexCoord:
- if (!(data instanceof FloatBuffer)) {
- throw new UnsupportedOperationException();
- }
-
- glTexCoordPointer(comps, vb.getStride(), (FloatBuffer) data);
- break;
- default:
- // Ignore, this is an unsupported attribute for OpenGL1.
- break;
- }
- }
-
- public void setVertexAttrib(VertexBuffer vb) {
- setVertexAttrib(vb, null);
- }
-
- private void drawElements(int mode, int format, Buffer data) {
- switch (format) {
- case GL_UNSIGNED_BYTE:
- glDrawElements(mode, (ByteBuffer) data);
- break;
- case GL_UNSIGNED_SHORT:
- glDrawElements(mode, (ShortBuffer) data);
- break;
- case GL_UNSIGNED_INT:
- glDrawElements(mode, (IntBuffer) data);
- break;
- default:
- throw new UnsupportedOperationException();
- }
- }
-
- public void drawTriangleList(VertexBuffer indexBuf, Mesh mesh, int count) {
- Mesh.Mode mode = mesh.getMode();
-
- Buffer indexData = indexBuf.getData();
- indexData.rewind();
-
- if (mesh.getMode() == Mode.Hybrid) {
- throw new UnsupportedOperationException();
- /*
- int[] modeStart = mesh.getModeStart();
- int[] elementLengths = mesh.getElementLengths();
-
- int elMode = convertElementMode(Mode.Triangles);
- int fmt = convertVertexFormat(indexBuf.getFormat());
- // int elSize = indexBuf.getFormat().getComponentSize();
- // int listStart = modeStart[0];
- int stripStart = modeStart[1];
- int fanStart = modeStart[2];
- int curOffset = 0;
- for (int i = 0; i < elementLengths.length; i++) {
- if (i == stripStart) {
- elMode = convertElementMode(Mode.TriangleStrip);
- } else if (i == fanStart) {
- elMode = convertElementMode(Mode.TriangleStrip);
- }
- int elementLength = elementLengths[i];
- indexData.position(curOffset);
-
- drawElements(elMode,
- fmt,
- indexData);
-
- curOffset += elementLength;
- }*/
- } else {
- drawElements(convertElementMode(mode),
- convertVertexFormat(indexBuf.getFormat()),
- indexData);
- }
- }
-
- public void clearVertexAttribs() {
- for (int i = 0; i < 16; i++) {
- VertexBuffer vb = context.boundAttribs[i];
- if (vb != null) {
- int arrayType = convertArrayType(vb.getBufferType());
- glDisableClientState(arrayType);
- context.boundAttribs[vb.getBufferType().ordinal()] = null;
- }
- }
- }
-
- private void renderMeshDefault(Mesh mesh, int lod, int count) {
- VertexBuffer indices = null;
-
- VertexBuffer interleavedData = mesh.getBuffer(Type.InterleavedData);
- if (interleavedData != null && interleavedData.isUpdateNeeded()) {
- updateBufferData(interleavedData);
- }
-
- IntMap<VertexBuffer> buffers = mesh.getBuffers();
- if (mesh.getNumLodLevels() > 0) {
- indices = mesh.getLodLevel(lod);
- } else {
- indices = buffers.get(Type.Index.ordinal());
- }
- for (Entry<VertexBuffer> entry : buffers) {
- VertexBuffer vb = entry.getValue();
-
- if (vb.getBufferType() == Type.InterleavedData
- || vb.getUsage() == Usage.CpuOnly // ignore cpu-only buffers
- || vb.getBufferType() == Type.Index) {
- continue;
- }
-
- if (vb.getStride() == 0) {
- // not interleaved
- setVertexAttrib(vb);
- } else {
- // interleaved
- setVertexAttrib(vb, interleavedData);
- }
- }
-
- if (indices != null) {
- drawTriangleList(indices, mesh, count);
- } else {
- glDrawArrays(convertElementMode(mesh.getMode()), 0, mesh.getVertexCount());
- }
-
- // TODO: Fix these to use IDList??
- clearVertexAttribs();
- clearTextureUnits();
- resetFixedFuncBindings();
- }
-
- public void renderMesh(Mesh mesh, int lod, int count) {
- if (mesh.getVertexCount() == 0) {
- return;
- }
-
- if (context.pointSize != mesh.getPointSize()) {
- glPointSize(mesh.getPointSize());
- context.pointSize = mesh.getPointSize();
- }
- if (context.lineWidth != mesh.getLineWidth()) {
- glLineWidth(mesh.getLineWidth());
- context.lineWidth = mesh.getLineWidth();
- }
-
- boolean dynamic = false;
- if (mesh.getBuffer(Type.InterleavedData) != null) {
- throw new UnsupportedOperationException("Interleaved meshes are not supported");
- }
-
- if (mesh.getNumLodLevels() == 0) {
- IntMap<VertexBuffer> bufs = mesh.getBuffers();
- for (Entry<VertexBuffer> entry : bufs) {
- if (entry.getValue().getUsage() != VertexBuffer.Usage.Static) {
- dynamic = true;
- break;
- }
- }
- } else {
- dynamic = true;
- }
-
- statistics.onMeshDrawn(mesh, lod);
-
-// if (!dynamic) {
- // dealing with a static object, generate display list
-// renderMeshDisplayList(mesh);
-// } else {
- renderMeshDefault(mesh, lod, count);
-// }
-
-
- }
-
- public void setAlphaToCoverage(boolean value) {
- }
-
- public void setShader(Shader shader) {
- }
-
- public void deleteShader(Shader shader) {
- }
-
- public void deleteShaderSource(ShaderSource source) {
- }
-
- public void copyFrameBuffer(FrameBuffer src, FrameBuffer dst) {
- }
-
- public void copyFrameBuffer(FrameBuffer src, FrameBuffer dst, boolean copyDepth) {
- }
-
- public void setMainFrameBufferOverride(FrameBuffer fb){
- }
-
- public void setFrameBuffer(FrameBuffer fb) {
- }
-
- public void readFrameBuffer(FrameBuffer fb, ByteBuffer byteBuf) {
- }
-
- public void deleteFrameBuffer(FrameBuffer fb) {
- }
-
- public void updateBufferData(VertexBuffer vb) {
- }
-
- public void deleteBuffer(VertexBuffer vb) {
- }
-}
OSDN Git Service
