TakeV/dxx-rebirth
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Add vm_vec_normal that returns result

Browse source
This commit is contained in:
Kp 2014-11-01 03:17:48 +00:00
parent 3665c02dda
commit 697bdcf078
4 changed files with 23 additions and 32 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
common/include/vecmat.h
View file

@ -231,6 +231,12 @@ vms_vector &vm_vec_cross (vms_vector &dest, const vms_vector &src0, const vms_ve
//returns ptr to dest
//dest CANNOT equal either source
vms_vector &vm_vec_normal (vms_vector &dest, const vms_vector &p0, const vms_vector &p1, const vms_vector &p2);
static inline vms_vector vm_vec_normal(const vms_vector &p0, const vms_vector &p1, const vms_vector &p2) __attribute_warn_unused_result;
static inline vms_vector vm_vec_normal(const vms_vector &p0, const vms_vector &p1, const vms_vector &p2)
{
vms_vector dest;
return vm_vec_normal(dest, p0, p1, p2), dest;
}
//computes non-normalized surface normal from three points.
//returns ptr to dest

4
similar/editor/segment.cpp
View file

@ -1549,12 +1549,12 @@ void create_coordinate_axes_from_segment(const vsegptr_t sp,array<int, 16> &vert
int check_seg_concavity(const vsegptr_t s)
{
int sn,vn;
vms_vector n0,n1;
vms_vector n0;
for (sn=0;sn<MAX_SIDES_PER_SEGMENT;sn++)
for (vn=0;vn<=4;vn++) {
vm_vec_normal(n1,
const auto n1 = vm_vec_normal(
Vertices[s->verts[Side_to_verts[sn][vn%4]]],
Vertices[s->verts[Side_to_verts[sn][(vn+1)%4]]],
Vertices[s->verts[Side_to_verts[sn][(vn+2)%4]]]);

42
similar/main/gameseg.cpp
View file

@ -1348,7 +1348,6 @@ static void get_verts_for_normal(int va, int vb, int vc, int vd, int *v0, int *v
// -------------------------------------------------------------------------------
static void add_side_as_2_triangles(const vsegptr_t sp, int sidenum)
{
vms_vector norm;
const sbyte *vs = Side_to_verts[sidenum];
fix dot;
@ -1360,7 +1359,7 @@ static void add_side_as_2_triangles(const vsegptr_t sp, int sidenum)
// Use Matt's formula: Na . AD > 0, where ABCD are vertices on side, a is face formed by A,B,C, Na is normal from face a.
// If not a wall, then triangulate so whatever is on the other side is triangulated the same (ie, between the same absoluate vertices)
if (!IS_CHILD(sp->children[sidenum])) {
vm_vec_normal(norm, Vertices[sp->verts[vs[0]]], Vertices[sp->verts[vs[1]]], Vertices[sp->verts[vs[2]]]);
const auto norm = vm_vec_normal(Vertices[sp->verts[vs[0]]], Vertices[sp->verts[vs[1]]], Vertices[sp->verts[vs[2]]]);
const auto vec_13 = vm_vec_sub(Vertices[sp->verts[vs[3]]], Vertices[sp->verts[vs[1]]]); // vector from vertex 1 to vertex 3
dot = vm_vec_dot(norm, vec_13);
@ -1372,15 +1371,11 @@ static void add_side_as_2_triangles(const vsegptr_t sp, int sidenum)
// Now, based on triangulation type, set the normals.
if (sidep->get_type() == SIDE_IS_TRI_02) {
vm_vec_normal(norm, Vertices[sp->verts[vs[0]]], Vertices[sp->verts[vs[1]]], Vertices[sp->verts[vs[2]]]);
sidep->normals[0] = norm;
vm_vec_normal(norm, Vertices[sp->verts[vs[0]]], Vertices[sp->verts[vs[2]]], Vertices[sp->verts[vs[3]]]);
sidep->normals[1] = norm;
vm_vec_normal(sidep->normals[0], Vertices[sp->verts[vs[0]]], Vertices[sp->verts[vs[1]]], Vertices[sp->verts[vs[2]]]);
vm_vec_normal(sidep->normals[1], Vertices[sp->verts[vs[0]]], Vertices[sp->verts[vs[2]]], Vertices[sp->verts[vs[3]]]);
} else {
vm_vec_normal(norm, Vertices[sp->verts[vs[0]]], Vertices[sp->verts[vs[1]]], Vertices[sp->verts[vs[3]]]);
sidep->normals[0] = norm;
vm_vec_normal(norm, Vertices[sp->verts[vs[1]]], Vertices[sp->verts[vs[2]]], Vertices[sp->verts[vs[3]]]);
sidep->normals[1] = norm;
vm_vec_normal(sidep->normals[0], Vertices[sp->verts[vs[0]]], Vertices[sp->verts[vs[1]]], Vertices[sp->verts[vs[3]]]);
vm_vec_normal(sidep->normals[1], Vertices[sp->verts[vs[1]]], Vertices[sp->verts[vs[2]]], Vertices[sp->verts[vs[3]]]);
}
} else {
int i,v[4], vsorted[4];
@ -1395,30 +1390,22 @@ static void add_side_as_2_triangles(const vsegptr_t sp, int sidenum)
sidep->set_type(SIDE_IS_TRI_02);
// Now, get vertices for normal for each triangle based on triangulation type.
get_verts_for_normal(v[0], v[1], v[2], 32767, &vsorted[0], &vsorted[1], &vsorted[2], &vsorted[3], &negate_flag);
vm_vec_normal(norm, Vertices[vsorted[0]], Vertices[vsorted[1]], Vertices[vsorted[2]]);
if (negate_flag)
vm_vec_negate(norm);
sidep->normals[0] = norm;
const auto n0 = vm_vec_normal(Vertices[vsorted[0]], Vertices[vsorted[1]], Vertices[vsorted[2]]);
sidep->normals[0] = negate_flag ? vm_vec_negated(n0) : n0;
get_verts_for_normal(v[0], v[2], v[3], 32767, &vsorted[0], &vsorted[1], &vsorted[2], &vsorted[3], &negate_flag);
vm_vec_normal(norm, Vertices[vsorted[0]], Vertices[vsorted[1]], Vertices[vsorted[2]]);
if (negate_flag)
vm_vec_negate(norm);
sidep->normals[1] = norm;
const auto n1 = vm_vec_normal(Vertices[vsorted[0]], Vertices[vsorted[1]], Vertices[vsorted[2]]);
sidep->normals[1] = negate_flag ? vm_vec_negated(n1) : n1;
} else {
sidep->set_type(SIDE_IS_TRI_13);
// Now, get vertices for normal for each triangle based on triangulation type.
get_verts_for_normal(v[0], v[1], v[3], 32767, &vsorted[0], &vsorted[1], &vsorted[2], &vsorted[3], &negate_flag);
vm_vec_normal(norm, Vertices[vsorted[0]], Vertices[vsorted[1]], Vertices[vsorted[2]]);
if (negate_flag)
vm_vec_negate(norm);
sidep->normals[0] = norm;
const auto n0 = vm_vec_normal(Vertices[vsorted[0]], Vertices[vsorted[1]], Vertices[vsorted[2]]);
sidep->normals[0] = negate_flag ? vm_vec_negated(n0) : n0;
get_verts_for_normal(v[1], v[2], v[3], 32767, &vsorted[0], &vsorted[1], &vsorted[2], &vsorted[3], &negate_flag);
vm_vec_normal(norm, Vertices[vsorted[0]], Vertices[vsorted[1]], Vertices[vsorted[2]]);
if (negate_flag)
vm_vec_negate(norm);
sidep->normals[1] = norm;
const auto n1 = vm_vec_normal(Vertices[vsorted[0]], Vertices[vsorted[1]], Vertices[vsorted[2]]);
sidep->normals[1] = negate_flag ? vm_vec_negated(n1) : n1;
}
}
}
@ -1439,7 +1426,6 @@ void create_walls_on_side(const vsegptridx_t sp, int sidenum)
{
int vm0, vm1, vm2, vm3, negate_flag;
int v0, v1, v2, v3;
vms_vector vn;
fix dist_to_plane;
v0 = sp->verts[Side_to_verts[sidenum][0]];
@ -1449,7 +1435,7 @@ void create_walls_on_side(const vsegptridx_t sp, int sidenum)
get_verts_for_normal(v0, v1, v2, v3, &vm0, &vm1, &vm2, &vm3, &negate_flag);
vm_vec_normal(vn, Vertices[vm0], Vertices[vm1], Vertices[vm2]);
auto vn = vm_vec_normal(Vertices[vm0], Vertices[vm1], Vertices[vm2]);
dist_to_plane = abs(vm_dist_to_plane(Vertices[vm3], vn, Vertices[vm0]));
if (negate_flag)

3
similar/main/terrain.cpp
View file

@ -398,8 +398,7 @@ static const vms_vector light{0x2e14,0xe8f5,0x5eb8};
static fix get_face_light(vms_vector *p0,vms_vector *p1,vms_vector *p2)
{
vms_vector norm;
vm_vec_normal(norm,*p0,*p1,*p2);
const auto norm = vm_vec_normal(*p0,*p1,*p2);
return -vm_vec_dot(norm,light);
}