Olga Khusainova

RGBM-кодировка цвета

2023-03-15T19:25:34.077Z

Хочется хранить цвета в вершинах как byte4, но значения у них могут быть сильно выше единицы. Следовательно, нужно как-то нормализовать.
Можно просто поделить на условную максимальную яркость и затем умножить в шейдере.
А можно использовать более хитрую кодировку в rgbm. Преимущество rgbm в том, что чем меньше значения цвета, тем меньше разница между оригиналом и декодированным значением, ошибка растет пропорционально яркости.

Кодировка цвета в скрипте

private static float MAX_BRIGHTNESS = 60;
private static Byte4 ColorToRGBM(Color color) {   
    float y = color.maxColorComponent;   
    y = math.clamp(math.ceil(y * 255 / MAX_BRIGHTNESS), 1, 255);   
    color *= 255 * 255 / (y * MAX_BRIGHTNESS);   
    Byte4 i = new Byte4((byte)color.r, (byte)color.g, (byte)color.b, (byte)y);   
    return i;
}

Декодировка в шейдере:

#define MAX_BRIGHTNESS 60
half3 DecodeColor(half4 data) {        
    return data.rgb * data.a * MAX_BRIGHTNESS;
}

https://t.me/lab_sborki

Blizzard BlendAdd shading

2022-09-02T13:13:24.760Z

В этом занимательном видео начиная с 19:45 разработчик из Близзард рассказывает о способе рисовать эффекты так, чтобы они хорошо выглядели и в темном и в светлом окружении, не уходя слишком в белый, но и не теряя свечения. Этот способ они называют BlendAdd.

Идея состоит в том, что в rgb мы храним изображение эффекта на черном фоне, а альфа-канал определяет насколько аддитивно, а насколько через бленд должно накладываться изображение. 1 - полностью через blend, 0 - полностью через add.

Но как же это конкретно реализовать?

Запишем выражение и раскроем скобочки:

Осталось воплотить эту формулу через параметры бленда и операции в шейдере. К dst тут явно просится OneMinusSrcAlpha, но для соответствия в альфа-канал фрагмента надо записать квадрат альфы. A для src установим One и прямо в шейдере домножим на (1 - alpha + alpha^2)

Shader "EffectBlendAdd" {
   ...
   SubShader {
       ...
       Blend One OneMinusSrcAlpha
       ...
       
       Pass {   
           HLSLPROGRAM
           ...
           half4 Fragment() {
              ...
               output.rgb *= 1 - a + a * a;
               output.a = a * a;
               return outputColor;
           }
           ENDHLSL
       }
           
   }
}

https://t.me/lab_sborki

Генерация случайных точек на поверхности мешей с помощью линий

2022-08-26T12:17:24.542Z

В этом посте речь пойдет о способе покрыть случайными равномерно-распределенными точками только видимые поверхности сцены, исключая поверхности внутри пересечений мешей.

Метод можно погуглить как "Sampling with Global Lines" или "Sampling with Uniformly Distributed Lines". Есть несколько интересных вариаций, расскажу о самой простой.

Итак:

Формируем баунд-сферу вокруг геометрии сцены.
Берем две случайные точки на поверхности баунд-сферы и делаем из них линию.
Находим точки пересечения линии с геометрией уровня. Это и будут наши искомые точки на поверхности.
Повторяем 2-4.

Если все меши на сцене замкнутые, то исключить точки внутри пересечений мешей довольно легко, подсчитывая число входов и выходов луча в поверхность по ходу рейкаста.

Результат такой же, как и в методе inverse cdf, с той лишь разницей, что мы исключили невидимые точки

https://t.me/lab_sborki

Генерация случайных точек на поверхности меша

2022-06-20T10:21:02.641Z

Задача: сгенерировать N равномерно распределенных точек по поверхности произвольного триангулированного меша.

Общая идея решения: выбираем треугольник с вероятностью, пропорциональной его площади, и уже внутри выбранного треугольника берем равномерно распределенную случайную точку.

Как выбрать треугольник с вероятностью, пропорциональной его площади?

Воспользуемся методом, который называется inverse cdf sampling. Подробно можно почитать здесь.

Представим, что у нас есть случайная величина и она может принимать 4 возможных дискретных значения v1, v2, v3 и v4 с вероятностями p1, p2, p3 и p4 соответственно.

p1 + p2 + p3 + p4 = 1

Сконструируем дискретную функцию cdf, где cdf[i] = p0 + p1 + ... + pi.

И теперь используя cdf мы можем замапить равномерно распределенную случайную величину на наши дискретные случайные величины v0, v1, v2, v3 с соответствующими вероятностями

/// <summary> Inverse cdf sampling </summary>
/// <param name="cumulativeProbabilities">дискретная cdf. 
/// cumulativeProbabilities[0] - p0, где p0 - вероятность, что выпадет случайная величина с индексом 0 
/// cumulativeProbabilities[1] - p0 + p1, где p1 - вероятность, что выпадет случайная величина с индексом 1 
/// cumulativeProbabilities[2] - p0 + p1 + p2, где p2 - вероятность, что выпадет случайная величина с индексом 2 
/// ...
/// cumulativeProbabilities[cumulativeProbabilities.Length - 1] = p0 + p1 + p2 + ... + pLast = 1</param>
/// <param name="randomValue">равномерно распределенная случайная величина</param>
/// <returns>индекс выпавшей случайной величины</returns>
public static int InverseSample(float[] cumulativeProbabilities, float randomValue) {
   int maxIndex = cumulativeProbabilities.Length - 1;   
   int minIndex = 0;   
      
   for (int i = 0; i < cumulativeProbabilities.Length; i++) {      
       int index = minIndex + (int)(0.5f * (maxIndex - minIndex));      
       var pr = cumulativeProbabilities[index];      
       if (randomValue <= pr) {         
           maxIndex = index;      
       } else {         
           minIndex = index + 1;      
       }      
       if (minIndex == maxIndex) return maxIndex;             
   }
   
   throw new Exception("Something was wrong");
}

Теперь остается сконструировать cumulativeProbabilities для наших треугольников и, используя обычный random и метод InverseSample, получать индексы треугольников с вероятностью, пропорциональной их площади.

float totalArea = 0;
for (var i = 0; i < triangles.Length; i++)
{    
    var triangle = triangles[i];    
    var triangleArea = CalculateTriangleArea(triangle);
    totalArea += triangleArea;
}  
var cumulativeProbabilities = new float[triangles.Length];
float probabilitySum = 0;
for (var i = 0; i < triangles.Length; i++)
{    
    var triangle = triangles[i];    
    var triangleArea = CalculateTriangleArea(triangle);
    var probability = triangleArea /totalArea;
    probabilitySum += probability;
    cumulativeProbabilities[i] = probabilitySum;    
}  
var triangleRandom = new Random(seed);
for (int i = 0; i < N; i++) {
    var index = InverseSample(cumulativeProbabilities, triangleRandom.NextFloat());
    var trianlge = triangles[index];
    ...
}

Как сгенерировать равномерно распределенную случайную точку внутри треугольника

float3 v0 = triangle.v0; // 1я вершина
float3 v1 = triangle.v1; // 2я вершина
float3 v2 = triangle.v2; // 3я вершина

var random = new Random(seed);
var r1 = random.NextValue();
var r2 = random.NextValue();
float sqrtR1 = math.sqrt(r1);
// Получим барицентрические координаты
w0 = 1 - sqrtR1;
w1 = (1 - r2) * sqrtR1;
w2 = r2 * sqrtR1;

var randomPoint = w0*v0 + w1*v1 + w2*v2; //Результат

https://t.me/lab_sborki

Трансформация нормалей

2022-05-26T12:29:55.091Z

Для трансформации нормалей на объекте с отрицательным скейлом метод Unity transform.TransformDirection() дает некорректный результат. Вместо него нужно использовать более дорогой, но правильный код

public static Vector3 TransformDir(Transform transform, Vector3 dir){
    var matrix = transform.localToWorldMatrix;    
    var matrixInverse = matrix.inverse;    
    var matrixTranspose = matrixInverse.transpose;    
    var n = (Vector3) (matrixTranspose * dir);    
    return n;
}

Подробное объяснение в главе 4.5 книги Mathematics for 3D Game Programming and Computer Graphics

https://t.me/lab_sborki