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

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

Идея состоит в том, что в 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

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

Итак:

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

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

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

https://t.me/lab_sborki

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

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

Воспользуемся методом, который называется 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

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