Max/korenkonder_AFTMods
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases 41 Wiki Activity
Files
dedebcbc129deae38cd306a6d647af702c1d0c80
korenkonder_AFTMods/src/DivaGL/Glitter/render_scene.cpp
T

995 lines
35 KiB
C++
Raw Blame History

/*
by korenkonder
GitHub/GitLab: korenkonder
*/
#include "glitter.hpp"
#include "../gl_state.hpp"
#include "../render_context.hpp"
#include "../shader_ft.hpp"
#include "../wrap.hpp"
namespace Glitter {
void RenderScene::CalcDisp() {
disp_quad = 0;
disp_line = 0;
disp_locus = 0;
bool (FASTCALL * RenderGroup_CannotDisp)(RenderGroup * rend_group)
= (bool(FASTCALL*)(RenderGroup * rend_group))0x00000001403A7120;
for (RenderGroup*& i : render_groups) {
if (!i)
continue;
RenderGroup* rend_group = i;
if (RenderGroup_CannotDisp(rend_group))
continue;
CalcDisp(rend_group);
}
}
void RenderScene::CalcDisp(RenderGroup* rend_group) {
rend_group->disp = 0;
switch (rend_group->type) {
case PARTICLE_QUAD:
if (!rend_group->vao)
return;
CalcDispQuad(rend_group);
disp_quad += (uint32_t)rend_group->disp;
break;
case PARTICLE_LINE:
if (!rend_group->vao)
return;
CalcDispLine(rend_group);
disp_line += (uint32_t)rend_group->disp;
break;
case PARTICLE_LOCUS:
if (!rend_group->vao)
return;
CalcDispLocus(rend_group);
disp_locus += (uint32_t)rend_group->disp;
break;
}
}
void Glitter::RenderScene::Disp(Glitter::DispType disp_type) {
bool (FASTCALL * RenderGroup_CannotDisp)(RenderGroup * rend_group)
= (bool(FASTCALL*)(RenderGroup * rend_group))0x00000001403A7120;
for (RenderGroup*& i : render_groups) {
if (!i)
continue;
RenderGroup* rend_group = i;
if (RenderGroup_CannotDisp(rend_group) && rend_group->disp_type != disp_type)
continue;
Disp(rend_group);
}
}
void RenderScene::Disp(RenderGroup* rend_group) {
switch (rend_group->type) {
case PARTICLE_QUAD:
case PARTICLE_LINE:
case PARTICLE_LOCUS:
break;
default:
return;
}
if (!rend_group->vao || rend_group->disp < 1)
return;
mat4 cam_view;
mat4 cam_projection;
mat4_transpose(&camera_data->view, &cam_view);
mat4_transpose(&camera_data->projection, &cam_projection);
mat4 mat;
mat4_transpose(&rend_group->mat_draw, &mat);
mat4_mul(&mat, &cam_view, &mat);
mat4_mul(&mat, &cam_projection, &mat);
float_t emission = 1.0f;
if (rend_group->flags & PARTICLE_EMISSION || rend_group->blend_mode == PARTICLE_BLEND_TYPICAL)
emission = rend_group->emission;
glitter_batch_shader_data shader_data = {};
mat4_transpose(&mat, &mat);
shader_data.g_mvp[0] = mat.row0;
shader_data.g_mvp[1] = mat.row1;
shader_data.g_mvp[2] = mat.row2;
shader_data.g_mvp[3] = mat.row3;
shader_data.g_glitter_blend_color = 1.0f;
shader_data.g_state_material_diffuse = 0.0f;
shader_data.g_state_material_emission = { emission, emission, emission, 1.0f };
rctx->glitter_batch_ubo.WriteMemory(shader_data);
GLenum blend_src = GL_SRC_ALPHA;
GLenum blend_dst = GL_ONE_MINUS_SRC_ALPHA;
switch (rend_group->blend_mode) {
case PARTICLE_BLEND_ADD:
blend_src = GL_SRC_ALPHA;
blend_dst = GL_ONE;
break;
case PARTICLE_BLEND_MULTIPLY:
blend_src = GL_ZERO;
blend_dst = GL_SRC_COLOR;
break;
}
gl_state_enable_blend();
gl_state_set_blend_func(blend_src, blend_dst);
gl_state_set_blend_equation(GL_FUNC_ADD);
GLuint texture = rctx->empty_texture_2d;
GLuint mask_texture = rctx->empty_texture_2d;
if (rend_group->type != PARTICLE_LINE && rend_group->texture) {
texture = rend_group->texture;
if (rend_group->mask_texture) {
mask_texture = rend_group->mask_texture;
uniform->arr[U_TEXTURE_COUNT] = 2;
switch (rend_group->mask_blend_mode) {
default:
uniform->arr[U_TEXTURE_BLEND] = 0;
break;
case PARTICLE_BLEND_MULTIPLY:
uniform->arr[U_TEXTURE_BLEND] = 1;
break;
case PARTICLE_BLEND_ADD:
uniform->arr[U_TEXTURE_BLEND] = 2;
break;
}
}
else {
uniform->arr[U_TEXTURE_COUNT] = 1;
uniform->arr[U_TEXTURE_BLEND] = 0;
}
}
else {
uniform->arr[U_TEXTURE_COUNT] = 0;
uniform->arr[U_TEXTURE_BLEND] = 0;
}
gl_state_active_bind_texture_2d(0, texture);
gl_state_active_bind_texture_2d(1, mask_texture);
switch (rend_group->type) {
case PARTICLE_QUAD:
switch (rend_group->fog_type) {
default:
uniform->arr[U_FOG_HEIGHT] = 0;
break;
case Glitter::FOG_DEPTH:
uniform->arr[U_FOG_HEIGHT] = 1;
break;
case Glitter::FOG_HEIGHT:
uniform->arr[U_FOG_HEIGHT] = 2;
break;
}
if (rend_group->blend_mode == PARTICLE_BLEND_PUNCH_THROUGH) {
uniform->arr[U_ALPHA_BLEND] = 1;
gl_state_enable_depth_test();
gl_state_set_depth_mask(GL_TRUE);
}
else {
uniform->arr[U_ALPHA_BLEND] = rend_group->disp_type ? 2 : 0;
gl_state_enable_depth_test();
gl_state_set_depth_mask(GL_FALSE);
}
if (rend_group->draw_type == DIRECTION_BILLBOARD) {
gl_state_enable_cull_face();
gl_state_set_cull_face_mode(GL_BACK);
}
else
gl_state_disable_cull_face();
break;
case PARTICLE_LINE:
uniform->arr[U_FOG_HEIGHT] = 0;
uniform->arr[U_ALPHA_BLEND] = 2;
gl_state_enable_depth_test();
gl_state_set_depth_mask(GL_FALSE);
gl_state_enable_cull_face();
gl_state_set_cull_face_mode(GL_BACK);
break;
case PARTICLE_LOCUS:
uniform->arr[U_FOG_HEIGHT] = 0;
uniform->arr[U_ALPHA_BLEND] = 2;
gl_state_enable_depth_test();
gl_state_set_depth_mask(GL_FALSE);
gl_state_disable_cull_face();
break;
}
shaders_ft.set(SHADER_FT_GLITTER_PT);
rctx->obj_scene_ubo.Bind(0);
rctx->glitter_batch_ubo.Bind(2);
switch (rend_group->type) {
case PARTICLE_QUAD:
gl_state_bind_vertex_array(rend_group->vao);
shaders_ft.enable_primitive_restart();
shaders_ft.draw_elements(GL_TRIANGLE_STRIP, (GLsizei)(5 * rend_group->disp - 1), GL_UNSIGNED_INT, 0);
shaders_ft.disable_primitive_restart();
break;
case PARTICLE_LINE:
gl_state_bind_vertex_array(rend_group->vao);
for (std::pair<GLint, GLsizei>& i : *rend_group->draw_list)
shaders_ft.draw_arrays(GL_LINE_STRIP, i.first, i.second);
break;
case PARTICLE_LOCUS:
gl_state_bind_vertex_array(rend_group->vao);
for (std::pair<GLint, GLsizei>& i : *rend_group->draw_list)
shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, i.first, i.second);
break;
}
}
void RenderScene::CalcDispLine(RenderGroup* rend_group) {
if (!rend_group->elements || rend_group->vbo.IsNull() || rend_group->ctrl < 1)
return;
size_t count = 0;
RenderElement* elem = rend_group->elements;
for (size_t i = rend_group->ctrl; i > 0; i--, elem++) {
if (!elem->alive)
continue;
if (elem->locus_history) {
size_t length = elem->locus_history->sub.vec.size();
if (length > 1)
count += length;
}
}
if (!count || count > rend_group->max_count)
return;
bool has_scale = false;
vec3 scale = 0.0f;
if (rend_group->flags & PARTICLE_EMITTER_LOCAL) {
mat4 mat;
mat4_transpose(&rend_group->mat, &mat);
mat4_get_scale(&mat, &scale);
scale -= 1.0f;
if (!(has_scale |= fabsf(scale.x) > 0.000001f ? true : false))
scale.x = 0.0f;
if (!(has_scale |= fabsf(scale.y) > 0.000001f ? true : false))
scale.y = 0.0f;
if (!(has_scale |= fabsf(scale.z) > 0.000001f ? true : false))
scale.z = 0.0f;
mat4_normalize_rotation(&mat, &mat);
mat4_transpose(&mat, &rend_group->mat_draw);
}
else
rend_group->mat_draw = mat4_identity;
Buffer* buf = (Buffer*)rend_group->vbo.MapMemory();
if (!buf)
return;
elem = rend_group->elements;
size_t disp = 0;
rend_group->draw_list->clear();
for (size_t i = rend_group->ctrl, index = 0; i > 0; elem++) {
if (!elem->alive)
continue;
i--;
LocusHistory* hist = elem->locus_history;
if (elem->color.w < 0.01f || !hist || hist->sub.vec.size() < 2)
continue;
size_t j = 0;
if (has_scale)
for (LocusHistory::Data& hist_data : hist->sub.vec) {
vec3& pos = hist_data.translation;
buf->position = pos + (pos - elem->base_translation) * scale;
buf->uv[0] = 0.0f;
buf->uv[1] = 0.0f;
buf->color = hist_data.color;
j++;
buf++;
}
else
for (LocusHistory::Data& hist_data : hist->sub.vec) {
buf->position = hist_data.translation;
buf->uv[0] = 0.0f;
buf->uv[1] = 0.0f;
buf->color = hist_data.color;
j++;
buf++;
}
if (j > 0) {
disp += j;
rend_group->draw_list->push_back({ (GLint)index, (GLsizei)j });
index += j;
}
}
rend_group->disp = disp;
rend_group->vbo.UnmapMemory();
}
void RenderScene::CalcDispLocus(RenderGroup* rend_group) {
if (!rend_group->elements || rend_group->vbo.IsNull() || rend_group->ctrl < 1)
return;
size_t count = 0;
RenderElement* elem = rend_group->elements;
for (size_t i = rend_group->ctrl; i > 0; i--, elem++) {
if (!elem->alive)
continue;
if (elem->locus_history) {
LocusHistory* hist = elem->locus_history;
size_t length = elem->locus_history->sub.vec.size();
if (length > 1)
count += 2 * length;
}
}
if (!count || count > rend_group->max_count)
return;
mat4 cam_view;
mat4 cam_inv_view;
mat4_transpose(&camera_data->view, &cam_view);
mat4_transpose(&camera_data->inv_view, &cam_inv_view);
vec3 x_vec = { 1.0f, 0.0f, 0.0f };
if (rend_group->flags & PARTICLE_LOCAL) {
mat4 mat;
mat4_transpose(&rend_group->mat, &mat);
mat4_mul(&cam_inv_view, &mat, &mat);
mat4_mul(&cam_view, &mat, &mat);
mat4_mul(&mat, &cam_inv_view, &mat);
mat4_transpose(&mat, &rend_group->mat_draw);
}
else
rend_group->mat_draw = mat4_identity;
bool has_scale = false;
vec3 scale = 0.0f;
mat3 model_mat;
if (rend_group->flags & PARTICLE_EMITTER_LOCAL) {
mat4 mat;
mat4_transpose(&rend_group->mat, &mat);
mat4_get_scale(&mat, &scale);
if (rend_group->flags & PARTICLE_SCALE)
x_vec.x = scale.x;
scale -= 1.0f;
if (!(has_scale |= fabsf(scale.x) > 0.000001f ? true : false))
scale.x = 0.0f;
if (!(has_scale |= fabsf(scale.y) > 0.000001f ? true : false))
scale.y = 0.0f;
if (!(has_scale |= fabsf(scale.z) > 0.000001f ? true : false))
scale.z = 0.0f;
mat4 mat_rot;
mat4_transpose(&rend_group->mat_rot, &mat_rot);
mat4_transform_vector(&mat_rot, &scale, &scale);
mat4_to_mat3(&mat, &model_mat);
mat3_normalize_rotation(&model_mat, &model_mat);
}
else
model_mat = mat3_identity;
mat3 cam_inv_view_mat3;
mat4_to_mat3(&cam_inv_view, &cam_inv_view_mat3);
mat3_invert(&cam_inv_view_mat3, &cam_inv_view_mat3);
mat3_transform_vector(&cam_inv_view_mat3, &x_vec, &x_vec);
Buffer* buf = (Buffer*)rend_group->vbo.MapMemory();
if (!buf)
return;
elem = rend_group->elements;
vec2 split_uv = rend_group->split_uv;
Pivot pivot = rend_group->pivot;
size_t disp = 0;
rend_group->draw_list->clear();
for (size_t i = rend_group->ctrl, index = 0; i > 0; elem++) {
if (!elem->alive)
continue;
i--;
LocusHistory* hist = elem->locus_history;
if (elem->color.w < 0.01f || !hist || hist->sub.vec.size() < 2)
continue;
float_t uv_u = elem->uv.x + elem->uv_scroll.x;
float_t uv_u_2nd = elem->uv.x + elem->uv_scroll.x + split_uv.x;
float_t uv_v_2nd = elem->uv.y + elem->uv_scroll.y + split_uv.y;
float_t uv_v_scale = split_uv.y / (float_t)(hist->sub.vec.size() - 1);
uv_v_2nd = 1.0f - uv_v_2nd;
size_t len = elem->locus_history->sub.vec.size();
size_t j = 0;
if (has_scale)
for (LocusHistory::Data& hist_data : hist->sub.vec) {
vec3 pos = hist_data.translation;
vec3 pos_diff = (pos - elem->base_translation) * scale;
mat3_transform_vector(&model_mat, &pos_diff, &pos_diff);
pos += pos_diff;
float_t v00;
float_t v01;
CalcDispLocusSetPivot(pivot,
hist_data.scale * elem->scale.x * elem->scale_all,
v00, v01);
buf[0].position = pos + x_vec * v00;
buf[0].uv[0].x = uv_u;
buf[0].uv[0].y = uv_v_2nd + (float_t)j * uv_v_scale;
buf[0].uv[1] = buf[0].uv[0];
buf[0].color = hist_data.color;
buf[1].position = pos + x_vec * v01;
buf[1].uv[0].x = uv_u_2nd;
buf[1].uv[0].y = uv_v_2nd + (float_t)j * uv_v_scale;
buf[1].uv[1] = buf[1].uv[0];
buf[1].color = hist_data.color;
j++;
buf += 2;
}
else
for (LocusHistory::Data& hist_data : hist->sub.vec) {
vec3 pos = hist_data.translation;
float_t v00;
float_t v01;
CalcDispLocusSetPivot(pivot,
hist_data.scale * elem->scale.x * elem->scale_all,
v00, v01);
buf[0].position = pos + x_vec * v00;
buf[0].uv[0].x = uv_u;
buf[0].uv[0].y = uv_v_2nd + (float_t)j * uv_v_scale;
buf[0].uv[1] = buf[0].uv[0];
buf[0].color = hist_data.color;
buf[1].position = pos + x_vec * v01;
buf[1].uv[0].x = uv_u_2nd;
buf[1].uv[0].y = uv_v_2nd + (float_t)j * uv_v_scale;
buf[1].uv[1] = buf[1].uv[0];
buf[1].color = hist_data.color;
j++;
buf += 2;
}
if (j > 0) {
disp += j;
rend_group->draw_list->push_back({ (GLint)index, (GLsizei)(j * 2) });
index += j * 2;
}
}
rend_group->disp = disp;
rend_group->vbo.UnmapMemory();
}
void RenderScene::CalcDispQuad(RenderGroup* rend_group) {
if (!rend_group->elements || rend_group->vbo.IsNull() || rend_group->ctrl < 1)
return;
mat4 cam_view;
mat4 cam_inv_view;
mat4_transpose(&camera_data->view, &cam_view);
mat4_transpose(&camera_data->inv_view, &cam_inv_view);
mat4 model_mat;
mat4 view_mat;
mat4 inv_view_mat;
if (rend_group->flags & PARTICLE_EMITTER_LOCAL) {
mat4_transpose(&rend_group->mat, &model_mat);
mat4_normalize_rotation(&model_mat, &view_mat);
mat4_mul(&view_mat, &cam_view, &view_mat);
mat4_invert(&view_mat, &inv_view_mat);
}
else {
model_mat = mat4_identity;
view_mat = cam_view;
inv_view_mat = cam_inv_view;
}
if (rend_group->flags & PARTICLE_LOCAL) {
mat4 mat;
mat4_transpose(&rend_group->mat, &mat);
mat4_mul(&inv_view_mat, &mat, &inv_view_mat);
mat4_mul(&view_mat, &inv_view_mat, &view_mat);
mat4_invert(&view_mat, &inv_view_mat);
}
mat4_mul(&view_mat, &cam_inv_view, &rend_group->mat_draw);
mat4_transpose(&rend_group->mat_draw, &rend_group->mat_draw);
mat4 dir_mat;
switch (rend_group->draw_type) {
case DIRECTION_BILLBOARD:
mat4_clear_trans(&model_mat, &dir_mat);
mat4_mul(&dir_mat, &inv_view_mat, &dir_mat);
mat4_clear_trans(&dir_mat, &dir_mat);
break;
case DIRECTION_EMITTER_DIRECTION:
mat4_transpose(&rend_group->mat_rot, &dir_mat);
mat4_clear_trans(&dir_mat, &dir_mat);
break;
case DIRECTION_PREV_POSITION:
case DIRECTION_EMIT_POSITION:
case DIRECTION_PREV_POSITION_DUP:
if (rend_group->flags & PARTICLE_EMITTER_LOCAL) {
mat4_transpose(&rend_group->mat_rot, &dir_mat);
mat4_clear_trans(&dir_mat, &dir_mat);
}
else
dir_mat = mat4_identity;
break;
case DIRECTION_Y_AXIS:
mat4_rotate_y((float_t)-M_PI_2, &dir_mat);
break;
case DIRECTION_X_AXIS:
mat4_rotate_x((float_t)-M_PI_2, &dir_mat);
break;
case DIRECTION_Z_AXIS:
mat4_rotate_z((float_t)-M_PI_2, &dir_mat);
break;
case DIRECTION_BILLBOARD_Y_AXIS:
mat4_rotate_y(camera_data->rotation.y, &dir_mat);
break;
default:
dir_mat = mat4_identity;
break;
}
switch (rend_group->draw_type) {
case DIRECTION_PREV_POSITION:
case DIRECTION_EMIT_POSITION:
case DIRECTION_PREV_POSITION_DUP:
CalcDispQuadDirectionRotation(rend_group, &model_mat, &dir_mat);
break;
default:
CalcDispQuadNormal(rend_group, &model_mat, &dir_mat);
break;
}
}
void RenderScene::CalcDispQuadDirectionRotation(
RenderGroup* rend_group, mat4* model_mat, mat4* dir_mat) {
mat4 inv_model_mat;
mat4_invert(model_mat, &inv_model_mat);
mat4_clear_trans(&inv_model_mat, &inv_model_mat);
vec3 x_vec_base = { 1.0f, 0.0f, 0.0f };
vec3 y_vec_base = { 0.0f, 1.0f, 0.0f };
mat4_transform_vector(&inv_model_mat, &x_vec_base, &x_vec_base);
mat4_transform_vector(&inv_model_mat, &y_vec_base, &y_vec_base);
vec3 up_vec;
mat4(*rotate_func)(RenderGroup*, RenderElement*, vec3*);
if (rend_group->draw_type == DIRECTION_EMIT_POSITION) {
up_vec = { 0.0f, 0.0f, 1.0f };
rotate_func = RenderGroup::RotateToEmitPosition;
}
else {
up_vec = { 0.0f, 1.0f, 0.0f };
rotate_func = RenderGroup::RotateToPrevPosition;
}
vec3 scale;
mat4_get_scale(model_mat, &scale);
Buffer* buf = (Buffer*)rend_group->vbo.MapMemory();
if (!buf)
return;
bool use_scale = rend_group->flags & PARTICLE_SCALE ? true : false;
RenderElement* elem = rend_group->elements;
vec2 split_uv = rend_group->split_uv;
Pivot pivot = rend_group->pivot;
size_t disp = 0;
for (size_t i = rend_group->ctrl, j_max = 1024; i > 0; i -= j_max) {
j_max = min_def(i, j_max);
for (size_t j = j_max; j > 0; elem++) {
if (!elem->alive)
continue;
j--;
if (elem->color.w < 0.01f)
continue;
vec2 scale_particle = *(vec2*)&elem->scale * elem->scale_particle * elem->scale_all;
if (fabsf(scale_particle.x) < 0.000001f || fabsf(scale_particle.y) < 0.000001f)
continue;
vec3 pos = elem->translation;
float_t v00;
float_t v01;
float_t v10;
float_t v11;
CalcDispQuadSetPivot(pivot,
scale_particle.x, scale_particle.y,
v00, v01, v10, v11);
vec2 pos_add[4];
vec2 uv_add[4];
pos_add[0].x = v00;
pos_add[0].y = v11;
uv_add[0].x = 0.0f;
uv_add[0].y = 0.0f;
pos_add[1].x = v00;
pos_add[1].y = v10;
uv_add[1].x = 0.0f;
uv_add[1].y = split_uv.y;
pos_add[2].x = v01;
pos_add[2].y = v10;
uv_add[2].x = split_uv.x;
uv_add[2].y = split_uv.y;
pos_add[3].x = v01;
pos_add[3].y = v11;
uv_add[3].x = split_uv.x;
uv_add[3].y = 0.0f;
vec2 uv = elem->uv + elem->uv_scroll;
mat4 mat = rotate_func(rend_group, elem, &up_vec);
mat4_clear_trans(&mat, &mat);
mat4_mul(dir_mat, &mat, &mat);
mat4_clear_trans(&mat, &mat);
vec3 x_vec;
mat4_transform_vector(&mat, &x_vec_base, &x_vec);
vec3 y_vec;
mat4_transform_vector(&mat, &y_vec_base, &y_vec);
if (use_scale) {
x_vec *= scale;
y_vec *= scale;
}
float_t rot_z_cos = elem->rot_z_cos;
float_t rot_z_sin = elem->rot_z_sin;
for (int32_t k = 0; k < 4; k++, buf++) {
vec3 x_vec_rot = x_vec * (pos_add[k].x * rot_z_cos - pos_add[k].y * rot_z_sin);
vec3 y_vec_rot = y_vec * (pos_add[k].x * rot_z_sin + pos_add[k].y * rot_z_cos);
buf->position = pos + (x_vec_rot + y_vec_rot);
buf->uv[0] = uv + uv_add[k];
buf->uv[1] = buf->uv[0];
buf->color = elem->color;
}
disp++;
}
}
rend_group->disp = disp;
rend_group->vbo.UnmapMemory();
}
void RenderScene::CalcDispQuadNormal(
RenderGroup* rend_group, mat4* model_mat, mat4* dir_mat) {
mat4 inv_model_mat;
mat4_invert(model_mat, &inv_model_mat);
mat4_clear_trans(&inv_model_mat, &inv_model_mat);
vec3 x_vec = { 1.0f, 0.0f, 0.0f };
vec3 y_vec = { 0.0f, 1.0f, 0.0f };
bool use_z_offset = false;
vec3 dist_to_cam = 0.0f;
mat4 z_offset_inv_mat = mat4_identity;
if (fabsf(rend_group->z_offset) > 0.000001f) {
use_z_offset = true;
mat4_get_translation(model_mat, &dist_to_cam);
dist_to_cam = camera_data->view_point - dist_to_cam;
if (rend_group->flags & PARTICLE_EMITTER_LOCAL) {
mat4_normalize_rotation(model_mat, &z_offset_inv_mat);
mat4_invert(&z_offset_inv_mat, &z_offset_inv_mat);
}
}
bool has_scale = false;
bool emitter_local = false;
vec3 scale = 0.0f;
if (rend_group->flags & PARTICLE_EMITTER_LOCAL) {
mat4_get_scale(model_mat, &scale);
if (rend_group->flags & PARTICLE_SCALE) {
x_vec.x = scale.x;
y_vec.y = scale.y;
}
scale -= 1.0f;
if (!(has_scale |= fabsf(scale.x) > 0.000001f ? true : false))
scale.x = 0.0f;
if (!(has_scale |= fabsf(scale.y) > 0.000001f ? true : false))
scale.y = 0.0f;
if (!(has_scale |= fabsf(scale.z) > 0.000001f ? true : false))
scale.z = 0.0f;
mat4 mat_rot;
mat4_transpose(&rend_group->mat_rot, &mat_rot);
mat4_transform_vector(&mat_rot, &scale, &scale);
emitter_local = true;
}
vec3 ext_anim_scale;
float_t some_scale = 0.0f;
bool (FASTCALL * RenderGroup_GetExtAnimScale)(RenderGroup * rend_group,
vec3 * ext_anim_scale, float_t * some_scale) = (bool(FASTCALL*)(RenderGroup * rend_group,
vec3 * ext_anim_scale, float_t * some_scale))0x00000001403A6800;
if (RenderGroup_GetExtAnimScale(rend_group, &ext_anim_scale, &some_scale)) {
if (some_scale <= 0.0f)
some_scale = 1.0f;
ext_anim_scale += some_scale;
x_vec.x *= ext_anim_scale.x;
y_vec.y *= ext_anim_scale.y;
}
if (rend_group->draw_type != DIRECTION_BILLBOARD) {
mat4_transform_vector(dir_mat, &x_vec, &x_vec);
mat4_transform_vector(dir_mat, &y_vec, &y_vec);
}
else
mat4_mul(&inv_model_mat, dir_mat, &inv_model_mat);
mat4_transform_vector(&inv_model_mat, &x_vec, &x_vec);
mat4_transform_vector(&inv_model_mat, &y_vec, &y_vec);
Buffer* buf = (Buffer*)rend_group->vbo.MapMemory();
if (!buf)
return;
RenderElement* elem = rend_group->elements;
vec2 split_uv = rend_group->split_uv;
Pivot pivot = rend_group->pivot;
float_t z_offset = rend_group->z_offset;
size_t disp = 0;
if (rend_group->draw_type == DIRECTION_PARTICLE_ROTATION)
for (size_t i = rend_group->ctrl, j_max = 1024; i > 0; i -= j_max) {
j_max = min_def(i, j_max);
for (size_t j = j_max; j > 0; elem++) {
if (!elem->alive)
continue;
j--;
if (elem->color.w < 0.01f)
continue;
vec2 scale_particle = *(vec2*)&elem->scale * elem->scale_particle * elem->scale_all;
if (fabsf(scale_particle.x) < 0.000001f || fabsf(scale_particle.y) < 0.000001f)
continue;
vec3 pos = elem->translation;
if (has_scale) {
vec3 pos_diff = (pos - elem->base_translation) * scale;
mat4_transform_vector(&inv_model_mat, &pos_diff, &pos_diff);
pos += pos_diff;
}
float_t v00;
float_t v01;
float_t v11;
float_t v10;
CalcDispQuadSetPivot(pivot,
scale_particle.x, scale_particle.y,
v00, v01, v10, v11);
vec2 pos_add[4];
vec2 uv_add[4];
pos_add[0].x = v00;
pos_add[0].y = v11;
uv_add[0].x = 0.0f;
uv_add[0].y = 0.0f;
pos_add[1].x = v00;
pos_add[1].y = v10;
uv_add[1].x = 0.0f;
uv_add[1].y = split_uv.y;
pos_add[2].x = v01;
pos_add[2].y = v10;
uv_add[2].x = split_uv.x;
uv_add[2].y = split_uv.y;
pos_add[3].x = v01;
pos_add[3].y = v11;
uv_add[3].x = split_uv.x;
uv_add[3].y = 0.0f;
vec2 uv = elem->uv + elem->uv_scroll;
if (use_z_offset) {
vec3 z_offset_dir = vec3::normalize(dist_to_cam - pos);
if (emitter_local)
mat4_transform_vector(&z_offset_inv_mat, &z_offset_dir, &z_offset_dir);
pos += z_offset_dir * z_offset;
}
mat3 ptc_rot;
mat3_rotate_zyx(elem->rotation.x, elem->rotation.y, elem->rotation.z, &ptc_rot);
for (int32_t k = 0; k < 4; k++, buf++) {
vec3 xy_vec_rot;
xy_vec_rot.x = x_vec.x * pos_add[k].x;
xy_vec_rot.y = y_vec.y * pos_add[k].y;
xy_vec_rot.z = 0.0f;
mat3_transform_vector(&ptc_rot, &xy_vec_rot, &xy_vec_rot);
buf->position = pos + xy_vec_rot;
buf->uv[0] = uv + uv_add[k];
buf->uv[1] = buf->uv[0];
buf->color = elem->color;
}
disp++;
}
}
else
for (size_t i = rend_group->ctrl, j_max = 1024; i > 0; i -= j_max) {
j_max = min_def(i, j_max);
for (size_t j = j_max; j > 0; elem++) {
if (!elem->alive)
continue;
j--;
if (elem->color.w < 0.01f)
continue;
vec2 scale_particle = *(vec2*)&elem->scale * elem->scale_particle * elem->scale_all;
if (fabsf(scale_particle.x) < 0.000001f || fabsf(scale_particle.y) < 0.000001f)
continue;
vec3 pos = elem->translation;
if (has_scale) {
vec3 pos_diff = (pos - elem->base_translation) * scale;
mat4_transform_vector(&inv_model_mat, &pos_diff, &pos_diff);
pos += pos_diff;
}
float_t v00;
float_t v01;
float_t v11;
float_t v10;
CalcDispQuadSetPivot(pivot,
scale_particle.x, scale_particle.y,
v00, v01, v10, v11);
vec2 pos_add[4];
vec2 uv_add[4];
pos_add[0].x = v00;
pos_add[0].y = v11;
uv_add[0].x = 0.0f;
uv_add[0].y = 0.0f;
pos_add[1].x = v00;
pos_add[1].y = v10;
uv_add[1].x = 0.0f;
uv_add[1].y = split_uv.y;
pos_add[2].x = v01;
pos_add[2].y = v10;
uv_add[2].x = split_uv.x;
uv_add[2].y = split_uv.y;
pos_add[3].x = v01;
pos_add[3].y = v11;
uv_add[3].x = split_uv.x;
uv_add[3].y = 0.0f;
vec2 uv = elem->uv + elem->uv_scroll;
if (use_z_offset) {
vec3 z_offset_dir = vec3::normalize(dist_to_cam - pos);
if (emitter_local)
mat4_transform_vector(&z_offset_inv_mat, &z_offset_dir, &z_offset_dir);
pos += z_offset_dir * z_offset;
}
float_t rot_z_cos = elem->rot_z_cos;
float_t rot_z_sin = elem->rot_z_sin;
for (int32_t k = 0; k < 4; k++, buf++) {
vec3 x_vec_rot = x_vec * (rot_z_cos * pos_add[k].x - rot_z_sin * pos_add[k].y);
vec3 y_vec_rot = y_vec * (rot_z_sin * pos_add[k].x + rot_z_cos * pos_add[k].y);
buf->position = pos + (x_vec_rot + y_vec_rot);
buf->uv[0] = uv + uv_add[k];
buf->uv[1] = buf->uv[0];
buf->color = elem->color;
}
disp++;
}
}
rend_group->disp = disp;
rend_group->vbo.UnmapMemory();
}
void RenderScene::CalcDispLocusSetPivot(Pivot pivot,
float_t w, float_t& v00, float_t& v01) {
switch (pivot) {
case PIVOT_TOP_LEFT:
case PIVOT_MIDDLE_LEFT:
case PIVOT_BOTTOM_LEFT:
v00 = 0.0f;
v01 = w;
break;
case PIVOT_TOP_CENTER:
case PIVOT_MIDDLE_CENTER:
case PIVOT_BOTTOM_CENTER:
default:
v00 = w * -0.5f;
v01 = w * 0.5f;
break;
case PIVOT_TOP_RIGHT:
case PIVOT_MIDDLE_RIGHT:
case PIVOT_BOTTOM_RIGHT:
v00 = -w;
v01 = 0.0f;
break;
}
}
void RenderScene::CalcDispQuadSetPivot(Pivot pivot,
float_t w, float_t h, float_t& v00, float_t& v01, float_t& v10, float_t& v11) {
switch (pivot) {
case PIVOT_TOP_LEFT:
v00 = 0.0f;
v01 = w;
v10 = -h;
v11 = 0.0f;
break;
case PIVOT_TOP_CENTER:
v00 = w * -0.5f;
v01 = w * 0.5f;
v10 = -h;
v11 = 0.0f;
break;
case PIVOT_TOP_RIGHT:
v00 = -w;
v01 = 0.0f;
v10 = -h;
v11 = 0.0f;
break;
case PIVOT_MIDDLE_LEFT:
v00 = 0.0f;
v01 = w;
v10 = h * -0.5f;
v11 = h * 0.5f;
break;
case PIVOT_MIDDLE_CENTER:
default:
v00 = w * -0.5f;
v01 = w * 0.5f;
v10 = h * -0.5f;
v11 = h * 0.5f;
break;
case PIVOT_MIDDLE_RIGHT:
v00 = -w;
v01 = 0.0f;
v10 = h * -0.5f;
v11 = h * 0.5f;
break;
case PIVOT_BOTTOM_LEFT:
v00 = 0.0f;
v01 = w;
v10 = 0.0f;
v11 = h;
break;
case PIVOT_BOTTOM_CENTER:
v00 = w * -0.5f;
v01 = w * 0.5f;
v10 = 0.0f;
v11 = h;
break;
case PIVOT_BOTTOM_RIGHT:
v00 = -w;
v01 = 0.0f;
v10 = 0.0f;
v11 = h;
break;
}
}
}
Reference in New Issue View Git Blame Copy Permalink