Вершинные шейдеры

static class FireworkEffect
{
// Константы с замедлениями искр. Общие для всех вершин
const float tSlowing = 0.105f;
const float rSlowing = 0.25f; 
// Константа времени жизни искр
const float liveTime = 4.0f;
// Входные	параметр time, timeLoop, diskSpeed
public	static float time;
public	static float timeLoop;
public	static float diskSpeed;
// Код вершинного шейдера.

// input - входные данные вершины, 
// output - выходные данные вершины
public static void VertexShader
(VertexPositionColorTexture[][] input,
VertexPositionColor[][] output) 
{ 
// Перебираем все вершины (в реальном вершинном 
шейдере этих циклов не будет). Так как при 
// тестировании производительности число вершин 
может превысить лимит примитивов, которые 
// может визуализировать за один проход GPU Intel 
GMA9xx, используется несколько массивов 
// вершин
for (int j = 0; j < input.Length; j++) 
{
for (int i = 0; i < input[j].Length; i++) 
{ 
// Вычисляем время, прошедшее с первого появления искры
float currentTime = time - input[j][i].Position.X; 
// Вычисляем локальное время, циклически 
пробегающее от 0 до timeLoop
float localTime = currentTime % timeLoop; 
// Определяем время, которое осталось существовать искре float 
remainTime = liveTime - localTime;
// Ограничиваем величину локального времени, 
чтобы искра останавливалась по достижению 
// нулевой скорости
float td = Math.Min(localTime, input[j][i].
TextureCoordinate.X / tSlowing); 
// Вычисляем расстояние вершины от центра диска
float distance = input[j][i].Position.Y + td * 
 (input[j][i].TextureCoordinate.X - td * tSlowing / 2.0f);
// Ограничиваем величину локального времени, 
чтобы искра останавливалась по достижению 
// нулевой угловой скорости
float tr = Math.Min(localTime, input[j][i].TextureCoordinate.Y / 
rSlowing); 
// Вычисляем текущий угол поворота искры вокруг диска
float angle = input[j][i].Position.Z + diskSpeed * 
(time - localTime) + 
tr * (input[j][i].TextureCoordinate.Y - tr * rSlowing / 2.0f); 
// Вычисляем координаты вершины на основе 
расстояния и угла поворота
output[j][i].Position.X = distance * (float)Math.Sin(angle);
output[j][i].Position.Y = distance * (float)Math.Cos(angle);
output [j ] [i] .Position. Z = 0.0f;
// Если искра появилась на экране, но еще не потухла
if ((currentTime >= 0) && (remainTime > 0)) 
{
Vector4 color = input[j][i].Color.ToVector4(); 
// Определяем коэффициент прозрачности вершины
color.W = remainTime / liveTime;
output[j][i].Color = new XnaGraphics.Color(color); 
}
else 
{
output[j][i].Color = new XnaGraphics.Color(0, 0, 0, 0); 
     } 
   } 
  } 
 } 
}

public partial class MainForm : Form
{
// Эффект для простой закраски объектов
const string effectFileName = "Data\\ColorFill.fx";
const int slices = 64;
const float diskSpeed = 3.0f; const float
 diskRadius = 0.018f;
// Число искр
const int fireworkVerticesCount = 300000; 
// Движения искр будут повторяться через каждые 20 секунд
const float timeLoop = 20.0f; 
// Минимальная скорость вершины
const float minSpeed = 0.3f; 
// Максимальная скорость вершины
const float maxSpeed = 0.45f; 
// Размер искры
const float pointSize = 1.0f;
// Декларация формата вершины. Диск и искры в режиме 
эмуляции вершинного шейдера используют 
// общий формат вершин
VertexDeclaration decl; 
// Массивы вершин с искрами
VertexPositionColorTexture[][] fireworkVertices = null; 
// Массивы вершин, обработанных эмулятором вершинного шейдера
VertexPositionColor[][] transformedFireworkVertices = null;
// Эффект, общий для диска и искр (в режиме эмуляции) Effect effect 
= null;
Random rnd = new Random();
Stopwatch stopwatch;
bool closing = false;
// Счетчики FPS
// Временя, прошедшее с момента последнего вычисления 
количества кадров в секунду
float lastTime = 0; 
// Число кадров, визуализированных за это время
int frameCount = 0;
private void MainForm_Load(object sender, EventArgs e) 
{ 
// Определяем число точек, которые может визуализировать
 видеокарта за один присест
int maxVerticesCount = Math.Min(device.GraphicsDeviceCapabilities.
MaxVertexIndex, 
device.GraphicsDeviceCapabilities.MaxPrimitiveCount); 
// Определяем количество массивов вершин, которые потребуются 
для визуализации
// fireworkVerticesCount вершин
int arrayCount = (int)Math.Ceiling((float)fireworkVerticesCount / 
(float)maxVerticesCount);
// Создаем массивы вершин
fireworkVertices = new VertexPositionColorTexture[arrayCount][]; 
// Создаем массивы вершин, трансформированных вершинным шейдером
transformedFireworkVertices = new VertexPositionColor[arrayCount][];
// Перебираем вершины
for (int k = 0; k < fireworkVerticesCount; k++) 
{ 
// Определяем индекс массива вершин, соответствующего текущей вершине
int j = k / maxVerticesCount; 
// Определяем индекс текущей вершины в массиве вершин
int i = k % maxVerticesCount; 
// Если мы перешли к новому массиву if (i == 0) 
{ 
// Определяем количество оставшихся вершин
int remain = fireworkVerticesCount - j * maxVerticesCount;
 // Число вершин в массиве не может превышать maxVerticesCount 
 remain = Math.Min(remain, 
maxVerticesCount);
// Выделяем память для текущих массивов вершин
fireworkVertices[j] = new VertexPositionColorTexture[remain]; 
transformedFireworkVertices[j] = new 
VertexPositionColor[remain]; 
}
// Вычисляем время появления вершины после запуска программы
fireworkVertices[j][i].Position.X = (float)rnd.NextDouble() * timeLoop;
// Определяем ее начальное удаление от центра диска
fireworkVertices[j][i].Position.Y = (float)rnd.NextDouble() * 
diskRadius;
// Определяем начальный угол поворота вершины относительно диска
fireworkVertices[j][i].Position.Z = (float)rnd.NextDouble() * 2.0f *
(float) Math. PI;
// Определяем начальную линейную скорость вершины
fireworkVertices[j][i].TextureCoordinate.X = minSpeed + 
(float)rnd.NextDouble() * (maxSpeed - minSpeed); 
// Определяем начальную угловую скорость вершины
fireworkVertices[j][i].TextureCoordinate.Y = diskSpeed / 4.0f * 
(1.0f + 0.01f * (float)rnd.NextDouble()); 
// Вычисляем цвет вершины
byte red = (byte)(255 * Math.Abs(Math.Sin(fireworkVertices[j][i].
Position.Z * ^ 3)) ) ;
byte green = (byte)(255 * Math.Abs(Math.Cos(fireworkVertices[j][i].
Position.Z * ^ 2) ) ) ;
fireworkVertices[j][i].Color = new XnaGraphics.Color
(red, green, 128, 255); 
}
      } 
}

private void MainFormPaint(object sender, PaintEventArgs e)
{
// Настраиваем параметры GPU для визуализации
device.RenderState.CullMode = CullMode.None;
device. RenderState.AlphaBlendEnable = true;
device.RenderState.BlendFunction = BlendFunction.Add;
device.RenderState.SourceBlend = Blend.SourceAlpha;
device.RenderState.DestinationBlend = Blend.InverseSourceAlpha;
device.RenderState.PointSize = pointSize;
device.VertexDeclaration = decl;
// Определяем время, прошедшее с момента запуска приложения
float time = (float)stopwatch.ElapsedTicks / 
(float)Stopwatch.Frequency;
// Настраиваем параметры эффекта, общие для всех вершин
FireworkEffect.time = time;
FireworkEffect.timeLoop = timeLoop;
FireworkEffect.diskSpeed = diskSpeed;
// Выполняем эмуляцию вершинного шейдера
FireworkEffect.VertexShader(fireworkVertices, 
transformedFireworkVertices);
effect.Begin();
for (int i = 0; i < effect.CurrentTechnique.Passes.Count; i++)
{
EffectPass currentPass = effect.CurrentTechnique.Passes[i];
currentPass.Begin();
// Перебираем все массивы вершин
for (int j = 0; j < transformedFireworkVertices.Length; j++)
{ // Визуализируем текущий массив вершин
device.DrawUserPrimitives(PrimitiveType.PointList, 
 transformedFireworkVertices[j], 0, 
 transformedFireworkVertices[j].Length);
}
currentPass.End(); 
} 
effect.End();
// Отключаем альфа-смешивание, которое не требуется 
при визуализации диска 
device.RenderState.AlphaBlendEnable = false;
float angle = diskSpeed * time;
// Выполняем эмуляцию вершинного шейдера диска
DiskEffect.angle = angle;
DiskEffect.VertexShader(diskVertices, transformedDiskVertices); 
// Визуализируем диск
// Оканчиваем визуализацию кадра 
device.Present();
// Увеличиваем счетчик кадров
frameCount++; 
// Если прошла одна секунда
if (time - lastTime >= 1)
{ 
// Отображаем в заголовке формы текущий FPS
Text = ((float)frameCount / (time - lastTime)).ToString(); 
// Сбрасываем счетчики
lastTime = time; frameCount = 0; 
} 
}

class Helper 
{
// Класс исключения, которое генерируется при
 возникновении проблем во время загрузки эффекта
public class LoadAndCompileEffectException : Exception 
{
public LoadAndCompileEffectException(string message) : base(message) 
{ 
        } 
}
// Загружает эффект из файла и выбирает наиболее подходящую технику. 
При возникновении 
// проблем генерирует исключение LoadEffectException.
public static Effect LoadAndCompileEffect(GraphicsDevice device,
 string filename) 
{
CompiledEffect compiledEffect;
try
{
compiledEffect = Effect.CompileEffectFromFile(filename, null,
 null, CompilerOptions.None,
TargetPlatform.Windows); 1`
1
}
catch (IOException ex) 
{
throw new LoadAndCompileEffectException(ex.Message); 
}
if (!compiledEffect.Success) 
{
throw new LoadAndCompileEffectException(String.Format
("Ошибка при компиляции эффекта: \r\n{0}",
compiledEffect.ErrorsAndWarnings)); 
}
Effect effect = new Effect(device, compiledEffect.GetEffectCode(), 
CompilerOptions.NotCloneable, null);
if (!effect.CurrentTechnique .Validate())
{
throw new LoadAndCompileEffectException(String.Format
("Ошибка при валидации " + 
 "техники \"{0}\" эффекта \"{1}\"\n\rСкорее всего, 
 функциональность шейдера превышает " +
 "возможности GPU", effect.CurrentTechnique.Name, filename));
}
return effect; 
} 
}

// Файл Firework.fx
//
// Константы tSlowing и rSlowing объединены в один двухмерный 
вектор, что позволит
// распараллелить расчет расстояния от вершины от центра 
и угла поворота вершины
static float2 slowing = {0.105, 0.25};
static float liveTime = 4.0;
float diskSpeed; float time;
float timeLoop;
struct VertexInput {
float3 pos : POSITION;
float4 color : COLOR;
float2 texcoord : TEXCOORD; 
};
struct VertexOutput 
{
float4 pos : POSITION;
float4 color : COLOR; 
};
VertexOutput MainVS(VertexInput input) 
{
VertexOutput output;
float currentTime = time - input.pos.x; float localTime = currentTime
 % timeLoop; float remainTime = liveTime - localTime;
// Расстояние от центра диска и угол поворота вершины 
рассчитываются параллельно float2 t = min(localTime.xx,
 input.texcoord / slowing); float2 sCoord = input.pos.yz + t * 
 (input.texcoord -t * slowing / 2.0f);
// Формула расчета угла поворота по сравнению с формулой 
расчета расстояния от центра 
// содержит один добавочный член
sCoord.y += diskSpeed * (time - localTime);
// Заменяем два умножения константы на sin и cos одним 
умножением на вектор (sin, cos) output.pos.xy = sCoord.x * 
float2(sin(sCoord.y), cos(sCoord.y)); output.pos.zw = float2(0.0, 1.0);
output.color.rgb = input.color.rgb;
if ((remainTime > 0) && (currentTime >= 0)) 
{
output.color.a = remainTime / liveTime; 
}
else 
{
output.color.a = 0; 
}
return output; 
}
float4 MainPS(float4 color:COLOR):COLOR 
{
return color; 
}
technique Firework 
{
pass p0
{
VertexShader = compile vs_1_1 MainVS();
PixelShader = compile ps_1_1 MainPS(); 
}
}