Каков наиболее эффективный способ освещения для тайлового движка в Java?
Будет ли это размещение черного фона позади тайлов и изменение альфа-канала тайлов?
Или добавление черного переднего плана и изменение альфа-канала этого тайла? ? Или что-то еще?
Вот пример освещения, которое мне нужно:
Есть много способов добиться этого. Потратьте некоторое время, прежде чем принять окончательное решение. Я кратко суммирую некоторые приемы, которые вы можете использовать, и в конце приведу код.
Если вы хотите создать резкий световой эффект (как в примере с изображением), мне приходят в голову некоторые подходы:
Проблема в том, что вы не можете ни сделать тайл ярче, чем он был раньше (блики), ни изменить цвет света. Оба эти аспекта обычно делают освещение в играх хорошим.
Этот подход имеет тот же эффект, что и первый, с тем преимуществом, что теперь вы можете раскрасить плитку наложения в цвет, отличный от черного, что позволяет использовать как цветные источники света, так и блики.
Пример: 
Несмотря на то, что это легко, проблема в том, что это действительно очень неэффективный способ. (Два отрендеренных тайла на тайл, постоянное перекрашивание, множество операций рендеринга и т. д.)
Глядя на ваш пример, я представляю, что свет всегда исходит от определенного источника (персонаж, факел и т. д.).
Мягкий свет теперь не имеет большого значения, просто используйте больше деталей в световой маске по сравнению с тайлами. Используя только 15% альфы в обычно черной области, вы можете добавить эффект плохой видимости, когда плитка не освещена:
Вы даже можете легко получить более сложные формы освещения (конусы и т. д.), просто изменив изображение маски.
При комбинировании нескольких источников света такой подход приводит к проблеме: рисование двух пересекающихся друг с другом масок может компенсировать друг друга:
Мы хотим, чтобы они добавляли свои источники света, а не вычитали их. Как избежать проблемы:
Это приведет к чему-то похожему на это: 
Предполагая, что вы сначала визуализируете все плитки в BufferedImage, я предоставлю некоторый код руководства, который напоминает последний показанный метод (только поддержка оттенков серого).
Несколько световых масок, например. факел и игрока можно комбинировать так:
public BufferedImage combineMasks(BufferedImage[] images)
{
// create the new image, canvas size is the max. of all image sizes
int w, h;
for (BufferedImage img : images)
{
w = img.getWidth() > w ? img.getWidth() : w;
h = img.getHeight() > h ? img.getHeight() : h;
}
BufferedImage combined = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
// paint all images, preserving the alpha channels
Graphics g = combined.getGraphics();
for (BufferedImage img : images)
g.drawImage(img, 0, 0, null);
return combined;
}
Окончательная маска создается и применяется с помощью этого метода:
public void applyGrayscaleMaskToAlpha(BufferedImage image, BufferedImage mask)
{
int width = image.getWidth();
int height = image.getHeight();
int[] imagePixels = image.getRGB(0, 0, width, height, null, 0, width);
int[] maskPixels = mask.getRGB(0, 0, width, height, null, 0, width);
for (int i = 0; i < imagePixels.length; i++)
{
int color = imagePixels[i] & 0x00ffffff; // Mask preexisting alpha
// get alpha from color int
// be careful, an alpha mask works the other way round, so we have to subtract this from 255
int alpha = (maskPixels[i] >> 24) & 0xff;
imagePixels[i] = color | alpha;
}
image.setRGB(0, 0, width, height, imagePixels, 0, width);
}
Как уже отмечалось, это примитивный пример. Реализация смешивания цветов может потребовать немного больше усилий.
может не будешь ходить по всей карте, может хватит если поставить свой рейтрейс на вид 20х20? ПРИМЕЧАНИЕ: вам действительно нужно ходить по границам окна просмотра, НЕ требуется отслеживать каждую точку.
я добавляю линейный алгоритм, чтобы упростить вашу работу:
public static ArrayList<Point> getLine(Point start, Point target) {
ArrayList<Point> ret = new ArrayList<Point>();
int x0 = start.x;
int y0 = start.y;
int x1 = target.x;
int y1 = target.y;
int sx = 0;
int sy = 0;
int dx = Math.abs(x1-x0);
sx = x0<x1 ? 1 : -1;
int dy = -1*Math.abs(y1-y0);
sy = y0<y1 ? 1 : -1;
int err = dx+dy, e2; /* error value e_xy */
for(;;){ /* loop */
ret.add( new Point(x0,y0) );
if (x0==x1 && y0==y1) break;
e2 = 2*err;
if (e2 >= dy) { err += dy; x0 += sx; } /* e_xy+e_x > 0 */
if (e2 <= dx) { err += dx; y0 += sy; } /* e_xy+e_y < 0 */
}
return ret;
}
Я сделал всю эту молниеносную штуку некоторое время назад, * pathfindin не стесняйтесь задавать дополнительные вопросы
Приложение: может быть, я мог бы просто добавить небольшие алгоритмы для трассировки лучей ^^
чтобы получить точку северной и южной границы, просто используйте этот фрагмент:
for (int x = 0; x <map.WIDTH; x++){
Point northBorderPoint = new Point(x,0);
Point southBorderPoint = new Point(x,map.HEIGHT);
rayTrace( getLine(player.getPos(), northBorderPoint), player.getLightRadius()) );
rayTrace( getLine(player.getPos(), southBorderPoint, player.getLightRadius()) );
}
и трассировка лучей работает так:
private static void rayTrace(ArrayList<Point> line, WorldMap map, int radius) {
//int radius = radius from light source
for (Point p: line){
boolean doContinue = true;
float d = distance(line.get(0), p);
//caclulate light linear 100%...0%
float amountLight = (radius - d) / radius;
if (amountLight < 0 ){
amountLight = 0;
}
map.setLight( p, amountLight );
if ( ! map.isViewBlocked(p) ){ //can be blockeb dy wall, or monster
doContinue = false;
break;
}
}
}
Я занимаюсь разработкой инди-игр уже около трех лет. Я бы сделал это, прежде всего, используя OpenGL, чтобы вы могли получить все преимущества графической вычислительной мощности графического процессора (надеюсь, вы уже это делаете). Предположим, мы начинаем со всех плиток в VBO, полностью освещенных. Теперь есть несколько вариантов достижения желаемого. В зависимости от того, насколько сложна ваша система освещения, вы можете выбрать другой подход.
Если ваш свет будет круговым вокруг игрока, независимо от того, будут ли препятствия блокировать свет в реальной жизни, вы можете выбрать алгоритм освещения, реализованный в вершинном шейдере. В вершинном шейдере вы можете вычислить расстояние от вершины до игрока и применить некоторую функцию, которая определяет, насколько яркими должны быть объекты в зависимости от вычисленного расстояния. Не используйте альфу, а просто умножьте цвет текстуры/плитки на значение освещения.
Если вы хотите использовать пользовательскую карту освещения (что более вероятно), я бы посоветовал добавить дополнительный атрибут вершины, определяющий яркость тайла. При необходимости обновите VBO. Здесь тот же подход: умножьте пиксель текстуры на значение света. Если вы рекурсивно заполняете свет положением игрока в качестве отправной точки, тогда вы будете обновлять VBO каждый раз, когда игрок движется.
Если ваша карта освещения зависит от того, где солнечный свет падает на ваш уровень, вы можете комбинировать два типа методов освещения. Создайте один атрибут вершины для яркости солнца и другой атрибут вершины для света, излучаемого световыми точками (например, факел, который держит игрок). Теперь вы можете объединить эти два значения в вершинном шейдере. Предположим, ваше солнце восходит и заходит, как день и ночь. Допустим, яркость солнца равна sun, то есть значению от 0 до 1. Это значение можно передать вершинному шейдеру как юниформу. Атрибут вершины, который представляет яркость солнца, равен s, а атрибут света, излучаемого световыми точками, — l. Затем вы можете вычислить общий свет для этой плитки следующим образом:
tileBrightness = max(s * sun, l + flicker);
Где flicker (также униформа вершинного шейдера) — это своего рода волнистая функция, которая представляет небольшие вариации яркости ваших световых точек.
Такой подход делает сцену динамичной без необходимости постоянно воссоздавать VBO. Я реализовал этот подход в проекте проверки концепции. Это прекрасно работает. Посмотреть, как это выглядит, можно здесь: http://www.youtube.com/watch?v=jTcNitp_IIo. Обратите внимание, как свет факела мерцает на 0:40 видео. Это делается тем, что я объяснил здесь.
