gistfile1.java

	public void render() {
		boolean firstPass = true;
		
		for(MapLight light : mapLightRenderer.lights) {
			batch.setShader(mapLightRenderer.lightShader);
			lightFBO.begin();
			batch.setProjectionMatrix(cam.combined);
			batch.setBlendFunction(GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);
			
			Gdx.gl.glClearColor(1f,0f,0f,0f);
			Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
			
			beginRender();
			
			Vector3 newLightPos = cam.project(new Vector3(light.x, light.y, 0f));
			newLightPos.x /= Gdx.graphics.getWidth();
			newLightPos.y /= Gdx.graphics.getHeight();
			
			mapLightRenderer.lightShader.setUniformf("LightColor", light.color.r, light.color.g, light.color.b, 
					MapLightRenderer.LIGHT_INTENSITY);
			mapLightRenderer.lightShader.setUniformf("LightPos", newLightPos.x, newLightPos.y, MapLightRenderer.DEFAULT_LIGHT_Z);
		 	
			for (MapLayer layer : map.getLayers()) {

				
				if (layer.isVisible()) {
					if (layer instanceof TiledMapTileLayer) {
						renderTileLayer((TiledMapTileLayer) layer, firstPass);
					}
					if (layer instanceof TiledMapImageLayer) {
						renderImageLayer((TiledMapImageLayer) layer);
					} else {
						renderObjects(layer);
					}
				}

			}
			
			endRender();
			
			lightFBO.end();
			
			batch.setBlendFunction(GL20.GL_ONE, GL20.GL_ONE);

			Matrix4 uiMatrix = cam.combined.cpy();
			uiMatrix.setToOrtho2D(0, 0, 400, 300);
			batch.setProjectionMatrix(uiMatrix);
			
			batch.setShader(null);
			
			beginRender();
			
			lightFBO.getColorBufferTexture().setFilter(TextureFilter.Nearest, TextureFilter.Nearest);
			TextureRegion fboTexture = new TextureRegion(lightFBO.getColorBufferTexture());
			fboTexture.flip(false, true);
			
			batch.draw(fboTexture, 0, 0);
			
			endRender();
			
			firstPass = false;
			
		}
	}
	
	
	public void renderTileLayer(TiledMapTileLayer layer, boolean firstPass) {
		final Color batchColor = batch.getColor();
		final float color = Color.toFloatBits(batchColor.r, batchColor.g,
				batchColor.b, batchColor.a * layer.getOpacity());

		final int layerWidth = layer.getWidth();
		final int layerHeight = layer.getHeight();

		final float layerTileWidth = layer.getTileWidth() * unitScale;
		final float layerTileHeight = layer.getTileHeight() * unitScale;

		final int col1 = Math.max(0, (int) (viewBounds.x / layerTileWidth));
		final int col2 = Math.min(layerWidth, (int) ((viewBounds.x
				+ viewBounds.width + layerTileWidth) / layerTileWidth));

		final int row1 = Math.max(0, (int) (viewBounds.y / layerTileHeight));
		final int row2 = Math.min(layerHeight, (int) ((viewBounds.y
				+ viewBounds.height + layerTileHeight) / layerTileHeight));

		float y = row2 * layerTileHeight;
		float xStart = col1 * layerTileWidth;
		final float[] vertices = this.vertices;
		
		

		for (int row = row2; row >= row1; row--) {

			if (renderCallback != null) {
				renderCallback.renderRow(batch, y, layer, this, firstPass);
				
				//batch.setShader(mapLightRenderer.lightShader);

			}


			float x = xStart;
			for (int col = col1; col < col2; col++) {
				final TiledMapTileLayer.Cell cell = layer.getCell(col, row);
				if (cell == null) {
					x += layerTileWidth;
					continue;
				}
				
				final TiledMapTile tile = cell.getTile();

				if (tile != null) {
					final boolean flipX = cell.getFlipHorizontally();
					final boolean flipY = cell.getFlipVertically();
					final int rotations = cell.getRotation();

					TextureRegion region = tile.getTextureRegion();
					
					float x1 = x + tile.getOffsetX() * unitScale;
					float y1 = y + tile.getOffsetY() * unitScale;
					float x2 = x1 + region.getRegionWidth() * unitScale;
					float y2 = y1 + region.getRegionHeight() * unitScale;

					float u1 = region.getU();
					float v1 = region.getV2();
					float u2 = region.getU2();
					float v2 = region.getV();

					vertices[X1] = x1;
					vertices[Y1] = y1;
					vertices[C1] = color;
					vertices[U1] = u1;
					vertices[V1] = v1;

					vertices[X2] = x1;
					vertices[Y2] = y2;
					vertices[C2] = color;
					vertices[U2] = u1;
					vertices[V2] = v2;

					vertices[X3] = x2;
					vertices[Y3] = y2;
					vertices[C3] = color;
					vertices[U3] = u2;
					vertices[V3] = v2;

					vertices[X4] = x2;
					vertices[Y4] = y1;
					vertices[C4] = color;
					vertices[U4] = u2;
					vertices[V4] = v1;

					if (flipX) {
						float temp = vertices[U1];
						vertices[U1] = vertices[U3];
						vertices[U3] = temp;
						temp = vertices[U2];
						vertices[U2] = vertices[U4];
						vertices[U4] = temp;
					}
					if (flipY) {
						float temp = vertices[V1];
						vertices[V1] = vertices[V3];
						vertices[V3] = temp;
						temp = vertices[V2];
						vertices[V2] = vertices[V4];
						vertices[V4] = temp;
					}
					if (rotations != 0) {
						switch (rotations) {
						case Cell.ROTATE_90: {
							float tempV = vertices[V1];
							vertices[V1] = vertices[V2];
							vertices[V2] = vertices[V3];
							vertices[V3] = vertices[V4];
							vertices[V4] = tempV;

							float tempU = vertices[U1];
							vertices[U1] = vertices[U2];
							vertices[U2] = vertices[U3];
							vertices[U3] = vertices[U4];
							vertices[U4] = tempU;
							break;
						}
						case Cell.ROTATE_180: {
							float tempU = vertices[U1];
							vertices[U1] = vertices[U3];
							vertices[U3] = tempU;
							tempU = vertices[U2];
							vertices[U2] = vertices[U4];
							vertices[U4] = tempU;
							float tempV = vertices[V1];
							vertices[V1] = vertices[V3];
							vertices[V3] = tempV;
							tempV = vertices[V2];
							vertices[V2] = vertices[V4];
							vertices[V4] = tempV;
							break;
						}
						case Cell.ROTATE_270: {
							float tempV = vertices[V1];
							vertices[V1] = vertices[V4];
							vertices[V4] = vertices[V3];
							vertices[V3] = vertices[V2];
							vertices[V2] = tempV;

							float tempU = vertices[U1];
							vertices[U1] = vertices[U4];
							vertices[U4] = vertices[U3];
							vertices[U3] = vertices[U2];
							vertices[U2] = tempU;
							break;
						}
						}
					}
					
					
					
					tilesetNormals.bind(1);
					
					Gdx.gl20.glActiveTexture(0);
					
					batch.draw(region.getTexture(), vertices, 0, NUM_VERTICES);
					
					
				}
				x += layerTileWidth;
			}

			y -= layerTileHeight;
		}
	}