//----------------------------------------------------------------------------------------------------------
void OneObjBones::CalcInfluence(BoneAfectCoord* coord) {
Ufloat dist,inf;
Ufloat pos[3];
OneObjBones* tmpB;
ObjMatrix.GetPos(pos);
dist = vec3_dist(coord->coord->origine, pos);
if (dist <= RayonInfluenceMin) { // on est dans la sphere d'influence du bone
if (dist <= RayonInfluenceMax) // influence totale du bone
coord->TotInfluence += inf = 1.0f;
else
coord->TotInfluence += inf = (RayonInfluenceMin - dist) / (RayonInfluenceMin - RayonInfluenceMax);
coord->AddBone(this, inf);
nbcoord ++;
}
//----------- detremine l'influence des fils
tmpB = enfant;
while (tmpB) {
tmpB->CalcInfluence(coord);
tmpB = tmpB->suiv;
}
}
int sound_play_at_looped(sound* s, vec3 pos, vec3 cam_pos, vec3 cam_dir, int loops) {
int c = sound_play_looped(s, loops);
const float HEARING = 5;
float distance = vec3_dist(pos, cam_pos);
Uint8 dist_val = (Uint8)clamp(distance * HEARING, 0, 255);
const float DEGREES = 57.2957795;
vec3 to_position = vec3_normalize(vec3_sub(pos, cam_pos));
vec3 to_forward = vec3_normalize(cam_dir);
float angle = acos(vec3_dot(to_position, to_forward));
Sint16 angle_val = DEGREES * angle;
Mix_SetPosition(c, angle_val, dist_val);
return c;
}
void move_entity( OBJMESH *objmesh,
NAVIGATIONPATHDATA *navigationpathdata,
int *next_point,
float speed ) {
objmesh->location.z =
navigationpathdata->path_point_array[ *next_point ].z = 0.0f;
float distance = vec3_dist( &objmesh->location,
&navigationpathdata->path_point_array[ *next_point ] );
if( distance < 0.1f ) {
++*next_point;
if( *next_point == ( navigationpathdata->path_point_count + 1 ) ) {
*next_point = -1;
}
}
if( *next_point != -1 ) {
vec3 direction;
vec3_diff( &direction,
&navigationpathdata->path_point_array[ *next_point ],
&objmesh->location );
vec3_normalize( &direction,
&direction );
objmesh->btrigidbody->setLinearVelocity( btVector3( direction.x * speed,
direction.y * speed,
0.0f ) );
objmesh->btrigidbody->setActivationState( ACTIVE_TAG );
}
else {
objmesh->btrigidbody->setActivationState( WANTS_DEACTIVATION );
navigationpathdata->path_point_count = 0;
}
}
static bool FindHandleAtPos(obs_scene_t scene, obs_sceneitem_t item,
void *param)
{
if (!obs_sceneitem_selected(item))
return true;
HandleFindData *data = reinterpret_cast<HandleFindData*>(param);
matrix4 transform;
vec3 pos3;
float closestHandle = HANDLE_SEL_RADIUS;
vec3_set(&pos3, data->pos.x, data->pos.y, 0.0f);
obs_sceneitem_get_box_transform(item, &transform);
auto TestHandle = [&] (float x, float y, ItemHandle handle)
{
vec3 handlePos = GetTransformedPosScaled(x, y, transform,
data->scale);
float dist = vec3_dist(&handlePos, &pos3);
if (dist < HANDLE_SEL_RADIUS) {
if (dist < closestHandle) {
closestHandle = dist;
data->handle = handle;
data->item = item;
}
}
};
TestHandle(0.0f, 0.0f, ItemHandle::TopLeft);
TestHandle(0.5f, 0.0f, ItemHandle::TopCenter);
TestHandle(1.0f, 0.0f, ItemHandle::TopRight);
TestHandle(0.0f, 0.5f, ItemHandle::CenterLeft);
TestHandle(1.0f, 0.5f, ItemHandle::CenterRight);
TestHandle(0.0f, 1.0f, ItemHandle::BottomLeft);
TestHandle(0.5f, 1.0f, ItemHandle::BottomCenter);
TestHandle(1.0f, 1.0f, ItemHandle::BottomRight);
UNUSED_PARAMETER(scene);
return true;
}
void templateAppToucheMoved(float x, float y, unsigned int tap_count)
{
if (y > ((screen_size * 0.5f) - (screen_size * 0.05f)) && y < ((screen_size * 0.5f) + (screen_size * 0.05f))) {
move_delta.z = view_delta.x = view_delta.y = 0.0f;
move_location.x = x;
move_location.y = y;
view_location.x = x;
view_location.y = y;
} else if (y < (screen_size * 0.5f)) {
vec3 touche = { x,
y,
0.0f
};
vec3_diff(&move_delta, &move_location, &touche);
vec3_normalize(&move_delta, &move_delta);
move_delta.z = CLAMP(vec3_dist(&move_location, &touche) / 128.0f, 0.0f, 1.0f);
} else {
view_delta.x = view_delta.x * 0.75f + (x - view_location.x) * 0.25f;
view_delta.y = view_delta.y * 0.75f + (y - view_location.y) * 0.25f;
view_location.x = x;
view_location.y = y;
}
}
static void terrain_new_chunk(terrain* ter, int i) {
const int SUBDIVISIONS = NUM_TERRAIN_SUBDIVISIONS+1;
terrain_chunk* tc = malloc(sizeof(terrain_chunk));
tc->id = i;
tc->x = i % ter->num_cols;
tc->y = i / ter->num_cols;
tc->width = ter->chunk_width;
tc->height = ter->chunk_height;
int x_max = tc->width * SUBDIVISIONS + 1;
int y_max = tc->height * SUBDIVISIONS + 1;
tc->num_verts = x_max * y_max + x_max * 2 + y_max * 2;
vec3* vertex_buffer = malloc(sizeof(vec3) * 4 * tc->num_verts);
int index = 0;
for(int x = 0; x < x_max; x++)
for(int y = 0; y < y_max; y++) {
float gx = tc->x * ter->chunk_width + (float)x/SUBDIVISIONS;
float gy = tc->y * ter->chunk_height + (float)y/SUBDIVISIONS;
float height = terrain_height(ter, vec2_new(gx, gy));
mat3 axis = terrain_tbn(ter, vec2_new(gx, gy));
vec3 pos = vec3_new(gx, height, gy);
vec3 tangent = mat3_mul_vec3(axis, vec3_new(1,0,0));
vec3 normal = mat3_mul_vec3(axis, vec3_new(0,1,0));
vec3 binorm = mat3_mul_vec3(axis, vec3_new(0,0,1));
vertex_buffer[index] = pos; index++;
vertex_buffer[index] = normal; index++;
vertex_buffer[index] = tangent; index++;
vertex_buffer[index] = binorm; index++;
}
/* Adding fins. Don't look, horrible code */
const float FIN_DEPTH = 5.0;
for(int y = 0; y < y_max; y++) {
int gx = tc->x * ter->chunk_width + 0;
int gy = tc->y * ter->chunk_height + (float)y/SUBDIVISIONS;
float height = terrain_height(ter, vec2_new(gx, gy)) - FIN_DEPTH;
mat3 axis = terrain_tbn(ter, vec2_new(gx, gy));
vec3 pos = vec3_new(gx, height, gy);
vec3 tangent = mat3_mul_vec3(axis, vec3_new(1,0,0));
vec3 normal = mat3_mul_vec3(axis, vec3_new(0,1,0));
vec3 binorm = mat3_mul_vec3(axis, vec3_new(0,0,1));
vertex_buffer[index] = pos; index++;
vertex_buffer[index] = normal; index++;
vertex_buffer[index] = tangent; index++;
vertex_buffer[index] = binorm; index++;
}
for(int y = 0; y < y_max; y++) {
int gx = tc->x * ter->chunk_width + ter->chunk_width;
int gy = tc->y * ter->chunk_height + (float)y/SUBDIVISIONS;
float height = terrain_height(ter, vec2_new(gx, gy)) - FIN_DEPTH;
mat3 axis = terrain_tbn(ter, vec2_new(gx, gy));
vec3 pos = vec3_new(gx, height, gy);
vec3 tangent = mat3_mul_vec3(axis, vec3_new(1,0,0));
vec3 normal = mat3_mul_vec3(axis, vec3_new(0,1,0));
vec3 binorm = mat3_mul_vec3(axis, vec3_new(0,0,1));
vertex_buffer[index] = pos; index++;
vertex_buffer[index] = normal; index++;
vertex_buffer[index] = tangent; index++;
vertex_buffer[index] = binorm; index++;
}
for(int x = 0; x < x_max; x++) {
int gx = tc->x * ter->chunk_width + (float)x/SUBDIVISIONS;
int gy = tc->y * ter->chunk_height + 0;
float height = terrain_height(ter, vec2_new(gx, gy)) - FIN_DEPTH;
mat3 axis = terrain_tbn(ter, vec2_new(gx, gy));
vec3 pos = vec3_new(gx, height, gy);
vec3 tangent = mat3_mul_vec3(axis, vec3_new(1,0,0));
vec3 normal = mat3_mul_vec3(axis, vec3_new(0,1,0));
vec3 binorm = mat3_mul_vec3(axis, vec3_new(0,0,1));
vertex_buffer[index] = pos; index++;
vertex_buffer[index] = normal; index++;
vertex_buffer[index] = tangent; index++;
vertex_buffer[index] = binorm; index++;
}
for(int x = 0; x < x_max; x++) {
int gx = tc->x * ter->chunk_width + (float)x/SUBDIVISIONS;
int gy = tc->y * ter->chunk_height + ter->chunk_height;
float height = terrain_height(ter, vec2_new(gx, gy)) - FIN_DEPTH;
mat3 axis = terrain_tbn(ter, vec2_new(gx, gy));
vec3 pos = vec3_new(gx, height, gy);
vec3 tangent = mat3_mul_vec3(axis, vec3_new(1,0,0));
vec3 normal = mat3_mul_vec3(axis, vec3_new(0,1,0));
vec3 binorm = mat3_mul_vec3(axis, vec3_new(0,0,1));
vertex_buffer[index] = pos; index++;
vertex_buffer[index] = normal; index++;
vertex_buffer[index] = tangent; index++;
vertex_buffer[index] = binorm; index++;
}
tc->bound.center = vec3_zero();
for (int i = 0; i < index; i+=4) {
tc->bound.center = vec3_add(tc->bound.center, vertex_buffer[i]);
}
tc->bound.center = vec3_div(tc->bound.center, tc->num_verts);
tc->bound.radius = 0;
for (int i = 0; i < index; i+=4) {
tc->bound.radius = max(tc->bound.radius, vec3_dist(tc->bound.center, vertex_buffer[i]));
}
if (net_is_client()) {
glGenBuffers(1, &tc->vertex_buffer);
glBindBuffer(GL_ARRAY_BUFFER, tc->vertex_buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(vec3) * 4 * tc->num_verts, vertex_buffer, GL_STATIC_DRAW);
}
free(vertex_buffer);
if (net_is_client()) {
glGenBuffers(NUM_TERRAIN_BUFFERS, tc->index_buffers);
}
for(int j = 0; j < NUM_TERRAIN_BUFFERS; j++) {
int off = pow(2, j);
int x_max = tc->width * SUBDIVISIONS;
int y_max = tc->height * SUBDIVISIONS;
tc->num_indicies[j] = (x_max / off) * (y_max / off) * 6 + (x_max / off) * 12 + (y_max / off) * 12;
uint32_t* index_buffer = malloc(sizeof(uint32_t) * tc->num_indicies[j]);
index = 0;
for(int x = 0; x < x_max; x+=off)
for(int y = 0; y < y_max; y+=off) {
index_buffer[index] = x + y * (x_max+1); index++;
index_buffer[index] = (x+off) + y * (x_max+1); index++;
index_buffer[index] = (x+off) + (y+off) * (x_max+1); index++;
index_buffer[index] = x + y * (x_max+1); index++;
index_buffer[index] = (x+off) + (y+off) * (x_max+1); index++;
index_buffer[index] = x + (y+off) * (x_max+1); index++;
}
/* Again, adding fins. Don't look horrible code */
int x_base = (x_max + 1) * (y_max + 1);
int y_base = (x_max + 1) * (y_max + 1) + (x_max + 1) * 2;
for(int x = 0; x < x_max; x+=off) {
index_buffer[index] = x + 0 * (x_max+1); index++;
index_buffer[index] = x_base + x; index++;
index_buffer[index] = (x+off) + 0 * (x_max+1); index++;
index_buffer[index] = (x+off) + 0 * (x_max+1); index++;
index_buffer[index] = x_base + x; index++;
index_buffer[index] = x_base + x+off; index++;
}
for(int x = 0; x < x_max; x+=off) {
index_buffer[index] = x + y_max * (x_max+1); index++;
index_buffer[index] = (x+off) + y_max * (x_max+1); index++;
index_buffer[index] = x_base + y_max+1 + x; index++;
index_buffer[index] = (x+off) + y_max * (x_max+1); index++;
index_buffer[index] = x_base + x_max+1 + x+off; index++;
index_buffer[index] = x_base + x_max+1 + x; index++;
}
for(int y = 0; y < y_max; y+=off) {
index_buffer[index] = 0 + y * (x_max+1); index++;
index_buffer[index] = 0 + (y+off) * (x_max+1); index++;
index_buffer[index] = y_base + y; index++;
index_buffer[index] = 0 + (y+off) * (x_max+1); index++;
index_buffer[index] = y_base + y+off; index++;
index_buffer[index] = y_base + y; index++;
}
for(int y = 0; y < y_max; y+=off) {
index_buffer[index] = x_max + y * (x_max+1); index++;
index_buffer[index] = y_base + y_max+1 + y; index++;
index_buffer[index] = x_max + (y+off) * (x_max+1); index++;
index_buffer[index] = x_max + (y+off) * (x_max+1); index++;
index_buffer[index] = y_base + y_max+1 + y; index++;
index_buffer[index] = y_base + y_max+1 + y+off; index++;
}
if (net_is_client()) {
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, tc->index_buffers[j]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32_t) * tc->num_indicies[j], index_buffer, GL_DYNAMIC_DRAW);
}
free(index_buffer);
}
tc->colmesh = malloc(sizeof(cmesh));
tc->colmesh->is_leaf = true;
tc->colmesh->triangles_num = (tc->width/4) * (tc->height/4) * 2;
tc->colmesh->triangles = malloc(sizeof(ctri) * tc->colmesh->triangles_num);
int tri_i = 0;
for (int x = 0; x < tc->width; x += 4)
for (int y = 0; y < tc->height; y += 4) {
float gx = tc->x * ter->chunk_width + (float)x;
float gy = tc->y * ter->chunk_height + (float)y;
vec3 a = vec3_new(gx , terrain_height(ter, vec2_new(gx , gy )) , gy );
vec3 b = vec3_new(gx+4, terrain_height(ter, vec2_new(gx+4, gy )) , gy );
vec3 c = vec3_new(gx+4, terrain_height(ter, vec2_new(gx+4, gy+4)) , gy+4);
vec3 d = vec3_new(gx , terrain_height(ter, vec2_new(gx , gy+4)) , gy+4);
vec3 tang = vec3_normalize(vec3_sub(b, a));
vec3 binorm = vec3_normalize(vec3_sub(d, a));
vec3 norm = vec3_cross( binorm, tang );
tc->colmesh->triangles[tri_i] = ctri_new(a, c, b, norm); tri_i++;
tc->colmesh->triangles[tri_i] = ctri_new(a, d, c, norm); tri_i++;
}
tc->colmesh->bound = cmesh_bound(tc->colmesh);
/* For some reason this is not working correctly */
cmesh_subdivide(tc->colmesh, 5);
ter->chunks[i] = tc;
}
