@Override public void create() { mesh = new Mesh( true, 3, 0, new VertexAttribute(Usage.Position, 3, "a_Position"), new VertexAttribute(Usage.ColorPacked, 4, "a_Color"), new VertexAttribute(Usage.TextureCoordinates, 2, "a_texCoords")); float c1 = Color.toFloatBits(255, 0, 0, 255); float c2 = Color.toFloatBits(255, 0, 0, 255); ; float c3 = Color.toFloatBits(0, 0, 255, 255); ; mesh.setVertices( new float[] {-0.5f, -0.5f, 0, c1, 0, 0, 0.5f, -0.5f, 0, c2, 1, 0, 0, 0.5f, 0, c3, 0.5f, 1}); texture = new Texture(Gdx.files.internal("data/badlogic.jpg")); spriteBatch = new SpriteBatch(); frameBuffer = new FrameBuffer(Format.RGB565, 128, 128, true); createShader(Gdx.graphics); }
@Override public void create() { vbo = new VertexBufferObject( true, 3, new VertexAttribute(VertexAttributes.Usage.Position, 2, "a_Position"), new VertexAttribute(VertexAttributes.Usage.TextureCoordinates, 2, "a_TexCoords"), new VertexAttribute(VertexAttributes.Usage.ColorPacked, 4, "a_Color")); float[] vertices = new float[] { -1, -1, 0, 0, Color.toFloatBits(1f, 0f, 0f, 1f), 0, 1, 0.5f, 1.0f, Color.toFloatBits(0f, 1f, 0f, 1f), 1, -1, 1, 0, Color.toFloatBits(0f, 0f, 1f, 1f) }; vbo.setVertices(vertices, 0, vertices.length); ibo = new IndexBufferObject(true, 3); ibo.setIndices(new short[] {0, 1, 2}, 0, 3); texture = new Texture(Gdx.files.internal("data/badlogic.jpg")); }
@Override public void create() { String vertexShader = "attribute vec4 a_position; \n" + "attribute vec4 a_color;\n" + "attribute vec2 a_texCoords;\n" + "varying vec4 v_color;" + "varying vec2 v_texCoords;" + "void main() \n" + "{ \n" + " v_color = vec4(a_color.x, a_color.y, a_color.z, 1); \n" + " v_texCoords = a_texCoords; \n" + " gl_Position = a_position; \n" + "} \n"; String fragmentShader = "#ifdef GL_ES\n" + "precision mediump float;\n" + "#endif\n" + "varying vec4 v_color;\n" + "varying vec2 v_texCoords;\n" + "uniform sampler2D u_texture;\n" + "void main() \n" + "{ \n" + " gl_FragColor = v_color * texture2D(u_texture, v_texCoords);\n" + "}"; shader = new ShaderProgram(vertexShader, fragmentShader); vbo = new VertexBufferObject( true, 3, new VertexAttribute(VertexAttributes.Usage.Position, 2, "a_position"), new VertexAttribute(VertexAttributes.Usage.TextureCoordinates, 2, "a_texCoords"), new VertexAttribute(VertexAttributes.Usage.ColorPacked, 4, "a_color")); float[] vertices = new float[] { -1, -1, 0, 0, Color.toFloatBits(1f, 0f, 0f, 1f), 0, 1, 0.5f, 1.0f, Color.toFloatBits(0f, 1f, 0f, 1f), 1, -1, 1, 0, Color.toFloatBits(0f, 0f, 1f, 1f) }; vbo.setVertices(vertices, 0, vertices.length); indices = new IndexBufferObject(3); indices.setIndices(new short[] {0, 1, 2}, 0, 3); texture = new Texture(Gdx.files.internal("data/badlogic.jpg")); }
public void drawTriangle( int x, int y, float w, float h, double rotation, double speed, double color, double puls) { if (once == 0) { System.out.println("Triangle entered"); // Image this.rectX = x; this.rectY = y; this.width = w; this.height = h; // Rotation purposes originX = x; originY = y; // Mesh Purposes float colour = Color.toFloatBits(0, 0, 0, 255); // default is black if (color == 1) { colour = Color.toFloatBits(255, 255, 255, 255); // set to white } float z = 0; float[] vertices = {x, y, z, colour, x, y, z, colour, x, y, z, colour}; float[] verticesTri = { x, y, x, y, x, y, }; this.verticesMesh = vertices; this.verticesPoly = verticesTri; this.speed = speed; this.rotation = rotation; this.color = color; this.pulsating = puls; once++; } // Triangle Polygon poly(); // Image rectX -= this.speed; rectY -= this.speed; width += this.speed * 2; height += this.speed * 2; // Update Indices once after poly() if (once < 10) { indices = Helper.earclip.computeTriangles(verticesPoly).toArray(); once++; } }
@Override public short vertex(Vector3 pos, Vector3 nor, Color col, Vector2 uv) { if (vindex >= Short.MAX_VALUE) throw new GdxRuntimeException("Too many vertices used"); if (col == null && colorSet) col = color; if (pos != null) { vertex[posOffset] = pos.x; if (posSize > 1) vertex[posOffset + 1] = pos.y; if (posSize > 2) vertex[posOffset + 2] = pos.z; } if (nor != null && norOffset >= 0) { vertex[norOffset] = nor.x; vertex[norOffset + 1] = nor.y; vertex[norOffset + 2] = nor.z; } if (col != null) { if (colOffset >= 0) { vertex[colOffset] = col.r; vertex[colOffset + 1] = col.g; vertex[colOffset + 2] = col.b; if (colSize > 3) vertex[colOffset + 3] = col.a; } else if (cpOffset > 0) vertex[cpOffset] = col.toFloatBits(); // FIXME cache packed color? } if (uv != null && uvOffset >= 0) { vertex[uvOffset] = uv.x; vertex[uvOffset + 1] = uv.y; } vertices.addAll(vertex); return (short) (vindex++); }
/** Builds final vertices with vertex attributes like coordinates, color and region u/v */ private void buildVertices() { vertices.clear(); for (int i = 0; i < parts.size; i++) { float verts[] = parts.get(i); if (verts == null) continue; float[] fullVerts = new float[5 * verts.length / 2]; int idx = 0; int col = i / rows; int row = i % rows; for (int j = 0; j < verts.length; j += 2) { fullVerts[idx++] = verts[j] + offset.x + x; fullVerts[idx++] = verts[j + 1] + offset.y + y; fullVerts[idx++] = color.toFloatBits(); float u = (verts[j] % gridWidth) / gridWidth; float v = (verts[j + 1] % gridHeight) / gridHeight; if (verts[j] == col * gridWidth) u = 0f; if (verts[j] == (col + 1) * gridWidth) u = 1f; if (verts[j + 1] == row * gridHeight) v = 0f; if (verts[j + 1] == (row + 1) * gridHeight) v = 1f; u = region.getU() + (region.getU2() - region.getU()) * u; v = region.getV() + (region.getV2() - region.getV()) * v; fullVerts[idx++] = u; fullVerts[idx++] = v; } vertices.add(fullVerts); } dirty = false; }
/** * Sets light color * * <p>NOTE: you can also use colorless light with shadows, e.g. (0,0,0,1) * * @param newColor RGB set the color and Alpha set intensity * @see #setColor(float, float, float, float) */ public void setColor(Color newColor) { if (newColor != null) { color.set(newColor); } else { color.set(DefaultColor); } colorF = color.toFloatBits(); if (staticLight) dirty = true; }
private float getColor(ColourDiffuse colourDiffuse) { String[] tokens = colourDiffuse.getValue().split(" "); if (tokens.length == 3) color.set(Float.valueOf(tokens[0]), Float.valueOf(tokens[1]), Float.valueOf(tokens[2]), 1); else color.set( Float.valueOf(tokens[0]), Float.valueOf(tokens[1]), Float.valueOf(tokens[2]), Float.valueOf(tokens[3])); return color.toFloatBits(); }
public void updateData(Transform transform) { Vector2 before; Vector2 vector; Vector2 after; for (int i = 0; i < vertices.length; i++) { before = vertices[i == 0 ? vertices.length - 1 : i - 1]; vector = vertices[i].cpy(); after = vertices[i == vertices.length - 1 ? 0 : i + 1]; // Vector2D vec1 = new Vector2D(new Point2D(after.x, after.y), new Point2D(vector.x, // vector.y)); // Vector2D vec2 = new Vector2D(new Point2D(before.x, before.y), new Point2D(vector.x, // vector.y)); // // double a1 = vec1.getAngle(); // double a2 = vec2.getAngle(); // double diff = a1 - a2; // double angle = (a1 + a2) / 2.0; // // if (diff > 0) { // angle -= Math.PI; // } // // Vector2D sum = new Vector2D(Math.cos(angle) * 0.2, Math.sin(angle) * 0.2); // sum.normalize(); // // sum = sum.times(0.04); // // Vector2 newPoint = new Vector2(vector.x + (float) sum.getX(), vector.y + (float) // sum.getY()); // // vector = newPoint.cpy(); transform.mul(vector); int dataIndex = i * 6; meshesData[dataIndex] = vector.x; meshesData[dataIndex + 1] = vector.y; meshesData[dataIndex + 2] = 0; meshesData[dataIndex + 3] = Color.toFloatBits(128, 128, 128, 255); meshesData[dataIndex + 4] = vertices[i].x / 8.0f + 0.5f; meshesData[dataIndex + 5] = 1.0f - (vertices[i].y / 8.0f + 0.5f); } mesh.setVertices(meshesData); }
/** * Sets the color used to tint images when they are added to the SpriteBatch. Default is {@link * Color#WHITE}. */ public void setColor(Color tint) { color = tint.toFloatBits(); }
public Boundary() { Vector2 point_1 = new Vector2(-SPACE_BOUNDARY_X - BOUNDARY_SIZE, SPACE_BOUNDARY_Y + BOUNDARY_SIZE); Vector2 point_2 = new Vector2(SPACE_BOUNDARY_X + BOUNDARY_SIZE, SPACE_BOUNDARY_Y + BOUNDARY_SIZE); Vector2 point_3 = new Vector2(SPACE_BOUNDARY_X + BOUNDARY_SIZE, SPACE_BOUNDARY_Y); Vector2 point_4 = new Vector2(-SPACE_BOUNDARY_X - BOUNDARY_SIZE, SPACE_BOUNDARY_Y); Vector2 point_5 = new Vector2(SPACE_BOUNDARY_X, SPACE_BOUNDARY_Y); Vector2 point_6 = new Vector2(SPACE_BOUNDARY_X + BOUNDARY_SIZE, -SPACE_BOUNDARY_Y); Vector2 point_7 = new Vector2(SPACE_BOUNDARY_X, -SPACE_BOUNDARY_Y); Vector2 point_8 = new Vector2(-SPACE_BOUNDARY_X - BOUNDARY_SIZE, -SPACE_BOUNDARY_Y); Vector2 point_9 = new Vector2(SPACE_BOUNDARY_X + BOUNDARY_SIZE, -SPACE_BOUNDARY_Y - BOUNDARY_SIZE); Vector2 point_10 = new Vector2(-SPACE_BOUNDARY_X - BOUNDARY_SIZE, -SPACE_BOUNDARY_Y - BOUNDARY_SIZE); Vector2 point_11 = new Vector2(-SPACE_BOUNDARY_X, SPACE_BOUNDARY_Y); Vector2 point_12 = new Vector2(-SPACE_BOUNDARY_X, -SPACE_BOUNDARY_Y); float border_colour = Color.toFloatBits(255, 0, 0, 255); meshes[0] = MeshFactory.square( point_1, border_colour, point_2, border_colour, point_3, border_colour, point_4, border_colour); meshes[1] = MeshFactory.square( point_5, border_colour, point_3, border_colour, point_6, border_colour, point_7, border_colour); meshes[2] = MeshFactory.square( point_8, border_colour, point_6, border_colour, point_9, border_colour, point_10, border_colour); meshes[3] = MeshFactory.square( point_4, border_colour, point_11, border_colour, point_12, border_colour, point_8, border_colour); }
@Override public void renderTileLayer(TiledMapTileLayer layer) { final float color = Color.toFloatBits(1, 1, 1, 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 float layerTileWidth25 = layerTileWidth * 0.25f; final float layerTileWidth50 = layerTileWidth * 0.50f; final float layerTileWidth75 = layerTileWidth * 0.75f; final float layerTileHeight50 = layerTileHeight * 0.50f; final float layerTileHeight150 = layerTileHeight * 1.50f; final int col1 = Math.max(0, (int) (((viewBounds.x - layerTileWidth25) / layerTileWidth75))); final int col2 = Math.min( layerWidth, (int) ((viewBounds.x + viewBounds.width + layerTileWidth75) / layerTileWidth75)); final int row1 = Math.max(0, (int) ((viewBounds.y / layerTileHeight150))); final int row2 = Math.min( layerHeight, (int) ((viewBounds.y + viewBounds.height + layerTileHeight150) / layerTileHeight)); final float[] vertices = this.vertices; for (int row = row1; row < row2; row++) { for (int col = col1; col < col2; col++) { float x = layerTileWidth75 * col; float y = (col % 2 == (yDown ? 0 : 1) ? 0 : layerTileHeight50) + (layerTileHeight * row); final TiledMapTileLayer.Cell cell = layer.getCell(col, row); if (cell == null) { x += layerTileWidth; continue; } final TiledMapTile tile = cell.getTile(); if (tile != null) { if (tile instanceof AnimatedTiledMapTile) continue; final boolean flipX = cell.getFlipHorizontally(); final boolean flipY = cell.getFlipVertically(); final int rotations = cell.getRotation(); TextureRegion region = tile.getTextureRegion(); float x1 = x; float y1 = y; 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 == 2) { 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; } spriteBatch.draw(region.getTexture(), vertices, 0, 20); } } } }
@Override public void renderTileLayer(TiledMapTileLayer layer) { 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 float layerTileWidth50 = layerTileWidth * 0.50f; final float layerTileHeight50 = layerTileHeight * 0.50f; final int minX = Math.max(0, (int) (((viewBounds.x - layerTileWidth50) / layerTileWidth))); final int maxX = Math.min( layerWidth, (int) ((viewBounds.x + viewBounds.width + layerTileWidth + layerTileWidth50) / layerTileWidth)); final int minY = Math.max(0, (int) (((viewBounds.y - layerTileHeight) / layerTileHeight))); final int maxY = Math.min( layerHeight, (int) ((viewBounds.y + viewBounds.height + layerTileHeight) / layerTileHeight50)); for (int y = maxY - 1; y >= minY; y--) { float offsetX = (y % 2 == 1) ? layerTileWidth50 : 0; for (int x = maxX - 1; x >= minX; x--) { final TiledMapTileLayer.Cell cell = layer.getCell(x, y); if (cell == null) 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 * layerTileWidth - offsetX + tile.getOffsetX() * unitScale; float y1 = y * layerTileHeight50 + 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; } } } batch.draw(region.getTexture(), vertices, 0, 20); } } } }
/** * Light is data container for all the light parameters. When created lights are automatically added * to rayHandler and could be removed by calling {@link #remove()} and added manually by calling * {@link #add(RayHandler)}. * * <p>Implements {@link Disposable} * * @author kalle_h */ public abstract class Light implements Disposable { static final Color DefaultColor = new Color(0.75f, 0.75f, 0.5f, 0.75f); static final float zeroColorBits = Color.toFloatBits(0f, 0f, 0f, 0f); static final int MIN_RAYS = 3; protected final Color color = new Color(); protected final Vector2 tmpPosition = new Vector2(); protected RayHandler rayHandler; protected boolean active = true; protected boolean soft = true; protected boolean xray = false; protected boolean staticLight = false; protected boolean culled = false; protected boolean dirty = true; protected boolean ignoreBody = false; protected int rayNum; protected int vertexNum; protected float direction; protected float colorF; protected float softShadowLength = 2.5f; protected Mesh lightMesh; protected Mesh softShadowMesh; protected float segments[]; protected float[] mx; protected float[] my; protected float[] f; protected int m_index = 0; /** * Creates new active light and automatically adds it to the specified {@link RayHandler} * instance. * * @param rayHandler not null instance of RayHandler * @param rays number of rays - more rays make light to look more realistic but will decrease * performance, can't be less than MIN_RAYS * @param color light color * @param distance light distance (if applicable) * @param directionDegree direction in degrees (if applicable) */ public Light(RayHandler rayHandler, int rays, Color color, float directionDegree) { rayHandler.lightList.add(this); this.rayHandler = rayHandler; setRayNum(rays); setColor(color); // setDistance(distance); //TODO move to a factory method setDirection(directionDegree); } /** Updates this light */ abstract void update(); /** Render this light */ abstract void render(); /** Sets light direction */ public abstract void setDirection(float directionDegree); /** * Attaches light to specified body * * @param body that will be automatically followed, note that the body rotation angle is taken * into account for the light offset and direction calculations */ public abstract void attachToBody(Body body); /** * @return attached body or {@code null} * @see #attachToBody(Body) */ public abstract Body getBody(); /** * Sets light starting position * * @see #setPosition(Vector2) */ public abstract void setPosition(float x, float y); /** * Sets light starting position * * @see #setPosition(float, float) */ public abstract void setPosition(Vector2 position); /** @return horizontal starting position of light in world coordinates */ public abstract float getX(); /** @return vertical starting position of light in world coordinates */ public abstract float getY(); /** * @return starting position of light in world coordinates * <p>NOTE: changing this vector does nothing */ public Vector2 getPosition() { return tmpPosition; } /** * Sets light color * * <p>NOTE: you can also use colorless light with shadows, e.g. (0,0,0,1) * * @param newColor RGB set the color and Alpha set intensity * @see #setColor(float, float, float, float) */ public void setColor(Color newColor) { if (newColor != null) { color.set(newColor); } else { color.set(DefaultColor); } colorF = color.toFloatBits(); if (staticLight) dirty = true; } /** * Sets light color * * <p>NOTE: you can also use colorless light with shadows, e.g. (0,0,0,1) * * @param r lights color red component * @param g lights color green component * @param b lights color blue component * @param a lights shadow intensity * @see #setColor(Color) */ public void setColor(float r, float g, float b, float a) { color.set(r, g, b, a); colorF = color.toFloatBits(); if (staticLight) dirty = true; } /** Adds light to specified RayHandler */ public void add(RayHandler rayHandler) { this.rayHandler = rayHandler; if (active) { rayHandler.lightList.add(this); } else { rayHandler.disabledLights.add(this); } } /** Removes light from specified RayHandler and disposes it */ public void remove() { remove(true); } /** Removes light from specified RayHandler and disposes it if requested */ public void remove(boolean doDispose) { if (active) { rayHandler.lightList.removeValue(this, false); } else { rayHandler.disabledLights.removeValue(this, false); } rayHandler = null; if (doDispose) dispose(); } /** Disposes all light resources */ public void dispose() { lightMesh.dispose(); softShadowMesh.dispose(); } /** @return if this light is active */ public boolean isActive() { return active; } /** Enables/disables this light update and rendering */ public void setActive(boolean active) { if (active == this.active) return; this.active = active; if (rayHandler == null) return; if (active) { rayHandler.lightList.add(this); rayHandler.disabledLights.removeValue(this, true); } else { rayHandler.disabledLights.add(this); rayHandler.lightList.removeValue(this, true); } } /** @return if this light beams go through obstacles */ public boolean isXray() { return xray; } /** * Enables/disables x-ray beams for this light * * <p>Enabling this will allow beams go through obstacles that reduce CPU burden of light about * 70%. * * <p>Use the combination of x-ray and non x-ray lights wisely */ public void setXray(boolean xray) { this.xray = xray; if (staticLight) dirty = true; } /** * @return if this light is static * <p>Static light do not get any automatic updates but setting any parameters will update it. * Static lights are useful for lights that you want to collide with static geometry but * ignore all the dynamic objects. */ public boolean isStaticLight() { return staticLight; } /** * Enables/disables this light static behavior * * <p>Static light do not get any automatic updates but setting any parameters will update it. * Static lights are useful for lights that you want to collide with static geometry but ignore * all the dynamic objects * * <p>Reduce CPU burden of light about 90% */ public void setStaticLight(boolean staticLight) { this.staticLight = staticLight; if (staticLight) dirty = true; } /** @return if tips of this light beams are soft */ public boolean isSoft() { return soft; } /** Enables/disables softness on tips of this light beams */ public void setSoft(boolean soft) { this.soft = soft; if (staticLight) dirty = true; } /** * @return softness value for beams tips * <p>Default: {@code 2.5f} */ public float getSoftShadowLength() { return softShadowLength; } /** * Sets softness value for beams tips * * <p>Default: {@code 2.5f} */ public void setSoftnessLength(float softShadowLength) { this.softShadowLength = softShadowLength; if (staticLight) dirty = true; } /** @return current color of this light */ public Color getColor() { return color; } /** * Checks if given point is inside of this light area * * @param x - horizontal position of point in world coordinates * @param y - vertical position of point in world coordinates */ public boolean contains(float x, float y) { return false; } /** * Sets if the attached body fixtures should be ignored during raycasting * * @param flag - if {@code true} all the fixtures of attached body will be ignored and will not * create any shadows for this light. By default is set to {@code false}. */ public void setIgnoreAttachedBody(boolean flag) { ignoreBody = flag; } /** @return if the attached body fixtures will be ignored during raycasting */ public boolean getIgnoreAttachedBody() { return ignoreBody; } /** Internal method for mesh update depending on ray number */ void setRayNum(int rays) { if (rays < MIN_RAYS) rays = MIN_RAYS; rayNum = rays; vertexNum = rays + 1; segments = new float[vertexNum * 8]; mx = new float[vertexNum]; my = new float[vertexNum]; f = new float[vertexNum]; } /** @return number of rays set for this light */ public int getRayNum() { return rayNum; } /** Global lights filter * */ private static Filter globalFilterA = null; /** This light specific filter * */ private Filter filterA = null; final RayCastCallback ray = new RayCastCallback() { @Override public final float reportRayFixture( Fixture fixture, Vector2 point, Vector2 normal, float fraction) { if (!globalContactFilter(fixture) || !contactFilter(fixture) || (ignoreBody && fixture.getBody() == getBody())) return -1; // if (fixture.isSensor()) // return -1; mx[m_index] = point.x; my[m_index] = point.y; f[m_index] = fraction; return fraction; } }; private static Filter newContactFilter(short categoryBits, short groupIndex, short maskBits) { Filter filter = new Filter(); filter.categoryBits = categoryBits; filter.groupIndex = groupIndex; filter.maskBits = maskBits; return filter; } private static boolean contactFilter(Fixture fixture, Filter filterA) { if (filterA == null) return true; Filter filterB = fixture.getFilterData(); if (filterA.groupIndex != 0 && filterA.groupIndex == filterB.groupIndex) return filterA.groupIndex > 0; return (filterA.maskBits & filterB.categoryBits) != 0 && (filterA.categoryBits & filterB.maskBits) != 0; } boolean contactFilter(Fixture fixtureB) { return contactFilter(fixtureB, filterA); } /** Sets given contact filter for this light */ public void setContactFilter(Filter filter) { filterA = filter; } /** * Creates new contact filter for this light with given parameters * * @param categoryBits - see {@link Filter#categoryBits} * @param groupIndex - see {@link Filter#groupIndex} * @param maskBits - see {@link Filter#maskBits} */ public void setContactFilter(short categoryBits, short groupIndex, short maskBits) { filterA = newContactFilter(categoryBits, groupIndex, maskBits); } boolean globalContactFilter(Fixture fixtureB) { return contactFilter(fixtureB, globalFilterA); } /** Sets given contact filter for ALL LIGHTS */ public static void setGlobalContactFilter(Filter filter) { globalFilterA = filter; } /** * Creates new contact filter for ALL LIGHTS with give parameters * * @param categoryBits - see {@link Filter#categoryBits} * @param groupIndex - see {@link Filter#groupIndex} * @param maskBits - see {@link Filter#maskBits} */ public static void setGlobalContactFilter(short categoryBits, short groupIndex, short maskBits) { globalFilterA = newContactFilter(categoryBits, groupIndex, maskBits); } }
/** * Sets light color * * <p>NOTE: you can also use colorless light with shadows, e.g. (0,0,0,1) * * @param r lights color red component * @param g lights color green component * @param b lights color blue component * @param a lights shadow intensity * @see #setColor(Color) */ public void setColor(float r, float g, float b, float a) { color.set(r, g, b, a); colorF = color.toFloatBits(); if (staticLight) dirty = true; }