Много ли здесь движкописателей? (28 стр) / Графика / Форум / Программирование игр / GameDev.ru

да открывай список созданных тем и смотри, https://gamedev.ru/users/?id=52570&a=createdtopics
дак вот же релиз: https://gamedev.ru/projects/forum/?id=256277, вот релиз https://gamedev.ru/projects/forum/?id=281229, вот релиз https://gamedev.ru/flame/forum/?id=277040

не фонтан, но этого уже достаточно чтоб тебе помалкивать про него

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

Виртекс решил стать писателем. Ясно.
Чем только Виртекс не занимался, лишь бы игру на Юнити до конца не доделать.

Меня тут осенило.
На Юнити любой игру сделает. Но вот крутость как раз то в том, чтобы не сделать. На это способны не все !
А лишь великие.

По крайней мере это отказ от иллюзий, Так что в каком-то смысле шаг вперёд

Тему пора переносить в болталку ))
Спор уже давно за рамками раздела...

Роннико, которое из расширений процессора самое полезное, с твоей точки зрения? (я про SSE, MMX, ...)

Sse, avx2
Avx 512 тоже имеет классные инструкции, но это процы с 2023 года попёрли массово.
У меня нет avx 512, мой проц за ноябрь 2019 год.

stratego
> Забавная штука, вот думаешь что что-то изобрёл - а нет, очередной велосипед же ))

И всё же, не стоит забывать, что мы с детства тем и занимаемся, что учимся по тому, что уже изобретено. Просто у нас времени не хватает на то, чтобы изобретать, есть только, чтобы учиться. А ведь изобрести велосипед, это же круто. Кто может такое сделать? Да даже в программировании многие уже берут готовые решения, чтобы делать просто логику, но некоторым нравиться делать и домысливать самим.

Я вот недавно например сделал бросание луча из экрана в сцену и кажется, что такого варианта люди ещё не придумывали, так как везде пишут про обратные матрицы. А мой способ намного быстрее как мне кажется из-за того, что не надо инвертировать матрицы. Ты же читаешь чужой код движков, видел ли ты такой способ бросания луча? Мне просто интересно, догадался ли я до этого первый или кто-то до меня такое уже делал.

void make_ray_from_cursor (struct game *game, struct camera *cam, struct ray *ray, int x, int y, float z_far)
{
  float v0[3];
  float v1[3];
  float v2[3];
  float v3[3];
  float d0[3];
  float d1[3];

  int xx = x - game->screen->w / 2;
  int yy = game->screen->h / 2 - y;

  float aspect = game->screen->aspect;
  float h = game->screen->fw * 0.5f;
  float v = game->screen->fh * 0.5f;

  float null_vector[3] = {0.f, 0.f, 0.f};

  float kh = (aspect + 1.f) / (1.f + aspect / 2.f);

  float near_x = (float) xx / (h / kh);
  float near_y = (float) yy / (v * (aspect / kh));

  float far_x = near_x / (2.f * kh);
  float far_y = near_y / 2.f;

  float x0 = ((far_x * ((z_far + 1.f) * kh)));
  float y0 = ((far_y * ((z_far + 1.f))));

  vec3_mul_scalar (v0, cam->front, z_far);

  vec3_mul_scalar (v1, cam->right, x0);
  vec3_add (v2, v0, v1); 

  vec3_mul_scalar (v1, cam->real_up, y0);
  vec3_sub (v0, v2, v1);

  vec3_copy (ray->dir, v0);

  vec3_mul_scalar (v1, cam->right, near_x);
  vec3_mul_scalar (v2, cam->real_up, near_y);

  vec3_add (v3, cam->front, v1);
  vec3_sub (v0, v3, v2);

  vec3_copy (ray->origin, v0);

  float e0[3];
  vec3_add (e0, cam->pos, v0);
  vec3_copy (ray->pos, e0);

  graphics_ray_setup_vertex_data (ray);

  translate (ray->transform, cam->pos[0], cam->pos[1], cam->pos[2]);

  float view[16];

  mat4x4_mul (view, ray->transform, cam->view);
  mat4x4_mul (ray->model, view, ray->projection);
}

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

Удобнее тем кто в Юнити.
Мне не всегда нужна инверсия матрицы.
Очень редко юзаю её.

xverizex молодец что делаешь так.
Подход думающего человека.

xverizex
> Я вот недавно например сделал бросание луча из экрана в сцену и кажется, что такого варианта люди ещё не придумывали, так как везде пишут про обратные матрицы. А мой способ намного быстрее как мне кажется из-за того, что не надо инвертировать матрицы.
Эту задачу, в принципе, невозможно решить без матриц. Математика однозначна, там не бывает вариантов. То, что ты спрятал (от себя) матрицы, размазав их по трем векторам, делает код только более длинным и менее понятным для людей, которые матрицы, таки, осилили. А чтобы расчет обратных матриц был более дешевым (не то, что бы это на что-то влияло, ибо одно обращение матрицы на кадр — это ниочем), можно использовать свойство ортогональных матриц.

}:+()___ [Smile]

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

https://vk.com/video583070625_456239119

}:+()___ [Smile]

Я использую как я понял масштабирование экрана, формулу которой я вывел, когда не понимал откуда берётся число 1.47... . Когда вывел эту формулу, спросил у нейросети что это за формула, она сказала, что это масштабирование экрана. Пробуя разные вычисления, в общем я потратил пять дней, я вывел форумулу дальнего масштабирования. То-есть с помощью новой формулы можно узнать какое масштабирование будет на определенном расстоянии. Это работает быстрее чем обратные матрицы, потому что чтобы вычислить обратную матрицу, нужно в более простом случае выполнить вот столько операций и сначала найти детерминант, который не должен быть равен нулю.

void
mat4x4_inverse (float *tr, float *e, float _det)
{
  float m[16];

  m[0] =      ( e[5] * (e[10] * e[15] - e[11] * e[14]) - e[6] * (e[9] * e[15] - e[11] * e[13]) + e[7] * (e[9] * e[14] - e[10] * e[13]));
  m[1] =    -( e[4] * (e[10] * e[15] - e[11] * e[14]) - e[6] * (e[8] * e[15] - e[11] * e[12]) + e[7] * (e[8] * e[14] - e[10] * e[12]));
  m[2] =     ( e[4] * (e[9] * e[15] - e[11] * e[13]) - e[5] * (e[8] * e[15] - e[11] * e[12]) + e[7] * (e[8] * e[13] - e[9] * e[12]));
  m[3] =     -( e[4] * (e[9] * e[14] - e[10] * e[13]) - e[5] * (e[8] * e[14] - e[10] * e[12]) + e[6] * (e[8] * e[13] - e[9] * e[12]));
  m[4] =     -( e[1] * (e[10] * e[15] - e[11] * e[14]) - e[2] * (e[9] * e[15] - e[11] * e[13]) + e[3] * (e[9] * e[14] - e[10] * e[13]));
  m[5] =     ( e[0] * (e[10] * e[15] - e[11] * e[14]) - e[2] * (e[8] * e[15] - e[11] * e[12]) + e[3] * (e[8] * e[14] - e[10] * e[12]));
  m[6] =     -( e[0] * (e[9] * e[15] - e[11] * e[13]) - e[1] * (e[8] * e[15] - e[11] * e[12]) + e[3] * (e[8] * e[13] - e[9] * e[12]));
  m[7] =     ( e[0] * (e[9] * e[14] - e[10] * e[13]) - e[1] * (e[8] * e[14] - e[10] * e[12]) + e[2] * (e[8] * e[13] - e[9] * e[12]));
  m[8] =     ( e[1] * (e[6] * e[15] - e[7] * e[14]) - e[2] * (e[5] * e[15] - e[7] * e[13]) + e[3] * (e[5] * e[14] - e[6] * e[13]));
  m[9] =     -( e[0] * (e[6] * e[15] - e[7] * e[14]) - e[2] * (e[4] * e[15] - e[7] * e[12]) + e[3] * (e[4] * e[14] - e[6] * e[12]));
  m[10] =   ( e[0] * (e[5] * e[15] - e[7] * e[13]) - e[1] * (e[4] * e[15] - e[7] * e[12]) + e[3] * (e[4] * e[13] - e[5] * e[12]));
  m[11] =   -( e[0] * (e[5] * e[14] - e[6] * e[13]) - e[1] * (e[4] * e[14] - e[6] * e[12]) + e[2] * (e[4] * e[13] - e[5] * e[12]));
  m[12] =   -( e[1] * (e[6] * e[11] - e[7] * e[10]) - e[2] * (e[5] * e[11] - e[7] * e[9]) + e[3] * (e[5] * e[10] - e[6] * e[9]));
  m[13] =   ( e[0] * (e[6] * e[11] - e[7] * e[10]) - e[2] * (e[4] * e[11] - e[7] * e[8]) + e[3] * (e[4] * e[10] - e[6] * e[8]));
  m[14] =   -( e[0] * (e[5] * e[11] - e[7] * e[9]) - e[1] * (e[4] * e[11] - e[7] * e[8]) + e[3] * (e[4] * e[9] - e[5] * e[8]));
  m[15] =   ( e[0] * (e[5] * e[10] - e[6] * e[9]) - e[1] * (e[4] * e[10] - e[6] * e[8]) + e[2] * (e[4] * e[9] - e[5] * e[8]));

  mat4x4_transpose (tr, m);

  tr[0] /= _det;
  tr[1] /= _det;
  tr[2] /= _det;
  tr[3] /= _det;
  tr[4] /= _det;
  tr[5] /= _det;
  tr[6] /= _det;
  tr[7] /= _det;
  tr[8] /= _det;
  tr[9] /= _det;
  tr[10] /= _det;
  tr[11] /= _det;
  tr[12] /= _det;
  tr[13] /= _det;
  tr[14] /= _det;
  tr[15] /= _det;
}

И где здесь вычисления минимальны? Ты хоть раз находил обратную матрицу? Моя формула быстрее работает.

Ну и ещё в твоем варианте надо обратные матрицы перемножить между собой как я помню из задачи, а это ещё вот какая операция.

void
mat4x4_mul (float *m, float *e0, float *e1)
{
  m[0] = e0[0] * e1[0] + e0[1] * e1[4] + e0[2] * e1[8] + e0[3] * e1[12];
  m[1] = e0[0] * e1[1] + e0[1] * e1[5] + e0[2] * e1[9] + e0[3] * e1[13];
  m[2] = e0[0] * e1[2] + e0[1] * e1[6] + e0[2] * e1[10] + e0[3] * e1[14];
  m[3] = e0[0] * e1[3] + e0[1] * e1[7] + e0[2] * e1[11] + e0[3] * e1[15];

  m[4] = e0[4] * e1[0] + e0[5] * e1[4] + e0[6] * e1[8] + e0[7] * e1[12];
  m[5] = e0[4] * e1[1] + e0[5] * e1[5] + e0[6] * e1[9] + e0[7] * e1[13];
  m[6] = e0[4] * e1[2] + e0[5] * e1[6] + e0[6] * e1[10] + e0[7] * e1[14];
  m[7] = e0[4] * e1[3] + e0[5] * e1[7] + e0[6] * e1[11] + e0[7] * e1[15];

  m[8] = e0[8] * e1[0] + e0[9] * e1[4] + e0[10] * e1[8] + e0[11] * e1[12];
  m[9] = e0[8] * e1[1] + e0[9] * e1[5] + e0[10] * e1[9] + e0[11] * e1[13];
  m[10] = e0[8] * e1[2] + e0[9] * e1[6] + e0[10] * e1[10] + e0[11] * e1[14];
  m[11] = e0[8] * e1[3] + e0[9] * e1[7] + e0[10] * e1[11] + e0[11] * e1[15];

  m[12] = e0[12] * e1[0] + e0[13] * e1[4] + e0[14] * e1[8] + e0[15] * e1[12];
  m[13] = e0[12] * e1[1] + e0[13] * e1[5] + e0[14] * e1[9] + e0[15] * e1[13];
  m[14] = e0[12] * e1[2] + e0[13] * e1[6] + e0[14] * e1[10] + e0[15] * e1[14];
  m[15] = e0[12] * e1[3] + e0[13] * e1[7] + e0[14] * e1[11] + e0[15] * e1[15];
}