квантование градиента цвета с помощью LIBGDX - PullRequest
Новая
       7

квантование градиента цвета с помощью LIBGDX

0 голосов
/ 30 ноября 2018

Я рисую цветовой градиент с прямоугольником shaperenderer.Это создает мягкий градиент.

Есть ли способ квантовать цвета.Например, мне нравится иметь только 10 различных цветов между минимальным цветом и максимальным цветом.

Возможно ли это с предопределенной функциональностью из LIBGDX без рисования этого самостоятельно?

1 Ответ

0 голосов
/ 03 декабря 2018

Один из способов достижения этого (если вы можете сэкономить циклы ЦП) может состоять в том, чтобы вручную свернуть версию ShapeRenderer::rect, которая делает это путем рисования нескольких линий и интерполяции между четырьмя цветами. 

    private static Color quantizedColor = new Color();
    private static void rectQuantized(ShapeRenderer shapeRenderer, float x, float y, float width, float height, Color color1, Color color2, Color color3, Color color4, int steps) {
        float dx = width / steps;
        float dy = height / steps;

        for(int sy = 0; sy < steps; ++sy) {
            float py = (float)sy / (steps - 1);
            for(int sx = 0; sx < steps; ++sx) {
                float px = (float)sx / (steps - 1);

                float minR = (1.0f - px) * color1.r + px * color2.r;  
                float maxR = (1.0f - px) * color4.r + px * color3.r;

                float minG = (1.0f - px) * color1.g + px * color2.g;  
                float maxG = (1.0f - px) * color4.g + px * color3.g;

                float minB = (1.0f - px) * color1.b + px * color2.b;  
                float maxB = (1.0f - px) * color4.b + px * color3.b;

                float minA = (1.0f - px) * color1.a + px * color2.a;  
                float maxA = (1.0f - px) * color4.a + px * color3.a;

                quantizedColor.set(minR + (maxR - minR) * py, minG + (maxG - minG) * py, minB + (maxB - minB) * py, minA + (maxA - minA) * py);

                shapeRenderer.setColor(quantizedColor);
                shapeRenderer.rect(x + dx * sx, y + dy * sy,  dx, dy);
            }
        }
    }

Используя приведенный выше код с прямоугольником 200x200, квантованным на 16 шагов, это выглядело бы так (сравнение с использованием стандартного вызова ShapeRenderer::rect слева)

Quantized rect

Полная работа libGDX пример вышеупомянутого: 

package com.bornander.sandbox;

import com.badlogic.gdx.ApplicationAdapter;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input.Keys;
import com.badlogic.gdx.assets.AssetManager;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType;
import com.badlogic.gdx.maps.tiled.TiledMap;
import com.badlogic.gdx.maps.tiled.TiledMapTile;
import com.badlogic.gdx.maps.tiled.TiledMapTileLayer;
import com.badlogic.gdx.maps.tiled.TiledMapTileLayer.Cell;
import com.badlogic.gdx.maps.tiled.TmxMapLoader;
import com.badlogic.gdx.maps.tiled.renderers.OrthogonalTiledMapRenderer;
import com.badlogic.gdx.math.Vector2;

public class SandboxGdxGame extends ApplicationAdapter {
    private ShapeRenderer shapeRenderer;
    private OrthographicCamera camera;

    @Override
    public void create () {
        shapeRenderer = new ShapeRenderer();
        camera = new OrthographicCamera(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());

    }

    private static Color quantizedColor = new Color();
    private static void rectQuantized(ShapeRenderer shapeRenderer, float x, float y, float width, float height, Color color1, Color color2, Color color3, Color color4, int steps) {
        float dx = width / steps;
        float dy = height / steps;

        for(int sy = 0; sy < steps; ++sy) {
            float py = (float)sy / (steps - 1);
            for(int sx = 0; sx < steps; ++sx) {
                float px = (float)sx / (steps - 1);

                float minR = (1.0f - px) * color1.r + px * color2.r;  
                float maxR = (1.0f - px) * color4.r + px * color3.r;

                float minG = (1.0f - px) * color1.g + px * color2.g;  
                float maxG = (1.0f - px) * color4.g + px * color3.g;

                float minB = (1.0f - px) * color1.b + px * color2.b;  
                float maxB = (1.0f - px) * color4.b + px * color3.b;

                float minA = (1.0f - px) * color1.a + px * color2.a;  
                float maxA = (1.0f - px) * color4.a + px * color3.a;

                quantizedColor.set(minR + (maxR - minR) * py, minG + (maxG - minG) * py, minB + (maxB - minB) * py, minA + (maxA - minA) * py);

                shapeRenderer.setColor(quantizedColor);
                shapeRenderer.rect(x + dx * sx, y + dy * sy,  dx, dy);
            }
        }
    }

    @Override
    public void render () {
        Gdx.gl.glClearColor(0, 0, 0, 1);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
        camera.update();
        shapeRenderer.setProjectionMatrix(camera.combined);
        shapeRenderer.begin(ShapeType.Filled);
        rectQuantized(shapeRenderer, 0, -100, 200, 200, Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW, 16);

        shapeRenderer.rect(-200, -100, 200, 200, Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW);

        shapeRenderer.end();
    }
}
...