[Из песочницы] Участие в конкурсе LudumDare #3326.10.2015 14:18

    public void postRender(Bitmap screenBitmap, Graphics2D g2d) {
        //получаем данные из оффскринного буфера
        int[] pixels = screenBitmap.pixels;

        //бежим по нему
        for (int i = 0; i < pixels.length; i++) {
            //находим координаты относительно центра экрана
            int x = i % screenBitmap.w - GameComponent.WIDTH / 2;
            int y = i / screenBitmap.w - GameComponent.HEIGHT / 2;

            //считаем угол на который повернем систему координат и возьмем пиксель из буфера
            //тут надо пояснить что x делим на высоту экрана, только ради эффекта закрытия глаза
            //ну и применяем скаляр зависимости от времени суток, это просто число от 0..255
            double angle = (x / (double) screenBitmap.h * y / (double) screenBitmap.h) * Math.PI * 2.0 * (255 - dayFactor) / 255.0;

            //поворачиваем координаты и получаем исходную точку
            int xx = (int) (x * Math.cos(angle) - y * Math.sin(angle)) + GameComponent.WIDTH / 2;
            int yy = (int) (y * Math.cos(angle) + x * Math.sin(angle)) + GameComponent.HEIGHT / 2;

            //разумеется эта точка может лежать за пределами, поэтому надо проверять
            if (xx >= 0 && yy >= 0 && xx < screenBitmap.w && yy < screenBitmap.h) {
                int c = pixels[xx + yy * screenBitmap.w];
                int r = (c >> 16) & 0xff;
                int g = (c >> 8) & 0xff;
                int b = (c >> 0) & 0xff;

                //тут мы получаем gray scale, формулу взял отсюда
                //https://ru.wikipedia.org/wiki/%D0%9E%D1%82%D1%82%D0%B5%D0%BD%D0%BA%D0%B8_%D1%81%D0%B5%D1%80%D0%BE%D0%B3%D0%BE
                int m = (r * 30 + g * 59 + b * 11) / 100;

                //ну и стандартные преобразования изменяя насыщенность цветов от времени суток
                r = (r + m) / 2 * dayFactor / 255;
                g = (g + m) / 2 * dayFactor / 255;
                b = (b + m) / 2 * dayFactor / 255;
                
                //все это засовываем в другой буфер, так как исходный нельзя менять до полного прогона
                postData[i] = 0xff << 24 | r << 16 | g << 8 | b;
            } else {
                //ну и если не попали, рисуем "закрытый глаз" немного шума с добавлением красного цвета
                int rnd = (int) (random.nextDouble() * 16);
                postData[i] = 0xff << 24 | (0x4C + rnd) << 16 | rnd << 8 | rnd;
            }
        }

        //теперь можно скопировать все из пост буфера в оффскринный буфер, который дальше пойдет на экран.
        for (int i = 0; i < postData.length; i++) {
            pixels[i] = postData[i];
        }
        g2d.setColor(Color.WHITE);
        g2d.drawString("score: " + score, 10, GameComponent.HEIGHT - 10);
    }

    //итак на входе у нас две текстуры 16х16, на выходе 16 текстур с переходами одной в другую
    public static BufferedImage[] generate(int[] t0, int[] t1, int sz) {
        double iSz = 1.0 / sz;
        BufferedImage[] result = new BufferedImage[16];
        for (int i = 0; i < 16; i++) {
            //создаем новый битмап в котором будем рисовать тайл
            result[i] = new BufferedImage(sz, sz, BufferedImage.TYPE_INT_RGB);
            int[] data = new int[sz * sz];
            
            //находим состояние 4 углов для данного тайла
            //очень важно понимать, что состояния будут уникальными для каждого значения i для всех 4 углов
            int a = (i >> 0) & 1;
            int b = (i >> 1) & 1;
            int c = (i >> 2) & 1;
            int d = (i >> 3) & 1;
            
            //бежим сверху внизу
            for (int y = 0; y < sz; y++) {
                double yp = y * iSz;
                for (int x = 0; x < sz; x++) {
                    double xp = x * iSz;
                    //сперва интерполируем углы ab между собой используя в качестве t = xp
                    double ab = a + (b - a) * xp;
                    //затем углы cd используя в качестве t = xp
                    double cd = c + (d - c) * xp;
                    //финальная интерполяция состояния ab и cd но используем в качестве t = yp
                    double val = ab + (cd - ab) * yp;
                    
                    //...возможно добавления какого-нибудь стабильного шума для val
                    //в теории значение не должно выходить за границы, но у меня выше были преобразования для val
                    if (val < 0) val = 0;
                    if (val > 1.0) val = 1.0;
                    
                    //получаем значение из текстуры 1 и 2 и интерполируем цвета в качестве t = val
                    int c0 = t0[x + y * sz];
                    int c1 = t1[x + y * sz];
                    int col = Mth.lerpRGB(c0, c1, val);
                    //исходный код размещаем в битмапе
                    data[x + y * sz] = col;
                }
            }
            result[i].setRGB(0, 0, sz, sz, data, 0, sz);
        }

        return result;
    }

    public void render(Graphics2D g2d, Level level, int x, int y, int xOffs, int yOffs) {
        int xx = x >> 4;
        int yy = y >> 4;

        int t = 0;

        //чтоб получить текущую текстуру нам необходимо проверить сперва тайл в центре
        if (level.getTile(xx, yy) != Tile.water) t += 1;
        //затем тайл справа от центра
        if (level.getTile(xx + 1, yy) != Tile.water) t += 2;
        //затем тайл снизу от центра
        if (level.getTile(xx, yy + 1) != Tile.water) t += 4;
        //затем тайл справа снизу от центра
        if (level.getTile(xx + 1, yy + 1) != Tile.water) t += 8;

        g2d.drawImage(Art.waterToGrassTiles[t], x - xOffs, y - yOffs, null);
    }