float rayIntersectDisk(ShadeRec* sr, Disk* disk, const Ray ray)
{
vec3 displacement;
vec3_sub(displacement, disk->center, ray.origin);
float t = vec3_dot(displacement, disk->normal) / vec3_dot(ray.direction, disk->normal);
if(t > K_EPSILON)
{
vec3 hit_point;
getPointOnRay(hit_point, ray, t);
vec3_sub(displacement, hit_point, disk->center);
if(vec3_length(displacement) <= disk->radius)
{
vec3_negate(sr->wo, ray.direction);
if(vec3_dot(sr->wo, disk->normal) < 0)
{
vec3_negate(sr->wo, disk->normal);
}else
{
vec3_copy(sr->normal, disk->normal);
}
vec3_copy(sr->hit_point, hit_point);
sr->mat = *(disk->mat);
return t;
}
}
return TMAX;
}
void calc_torque(struct vec3 *dst, const struct vec3 *v1,
const struct vec3 *v2, float torque, float min_adjust,
float t)
{
struct vec3 line, dir;
float orig_dist, torque_dist, adjust_dist;
if (vec3_close(v1, v2, EPSILON)) {
vec3_copy(dst, v1);
return;
}
vec3_sub(&line, v2, v1);
orig_dist = vec3_len(&line);
vec3_mulf(&dir, &line, 1.0f/orig_dist);
torque_dist = orig_dist*torque; /* use distance to determine speed */
if (torque_dist < min_adjust) /* prevent from going too slow */
torque_dist = min_adjust;
adjust_dist = torque_dist*t;
if (adjust_dist <= (orig_dist-LARGE_EPSILON)) {
vec3_mulf(dst, &dir, adjust_dist);
vec3_add(dst, dst, v1); /* add torque */
} else {
vec3_copy(dst, v2); /* clamp if overshoot */
}
}
static bool AddItemBounds(obs_scene_t scene, obs_sceneitem_t item,
void *param)
{
SelectedItemBounds *data = reinterpret_cast<SelectedItemBounds*>(param);
if (!obs_sceneitem_selected(item))
return true;
matrix4 boxTransform;
obs_sceneitem_get_box_transform(item, &boxTransform);
vec3 t[4] = {
GetTransformedPos(0.0f, 0.0f, boxTransform),
GetTransformedPos(1.0f, 0.0f, boxTransform),
GetTransformedPos(0.0f, 1.0f, boxTransform),
GetTransformedPos(1.0f, 1.0f, boxTransform)
};
for (const vec3 &v : t) {
if (data->first) {
vec3_copy(&data->tl, &v);
vec3_copy(&data->br, &v);
data->first = false;
} else {
vec3_min(&data->tl, &data->tl, &v);
vec3_max(&data->br, &data->br, &v);
}
}
UNUSED_PARAMETER(scene);
return true;
}
void OBSBasicPreview::SnapStretchingToScreen(vec3 &tl, vec3 &br)
{
uint32_t stretchFlags = (uint32_t)stretchHandle;
vec3 newTL = GetTransformedPos(tl.x, tl.y, itemToScreen);
vec3 newTR = GetTransformedPos(br.x, tl.y, itemToScreen);
vec3 newBL = GetTransformedPos(tl.x, br.y, itemToScreen);
vec3 newBR = GetTransformedPos(br.x, br.y, itemToScreen);
vec3 boundingTL;
vec3 boundingBR;
vec3_copy(&boundingTL, &newTL);
vec3_min(&boundingTL, &boundingTL, &newTR);
vec3_min(&boundingTL, &boundingTL, &newBL);
vec3_min(&boundingTL, &boundingTL, &newBR);
vec3_copy(&boundingBR, &newTL);
vec3_max(&boundingBR, &boundingBR, &newTR);
vec3_max(&boundingBR, &boundingBR, &newBL);
vec3_max(&boundingBR, &boundingBR, &newBR);
vec3 offset = GetScreenSnapOffset(boundingTL, boundingBR);
vec3_add(&offset, &offset, &newTL);
vec3_transform(&offset, &offset, &screenToItem);
vec3_sub(&offset, &offset, &tl);
if (stretchFlags & ITEM_LEFT)
tl.x += offset.x;
else if (stretchFlags & ITEM_RIGHT)
br.x += offset.x;
if (stretchFlags & ITEM_TOP)
tl.y += offset.y;
else if (stretchFlags & ITEM_BOTTOM)
br.y += offset.y;
}
t_material *create_material(const char *name, const t_vec3 *ambient, const t_vec3 *diffuse, const t_vec3 *specular)
{
t_material *material;
material = (t_material*)calloc(1, sizeof(t_material));
material->name = ft_strdup(name);
vec3_copy(&material->ambient, ambient);
vec3_copy(&material->diffuse, diffuse);
vec3_copy(&material->specular, specular);
return (material);
}
static void set_ray_direction(t_ray *ray, const t_camera *camera, float increment_x, float increment_y)
{
t_vec3 dest;
vec3_copy(&dest, &camera->viewplane.upleft);
dest.x += increment_x;
dest.y -= increment_y;
vec3_copy(&ray->direction, &dest);
vec3_sub(&ray->direction, &ray->origin);
vec3_normalize(&ray->direction);
}
/*
Create a new buffer object from an array of vec3s for pts, and vec3s for texture coordinates.
Faces is an array of 3 shorts for each face.
*/
BUFFER_T *buffer_new(float pts[][3], float tex[][3], short faces[][3], int numpts, int numfaces)
{
int i;
float normals[numpts][3];
BUFFER_T *buf;
NEW(buf);
for(i=0; i<numpts; i++)
{
normals[i][0]=0;
normals[i][1]=0;
normals[i][2]=1;
}
for(i=0; i<numfaces; i++)
{
int a = faces[i][0];
int b = faces[i][1];
int c = faces[i][2];
float tmp[3];
float tmp2[3];
float n[3];
vec3_sub(tmp,pts[b],pts[a]);
vec3_sub(tmp2,pts[c],pts[a]);
vec3_cross(n,tmp,tmp2);
vec3_normal(n,n);
vec3_copy(normals[a],n);
vec3_copy(normals[b],n);
vec3_copy(normals[c],n);
}
float B[3*3*numpts];
for(i=0; i<numpts; i++)
{
for(int j=0; j<3; j++)
{
B[i*3*3+j]=pts[i][j];
B[i*3*3+3+j]=tex[i][j];
B[i*3*3+6+j]=normals[i][j];
}
}
buf->ntris=numfaces;
glGenBuffers(1,&buf->vbuf);
glBindBuffer(GL_ARRAY_BUFFER, buf->vbuf);
glBufferData(GL_ARRAY_BUFFER, 36*numpts, B, GL_STATIC_DRAW);
buf->vbuf_num = numpts;
glGenBuffers(1,&buf->ebuf);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf->ebuf);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6*numfaces, faces, GL_STATIC_DRAW);
buf->ebuf_num = numfaces*3;
return buf;
}
void mat3_to_eul(const float m[3][3], int order, float e[3])
{
float e1[3], e2[3];
mat3_to_eul2(m, order, e1, e2);
// Pick best.
if ( fabs(e1[0]) + fabs(e1[1]) + fabs(e1[2]) >
fabs(e2[0]) + fabs(e2[1]) + fabs(e2[2])) {
vec3_copy(e2, e);
} else {
vec3_copy(e1, e);
}
}
void BoneFrame_Copy(bone_frame_p dst, const bone_frame_p src)
{
if(dst->bone_tag_count < src->bone_tag_count)
{
dst->bone_tags = (bone_tag_p)realloc(dst->bone_tags, src->bone_tag_count * sizeof(bone_tag_t));
}
dst->bone_tag_count = src->bone_tag_count;
vec3_copy(dst->pos, src->pos);
vec3_copy(dst->centre, src->centre);
vec3_copy(dst->bb_max, src->bb_max);
vec3_copy(dst->bb_min, src->bb_min);
memcpy(dst->bone_tags, src->bone_tags, src->bone_tag_count * sizeof(struct bone_tag_s));
}
void Sector_LowestCeilingCorner(room_sector_p rs, float v[3])
{
float *r1 = (rs->ceiling_corners[0][2] > rs->ceiling_corners[1][2])?(rs->ceiling_corners[0]):(rs->ceiling_corners[1]);
float *r2 = (rs->ceiling_corners[2][2] > rs->ceiling_corners[3][2])?(rs->ceiling_corners[2]):(rs->ceiling_corners[3]);
if(r1[2] < r2[2])
{
vec3_copy(v, r1);
}
else
{
vec3_copy(v, r2);
}
}
void Sector_HighestFloorCorner(room_sector_p rs, float v[3])
{
float *r1 = (rs->floor_corners[0][2] > rs->floor_corners[1][2])?(rs->floor_corners[0]):(rs->floor_corners[1]);
float *r2 = (rs->floor_corners[2][2] > rs->floor_corners[3][2])?(rs->floor_corners[2]):(rs->floor_corners[3]);
if(r1[2] > r2[2])
{
vec3_copy(v, r1);
}
else
{
vec3_copy(v, r2);
}
}
void SSBoneFrame_FillSkinnedMeshMap(ss_bone_frame_p bf)
{
uint32_t *ch;
uint32_t founded_index = 0xFFFFFFFF;
float tv[3];
vertex_p v, founded_vertex;
base_mesh_p mesh_base, mesh_skin;
ss_bone_tag_p tree_tag = bf->bone_tags;
for(uint16_t i = 0; i < bf->bone_tag_count; i++, tree_tag++)
{
if(!tree_tag->mesh_skin)
{
continue;
}
if(tree_tag->skin_map)
{
free(tree_tag->skin_map);
tree_tag->skin_map = NULL;
}
mesh_base = tree_tag->mesh_base;
mesh_skin = tree_tag->mesh_skin;
ch = tree_tag->skin_map = (uint32_t*)malloc(mesh_skin->vertex_count * sizeof(uint32_t));
v = mesh_skin->vertices;
for(uint32_t k = 0; k < mesh_skin->vertex_count; k++, v++, ch++)
{
*ch = 0xFFFFFFFF;
founded_index = BaseMesh_FindVertexIndex(mesh_base, v->position);
if(founded_index != 0xFFFFFFFF)
{
founded_vertex = mesh_base->vertices + founded_index;
vec3_copy(v->position, founded_vertex->position);
vec3_copy(v->normal, founded_vertex->normal);
}
else if(tree_tag->parent)
{
vec3_add(tv, v->position, tree_tag->offset);
founded_index = BaseMesh_FindVertexIndex(tree_tag->parent->mesh_base, tv);
if(founded_index != 0xFFFFFFFF)
{
founded_vertex = tree_tag->parent->mesh_base->vertices + founded_index;
*ch = founded_index;
vec3_sub(v->position, founded_vertex->position, tree_tag->offset);
vec3_copy(v->normal, founded_vertex->normal);
}
}
}
}
}
void mat3_to_eul2(const float m[3][3], int order, float e1[3], float e2[3])
{
const int *r = EUL_ORDERS[order];
int i = r[0], j = r[1], k = r[2];
int parity = r[3];
float cy = hypot(m[i][i], m[i][j]);
float n[3][3];
mat3_normalize_(m, n);
if (cy > 16.0f * FLT_EPSILON) {
e1[i] = atan2(m[j][k], m[k][k]);
e1[j] = atan2(-m[i][k], cy);
e1[k] = atan2(m[i][j], m[i][i]);
e2[i] = atan2(-m[j][k], -m[k][k]);
e2[j] = atan2(-m[i][k], -cy);
e2[k] = atan2(-m[i][j], -m[i][i]);
} else {
e1[i] = atan2(-m[k][j], m[j][j]);
e1[j] = atan2(-m[i][k], cy);
e1[k] = 0.0;
vec3_copy(e1, e2);
}
if (parity) {
vec3_imul(e1, -1);
vec3_imul(e2, -1);
}
}
bullet* bullet_create(vec3 position, vec3 direction, bulletType *specs) {
bullet* ret = (bullet*)malloc(sizeof(bullet));
ret->specs = specs;
ret->distanceTraveled = 0;
vec3_copy(ret->direction, direction);
vec3_copy(ret->position, position);
ret->frameDistance = ret->specs->speed * sqrt(ret->direction[0]*ret->direction[0] + ret->direction[1]*ret->direction[1] + ret->direction[2]*ret->direction[2]);
ret->model = (mesh*)malloc(sizeof(mesh));
memcpy(ret->model, ret->specs->model, sizeof(mesh));
mesh_translate(ret->model, position[0], position[1], position[2]);
return ret;
}
int raycast_to_sphere(t_hit *hit, const t_ray *ray, const t_sphere *sphere)
{
t_vec3 distance_to_center;
float tca;
float d2;
float thc;
vec3_copy(&distance_to_center, &sphere->position);
vec3_sub(&distance_to_center, &ray->origin);
tca = vec3_dot(&distance_to_center, &ray->direction);
if (tca < 0)
return (0);
d2 = vec3_dot(&distance_to_center, &distance_to_center) - tca * tca;
if (d2 > sphere->radius * sphere->radius)
return (0);
thc = sqrt(sphere->radius * sphere->radius - d2);
hit->distance = select_closest_hit(tca - thc, tca + thc);
update_hit_from_ray(hit, ray, &sphere->material->ambient);
return (1);
}
void SSBoneFrame_CreateFromModel(ss_bone_frame_p bf, skeletal_model_p model)
{
vec3_set_zero(bf->bb_min);
vec3_set_zero(bf->bb_max);
vec3_set_zero(bf->centre);
vec3_set_zero(bf->pos);
bf->animations.type = ANIM_TYPE_BASE;
bf->animations.anim_frame_flags = 0x0000;
bf->animations.anim_ext_flags = 0x0000;
bf->animations.frame_time = 0.0;
bf->animations.period = 1.0 / 30.0;
bf->animations.next_state = 0;
bf->animations.lerp = 0.0;
bf->animations.current_animation = 0;
bf->animations.current_frame = 0;
bf->animations.next_animation = 0;
bf->animations.next_frame = 0;
vec3_set_zero(bf->animations.target);
bf->animations.bone_direction[0] = 0.0f;
bf->animations.bone_direction[1] = 1.0f;
bf->animations.bone_direction[2] = 0.0f;
bf->animations.targeting_limit[0] = 0.0f;
bf->animations.targeting_limit[1] = 1.0f;
bf->animations.targeting_limit[2] = 0.0f;
bf->animations.targeting_limit[3] =-1.0f;
vec3_set_one(bf->animations.targeting_axis_mod);
bf->animations.targeting_bone = 0x00;
bf->animations.targeting_flags = 0x0000;
vec4_set_zero_angle(bf->animations.current_mod);
bf->animations.next = NULL;
bf->animations.onFrame = NULL;
bf->animations.onEndFrame = NULL;
bf->transform = NULL;
bf->animations.model = model;
bf->bone_tag_count = model->mesh_count;
bf->bone_tags = (ss_bone_tag_p)malloc(bf->bone_tag_count * sizeof(ss_bone_tag_t));
bf->bone_tags[0].parent = NULL; // root
for(uint16_t i = 0; i < bf->bone_tag_count; i++)
{
bf->bone_tags[i].index = i;
bf->bone_tags[i].mesh_base = model->mesh_tree[i].mesh_base;
bf->bone_tags[i].mesh_skin = model->mesh_tree[i].mesh_skin;
bf->bone_tags[i].mesh_slot = NULL;
bf->bone_tags[i].alt_anim = NULL;
bf->bone_tags[i].body_part = model->mesh_tree[i].body_part;
vec3_copy(bf->bone_tags[i].offset, model->mesh_tree[i].offset);
vec4_set_zero(bf->bone_tags[i].qrotate);
Mat4_E_macro(bf->bone_tags[i].transform);
Mat4_E_macro(bf->bone_tags[i].full_transform);
if(i > 0)
{
bf->bone_tags[i].parent = bf->bone_tags + model->mesh_tree[i].parent;
}
}
}
/* find the two endpoints of a line segment that are inside a given sphere
http://stackoverflow.com/a/17499940 */
int sphere_line_segment_intersection(const union vec3 *v0, const union vec3 *v1, const union vec3 *center, double r, union vec3 *vo0, union vec3 *vo1)
{
double cx = center->v.x;
double cy = center->v.y;
double cz = center->v.z;
double px = v0->v.x;
double py = v0->v.y;
double pz = v0->v.z;
double vx = v1->v.x - px;
double vy = v1->v.y - py;
double vz = v1->v.z - pz;
double A = vx * vx + vy * vy + vz * vz;
double B = 2.0 * (px * vx + py * vy + pz * vz - vx * cx - vy * cy - vz * cz);
double C = px * px - 2 * px * cx + cx * cx + py * py - 2 * py * cy + cy * cy +
pz * pz - 2 * pz * cz + cz * cz - r * r;
double D = B * B - 4.0 * A * C;
/* outside or tanget to sphere, no segment intersection */
if (D <= 0)
return -1;
double t1 = (-B - sqrt(D)) / (2.0 * A);
double t2 = (-B + sqrt(D)) / (2.0 * A);
/* infinte line intersects but this segment doesn't */
if ((t1 < 0 && t2 < 0) || (t1 > 1 && t2 > 1))
return -1;
if (t1 < 0)
vec3_copy(vo0, v0);
else if (t1 > 1)
vec3_copy(vo1, v1);
else
vec3_init(vo0, v0->v.x * (1.0 - t1) + t1 * v1->v.x, v0->v.y * (1.0 - t1) + t1 * v1->v.y, v0->v.z * (1.0 - t1) + t1 * v1->v.z);
if (t2 < 0)
vec3_copy(vo0, v0);
else if (t2 > 1)
vec3_copy(vo1, v1);
else
vec3_init(vo1, v0->v.x * (1.0 - t2) + t2 * v1->v.x, v0->v.y * (1.0 - t2) + t2 * v1->v.y, v0->v.z * (1.0 - t2) + t2 * v1->v.z);
return 2;
}
static void raycast_light(t_hit *hit, unsigned depth)
{
t_lstiter it;
t_ray ray;
t_light *light;
int raycast_result;
t_vec3 lightness;
t_hit sub_hit;
if (depth == 0)
return ;
vec3_set(&lightness, 0, 0, 0);
init_iter(&it, rt.scene->lights, increasing);
while (lst_iterator_next(&it))
{
light = (t_light*)it.data;
vec3_copy(&ray.origin, &hit->position);
vec3_copy(&ray.direction, &light->position);
vec3_sub(&ray.direction, &hit->position);
vec3_normalize(&ray.direction);
ray.origin.x += ray.direction.x * RC_SHADOW_SHIFT;
ray.origin.y += ray.direction.y * RC_SHADOW_SHIFT;
ray.origin.z += ray.direction.z * RC_SHADOW_SHIFT;
raycast_result = raycast(&ray, &sub_hit, depth - 1, NULL);
if (sub_hit.object != NULL)
{
// ray bounce
}
else
{
vec3_add(&lightness, &light->color);
}
}
vec3_div(&lightness, rt.scene->lights->size);
vec3_add(&lightness, &rt.scene->ambient_light);
color_clamp(&lightness);
hit->color.x *= lightness.x;
hit->color.y *= lightness.y;
hit->color.z *= lightness.z;
}
void SkeletalModel_FillSkinnedMeshMap(skeletal_model_p model)
{
uint32_t *ch;
uint32_t founded_index = 0xFFFFFFFF;
float tv[3];
vertex_p v, founded_vertex;
base_mesh_p mesh_base, mesh_skin;
mesh_tree_tag_p tree_tag, prev_tree_tag;
tree_tag = model->mesh_tree;
for(uint16_t i = 0; i < model->mesh_count; i++, tree_tag++)
{
if(!tree_tag->mesh_skin)
{
continue;
}
mesh_base = tree_tag->mesh_base;
mesh_skin = tree_tag->mesh_skin;
ch = mesh_skin->skin_map = (uint32_t*)malloc(mesh_skin->vertex_count * sizeof(uint32_t));
v = mesh_skin->vertices;
for(uint32_t k = 0; k < mesh_skin->vertex_count; k++, v++, ch++)
{
*ch = 0xFFFFFFFF;
founded_index = BaseMesh_FindVertexIndex(mesh_base, v->position);
if(founded_index != 0xFFFFFFFF)
{
founded_vertex = mesh_base->vertices + founded_index;
vec3_copy(v->position, founded_vertex->position);
vec3_copy(v->normal, founded_vertex->normal);
}
else
{
vec3_add(tv, v->position, tree_tag->offset);
prev_tree_tag = model->mesh_tree + tree_tag->parent;
founded_index = BaseMesh_FindVertexIndex(prev_tree_tag->mesh_base, tv);
if(founded_index != 0xFFFFFFFF)
{
founded_vertex = prev_tree_tag->mesh_base->vertices + founded_index;
*ch = founded_index;
vec3_sub(v->position, founded_vertex->position, tree_tag->offset);
vec3_copy(v->normal, founded_vertex->normal);
}
}
}
}
}
void BoneFrame_Copy(bone_frame_p dst, bone_frame_p src)
{
if(dst->bone_tag_count < src->bone_tag_count)
{
dst->bone_tags = (bone_tag_p)realloc(dst->bone_tags, src->bone_tag_count * sizeof(bone_tag_t));
}
dst->bone_tag_count = src->bone_tag_count;
vec3_copy(dst->pos, src->pos);
vec3_copy(dst->centre, src->centre);
vec3_copy(dst->bb_max, src->bb_max);
vec3_copy(dst->bb_min, src->bb_min);
for(uint16_t i = 0; i < dst->bone_tag_count; i++)
{
vec4_copy(dst->bone_tags[i].qrotate, src->bone_tags[i].qrotate);
vec3_copy(dst->bone_tags[i].offset, src->bone_tags[i].offset);
}
}
void Polygon_TransformSelf(polygon_p p, float tr[16])
{
float v[3];
vertex_p vp;
Mat4_vec3_rot_macro(v, tr, p->plane);
vec3_copy(p->plane, v);
vp = p->vertices;
for(uint16_t i = 0; i < p->vertex_count; i++, vp++)
{
Mat4_vec3_mul_macro(v, tr, vp->position);
vec3_copy(vp->position, v);
Mat4_vec3_rot_macro(v, tr, vp->normal);
vec3_copy(vp->normal, v);
}
p->plane[3] = -vec3_dot(p->plane, p->vertices[0].position);
}
void SSBoneFrame_CreateFromModel(ss_bone_frame_p bf, skeletal_model_p model)
{
vec3_set_zero(bf->bb_min);
vec3_set_zero(bf->bb_max);
vec3_set_zero(bf->centre);
vec3_set_zero(bf->pos);
bf->transform = NULL;
bf->flags = 0x0000;
bf->bone_tag_count = 0;
bf->bone_tags = NULL;
SSBoneFrame_InitSSAnim(&bf->animations, model, ANIM_TYPE_BASE);
bf->animations.model = model;
if(model)
{
bf->bone_tag_count = model->mesh_count;
bf->bone_tags = (ss_bone_tag_p)malloc(bf->bone_tag_count * sizeof(ss_bone_tag_t));
bf->bone_tags[0].parent = NULL; // root
for(uint16_t i = 0; i < bf->bone_tag_count; i++)
{
ss_bone_tag_p b_tag = bf->bone_tags + i;
b_tag->index = i;
b_tag->is_hidden = 0x00;
b_tag->is_targeted = 0x00;
b_tag->is_axis_modded = 0x00;
b_tag->mesh_base = model->mesh_tree[i].mesh_base;
b_tag->mesh_replace = NULL;
b_tag->mesh_skin = NULL;
b_tag->mesh_slot = NULL;
b_tag->skin_map = NULL;
b_tag->alt_anim = NULL;
b_tag->body_part = model->mesh_tree[i].body_part;
vec3_copy(b_tag->offset, model->mesh_tree[i].offset);
vec4_set_zero(b_tag->qrotate);
Mat4_E_macro(b_tag->local_transform);
Mat4_E_macro(b_tag->current_transform);
vec3_set_zero(b_tag->mod.target_pos);
vec4_set_zero_angle(b_tag->mod.current_q);
b_tag->mod.bone_local_direction[0] = 0.0f;
b_tag->mod.bone_local_direction[1] = 1.0f;
b_tag->mod.bone_local_direction[2] = 0.0f;
b_tag->mod.limit[0] = 0.0f;
b_tag->mod.limit[1] = 1.0f;
b_tag->mod.limit[2] = 0.0f;
b_tag->mod.limit[3] =-1.0f;
b_tag->mod.current_slerp = 1.0f;
vec3_set_one(b_tag->mod.axis_mod);
if(i > 0)
{
b_tag->parent = bf->bone_tags + model->mesh_tree[i].parent;
}
}
}
}
void SSBoneFrame_TargetBoneToSlerp(struct ss_bone_frame_s *bf, struct ss_animation_s *ss_anim)
{
extern float engine_frame_time;
if(ss_anim->anim_ext_flags & ANIM_EXT_TARGET_TO)
{
ss_bone_tag_p b_tag = bf->bone_tags + ss_anim->targeting_bone;
float clamped_q[4], q[4], target_dir[3], target_local[3], bone_dir[3];
Mat4_vec3_mul_inv(target_local, bf->transform, ss_anim->target);
if(b_tag->parent)
{
Mat4_vec3_mul_inv(target_local, b_tag->parent->full_transform, target_local);
}
vec3_sub(target_dir, target_local, b_tag->transform + 12);
if(ss_anim->targeting_flags & ANIM_TARGET_OWERRIDE_ANIM)
{
Mat4_vec3_rot_macro(bone_dir, b_tag->transform, ss_anim->bone_direction);
}
else
{
vec3_copy(bone_dir, ss_anim->bone_direction);
}
vec4_GetQuaternionRotation(q, bone_dir, target_dir);
if(ss_anim->targeting_flags & ANIM_TARGET_USE_AXIS_MOD)
{
q[0] *= ss_anim->targeting_axis_mod[0];
q[1] *= ss_anim->targeting_axis_mod[1];
q[2] *= ss_anim->targeting_axis_mod[2];
q[3] = 1.0f - vec3_sqabs(q);
q[3] = sqrtf(q[3]);
}
if(q[3] < ss_anim->targeting_limit[3])
{
vec4_clampw(q, ss_anim->targeting_limit[3]);
}
vec4_slerp_to(clamped_q, ss_anim->current_mod, q, engine_frame_time * M_PI / 1.3f);
vec4_copy(ss_anim->current_mod, clamped_q);
SSBoneFrame_RotateBone(bf, ss_anim->current_mod, ss_anim->targeting_bone);
}
else if(ss_anim->current_mod[3] < 1.0f)
{
if(ss_anim->current_mod[3] < 0.99f)
{
float zero_ang[4] = {0.0f, 0.0f, 0.0f, 1.0f};
float clamped_q[4];
vec4_slerp_to(clamped_q, ss_anim->current_mod, zero_ang, engine_frame_time * M_PI / 1.3f);
vec4_copy(ss_anim->current_mod, clamped_q);
SSBoneFrame_RotateBone(bf, ss_anim->current_mod, ss_anim->targeting_bone);
}
else
{
vec4_set_zero_angle(ss_anim->current_mod);
}
}
}
void SSBoneFrame_Update(struct ss_bone_frame_s *bf, float time)
{
float t = 1.0f - bf->animations.lerp;
ss_bone_tag_p btag = bf->bone_tags;
bone_tag_p src_btag, next_btag;
bone_frame_p prev_bf = &bf->animations.prev_bf;
bone_frame_p curr_bf = &bf->animations.current_bf;
vec3_interpolate_macro(bf->bb_max, prev_bf->bb_max, curr_bf->bb_max, bf->animations.lerp, t);
vec3_interpolate_macro(bf->bb_min, prev_bf->bb_min, curr_bf->bb_min, bf->animations.lerp, t);
vec3_interpolate_macro(bf->centre, prev_bf->centre, curr_bf->centre, bf->animations.lerp, t);
vec3_interpolate_macro(bf->pos, prev_bf->pos, curr_bf->pos, bf->animations.lerp, t);
next_btag = curr_bf->bone_tags;
src_btag = prev_bf->bone_tags;
for(uint16_t k = 0; k < prev_bf->bone_tag_count; k++, btag++, src_btag++, next_btag++)
{
vec3_interpolate_macro(btag->offset, src_btag->offset, next_btag->offset, bf->animations.lerp, t);
vec3_copy(btag->local_transform + 12, btag->offset);
btag->local_transform[15] = 1.0f;
if(k == 0)
{
vec3_add(btag->local_transform + 12, btag->local_transform + 12, bf->pos);
vec4_slerp(btag->qrotate, src_btag->qrotate, next_btag->qrotate, bf->animations.lerp);
}
else
{
bone_tag_p ov_src_btag = src_btag;
bone_tag_p ov_next_btag = next_btag;
float ov_lerp = bf->animations.lerp;
if(btag->alt_anim && btag->alt_anim->model && btag->alt_anim->enabled && (btag->alt_anim->model->mesh_tree[k].replace_anim != 0))
{
bone_frame_p ov_curr_bf = &btag->alt_anim->prev_bf;
bone_frame_p ov_next_bf = &btag->alt_anim->current_bf;
ov_lerp = btag->alt_anim->lerp;
ov_src_btag = ov_curr_bf->bone_tags + k;
ov_next_btag = ov_next_bf->bone_tags + k;
}
vec4_slerp(btag->qrotate, ov_src_btag->qrotate, ov_next_btag->qrotate, ov_lerp);
}
Mat4_set_qrotation(btag->local_transform, btag->qrotate);
}
/*
* build absolute coordinate matrix system
*/
btag = bf->bone_tags;
Mat4_Copy(btag->current_transform, btag->local_transform);
btag++;
for(uint16_t k = 1; k < prev_bf->bone_tag_count; k++, btag++)
{
Mat4_Mat4_mul(btag->current_transform, btag->parent->current_transform, btag->local_transform);
SSBoneFrame_TargetBoneToSlerp(bf, btag, time);
}
}
void leapfrog_start(sim_state_t* s, double dt)
{
int n = s->n;
for (int i = 0; i < n; ++i) {
particle_t* p = s->part + i;
vec3_copy(p->vh, p->v);
vec3_saxpy(p->vh, dt/2, p->a);
vec3_saxpy(p->v, dt, p->a);
vec3_saxpy(p->x, dt, p->vh);
}
reflect_bc(s);
}
t_vec3 vec3_normalize(t_cvec3 rhs)
{
float norme;
t_vec3 ret;
ret = vec3_copy(rhs);
norme = vec3_norme(rhs);
(*ret)[0] /= norme;
(*ret)[1] /= norme;
(*ret)[2] /= norme;
return (ret);
}
void polar_to_cart(struct vec3 *dst, const struct vec3 *v)
{
struct vec3 cart;
float sinx = cosf(v->x);
float sinx_z = v->z * sinx;
cart.x = sinx_z * sinf(v->y);
cart.z = sinx_z * cosf(v->y);
cart.y = v->z * sinf(v->x);
vec3_copy(dst, &cart);
}
void Controls_PrimaryMouseDown(float from[3], float to[3])
{
float test_to[3];
collision_result_t cb;
vec3_add_mul(test_to, engine_camera.gl_transform + 12, engine_camera.gl_transform + 8, 32768.0f);
if(Physics_RayTestFiltered(&cb, engine_camera.gl_transform + 12, test_to, NULL))
{
vec3_copy(from, cb.point);
vec3_add_mul(to, cb.point, cb.normale, 256.0);
}
}
void SSBoneFrame_SetTargetingAxisMod(struct ss_bone_tag_s *b_tag, const float mod[3])
{
if(mod)
{
vec3_copy(b_tag->mod.axis_mod, mod);
b_tag->is_axis_modded = 0x01;
}
else
{
vec3_set_one(b_tag->mod.axis_mod);
b_tag->is_axis_modded = 0x00;
}
}
void SSBoneFrame_SetTargetingAxisMod(struct ss_animation_s *ss_anim, const float mod[3])
{
if(mod)
{
vec3_copy(ss_anim->targeting_axis_mod, mod);
ss_anim->targeting_flags |= ANIM_TARGET_USE_AXIS_MOD;
}
else
{
vec3_set_one(ss_anim->targeting_axis_mod);
ss_anim->targeting_flags &= ~ANIM_TARGET_USE_AXIS_MOD;
}
}
