📄 lwjglrenderer.java
字号:
GL11.glEnableClientState(GL11.GL_COLOR_ARRAY);
rendRecord.setBoundVBO(vbo.getVBOColorID());
GL11.glColorPointer(4, GL11.GL_FLOAT, 0, 0);
} else if (colors == null) {
GL11.glDisableClientState(GL11.GL_COLOR_ARRAY);
// Disabling a color array causes the current color to be undefined.
// So enforce a current color here.
ColorRGBA defCol = g.getDefaultColor();
if (defCol != null) {
rendRecord.setCurrentColor(defCol);
} else {
// no default color, so set to white.
rendRecord.setCurrentColor(1, 1, 1, 1);
}
} else if (prevColor != colors) {
// colors have changed
GL11.glEnableClientState(GL11.GL_COLOR_ARRAY);
// ensure no VBO is bound
if (supportsVBO)
rendRecord.setBoundVBO(0);
colors.rewind();
GL11.glColorPointer(4, 0, colors);
}
if (oldLimit != -1)
colors.limit(oldLimit);
prevColor = colors;
TextureState ts = (TextureState) context.currentStates[RenderState.StateType.Texture.ordinal()];
int offset = 0;
if (ts != null) {
offset = ts.getTextureCoordinateOffset();
for (int i = 0; i < ts.getNumberOfSetTextures()
&& i < TextureState.getNumberOfFragmentTexCoordUnits(); i++) {
TexCoords texC = g.getTextureCoords(i + offset);
oldLimit = -1;
if (texC != null) {
// make sure only the necessary texture coords are sent
// through on old cards.
oldLimit = texC.coords.limit();
texC.coords.limit(g.getVertexCount() * texC.perVert);
}
if (capabilities.GL_ARB_multitexture) {
ARBMultitexture
.glClientActiveTextureARB(ARBMultitexture.GL_TEXTURE0_ARB
+ i);
}
if ((supportsVBO && vbo != null && vbo.getVBOTextureID(i) > 0)) { // use
// VBO
GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
rendRecord.setBoundVBO(vbo.getVBOTextureID(i));
GL11.glTexCoordPointer(texC.perVert, GL11.GL_FLOAT, 0, 0);
} else if (texC == null) {
GL11.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
} else if (prevTex[i] != texC.coords) {
// textures have changed
GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
// ensure no VBO is bound
if (supportsVBO)
rendRecord.setBoundVBO(0);
// set data
texC.coords.rewind();
GL11.glTexCoordPointer(texC.perVert, 0, texC.coords);
} else {
GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
}
prevTex[i] = texC != null ? texC.coords : null;
if (oldLimit != -1)
texC.coords.limit(oldLimit);
}
if (ts.getNumberOfSetTextures() < prevTextureNumber) {
for (int i = ts.getNumberOfSetTextures(); i < prevTextureNumber; i++) {
if (capabilities.GL_ARB_multitexture) {
ARBMultitexture
.glClientActiveTextureARB(ARBMultitexture.GL_TEXTURE0_ARB
+ i);
}
GL11.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
}
}
prevTextureNumber = ts.getNumberOfSetTextures() < TextureState
.getNumberOfFixedUnits() ? ts.getNumberOfSetTextures()
: TextureState.getNumberOfFixedUnits();
}
return indicesVBO;
}
private void applyNormalMode(Spatial.NormalsMode normMode, Geometry t) {
switch (normMode) {
case NormalizeIfScaled:
Vector3f scale = t.getWorldScale();
if (!scale.equals(Vector3f.UNIT_XYZ)) {
if (scale.x == scale.y && scale.y == scale.z
&& capabilities.OpenGL12
&& prevNormMode != GL12.GL_RESCALE_NORMAL) {
if (prevNormMode == GL11.GL_NORMALIZE)
GL11.glDisable(GL11.GL_NORMALIZE);
GL11.glEnable(GL12.GL_RESCALE_NORMAL);
prevNormMode = GL12.GL_RESCALE_NORMAL;
} else if (prevNormMode != GL11.GL_NORMALIZE) {
if (prevNormMode == GL12.GL_RESCALE_NORMAL)
GL11.glDisable(GL12.GL_RESCALE_NORMAL);
GL11.glEnable(GL11.GL_NORMALIZE);
prevNormMode = GL11.GL_NORMALIZE;
}
} else {
if (prevNormMode == GL12.GL_RESCALE_NORMAL) {
GL11.glDisable(GL12.GL_RESCALE_NORMAL);
prevNormMode = GL11.GL_ZERO;
} else if (prevNormMode == GL11.GL_NORMALIZE) {
GL11.glDisable(GL11.GL_NORMALIZE);
prevNormMode = GL11.GL_ZERO;
}
}
break;
case AlwaysNormalize:
if (prevNormMode != GL11.GL_NORMALIZE) {
if (prevNormMode == GL12.GL_RESCALE_NORMAL)
GL11.glDisable(GL12.GL_RESCALE_NORMAL);
GL11.glEnable(GL11.GL_NORMALIZE);
prevNormMode = GL11.GL_NORMALIZE;
}
break;
case UseProvided:
default:
if (prevNormMode == GL12.GL_RESCALE_NORMAL) {
GL11.glDisable(GL12.GL_RESCALE_NORMAL);
prevNormMode = GL11.GL_ZERO;
} else if (prevNormMode == GL11.GL_NORMALIZE) {
GL11.glDisable(GL11.GL_NORMALIZE);
prevNormMode = GL11.GL_ZERO;
}
break;
}
}
protected boolean doTransforms(Spatial t) {
// set world matrix
if (!generatingDisplayList
|| (t.getLocks() & Spatial.LOCKED_TRANSFORMS) != 0) {
boolean doT = false, doR = false, doS = false;
Vector3f translation = t.getWorldTranslation();
if (!translation.equals(Vector3f.ZERO)) {
doT = true;
}
Quaternion rotation = t.getWorldRotation();
if (!rotation.isIdentity()) {
doR = true;
}
Vector3f scale = t.getWorldScale();
if (!scale.equals(Vector3f.UNIT_XYZ)) {
doS = true;
}
if (doT || doR || doS) {
RendererRecord matRecord = (RendererRecord) DisplaySystem.getDisplaySystem().getCurrentContext().getRendererRecord();
matRecord.switchMode(GL11.GL_MODELVIEW);
GL11.glPushMatrix();
if (doT)
GL11.glTranslatef(translation.x, translation.y, translation.z);
if (doR) {
float rot = rotation.toAngleAxis(vRot) * FastMath.RAD_TO_DEG;
GL11.glRotatef(rot, vRot.x, vRot.y, vRot.z);
}
if (doS) {
GL11.glScalef(scale.x, scale.y, scale.z);
}
return true;
}
}
return false;
}
protected void undoTransforms(Spatial t) {
if (!generatingDisplayList
|| (t.getLocks() & Spatial.LOCKED_TRANSFORMS) != 0) {
RendererRecord matRecord = (RendererRecord) DisplaySystem
.getDisplaySystem().getCurrentContext().getRendererRecord();
matRecord.switchMode(GL11.GL_MODELVIEW);
GL11.glPopMatrix();
}
}
// inherited documentation
public int createDisplayList(Geometry g) {
int listID = GL11.glGenLists(1);
generatingDisplayList = true;
RenderContext<?> context = DisplaySystem.getDisplaySystem()
.getCurrentContext();
// invalidate states -- this makes sure things like line stipple get
// called in list.
context.invalidateStates();
RenderState oldTS = context.currentStates[RenderState.StateType.Texture.ordinal()];
context.currentStates[RenderState.StateType.Texture.ordinal()] = g.states[RenderState.StateType.Texture.ordinal()];
GL11.glNewList(listID, GL11.GL_COMPILE);
if (g instanceof TriMesh)
draw((TriMesh) g);
else if (g instanceof QuadMesh)
draw((QuadMesh) g);
else if (g instanceof Line)
draw((Line) g);
else if (g instanceof Point)
draw((Point) g);
GL11.glEndList();
context.currentStates[RenderState.StateType.Texture.ordinal()] = oldTS;
generatingDisplayList = false;
return listID;
}
// inherited documentation
public void releaseDisplayList(int listId) {
GL11.glDeleteLists(listId, 1);
}
// inherited documentation
public void setPolygonOffset(float factor, float offset) {
GL11.glEnable(GL11.GL_POLYGON_OFFSET_FILL);
GL11.glEnable(GL11.GL_POLYGON_OFFSET_LINE);
GL11.glEnable(GL11.GL_POLYGON_OFFSET_POINT);
GL11.glPolygonOffset(factor, offset);
}
// inherited documentation
public void clearPolygonOffset() {
GL11.glDisable(GL11.GL_POLYGON_OFFSET_FILL);
GL11.glDisable(GL11.GL_POLYGON_OFFSET_LINE);
GL11.glDisable(GL11.GL_POLYGON_OFFSET_POINT);
}
/**
* @see Renderer#deleteVBO(Buffer)
*/
public void deleteVBO(Buffer buffer) {
Integer i = removeFromVBOCache(buffer);
if (i != null)
deleteVBO(i.intValue());
}
/**
* @see Renderer#deleteVBO(int)
*/
public void deleteVBO(int vboid) {
if (vboid < 1 || !supportsVBO())
return;
RendererRecord rendRecord = (RendererRecord) DisplaySystem
.getDisplaySystem().getCurrentContext().getRendererRecord();
rendRecord.deleteVBOId(vboid);
}
/**
* @see Renderer#clearVBOCache()
*/
public void clearVBOCache() {
vboMap.clear();
}
/**
* @see Renderer#removeFromVBOCache(Buffer)
*/
public Integer removeFromVBOCache(Buffer buffer) {
return vboMap.remove(buffer);
}
/**
* <code>setStates</code> applies the given states if and only if they are
* different from the currently set states.
*/
public void applyStates(RenderState[] states, Geometry geom) {
if (Debug.stats) {
StatCollector.startStat(StatType.STAT_STATES_TIMER);
}
RenderContext<?> context = DisplaySystem.getDisplaySystem()
.getCurrentContext();
// TODO: To be used for the attribute shader solution
if (geom != null) {
GLSLShaderObjectsState shaderState = (GLSLShaderObjectsState) (context.enforcedStateList[RenderState.StateType.GLSLShaderObjects.ordinal()] != null ? context.enforcedStateList[RenderState.StateType.GLSLShaderObjects.ordinal()]
: states[RenderState.StateType.GLSLShaderObjects.ordinal()]);
if (shaderState != null
&& shaderState != defaultStateList[RenderState.StateType.GLSLShaderObjects.ordinal()]) {
shaderState.setGeometry(geom);
shaderState.setNeedsRefresh(true);
}
}
RenderState tempState = null;
for (int i = 0; i < states.length; i++) {
tempState = context.enforcedStateList[i] != null ? context.enforcedStateList[i]
: states[i];
if (tempState != null) {
if (!tempState.getStateType().canQuickCompare() || tempState.needsRefresh()
|| tempState != context.currentStates[i]) {
tempState.apply();
tempState.setNeedsRefresh(false);
}
}
}
if (Debug.stats) {
StatCollector.endStat(StatType.STAT_STATES_TIMER);
}
}
@Override
public StateRecord createLineRecord() {
return new LineRecord();
}
@Override
public StateRecord createRendererRecord() {
return new RendererRecord();
}
@Override
public void updateTextureSubImage(Texture dstTexture, int dstX, int dstY,
Image srcImage, int srcX, int srcY, int width, int height)
throws JmeException, UnsupportedOperationException {
// Check that the texture type is supported.
if (dstTexture.getType() != Texture.Type.TwoDimensional)
throw new UnsupportedOperationException(
"Unsupported Texture Type: " + dstTexture.getType());
// Determine the original texture configuration, so that this method can
// restore the texture configuration to its original state.
final IntBuffer intBuf = BufferUtils.createIntBuffer(16);
GL11.glGetInteger(GL11.GL_TEXTURE_BINDING_2D, intBuf);
final int origTexBinding = intBuf.get(0);
GL11.glGetInteger(GL11.GL_UNPACK_ALIGNMENT, intBuf);
final int origAlignment = intBuf.get(0);
final int origRowLength = 0;
final int origSkipPixels = 0;
final int origSkipRows = 0;
int alignment = 1;
int rowLength;
if (srcImage.getWidth() == width) {
// When the row length is zero, then the width parameter is used.
// We use zero in these cases in the hope that we can avoid two
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -