Написать 3D Soft Engine с нуля: Бонус Партия

В предыдущем уроке мы узнали, как заполнять наши треугольники. Поскольку мы работаем на базе процессора с нашим программным 3D-движком, это действительно начинает стоить много процессорного времени. Хорошей новостью является то, что современные процессоры являются многоядерными . Тогда мы могли бы представить себе использование параллелизма для повышения производительности . Мы собираемся сделать это только в C #, и я объясню, почему мы не будем делать это в HTML5. Мы также увидим несколько простых советов, которые могут повысить производительность в таком коде цикла рендеринга. В самом деле, мы собираемся перейти с 5 FPS на 50 FPS , что увеличит производительность в 10 раз!

Вычислить FPS

Первым шагом является вычисление FPS, чтобы можно было проверить, собираемся ли мы повысить производительность, изменив наш алгоритм. Вы можете сделать это в C # или TypeScript / JavaScript, конечно.

Нам нужно знать время дельты между двумя кадрами . Затем нам просто нужно захватить текущее время, нарисовать новый кадр ( requestAnimationFrame в HTML5 или CompositionTarget.Rendering в XAML), снова захватить текущее время и сравнить его с предыдущим сохраненным временем. Вы получите результат в миллисекундах. Чтобы получить FPS, просто разделите 1000 на этот результат. Например, если это 16,66 мс, оптимальное время дельты , у вас будет 60 FPS.

Вы можете сделать это после каждого рендеринга кадра, чтобы иметь очень точный FPS или вычислить средний FPS, например, для 60 выборок. Мы с Дэвидом уже работали над этой темой в этой серии: Сравнительный анализ игры HTML5: HTML5 Potatoes Gaming Bench

В заключение, в C # добавьте новый элемент управления TextBlock XAML с именем « fps » и используйте этот код для вычисления FPS:

  DateTime previousDate; 
  void CompositionTarget_Rendering ( отправитель объекта , объект e) 
     // Fps 
     var now = DateTime .Now; 
     var currentFps = 1000.0 / (сейчас - previousDate) .TotalMilliseconds; 
     previousDate = сейчас; 
      fps.Text = string .Format ( "{0: 0.00} fps" , currentFps); 
      // цикл рендеринга 
     device.Clear (0, 0, 0, 255); 
      foreach ( сетка в ячейках) 
     { 
         mesh.Rotation = new Vector3 (mesh.Rotation.X, mesh.Rotation.Y + 0.01f, mesh.Rotation.Z); 
         device.Render (мера, сетка); 
     } 
      device.Present (); 
 

Приложения WinRT используют .NET Framework 4.5, которая по умолчанию включает библиотеку параллельных задач (TPL). Если вы обращаете внимание на то, как вы пишете свой алгоритм, и если ваш алгоритм может быть распараллелен, сделать его параллельным становится очень легко благодаря TPL. Если вы еще не знаете эту концепцию, обратите внимание на Параллельное программирование в .NET Framework 4: Начало работы

Избегайте прикосновений к элементам управления пользовательского интерфейса

Первое правило для многопоточности / многозадачности состоит в том, чтобы код 0 касался интерфейса в порождении потоков. Только поток пользовательского интерфейса может касаться / манипулировать графическими элементами управления. В нашем случае у нас был фрагмент кода, обращающийся к bmp.PixelWidth или bmp.PixelHeight, где bmp имеет тип WriteableBitmap . WriteableBitmap рассматривается как элемент пользовательского интерфейса и не является потокобезопасным. Вот почему нам нужно сначала изменить эти блоки кода, чтобы сделать их «параллелизуемыми». В предыдущем уроке мы начали с этого. Вам просто нужно сохранить эти значения в начале. Мы сделали это в renderWidth и renderHeight . Используйте эти значения в своем коде вместо доступа к bmp . Измените все ссылки на bmp.PixelWidth на renderWidth и на bmp.PixelHeight на renderHeight.

Кстати, это правило важно не только для распараллеливания. Это также для оптимизации производительности в целом. Таким образом, просто удаляя доступ к свойствам WriteableBitmap в моем коде, я переключаюсь со средней скорости 5 FPS на более чем 45 FPS на одной машине!

Это же правило очень важно (даже, может быть, даже больше) в HTML5. Вы должны избегать прямого тестирования свойств элементов DOM . Операции DOM очень медленные. Так что на самом деле не стоит заходить к ним каждые 16 мсек, если в этом нет необходимости. Всегда кэшируйте значения, которые необходимо проверить позже. Мы уже делали это в предыдущих уроках для HTML5-версии 3D-движка.

Быть самодостаточным

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

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

Первый случай в методе DrawTriangle . Затем мы собираемся нарисовать несколько линий на треугольнике параллельно. Затем вы можете легко преобразовать цикл 2 normal For в цикл 2 Parallel.For :

  если (dP1P2> dP1P3) 
     Параллельно .For (( int ) p1.Y, ( int ) p3.Y + 1, y => 
         { 
             если (у <p2.Y) 
             { 
                 ProcessScanLine (y, p1, p3, p1, p2, color); 
             } 
             еще 
             { 
                 ProcessScanLine (y, p1, p3, p2, p3, color); 
             } 
         }); 
  еще 
  { 
     Параллельно .For (( int ) p1.Y, ( int ) p3.Y + 1, y => 
         { 
             если (у <p2.Y) 
             { 
                 ProcessScanLine (y, p1, p2, p1, p3, color); 
             } 
             еще 
             { 
                 ProcessScanLine (y, p2, p3, p1, p3, color); 
             } 
         }); 
 

  закрытый объект [] lockBuffer; 
  Публичное устройство ( WriteableBitmap BMP) 
     это .bmp = bmp; 
     renderWidth = bmp.PixelWidth; 
     renderHeight = bmp.PixelHeight; 
      // размер заднего буфера равен количеству пикселей для рисования 
     // на экране (ширина * высота) * 4 (значения R, G, B и Alpha).  
     backBuffer = новый байт [renderWidth * renderHeight * 4]; 
     deepBuffer = new float [renderWidth * renderHeight]; 
     lockBuffer = новый объект [renderWidth * renderHeight]; 
     for ( var i = 0; i <lockBuffer.Length; i ++) 
     { 
         lockBuffer [i] = новый объект (); 
     } 
  // Вызывается поставить пиксель на экран с определенными координатами X, Y 
  public void PutPixel ( int x, int y, float z, Color4 color) 
     // Поскольку у нас есть 1-D массив для нашего заднего буфера 
     // нам нужно знать эквивалентную ячейку в 1-D 
     // в 2D координатах на экране 
     var index = (x + y * renderWidth); 
     var index4 = index * 4; 
      // Защита нашего буфера от параллелизма потоков 
     блокировка (lockBuffer [индекс]) 
     { 
         if (deepBuffer [index] <z) 
         { 
             возврат ;  // Сброс 
         } 
          deepBuffer [index] = z; 
          backBuffer [index4] = ( byte ) (color.Blue * 255); 
         backBuffer [index4 + 1] = ( байт ) (color.Green * 255); 
         backBuffer [index4 + 2] = ( байт ) (color.Red * 255); 
         backBuffer [index4 + 3] = ( байт ) (color.Alpha * 255); 
     }