Войти

Программирование игр

Игровой движок, 3D графика, сеть, физика, логика, уеб

Новости Статьи Подсказки Термины FAQ Форум Инфо

Статьи

Recursive Tile-based architecture

Данная статья вводит понятие Recursive Tile-Based Architecture (RTBA), расширяющее возможности традиционной tile-based архитектуры. Предложенный подход позволяет работать с аппаратно-ускоренным тайловым растеризатором в терминах когерентного рейтрейсинга, каждый тайл рассматривается, как средство обработки пучка лучей.

Читать | Комментарии [116]
8 янв 2022

Имитация раскачивания дерева под воздействием ветра

Статья демонстрирует простой метод имитации воздействия ветра на дерево (куст), реализованный на вертексном шейдере.

Читать | Комментарии [19]
9 окт 2020

Освещение с использованием фотометрического профиля
Гидродинамика Шрёдингера на пальцах
Предрасчёт рейкаста для эффективного рендеринга травы и меха
На пути к эффективному алгоритму Global Illumination, часть 1

Термины

Universal Scene Description (USD)

Universal Scene Description (USD) — файловый формат описания трехмерной сцены, разработанный компанией Pixar.

Читать
5 июня 2018

Verge3D

Verge3D - трёхмерный движок для веба, использующий технологию WebGL. Основан на Three.js, от которого отличается наличием реалистичных материалов, визуальным редактором логики Puzzles, средой создания приложений и более тесной интеграцией с программами моделирования Blender и 3ds Max. 14 декабря 2017 года в рамках проекта был запущен облачный сервис Verge3D Network для публикации и распространения 3D-приложений.

Читать | Комментарии [19]
8 дек 2017

Вуду-программирование
Blend4Web
Forward+

Подсказки

MAX Script: Разделение 3D модели на элементы по группам нормаль векторов.

Здесь представлен скрипт 3D Studio MAX, при помощи которого можно разделить 3D модели на элементы по группам нормалей, также смотрите «MAX Script: Разделение 3D модели на элементы по группам сглаживания».

Читать
10 мая 2020

Delphi: Точный таймер (Win API)
^ Матрица LookAt
Инверсия матрицы 4x4

Новости

Вышла книга 3D Graphics Rendering Cookbook

Вышла книга 3D Graphics Rendering Cookbook: A comprehensive guide to exploring rendering algorithms in modern OpenGL and Vulkan авторов Sergey Kosarevsky (_NetSurfer_) и Viktor Latypov (Vinil)
Подробнее…

Ссылка | Комментарии [50]
6 фев 2022

Развитие рендера в Path of Exile

Выложили мой доклад с exilecon. В нём я рассказываю о нескольких необычных техниках рендеринга, разработанных для Path of Exile. Доклад на английском языке. Есть русские субтитры.

Запустить видео по клику - Как делать игры

Ссылка | Комментарии [69]
8 апр 2020

Ray Tracing Gem. Доступно бесплатно!

Опубликована PDF-книга «Ray Tracing Gem. High-quality and real-time rendering with DXR and other APIs» на 600+ страниц, подготовленная NVIDIA и разными специалистами из области рейтрейсинга. Можно скачать отсюда:
https://link.springer.com/book/10.1007/978-1-4842-4427-2

Ссылка | Комментарии [7]
4 мар 2019

Microsoft анонсировала DirectX Raytracing (DXR)

На проходящей в Сан-Франциско конференции разработчиков игр (GDC) компания Microsoft анонсировала поддержку в DirectX 12 технологии DirectX Raytracing (DXR). Новый программный интерфейс позволяет производить просчет рейтрейсинга при помощи поддержки этой технологии в железе.

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

SEED-screenshot | Microsoft анонсировала DirectX Raytracing (DXR)

Подробнее…

Ссылка | Комментарии [504]
20 мар 2018

Предыдущие записи

Форум

Оптимизация. Как еще улучшить внутренние циклы? Масштабирование CSR-спрайтов	24 сен 2022	21:05	ArtProg

Есть такой код:

+ Показать

− Скрыть

// Some definitions:
nt - not transparent(alpha channel value=255)
type
    PInteger =PLongWord;
    TColor   =LongWord;
    TColorArr=array of TColor;
    TPtPosF  =packed record
      x,y: double;
    end;
  var
    nt_pix_intr_cnt_arr   : TColorArr; // array of nt-items counts in each of rows;
    nt_pix_intr_sht_arr   : TColorArr; // array of nt-items shifts: from first item in the same row to current;
    nt_pix_intr_ccl_arr   : TColorArr; // array of nt-items color data;
    scl_mul               : TPtPosF;   // scale multiplier;
    bmp_ftimg_left        : integer;   // x-coordinate of left top corner of image;
    bmp_ftimg_top         : integer;   // y-coordinate of left top corner of image;
    bmp_bkgnd_width       : integer;   // width of drawing surface(background bitmap);
    nt_pix_arr_row_mrg_top: TColor;    // distance from the top    down to the first row containing at least one fully opaque(not transparent) pixel;
    nt_pix_arr_row_mrg_btm: TColor;    // distance from the bottom up   to the first row containing at least one fully opaque(not transparent) pixel;
    bmp_bkgnd_ptr         : PInteger;  // pointer to first pixel of drawing surface(background bitmap pointer);
// NT - not transparent pixels:
// scale down:
// color:
procedure TFastImageProc.FilNTColorScaleDown; {$ifdef Linux}[local];{$endif} {$region -fold}
var
  nt_pix_intr_cnt_arr_ptr                                     : PInteger;
  nt_pix_intr_sht_arr_ptr                                     : PInteger;
  nt_pix_intr_ccl_arr_ptr                                     : PInteger;
  first_row_pix_ptr                                           : PInteger;
  bmp_bkgnd_ptr2                                              : PInteger;
  scl_mul_x,scl_mul_y,d1_,d2_,s1_,s2_,x,y,v1,v2               : integer;
  px,py,s1,s2,g1,g2,alpha,alpha_inv,alpha_inv_mul_s10000,d1,d2: double;
  b1,b2                                                       : TColor;
  row_parity                                                  : boolean;
  nt_pix_r,nt_pix_g,nt_pix_b,bg_pix_r,bg_pix_g,bg_pix_b       : byte;
label
  l1;
begin
  with fast_image_data_ptr0^ do
    begin
      d1                     :=bmp_ftimg_left*(1-scl_mul.x);
      d2                     :=bmp_ftimg_top *(1-scl_mul.y);
      scl_mul_x              :=Trunc($0010000*   scl_mul.x);
      scl_mul_y              :=Trunc($0010000*   scl_mul.y);
      d1_                    :=Trunc($0010000*   d1       );
      d2_                    :=Trunc($0010000*   d2       );
      first_row_pix_ptr      :=Unaligned(@bmp_bkgnd_ptr      [(nt_pix_arr_row_mrg_top+bmp_ftimg_top)*bmp_bkgnd_width+bmp_ftimg_left]);
      bmp_bkgnd_ptr          :=Unaligned(@bmp_bkgnd_ptr      [000000000000000000000000000000000000000000000000000000000000000000000]);
      nt_pix_intr_cnt_arr_ptr:=Unaligned(@nt_pix_intr_cnt_arr[ nt_pix_arr_row_mrg_top+000000000000000000000000000000000000000000000]);
      nt_pix_intr_sht_arr_ptr:=Unaligned(@nt_pix_intr_sht_arr[000000000000000000000000000000000000000000000000000000000000000000000]);
      nt_pix_intr_ccl_arr_ptr:=Unaligned( nt_pix_intr_arr_ptr);
      if (scl_mul.x<0.15) and (scl_mul.y<0.15) then
        for y:=0 to bmp_ftimg_height-nt_pix_arr_row_mrg_top-nt_pix_arr_row_mrg_btm-1 do
          begin
            row_parity:=not row_parity;
            for x:=0 to nt_pix_intr_cnt_arr_ptr^-1 do
              begin
                if Odd                       (nt_pix_intr_sht_arr_ptr-first_row_pix_ptr) and row_parity then
                  (bmp_bkgnd_ptr+((scl_mul_x*(nt_pix_intr_sht_arr_ptr^+bmp_ftimg_left)+d1_)>>16)+
                                 ((scl_mul_y*(nt_pix_arr_row_mrg_top+y+bmp_ftimg_top )+d2_)>>16)*bmp_bkgnd_width)^:=
                                              nt_pix_intr_ccl_arr_ptr^;
                                          Inc(nt_pix_intr_sht_arr_ptr);
                                          Inc(nt_pix_intr_ccl_arr_ptr);
              end;
                                          Inc(nt_pix_intr_cnt_arr_ptr);
          end
      else
      if ((scl_mul.x<0.2)         and
          (scl_mul.y<0.2))         or
         ((scl_mul.x>0.5-0.01)    and
          (scl_mul.x<0.5+0.01)    and
          (scl_mul.y>0.5-0.01)    and
          (scl_mul.y<0.5+0.01))    or
         ((scl_mul.x>0.5-0.01)    and
          (scl_mul.x<0.5+0.01)    and
          (scl_mul.y>1.0-0.01)    and
          (scl_mul.y<1.0+0.01))    or
         ((scl_mul.x>0.5-0.01)    and
          (scl_mul.x<0.5+0.01)    and
          (scl_mul.y>1.0-0.01)    and
          (scl_mul.y<1.0+0.01))  then
        begin
          l1:
          for y:=0 to bmp_ftimg_height-nt_pix_arr_row_mrg_top-nt_pix_arr_row_mrg_btm-1 do
            begin
              for x:=0 to nt_pix_intr_cnt_arr_ptr^-1 do
                begin
                  (bmp_bkgnd_ptr+((scl_mul_x*(nt_pix_intr_sht_arr_ptr^+bmp_ftimg_left)+d1_)>>16)+
                                 ((scl_mul_y*(nt_pix_arr_row_mrg_top+y+bmp_ftimg_top )+d2_)>>16)*bmp_bkgnd_width)^:=
                                              nt_pix_intr_ccl_arr_ptr^;
                                          Inc(nt_pix_intr_sht_arr_ptr);
                                          Inc(nt_pix_intr_ccl_arr_ptr);
                end;
                                          Inc(nt_pix_intr_cnt_arr_ptr);
            end;
          Exit;
        end
      else
      if (scl_mul.x<0.25) and (scl_mul.y<0.25) then
        begin
          alpha               :=exp(((scl_mul.x+scl_mul.y)/2)*ln(0.95));
          alpha_inv           :=1/alpha;
          alpha_inv_mul_s10000:=$10000*alpha_inv;
          for y:=0 to bmp_ftimg_height-nt_pix_arr_row_mrg_top-nt_pix_arr_row_mrg_btm-1 do
            begin
              row_parity:=not row_parity;
              for x:=0 to nt_pix_intr_cnt_arr_ptr^-1 do
                begin
                  if Odd(nt_pix_intr_sht_arr_ptr-first_row_pix_ptr) and row_parity then
                    begin
                      v1                                     :=((scl_mul_x*(nt_pix_intr_sht_arr_ptr^+bmp_ftimg_left)+d1_)>>16);
                      v2                                     :=((scl_mul_y*(nt_pix_arr_row_mrg_top+y+bmp_ftimg_top )+d2_)>>16);
                      g1                                     :=  scl_mul.x*(nt_pix_intr_sht_arr_ptr^+bmp_ftimg_left)+d1;
                      g2                                     :=  scl_mul.y*(nt_pix_arr_row_mrg_top+y+bmp_ftimg_top )+d2;
                      px                                     :=(Min(v1+1,g1+scl_mul.x)-Max(v1+0,g1));
                      py                                     :=(Min(v2+1,g2+scl_mul.y)-Max(v2+0,g2));
                      bmp_bkgnd_ptr2                         :=bmp_bkgnd_ptr+v1+v2*bmp_bkgnd_width;
                      nt_pix_r                               :=Byte(nt_pix_intr_ccl_arr_ptr^>>00);
                      nt_pix_g                               :=Byte(nt_pix_intr_ccl_arr_ptr^>>08);
                      nt_pix_b                               :=Byte(nt_pix_intr_ccl_arr_ptr^>>16);
                      s1                                     :=px*py;
                      s2                                     :=alpha-s1;
                      if (s1>0.0) then
                        begin
                          s1_                                :=Trunc(alpha_inv_mul_s10000*s1);
                          bg_pix_r                           :=Byte((bmp_bkgnd_ptr2+00000000000000000)^>>00);
                          bg_pix_g                           :=Byte((bmp_bkgnd_ptr2+00000000000000000)^>>08);
                          bg_pix_b                           :=Byte((bmp_bkgnd_ptr2+00000000000000000)^>>16);
                          (bmp_bkgnd_ptr2+00000000000000000)^:=    ((bg_pix_r+(s1_*(nt_pix_r-bg_pix_r))>>16)<<00+
                                                                    (bg_pix_g+(s1_*(nt_pix_g-bg_pix_g))>>16)<<08+
                                                                    (bg_pix_b+(s1_*(nt_pix_b-bg_pix_b))>>16)<<16);
                         {s2_                                :=65536-s1_{-1};//Trunc(alpha_inv_mul_s10000*s2);
                          (bmp_bkgnd_ptr2+00000000000000000)^:=  {RGB}(((s2_*Byte(b1>>00)+s1_*nt_pix_r)>>16){,}<<00+
                                                                       ((s2_*Byte(b1>>08)+s1_*nt_pix_g)>>16){,}<<08+
                                                                       ((s2_*Byte(b1>>16)+s1_*nt_pix_b)>>16){ }<<16);}
                        end;
                      s1                                     :=(alpha-px)*py;
                      s2                                     := alpha-s1;
                      if (s1<0.25) then
                        begin
                          s1_                                :=Trunc(alpha_inv_mul_s10000*s1);
                          bg_pix_r                           :=Byte((bmp_bkgnd_ptr2+000000000000000+1)^>>00);
                          bg_pix_g                           :=Byte((bmp_bkgnd_ptr2+000000000000000+1)^>>08);
                          bg_pix_b                           :=Byte((bmp_bkgnd_ptr2+000000000000000+1)^>>16);
                          (bmp_bkgnd_ptr2+000000000000000+1)^:=    ((bg_pix_r+(s1_*(nt_pix_r-bg_pix_r))>>16)<<00+
                                                                    (bg_pix_g+(s1_*(nt_pix_g-bg_pix_g))>>16)<<08+
                                                                    (bg_pix_b+(s1_*(nt_pix_b-bg_pix_b))>>16)<<16);
                         {s2_                                :=65536-s1_{-1};//Trunc(alpha_inv_mul_s10000*s2);
                          (bmp_bkgnd_ptr2+000000000000000+1)^:=  {RGB}(((s2_*Byte(b1>>00)+s1_*nt_pix_r)>>16){,}<<00+
                                                                       ((s2_*Byte(b1>>08)+s1_*nt_pix_g)>>16){,}<<08+
                                                                       ((s2_*Byte(b1>>16)+s1_*nt_pix_b)>>16){ }<<16);}
                        end
                      else
                          (bmp_bkgnd_ptr2+000000000000000+1)^:=
                           nt_pix_intr_ccl_arr_ptr^;
                      if  (px*(alpha-py)>0.25) then
                          (bmp_bkgnd_ptr2+bmp_bkgnd_width+0)^:=
                           nt_pix_intr_ccl_arr_ptr^;
                      if  ((alpha-px)*(alpha-py)>0.25) then
                          (bmp_bkgnd_ptr2+bmp_bkgnd_width+1)^:=
                           nt_pix_intr_ccl_arr_ptr^;
                    end;
                  Inc(nt_pix_intr_sht_arr_ptr);
                  Inc(nt_pix_intr_ccl_arr_ptr);
                end;
              Inc    (nt_pix_intr_cnt_arr_ptr);
            end;
        end
      else
      if (scl_mul.x<0.75) and (scl_mul.y<0.75) then
        begin
          alpha               :=exp(((scl_mul.x+scl_mul.y)/2)*ln(0.95));
          alpha_inv           :=1/alpha;
          alpha_inv_mul_s10000:=$10000*alpha_inv;
          for y:=0 to bmp_ftimg_height-nt_pix_arr_row_mrg_top-nt_pix_arr_row_mrg_btm-1 do
            begin
              for x:=0 to nt_pix_intr_cnt_arr_ptr^-1 do
                begin
                  v1                                     :=((scl_mul_x*(nt_pix_intr_sht_arr_ptr^+bmp_ftimg_left)+d1_)>>16);
                  v2                                     :=((scl_mul_y*(nt_pix_arr_row_mrg_top+y+bmp_ftimg_top )+d2_)>>16);
                  g1                                     :=  scl_mul.x*(nt_pix_intr_sht_arr_ptr^+bmp_ftimg_left)+d1;
                  g2                                     :=  scl_mul.y*(nt_pix_arr_row_mrg_top+y+bmp_ftimg_top )+d2;
                  px                                     :=(Min(v1+1,g1+scl_mul.x)-Max(v1+0,g1));
                  py                                     :=(Min(v2+1,g2+scl_mul.y)-Max(v2+0,g2));
                  bmp_bkgnd_ptr2                         :=bmp_bkgnd_ptr+v1+v2*bmp_bkgnd_width;
                  nt_pix_r                               :=Byte(nt_pix_intr_ccl_arr_ptr^>>00);
                  nt_pix_g                               :=Byte(nt_pix_intr_ccl_arr_ptr^>>08);
                  nt_pix_b                               :=Byte(nt_pix_intr_ccl_arr_ptr^>>16);
                  s1                                     :=px*py;
                  s2                                     :=alpha-s1;
                  if (s1>0.0) then
                    begin
                      s1_                                :=Trunc(alpha_inv_mul_s10000*s1);
                      bg_pix_r                           :=Byte((bmp_bkgnd_ptr2+00000000000000000)^>>00);
                      bg_pix_g                           :=Byte((bmp_bkgnd_ptr2+00000000000000000)^>>08);
                      bg_pix_b                           :=Byte((bmp_bkgnd_ptr2+00000000000000000)^>>16);
                      (bmp_bkgnd_ptr2+00000000000000000)^:=    ((bg_pix_r+(s1_*(nt_pix_r-bg_pix_r))>>16)<<00+
                                                                (bg_pix_g+(s1_*(nt_pix_g-bg_pix_g))>>16)<<08+
                                                                (bg_pix_b+(s1_*(nt_pix_b-bg_pix_b))>>16)<<16);
                     {s2_                                :=65536-s1_{-1};//Trunc(alpha_inv_mul_s10000*s2);
                      (bmp_bkgnd_ptr2+00000000000000000)^:=  {RGB}(((s2_*Byte(b1>>00)+s1_*nt_pix_r)>>16){,}<<00+
                                                                   ((s2_*Byte(b1>>08)+s1_*nt_pix_g)>>16){,}<<08+
                                                                   ((s2_*Byte(b1>>16)+s1_*nt_pix_b)>>16){ }<<16);}
                    end;
                  s1                                     :=(alpha-px)*py;
                  s2                                     := alpha-s1;
                  if (s1<0.25) then
                    begin
                      s1_                                :=Trunc(alpha_inv_mul_s10000*s1);
                      bg_pix_r                           :=Byte((bmp_bkgnd_ptr2+000000000000000+1)^>>00);
                      bg_pix_g                           :=Byte((bmp_bkgnd_ptr2+000000000000000+1)^>>08);
                      bg_pix_b                           :=Byte((bmp_bkgnd_ptr2+000000000000000+1)^>>16);
                      (bmp_bkgnd_ptr2+000000000000000+1)^:=    ((bg_pix_r+(s1_*(nt_pix_r-bg_pix_r))>>16)<<00+
                                                                (bg_pix_g+(s1_*(nt_pix_g-bg_pix_g))>>16)<<08+
                                                                (bg_pix_b+(s1_*(nt_pix_b-bg_pix_b))>>16)<<16);
                     {s2_                                :=65536-s1_{-1};//Trunc(alpha_inv_mul_s10000*s2);
                      (bmp_bkgnd_ptr2+000000000000000+1)^:=  {RGB}(((s2_*Byte(b1>>00)+s1_*nt_pix_r)>>16){,}<<00+
                                                                   ((s2_*Byte(b1>>08)+s1_*nt_pix_g)>>16){,}<<08+
                                                                   ((s2_*Byte(b1>>16)+s1_*nt_pix_b)>>16){ }<<16);}
                    end
                  else
                      (bmp_bkgnd_ptr2+000000000000000+1)^:=
                       nt_pix_intr_ccl_arr_ptr^;
                  if  (px*(alpha-py)>0.25) then
                      (bmp_bkgnd_ptr2+bmp_bkgnd_width+0)^:=
                       nt_pix_intr_ccl_arr_ptr^;
                  if  ((alpha-px)*(alpha-py)>0.25) then
                      (bmp_bkgnd_ptr2+bmp_bkgnd_width+1)^:=
                       nt_pix_intr_ccl_arr_ptr^;
                  Inc (nt_pix_intr_sht_arr_ptr);
                  Inc (nt_pix_intr_ccl_arr_ptr);
                end;
              Inc     (nt_pix_intr_cnt_arr_ptr);
            end;
        end
      else
      if (scl_mul.x<1.0) and (scl_mul.y<1.0) then
        goto l1;
    end;
end; {$endregion}

Делает масштабирование непрозрачных пикселей CSR-спрайта, но не суть. Вопрос в том, можно ли еще как-то оптимизировать внутренние циклы? Например, избавиться от взятия целых частей или еще какие-то трюки?

Правка: 23:59

Проблема с внутриигровой системой наведения на цель	23 сен 2022	0:37	Xardkort

Трехмерное пространство.
Цель статична.
В расчетах учтены: своя угловая скорость * тензор инерции и орбитальная угловая скорость вокруг цели.
Стрелок совершает маневры по перпендикулярному к цели кругу.
Аим работает идеально но стоит добавить простое упреждение (позиция Цели + (Скорость Цели - Моя Скорость) * (Расстояние до цели / Скорость снаряда) погрешность наведения меняется с 5-20 см, до 10-15 м.
Упреждение с любыми другими маневрами работает нормально.
Вопрос:
Что нужно добавить в расчеты чтобы круговые маневры перпендикулярно к цели не приводили к потере точности?
Или может я уже учел все что нужно и проблема в чем-то другом?

GeForce RTX 4000	21 сен 2022	11:42	g-cont

Nvida анонсировала новое поколение видеокарт:
https://dtf.ru/hard/1363704-videokarty-geforce-rtx-4000-dlss-3-0-… ntacii-nvidia

Что-то я понять не могу, этот DLSS 3.0 теперь будет при помощи нейросети генерировать какую-то отсебятину?
Видеокарта перестаёт быть устройством для рендинга полигонов и начинает жить своей собственной жизнью?
И такой вопрос - в современной архитектуре, получается больше нет ни вертексных, ни пиксельных конвейеров, там теперь только унифицированные ядра CUDA?

Не рисует ortho рисунок в текстуру	20 сен 2022	15:04	v7

Я проверял структуру text на обычном фреймбуфере и текст отображается. Хочу рисовать в текстуру, но в текстуру рисуется только цвет glClear. Несколько дней бьюсь над проблемой и не пойму в чем она. вот код framebuffer.

#include <GLES3/gl3.h>
#include <stdint.h>
#include <wchar.h>
#include <stdlib.h>
#include <stdio.h>
#include "text.h"

static uint32_t render_buffer;
static uint32_t ids;
static uint32_t w = 128;
static uint32_t h = 128;
static uint32_t texture_map;
static uint32_t texture_depth;
GLuint depthrenderbuffer;

void init_framebuffer ()
{
  //int ret = glCheckFramebufferStatus (GL_FRAMEBUFFER);

  //printf ("error: %d\n", glGetError ());
  
  glGenFramebuffers (1, &ids);

  glBindFramebuffer (GL_FRAMEBUFFER, ids);

  glGenTextures (1, &texture_map);

  glBindTexture (GL_TEXTURE_2D, texture_map);

  glTexImage2D (GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);


  glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_map, 0);
  glBindTexture (GL_TEXTURE_2D, 0);

  glGenRenderbuffers(1, &depthrenderbuffer);
  glBindRenderbuffer(GL_RENDERBUFFER, depthrenderbuffer);

  glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, w, h);
  glBindRenderbuffer (GL_RENDERBUFFER, 0);
  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthrenderbuffer);

  int ret = glCheckFramebufferStatus (GL_FRAMEBUFFER);
}

uint8_t *framebuffer_render_tile_day (int day_num, uint32_t *_w, uint32_t *_h)
{
  *_w = w;
  *_h = h;
  uint8_t *buffer = malloc (w * h * 4);
  glViewport (0, 0, w, h);

  glBindFramebuffer (GL_FRAMEBUFFER, ids);
  int ret = glCheckFramebufferStatus (GL_FRAMEBUFFER);

  glClearColor (1.f, 1.f, 1.f, 1.f);
  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  wchar_t day[3];
  day[2] = 0;

  swprintf (day, 3, L"%d", day_num);

  struct text *text = text_build (day, 48);

  text_render (text, 0.0f, 10.0f, 10.f, 1.f, 0.f, 0.f);

  glReadPixels (0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, buffer);

  glBindFramebuffer (GL_FRAMEBUFFER, 0);
  glViewport (0, 0, 1024, 600);

  return buffer;
}

Текст рисуется в ortho проекции. 128 на 128.

C чего начать писать свой движок ? И как его проектировать	19 сен 2022	19:33	IGamedevStudio

Для того что бы повысить скиллы, понять технологии. В основном интересует графика.Плюсы тоже надо подтянуть.
Думаю начать с directx11, потому что вроде он самый лёгкий и доступный из относительно современных.
Вероятно OGL тоже, хоть он вроде уже труп, но с него многие начинали.
Платформа PC.
Вчера посмотрел текстовый туториал и пролистал Фрэнка Луну.Но чёт не вижу смысла делать что то своё основываясь на чужом.
Нужна структура движка и какая то система сущностей.
Как получить суперспособность проектирования ?

Насколько выгодно пустить логику игры в отдельном потоке?	17 сен 2022	7:27	mingw

Доброго времени года!

Сабж.

У меня проект с фиксированной частотой логики в 30 ФПС. Рендер - в свободном плавании интерполируется через tween. И вот пришла мысль пустить логику в отдельный поток... будет ли выигрыш при таких раскладах или не заморачиваться?

Quadtree mesh и корректный frustum culling	15 сен 2022	13:28	Kripto289

В большинстве проектов используется frustum culling на основе бесконечных plane.
Это выливается в следующую проблему (особенно при использовании quad mesh)

То есть если объект достаточно большой, то будет ложное положительное срабатывание.
В случае использования quad tree mesh с огромной площадью (например 10 километров), отбраковка просто не работает, потому что почти все квадраты имеют ложное срабатывание и не отбрасываются.

Собственно вопрос, почему об этой проблеме нигде нет информации? По всем гайдам quad tree mesh пробежался и нигде подобного не видел. Кто как с этим борется или просто никто не замечал?
Усложнять код отсечения не сильно хочется, да и не смог найти нормальный код пересечения frustum planes VS AABB, везде какие-то усложнения с полярными координатами, OOBB преобразованиями и т.д.

Правка: 21:20

Удобный редактор/дизайнер шейдеров анимированных частиц?	14 сен 2022	23:38	romanshuvalov

Есть такой? Чтоб не вслепую GLSL код писать, а чуть менее вслепую, с предпросмотром результата?

Звукореж, саунд-дизайнер, композитор вступлю в команду или проект	14 сен 2022	11:04	danny.rimshot11

Всем привет, я - саунд-продюсер из Москвы. Озвучу ваш проект, также напишу к нему музыку. Мои работы по саунд-дизайну на ютуб канале:
https://www.youtube.com/playlist?list=PLFaO2Z1sLk7JwMlXLu5ek-q-H-nHwB1ky

Тут немного музыки отдельно:
https://soundcloud.com/danny-soroka

Есть возможность записи дикторов/актеров. Сейчас изучаю интерактивное аудио в Unity чтобы поучавствовать с точки зрения звука в каком то более сложном проекте, делать там имплементацию звучков и их настройку. Так что проектам на Unity

Пишите лучше в телеграм или вацап +79998569280

[C++] Проверить наличие глобальной переменной	13 сен 2022	20:16	gammaker

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

Я попытался набросать такой детектор:

#define META_CHECK_IF_GLOBALLY_DECLARED_VAR(id) \
  namespace z_D {struct id##_DeclaredType {}; int id(id##_DeclaredType);} \
  template<typename T> concept z_D_##id##Declared = requires {id(T());}; \
  namespace MetaGloballyDeclaredVar {\
    namespace Exists {constexpr bool id = !z_D_##id##Declared<z_D::id##_DeclaredType>;} \
    namespace GetPtr {template<typename T> T* id() {return &::id;};} \
  }

Пример использования:

int declaredVar = 5;
META_CHECK_IF_GLOBALLY_DECLARED_VAR(declaredVar)
META_CHECK_IF_GLOBALLY_DECLARED_VAR(notDeclaredVar)
static_assert(MetaGloballyDeclaredVar::Exists::declaredVar);
static_assert(!MetaGloballyDeclaredVar::Exists::notDeclaredVar);

#include "third_party_file.h"

META_CHECK_IF_GLOBALLY_DECLARED_VAR(third_party_var)

// Должна вернуть third_party_var, если она объявлена в third_party_file.h.
// Иначе должна вернуть 0.
int getValOrZero()
{
  int* ptr = MetaGloballyDeclaredVar::GetPtr::third_party_var<int>();
  return ptr? *ptr: 0;
}

Exists уже отрабатывает как надо. А GetPtr надо реализовать, чтобы не было ошибки компиляции, когда переменная не определена. Возможно ли это реализовать?
Можно использовать C++20 фичи, но только те, которые можно заставить работать на GCC 8.

Правка: 20:20

Купить выкидные ножи по ссылке: nozheman.club/vykidnyye-nozhi/ в интеренет-магазине Ножеман . , Ищешь спортивные ставки на айфон? Попробуй это приложение