org.andengine.opengl.util.GLState Java Examples

public void warmup(final GLState pGLState, final ITexture pTexture) {
	pTexture.bind(pGLState);
	this.bind(pGLState, PositionTextureCoordinatesShaderProgram.getInstance());

	pGLState.pushModelViewGLMatrix();
	{
		/* Far far away and really small. */
		pGLState.loadModelViewGLMatrixIdentity();
		pGLState.translateModelViewGLMatrixf(1000000, 1000000, 0);
		pGLState.scaleModelViewGLMatrixf(0.0001f, 0.0001f, 0);

		this.draw(GLES20.GL_TRIANGLES, TextureWarmUpVertexBufferObject.VERTICES_PER_VERTEXBUFFEROBJECT_SIZE);
	}
	pGLState.popModelViewGLMatrix();

	this.unbind(pGLState, PositionTextureCoordinatesShaderProgram.getInstance());
}
 

@Override
protected void onManagedDraw(final GLState pGLState, final Camera pCamera) {
	this.mSpriteBatch.setIndex(0);

	final Particle<Entity>[] particles = this.mParticles;
	for(int i = this.mParticlesAlive - 1; i >= 0; i--) {
		final Entity entity = particles[i].getEntity();

		/* In order to support alpha changes of the sprites inside the spritebatch,
		 * we have to 'premultiply' the RGB channels of the sprite with its alpha channel. */
		final float alpha = entity.getAlpha();
		final float colorABGRPackedInt = ColorUtils.convertRGBAToABGRPackedFloat(entity.getRed() * alpha, entity.getGreen() * alpha, entity.getBlue() * alpha, alpha);

		this.mSpriteBatch.drawWithoutChecks(this.mTextureRegion, entity, this.mTextureRegion.getWidth(), this.mTextureRegion.getHeight(), colorABGRPackedInt);
	}
	this.mSpriteBatch.submit();

	this.mSpriteBatch.onDraw(pGLState, pCamera);
}
 

@Override
public void bind(final GLState pGLState) {
	if (this.mHardwareBufferID == IVertexBufferObject.HARDWARE_BUFFER_ID_INVALID) {
		this.loadToHardware(pGLState);

		if (this.mVertexBufferObjectManager != null) {
			this.mVertexBufferObjectManager.onVertexBufferObjectLoaded(this);
		}
	}

	pGLState.bindArrayBuffer(this.mHardwareBufferID);

	if (this.mDirtyOnHardware) {
		this.onBufferData();

		this.mDirtyOnHardware = false;
	}
}
 

LoadingScene() {

        super();

        float spriteSTartY = (camera.getHeight() - camera.getWidth()) / 2;
        setBackground(new Background(Color.BLACK));
        this.attachChild(new Sprite(0, spriteSTartY, camera.getWidth(), camera.getWidth(),
                ResourcesManager.getInstance().loadingScreenBackgroundRegion, vbom) {

                @Override
                protected void preDraw(GLState pGLState, Camera pCamera) {

                    super.preDraw(pGLState, pCamera);
                    pGLState.enableDither();
                }
            });
    }
 

protected void onApplyTransformations(final GLState pGLState) {
	/* Offset. */
	this.applyOffset(pGLState);

	/* Translation. */
	this.applyTranslation(pGLState);

	/* Rotation. */
	this.applyRotation(pGLState);

	/* Skew. */
	this.applySkew(pGLState);

	/* Scale. */
	this.applyScale(pGLState);
}
 

/**
 * Must be called from the GL-{@link Thread}.
 *
 * @param pGLState
 * @param pTexture the {@link ITexture} to be loaded right now, if it is not loaded.
 * @return <code>true</code> when the {@link ITexture} was previously not managed by this {@link TextureManager}, <code>false</code> if it was already managed.
 */
public synchronized boolean loadTexture(final GLState pGLState, final ITexture pTexture) throws IOException {
	if (pTexture == null) {
		throw new IllegalArgumentException("pTexture must not be null!");
	}

	if (!pTexture.isLoadedToHardware()) {
		pTexture.loadToHardware(pGLState);
	} else if (pTexture.isUpdateOnHardwareNeeded()) {
		pTexture.reloadToHardware(pGLState);
	}

	if (this.mTexturesManaged.contains(pTexture)) {
		/* Just make sure it doesn't get deleted. */
		this.mTexturesToBeUnloaded.remove(pTexture);
		return false;
	} else {
		this.mTexturesManaged.add(pTexture);
		this.mTexturesLoaded.add(pTexture);
		return true;
	}
}
 

@Override
public void onDraw(final GLState pGLState, final Camera pCamera) {
	super.onDraw(pGLState, pCamera);

	final float parallaxValue = this.mParallaxValue;
	final ArrayList<ParallaxEntity> parallaxEntities = this.mParallaxEntities;

	for(int i = 0; i < this.mParallaxEntityCount; i++) {
		parallaxEntities.get(i).onDraw(pGLState, pCamera, parallaxValue);
	}
}
 

@Override
public void bind(final GLState pGLState, final VertexBufferObjectAttributes pVertexBufferObjectAttributes) {
	super.bind(pGLState, pVertexBufferObjectAttributes);

	GLES20.glUniformMatrix4fv(PositionColorTextureCoordinatesShaderProgram.sUniformModelViewPositionMatrixLocation, 1, false, pGLState.getModelViewProjectionGLMatrix(), 0);
	GLES20.glUniform1i(PositionColorTextureCoordinatesShaderProgram.sUniformTexture0Location, 0);
}
 

@Override
protected void onDrawScene(final GLState pGLState, final Camera pFirstCamera) {
	final Camera secondCamera = this.getSecondCamera();

	final int surfaceWidth = this.mSurfaceWidth;
	final int surfaceWidthHalf = surfaceWidth >> 1;

	final int surfaceHeight = this.mSurfaceHeight;

	pGLState.enableScissorTest();

	/* First Screen. With first camera, on the left half of the screens width. */
	if(super.mScene != null) {
		GLES20.glScissor(0, 0, surfaceWidthHalf, surfaceHeight);
		GLES20.glViewport(0, 0, surfaceWidthHalf, surfaceHeight);

		super.mScene.onDraw(pGLState, pFirstCamera);
		pFirstCamera.onDrawHUD(pGLState);
	}

	/* Second Screen. With second camera, on the right half of the screens width. */
	if(this.mSecondScene != null) {
		GLES20.glScissor(surfaceWidthHalf, 0, surfaceWidthHalf, surfaceHeight);
		GLES20.glViewport(surfaceWidthHalf, 0, surfaceWidthHalf, surfaceHeight);

		this.mSecondScene.onDraw(pGLState, secondCamera);
		secondCamera.onDrawHUD(pGLState);
	}

	pGLState.disableScissorTest();
}
 

@Override
protected void preDraw(final GLState pGLState, final Camera pCamera) {
	if(this.mBlendingEnabled) {
		pGLState.enableBlend();
		pGLState.blendFunction(this.mBlendFunctionSource, this.mBlendFunctionDestination);
	}
}
 

@Override
protected void preDraw(final GLState pGLState, final Camera pCamera) {
	super.preDraw(pGLState, pCamera);

	this.mFont.getTexture().bind(pGLState);

	this.mTextVertexBufferObject.bind(pGLState, this.mShaderProgram);
}
 

@Override
protected void preDraw(final GLState pGLState, final Camera pCamera) {
	super.preDraw(pGLState, pCamera);

	if(this.mBlendingEnabled) {
		pGLState.enableBlend();
		pGLState.blendFunction(this.mBlendFunctionSource, this.mBlendFunctionDestination);
	}

	this.mTexture.bind(pGLState);

	this.mSpriteBatchVertexBufferObject.bind(pGLState, this.mShaderProgram);
}
 

protected void applySkew(final GLState pGLState) {
	final float skewX = this.mSkewX;
	final float skewY = this.mSkewY;

	if((skewX != 0) || (skewY != 0)) {
		final float skewCenterX = this.mSkewCenterX;
		final float skewCenterY = this.mSkewCenterY;

		pGLState.translateModelViewGLMatrixf(skewCenterX, skewCenterY, 0);
		pGLState.skewModelViewGLMatrixf(skewX, skewY);
		pGLState.translateModelViewGLMatrixf(-skewCenterX, -skewCenterY, 0);
	}
}
 

@Override
protected void link(final GLState pGLState) throws ShaderProgramLinkException {
	GLES20.glBindAttribLocation(this.mProgramID, ShaderProgramConstants.ATTRIBUTE_POSITION_LOCATION, ShaderProgramConstants.ATTRIBUTE_POSITION);
	GLES20.glBindAttribLocation(this.mProgramID, ShaderProgramConstants.ATTRIBUTE_TEXTURECOORDINATES_LOCATION, ShaderProgramConstants.ATTRIBUTE_TEXTURECOORDINATES);

	super.link(pGLState);

	PositionTextureCoordinatesUniformColorShaderProgram.sUniformModelViewPositionMatrixLocation = this.getUniformLocation(ShaderProgramConstants.UNIFORM_MODELVIEWPROJECTIONMATRIX);
	PositionTextureCoordinatesUniformColorShaderProgram.sUniformTexture0Location = this.getUniformLocation(ShaderProgramConstants.UNIFORM_TEXTURE_0);
	PositionTextureCoordinatesUniformColorShaderProgram.sUniformColorLocation = this.getUniformLocation(ShaderProgramConstants.UNIFORM_COLOR);
}
 

@Override
protected void link(final GLState pGLState) throws ShaderProgramLinkException {
	GLES20.glBindAttribLocation(this.mProgramID, ShaderProgramConstants.ATTRIBUTE_POSITION_LOCATION, ShaderProgramConstants.ATTRIBUTE_POSITION);
	GLES20.glBindAttribLocation(this.mProgramID, ShaderProgramConstants.ATTRIBUTE_TEXTURECOORDINATES_LOCATION, ShaderProgramConstants.ATTRIBUTE_TEXTURECOORDINATES);

	super.link(pGLState);

	PositionTextureCoordinatesTextureSelectShaderProgram.sUniformModelViewPositionMatrixLocation = this.getUniformLocation(ShaderProgramConstants.UNIFORM_MODELVIEWPROJECTIONMATRIX);
	PositionTextureCoordinatesTextureSelectShaderProgram.sUniformTexture0Location = this.getUniformLocation(ShaderProgramConstants.UNIFORM_TEXTURE_0);
	PositionTextureCoordinatesTextureSelectShaderProgram.sUniformTexture1Location = this.getUniformLocation(ShaderProgramConstants.UNIFORM_TEXTURE_1);
	PositionTextureCoordinatesTextureSelectShaderProgram.sUniformTextureSelectTexture0Location = this.getUniformLocation(ShaderProgramConstants.UNIFORM_TEXTURESELECT_TEXTURE_0);
}
 

@Override
protected void onDrawScene(final GLState pGLState, final Camera pFirstCamera) {
	if(super.mScene != null) {
		final Camera secondCamera = this.getSecondCamera();

		final int surfaceWidth = this.mSurfaceWidth;
		final int surfaceWidthHalf = surfaceWidth >> 1;

		final int surfaceHeight = this.mSurfaceHeight;

		pGLState.enableScissorTest();

		/* First Screen. With first camera, on the left half of the screens width. */
		{
			GLES20.glScissor(0, 0, surfaceWidthHalf, surfaceHeight);
			GLES20.glViewport(0, 0, surfaceWidthHalf, surfaceHeight);

			super.mScene.onDraw(pGLState, pFirstCamera);
			pFirstCamera.onDrawHUD(pGLState);
		}

		/* Second Screen. With second camera, on the right half of the screens width. */
		{
			GLES20.glScissor(surfaceWidthHalf, 0, surfaceWidthHalf, surfaceHeight);
			GLES20.glViewport(surfaceWidthHalf, 0, surfaceWidthHalf, surfaceHeight);

			super.mScene.onDraw(pGLState, secondCamera);
			secondCamera.onDrawHUD(pGLState);
		}

		pGLState.disableScissorTest();
	}
}
 

@Override
protected void preDraw(final GLState pGLState, final Camera pCamera) {
	super.preDraw(pGLState, pCamera);

	pGLState.lineWidth(this.mLineWidth);

	this.mLineChainVertexBufferObject.bind(pGLState, this.mShaderProgram);
}
 

public void bind(final GLState pGLState, final VertexBufferObjectAttributes pVertexBufferObjectAttributes) throws ShaderProgramException {
	if (!this.mCompiled) {
		this.compile(pGLState);
	}
	pGLState.useProgram(this.mProgramID);

	pVertexBufferObjectAttributes.glVertexAttribPointers();
}
 

protected void link(final GLState pGLState) throws ShaderProgramLinkException {
	GLES20.glLinkProgram(this.mProgramID);

	GLES20.glGetProgramiv(this.mProgramID, GLES20.GL_LINK_STATUS, ShaderProgram.HARDWAREID_CONTAINER, 0);
	if (ShaderProgram.HARDWAREID_CONTAINER[0] == 0) {
		throw new ShaderProgramLinkException(GLES20.glGetProgramInfoLog(this.mProgramID));
	}

	this.initAttributeLocations();
	this.initUniformLocations();

	this.mCompiled = true;
}
 

@Override
public void bind(final GLState pGLState, final VertexBufferObjectAttributes pVertexBufferObjectAttributes) {
	GLES20.glDisableVertexAttribArray(ShaderProgramConstants.ATTRIBUTE_COLOR_LOCATION);

	super.bind(pGLState, pVertexBufferObjectAttributes);

	GLES20.glUniformMatrix4fv(PositionTextureCoordinatesTextureSelectShaderProgram.sUniformModelViewPositionMatrixLocation, 1, false, pGLState.getModelViewProjectionGLMatrix(), 0);
	GLES20.glUniform1i(PositionTextureCoordinatesTextureSelectShaderProgram.sUniformTexture0Location, 0);
	GLES20.glUniform1i(PositionTextureCoordinatesTextureSelectShaderProgram.sUniformTexture1Location, 1);
}
 

@Override
public String getShaderSource(final GLState pGLState) {
	for(int i = 0; i < this.mCriteriaShaderSourceEntries.length; i++) {
		final CriteriaShaderSourceEntry criteriaShaderSourceEntry = this.mCriteriaShaderSourceEntries[i];
		if(criteriaShaderSourceEntry.isMet(pGLState)) {
			return criteriaShaderSourceEntry.getShaderSource();
		}
	}
	throw new ShaderProgramException("No " + CriteriaShaderSourceEntry.class.getSimpleName() + " met!");
}
 

public synchronized void updateVertexBufferObjects(final GLState pGLState) {
	final ArrayList<IVertexBufferObject> vertexBufferObjectsLoaded = this.mVertexBufferObjectsLoaded;
	final ArrayList<IVertexBufferObject> vertexBufferObjectsToBeUnloaded = this.mVertexBufferObjectsToBeUnloaded;

	/* Unload pending VertexBufferObjects. */
	for(int i = vertexBufferObjectsToBeUnloaded.size() - 1; i >= 0; i--){
		final IVertexBufferObject vertexBufferObjectToBeUnloaded = vertexBufferObjectsToBeUnloaded.remove(i);
		if(vertexBufferObjectToBeUnloaded.isLoadedToHardware()){
			vertexBufferObjectToBeUnloaded.unloadFromHardware(pGLState);
		}
		vertexBufferObjectsLoaded.remove(vertexBufferObjectToBeUnloaded);
	}
}
 

public synchronized void update(final GLState pGLState) {
	if (this.mTexture.isLoadedToHardware()) {
		final ArrayList<Letter> lettersPendingToBeDrawnToTexture = this.mLettersPendingToBeDrawnToTexture;
		if (lettersPendingToBeDrawnToTexture.size() > 0) {
			this.mTexture.bind(pGLState);
			final PixelFormat pixelFormat = this.mTexture.getPixelFormat();

			final boolean preMultipyAlpha = this.mTexture.getTextureOptions().mPreMultiplyAlpha;
			for (int i = lettersPendingToBeDrawnToTexture.size() - 1; i >= 0; i--) {
				final Letter letter = lettersPendingToBeDrawnToTexture.get(i);
				if (!letter.isWhitespace()) {
					final Bitmap bitmap = this.getLetterBitmap(letter);

					final boolean useDefaultAlignment = MathUtils.isPowerOfTwo(bitmap.getWidth()) && MathUtils.isPowerOfTwo(bitmap.getHeight()) && (pixelFormat == PixelFormat.RGBA_8888);
					if (!useDefaultAlignment) {
						/* Adjust unpack alignment. */
						GLES20.glPixelStorei(GLES20.GL_UNPACK_ALIGNMENT, 1);
					}

					if (preMultipyAlpha) {
						GLUtils.texSubImage2D(GLES20.GL_TEXTURE_2D, 0, letter.mTextureX, letter.mTextureY, bitmap);
					} else {
						pGLState.glTexSubImage2D(GLES20.GL_TEXTURE_2D, 0, letter.mTextureX, letter.mTextureY, bitmap, pixelFormat);
					}

					if (!useDefaultAlignment) {
						/* Restore default unpack alignment. */
						GLES20.glPixelStorei(GLES20.GL_UNPACK_ALIGNMENT, GLState.GL_UNPACK_ALIGNMENT_DEFAULT);
					}

					bitmap.recycle();
				}
			}
			lettersPendingToBeDrawnToTexture.clear();

			System.gc();
		}
	}
}
 

@Override
protected void draw(final GLState pGLState, final Camera pCamera) {
	this.begin();

	this.mSpriteBatchVertexBufferObject.draw(GLES20.GL_TRIANGLES, this.mVertices);

	this.end();
}
 

@Override
public void unloadFromHardware(final GLState pGLState) {
	pGLState.deleteTexture(this.mHardwareTextureID);

	this.mHardwareTextureID = Texture.HARDWARE_TEXTURE_ID_INVALID;

	if (this.mTextureStateListener != null) {
		this.mTextureStateListener.onUnloadedFromHardware(this);
	}
}
 

@Override
protected void preDraw(final GLState pGLState, final Camera pCamera) {
	if (this.mBlendingEnabled) {
		pGLState.enableBlend();
		pGLState.blendFunction(this.mBlendFunctionSource, this.mBlendFunctionDestination);
	}
}
 

public void onApplySceneMatrix(final GLState pGLState) {
	pGLState.orthoProjectionGLMatrixf(this.getXMin(), this.getXMax(), this.getYMin(), this.getYMax(), this.mZNear, this.mZFar);

	final float rotation = this.mRotation;
	if (rotation != 0) {
		this.applyRotation(pGLState, this.getCenterX(), this.getCenterY(), rotation);
	}
}
 

@Override
protected void preDraw(final GLState pGLState, final Camera pCamera) {
	super.preDraw(pGLState, pCamera);

	this.getTextureRegion().getTexture().bind(pGLState);

	this.mSpriteVertexBufferObject.bind(pGLState, this.mShaderProgram);
}
 

@Override
public void bind(final GLState pGLState, final VertexBufferObjectAttributes pVertexBufferObjectAttributes) {
	GLES20.glDisableVertexAttribArray(ShaderProgramConstants.ATTRIBUTE_TEXTURECOORDINATES_LOCATION);

	super.bind(pGLState, pVertexBufferObjectAttributes);

	GLES20.glUniformMatrix4fv(PositionColorShaderProgram.sUniformModelViewPositionMatrixLocation, 1, false, pGLState.getModelViewProjectionGLMatrix(), 0);
}
 

@Override
	public void onSurfaceCreated(final GL10 pGL, final EGLConfig pEGLConfig) {
		synchronized(GLState.class) {
			final RenderOptions renderOptions = this.mEngine.getEngineOptions().getRenderOptions();
			this.mGLState.reset(renderOptions, this.mConfigChooser, pEGLConfig);

			// TODO Check if available and make available through EngineOptions-RenderOptions
//			GLES20.glEnable(GLES20.GL_POLYGON_SMOOTH);
//			GLES20.glHint(GLES20.GL_POLYGON_SMOOTH_HINT, GLES20.GL_NICEST);
//			GLES20.glEnable(GLES20.GL_LINE_SMOOTH);
//			GLES20.glHint(GLES20.GL_LINE_SMOOTH_HINT, GLES20.GL_NICEST);
//			GLES20.glEnable(GLES20.GL_POINT_SMOOTH);
//			GLES20.glHint(GLES20.GL_POINT_SMOOTH_HINT, GLES20.GL_NICEST);

			this.mGLState.disableDepthTest();
			this.mGLState.enableBlend();
			this.mGLState.setDitherEnabled(renderOptions.isDithering());

			/* Enabling culling doesn't really make sense, because triangles are never drawn 'backwards' on purpose. */
//			this.mGLState.enableCulling();
//			GLES20.glFrontFace(GLES20.GL_CCW);
//			GLES20.glCullFace(GLES20.GL_BACK);

			if (this.mRendererListener != null) {
				this.mRendererListener.onSurfaceCreated(this.mGLState);
			}
		}
	}