olegpz
/
ericw-tools
mirror of https://github.com/ericwa/ericw-tools.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

light: refactor phong shading to use GLM

This commit is contained in:
Eric Wasylishen 2017-02-06 22:50:56 -07:00
parent 2dc01b8469
commit f018b7324d
4 changed files with 79 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
include/common/mathlib.hh
View File

@ -60,6 +60,15 @@ extern const vec3_t vec3_origin;
qboolean VectorCompare(const vec3_t v1, const vec3_t v2); qboolean VectorCompare(const vec3_t v1, const vec3_t v2);
static inline bool
GLMVectorCompare(const glm::vec3 &v1, const glm::vec3 &v2)
{
for (int i = 0; i < 3; i++)
if (fabs(v1[i] - v2[i]) > EQUAL_EPSILON)
return false;
return true;
}
static inline vec_t static inline vec_t
DotProduct(const vec3_t x, const vec3_t y) DotProduct(const vec3_t x, const vec3_t y)
{ {
@ -114,6 +123,20 @@ VectorSet(vec3_t out, vec_t x, vec_t y, vec_t z)
out[2] = z; out[2] = z;
} }
static inline void
VectorCopyFromGLM(const glm::vec3 &in, vec3_t out)
{
out[0] = in.x;
out[1] = in.y;
out[2] = in.z;
}
static inline glm::vec3
VectorToGLM(const vec3_t in)
{
return glm::vec3(in[0], in[1], in[2]);
}
static inline vec_t static inline vec_t
Q_rint(vec_t in) Q_rint(vec_t in)
{ {

2
include/light/light.hh
View File

@ -412,7 +412,7 @@ const modelinfo_t *ModelInfoForFace(const bsp2_t *bsp, int facenum);
bool FacesSmoothed(const bsp2_dface_t *f1, const bsp2_dface_t *f2); bool FacesSmoothed(const bsp2_dface_t *f1, const bsp2_dface_t *f2);
const std::set<const bsp2_dface_t *> &GetSmoothFaces(const bsp2_dface_t *face); const std::set<const bsp2_dface_t *> &GetSmoothFaces(const bsp2_dface_t *face);
const std::vector<const bsp2_dface_t *> &GetPlaneFaces(const bsp2_dface_t *face); const std::vector<const bsp2_dface_t *> &GetPlaneFaces(const bsp2_dface_t *face);
const vec_t *GetSurfaceVertexNormal(const bsp2_t *bsp, const bsp2_dface_t *f, const int v); const glm::vec3 GetSurfaceVertexNormal(const bsp2_t *bsp, const bsp2_dface_t *f, const int v);
const bsp2_dface_t *Face_EdgeIndexSmoothed(const bsp2_t *bsp, const bsp2_dface_t *f, const int edgeindex); const bsp2_dface_t *Face_EdgeIndexSmoothed(const bsp2_t *bsp, const bsp2_dface_t *f, const int edgeindex);
const std::vector<bouncelight_t> &BounceLights(); const std::vector<bouncelight_t> &BounceLights();
std::vector<bouncelight_t> BounceLightsForFaceNum(int facenum); std::vector<bouncelight_t> BounceLightsForFaceNum(int facenum);

92
light/light.cc
View File

@ -45,7 +45,10 @@
#include <mutex> #include <mutex>
#include <string> #include <string>
#include <glm/glm.hpp>
using namespace std; using namespace std;
using namespace glm;
globalconfig_t cfg_static {}; globalconfig_t cfg_static {};
@ -342,12 +345,12 @@ FindModelInfo(const bsp2_t *bsp, const char *lmscaleoverride)
/* return 0 if either vector is zero-length */ /* return 0 if either vector is zero-length */
static float static float
AngleBetweenVectors(const vec3_t d1, const vec3_t d2) AngleBetweenVectors(const vec3 &d1, const vec3 &d2)
{ {
float length_product = (VectorLength(d1)*VectorLength(d2)); float length_product = (length(d1)*length(d2));
if (length_product == 0) if (length_product == 0)
return 0; return 0;
float cosangle = DotProduct(d1, d2)/length_product; float cosangle = dot(d1, d2)/length_product;
if (cosangle < -1) cosangle = -1; if (cosangle < -1) cosangle = -1;
if (cosangle > 1) cosangle = 1; if (cosangle > 1) cosangle = 1;
@ -357,24 +360,15 @@ AngleBetweenVectors(const vec3_t d1, const vec3_t d2)
/* returns the angle between vectors p2->p1 and p2->p3 */ /* returns the angle between vectors p2->p1 and p2->p3 */
static float static float
AngleBetweenPoints(const vec3_t p1, const vec3_t p2, const vec3_t p3) AngleBetweenPoints(const vec3 &p1, const vec3 &p2, const vec3 &p3)
{ {
vec3_t d1, d2; const vec3 d1 = p1 - p2;
VectorSubtract(p1, p2, d1); const vec3 d2 = p3 - p2;
VectorSubtract(p3, p2, d2);
float result = AngleBetweenVectors(d1, d2); float result = AngleBetweenVectors(d1, d2);
return result; return result;
} }
class vec3_struct_t { std::map<const bsp2_dface_t *, std::vector<vec3>> vertex_normals;
public:
vec3_t v;
vec3_struct_t() {
VectorSet(v, 0, 0, 0);
}
};
std::map<const bsp2_dface_t *, std::vector<vec3_struct_t>> vertex_normals;
std::set<int> interior_verts; std::set<int> interior_verts;
map<const bsp2_dface_t *, set<const bsp2_dface_t *>> smoothFaces; map<const bsp2_dface_t *, set<const bsp2_dface_t *>> smoothFaces;
map<int, vector<const bsp2_dface_t *>> vertsToFaces; map<int, vector<const bsp2_dface_t *>> vertsToFaces;
@ -418,28 +412,28 @@ const std::vector<const bsp2_dface_t *> &GetPlaneFaces(const bsp2_dface_t *face)
/* given a triangle, just adds the contribution from the triangle to the given vertexes normals, based upon angles at the verts. /* given a triangle, just adds the contribution from the triangle to the given vertexes normals, based upon angles at the verts.
* v1, v2, v3 are global vertex indices */ * v1, v2, v3 are global vertex indices */
static void static void
AddTriangleNormals(std::map<int, vec3_struct_t> &smoothed_normals, const vec_t *norm, const dvertex_t *verts, int v1, int v2, int v3) AddTriangleNormals(std::map<int, vec3> &smoothed_normals, const vec3 &norm, const bsp2_t *bsp, int v1, int v2, int v3)
{ {
const vec_t *p1 = verts[v1].point; const vec3 p1 = Vertex_GetPos_E(bsp, v1);
const vec_t *p2 = verts[v2].point; const vec3 p2 = Vertex_GetPos_E(bsp, v2);
const vec_t *p3 = verts[v3].point; const vec3 p3 = Vertex_GetPos_E(bsp, v3);
float weight; float weight;
weight = AngleBetweenPoints(p2, p1, p3); weight = AngleBetweenPoints(p2, p1, p3);
VectorMA(smoothed_normals[v1].v, weight, norm, smoothed_normals[v1].v); smoothed_normals[v1] = smoothed_normals[v1] + (weight * norm);
weight = AngleBetweenPoints(p1, p2, p3); weight = AngleBetweenPoints(p1, p2, p3);
VectorMA(smoothed_normals[v2].v, weight, norm, smoothed_normals[v2].v); smoothed_normals[v2] = smoothed_normals[v2] + (weight * norm);
weight = AngleBetweenPoints(p1, p3, p2); weight = AngleBetweenPoints(p1, p3, p2);
VectorMA(smoothed_normals[v3].v, weight, norm, smoothed_normals[v3].v); smoothed_normals[v3] = smoothed_normals[v3] + (weight * norm);
} }
/* access the final phong-shaded vertex normal */ /* access the final phong-shaded vertex normal */
const vec_t *GetSurfaceVertexNormal(const bsp2_t *bsp, const bsp2_dface_t *f, const int vertindex) const glm::vec3 GetSurfaceVertexNormal(const bsp2_t *bsp, const bsp2_dface_t *f, const int vertindex)
{ {
const auto &face_normals_vector = vertex_normals.at(f); const auto &face_normals_vector = vertex_normals.at(f);
return face_normals_vector.at(vertindex).v; return face_normals_vector.at(vertindex);
} }
static bool static bool
@ -537,8 +531,7 @@ CalcualateVertexNormals(const bsp2_t *bsp)
for (int i = 0; i < bsp->numfaces; i++) { for (int i = 0; i < bsp->numfaces; i++) {
bsp2_dface_t *f = &bsp->dfaces[i]; bsp2_dface_t *f = &bsp->dfaces[i];
vec3_t f_norm; const vec3 f_norm = Face_Normal_E(bsp, f);
Face_Normal(bsp, f, f_norm);
// any face normal within this many degrees can be smoothed with this face // any face normal within this many degrees can be smoothed with this face
const int f_smoothangle = (extended_texinfo_flags[f->texinfo] & TEX_PHONG_ANGLE_MASK) >> TEX_PHONG_ANGLE_SHIFT; const int f_smoothangle = (extended_texinfo_flags[f->texinfo] & TEX_PHONG_ANGLE_MASK) >> TEX_PHONG_ANGLE_SHIFT;
@ -556,10 +549,9 @@ CalcualateVertexNormals(const bsp2_t *bsp)
if (!f2_smoothangle) if (!f2_smoothangle)
continue; continue;
vec3_t f2_norm; const vec3 f2_norm = Face_Normal_E(bsp, f2);
Face_Normal(bsp, f2, f2_norm);
const vec_t cosangle = DotProduct(f_norm, f2_norm); const vec_t cosangle = dot(f_norm, f2_norm);
const vec_t cosmaxangle = cos(DEG2RAD(qmin(f_smoothangle, f2_smoothangle))); const vec_t cosmaxangle = cos(DEG2RAD(qmin(f_smoothangle, f2_smoothangle)));
// check the angle between the face normals // check the angle between the face normals
@ -580,10 +572,7 @@ CalcualateVertexNormals(const bsp2_t *bsp)
} }
const auto &neighboursToSmooth = smoothFaces[f]; const auto &neighboursToSmooth = smoothFaces[f];
vec3_t f_norm; const vec3 f_norm = Face_Normal_E(bsp, f); // get the face normal
// get the face normal
Face_Normal(bsp, f, f_norm);
// gather up f and neighboursToSmooth // gather up f and neighboursToSmooth
std::vector<const bsp2_dface_t *> fPlusNeighbours; std::vector<const bsp2_dface_t *> fPlusNeighbours;
@ -593,12 +582,11 @@ CalcualateVertexNormals(const bsp2_t *bsp)
} }
// global vertex index -> smoothed normal // global vertex index -> smoothed normal
std::map<int, vec3_struct_t> smoothedNormals; std::map<int, vec3> smoothedNormals;
// walk fPlusNeighbours // walk fPlusNeighbours
for (auto f2 : fPlusNeighbours) { for (auto f2 : fPlusNeighbours) {
vec3_t f2_norm; const vec3 f2_norm = Face_Normal_E(bsp, f2);
Face_Normal(bsp, f2, f2_norm);
/* now just walk around the surface as a triangle fan */ /* now just walk around the surface as a triangle fan */
int v1, v2, v3; int v1, v2, v3;
@ -607,16 +595,16 @@ CalcualateVertexNormals(const bsp2_t *bsp)
for (int j = 2; j < f2->numedges; j++) for (int j = 2; j < f2->numedges; j++)
{ {
v3 = Face_VertexAtIndex(bsp, f2, j); v3 = Face_VertexAtIndex(bsp, f2, j);
AddTriangleNormals(smoothedNormals, f2_norm, bsp->dvertexes, v1, v2, v3); AddTriangleNormals(smoothedNormals, f2_norm, bsp, v1, v2, v3);
v2 = v3; v2 = v3;
} }
} }
// normalize vertex normals // normalize vertex normals (NOTE: updates smoothedNormals map)
for (auto &pair : smoothedNormals) { for (auto &pair : smoothedNormals) {
const int vertIndex = pair.first; const int vertIndex = pair.first;
vec_t *vertNormal = pair.second.v; const vec3 vertNormal = pair.second;
if (0 == VectorNormalize(vertNormal)) { if (0 == length(vertNormal)) {
// this happens when there are colinear vertices, which give zero-area triangles, // this happens when there are colinear vertices, which give zero-area triangles,
// so there is no contribution to the normal of the triangle in the middle of the // so there is no contribution to the normal of the triangle in the middle of the
// line. Not really an error, just set it to use the face normal. // line. Not really an error, just set it to use the face normal.
@ -627,14 +615,18 @@ CalcualateVertexNormals(const bsp2_t *bsp)
bsp->dvertexes[vertIndex].point[1], bsp->dvertexes[vertIndex].point[1],
bsp->dvertexes[vertIndex].point[2]); bsp->dvertexes[vertIndex].point[2]);
#endif #endif
VectorCopy(f_norm, vertNormal); pair.second = f_norm;
}
else
{
pair.second = normalize(vertNormal);
} }
} }
// sanity check // sanity check
if (!neighboursToSmooth.size()) { if (!neighboursToSmooth.size()) {
for (auto vertIndexNormalPair : smoothedNormals) { for (auto vertIndexNormalPair : smoothedNormals) {
Q_assert(VectorCompare(vertIndexNormalPair.second.v, f_norm)); Q_assert(GLMVectorCompare(vertIndexNormalPair.second, f_norm));
} }
} }
@ -797,7 +789,7 @@ LoadExtendedTexinfoFlags(const char *sourcefilename, const bsp2_t *bsp)
// radiosity // radiosity
mutex radlights_lock; mutex radlights_lock;
map<string, vec3_struct_t> texturecolors; map<string, vec3> texturecolors;
std::vector<bouncelight_t> radlights; std::vector<bouncelight_t> radlights;
std::map<int, std::vector<bouncelight_t>> radlightsByFacenum; // duplicate of `radlights` but indexed by face std::map<int, std::vector<bouncelight_t>> radlightsByFacenum; // duplicate of `radlights` but indexed by face
@ -875,8 +867,8 @@ Face_LookupTextureColor(const bsp2_t *bsp, const bsp2_dface_t *face, vec3_t colo
const char *facename = Face_TextureName(bsp, face); const char *facename = Face_TextureName(bsp, face);
if (texturecolors.find(facename) != texturecolors.end()) { if (texturecolors.find(facename) != texturecolors.end()) {
vec3_struct_t texcolor = texturecolors.at(facename); const vec3 texcolor = texturecolors.at(facename);
VectorCopy(texcolor.v, color); VectorCopyFromGLM(texcolor, color);
} else { } else {
VectorSet(color, 127, 127, 127); VectorSet(color, 127, 127, 127);
} }
@ -1042,11 +1034,11 @@ MakeTextureColors (const bsp2_t *bsp)
const miptex_t *miptex = (miptex_t *)(bsp->dtexdata.base + ofs); const miptex_t *miptex = (miptex_t *)(bsp->dtexdata.base + ofs);
string name { miptex->name }; string name { miptex->name };
vec3_struct_t color; vec3_t color;
Texture_AvgColor(bsp, miptex, color.v); Texture_AvgColor(bsp, miptex, color);
// printf("%s has color %f %f %f\n", name.c_str(), color.v[0], color.v[1], color.v[2]); // printf("%s has color %f %f %f\n", name.c_str(), color.v[0], color.v[1], color.v[2]);
texturecolors[name] = color; texturecolors[name] = VectorToGLM(color);
} }
} }
@ -1091,7 +1083,7 @@ ExportObjFace(FILE *f, const bsp2_t *bsp, const bsp2_dface_t *face, int *vertcou
for (int i=0; i<face->numedges; i++) for (int i=0; i<face->numedges; i++)
{ {
int vertnum = Face_VertexAtIndex(bsp, face, i); int vertnum = Face_VertexAtIndex(bsp, face, i);
const vec_t *normal = GetSurfaceVertexNormal(bsp, face, i); const vec3 normal = GetSurfaceVertexNormal(bsp, face, i);
const float *pos = bsp->dvertexes[vertnum].point; const float *pos = bsp->dvertexes[vertnum].point;
fprintf(f, "v %.9g %.9g %.9g\n", pos[0], pos[1], pos[2]); fprintf(f, "v %.9g %.9g %.9g\n", pos[0], pos[1], pos[2]);
fprintf(f, "vn %.9g %.9g %.9g\n", normal[0], normal[1], normal[2]); fprintf(f, "vn %.9g %.9g %.9g\n", normal[0], normal[1], normal[2]);

27
light/ltface.cc
View File

@ -290,7 +290,7 @@ PrintFaceInfo(const bsp2_dface_t *face, const bsp2_t *bsp)
int edge = bsp->dsurfedges[face->firstedge + i]; int edge = bsp->dsurfedges[face->firstedge + i];
int vert = Face_VertexAtIndex(bsp, face, i); int vert = Face_VertexAtIndex(bsp, face, i);
const vec_t *point = GetSurfaceVertexPoint(bsp, face, i); const vec_t *point = GetSurfaceVertexPoint(bsp, face, i);
const vec_t *norm = GetSurfaceVertexNormal(bsp, face, i); const glm::vec3 norm = GetSurfaceVertexNormal(bsp, face, i);
logprint("%s %3d (%3.3f, %3.3f, %3.3f) :: normal (%3.3f, %3.3f, %3.3f) :: edge %d\n", logprint("%s %3d (%3.3f, %3.3f, %3.3f) :: normal (%3.3f, %3.3f, %3.3f) :: edge %d\n",
i ? " " : " verts ", vert, i ? " " : " verts ", vert,
point[0], point[1], point[2], point[0], point[1], point[2],
@ -466,13 +466,13 @@ static void CalcPointNormal(const bsp2_t *bsp, const bsp2_dface_t *face, vec_t *
// area test rejects the case when v1, v2, v3 are colinear // area test rejects the case when v1, v2, v3 are colinear
if (TriangleArea(v1, v2, v3) >= 1) { if (TriangleArea(v1, v2, v3) >= 1) {
v1 = GetSurfaceVertexNormal(bsp, face, 0); const glm::vec3 v1 = GetSurfaceVertexNormal(bsp, face, 0);
v2 = GetSurfaceVertexNormal(bsp, face, j-1); const glm::vec3 v2 = GetSurfaceVertexNormal(bsp, face, j-1);
v3 = GetSurfaceVertexNormal(bsp, face, j); const glm::vec3 v3 = GetSurfaceVertexNormal(bsp, face, j);
VectorScale(v1, bary[0], norm);
VectorMA(norm, bary[1], v2, norm); const glm::vec3 glmnorm = normalize((bary[0] * v1) + (bary[1] * v2) + (bary[2] * v3));
VectorMA(norm, bary[2], v3, norm);
VectorNormalize(norm); VectorCopyFromGLM(glmnorm, norm);
return; return;
} }
} }
@ -533,12 +533,11 @@ static void CalcPointNormal(const bsp2_t *bsp, const bsp2_dface_t *face, vec_t *
vec_t t = FractionOfLine(v1, v2, point); vec_t t = FractionOfLine(v1, v2, point);
t = qmax(qmin(t, 1.0f), 0.0f); t = qmax(qmin(t, 1.0f), 0.0f);
v1 = GetSurfaceVertexNormal(bsp, face, bestplane); const glm::vec3 v1 = GetSurfaceVertexNormal(bsp, face, bestplane);
v2 = GetSurfaceVertexNormal(bsp, face, (bestplane+1)%face->numedges); const glm::vec3 v2 = GetSurfaceVertexNormal(bsp, face, (bestplane+1)%face->numedges);
VectorScale(v2, t, norm); const glm::vec3 glmnorm = normalize((v2 * t) + (1-t)*v1);
VectorMA(norm, 1-t, v1, norm); VectorCopyFromGLM(glmnorm, norm);
VectorNormalize(norm);
free(edgeplanes); free(edgeplanes);
return; return;
@ -561,7 +560,7 @@ static void CalcPointNormal(const bsp2_t *bsp, const bsp2_dface_t *face, vec_t *
{ {
bestd = dist; bestd = dist;
bestv = v; bestv = v;
VectorCopy(GetSurfaceVertexNormal(bsp, face, i), norm); VectorCopyFromGLM(GetSurfaceVertexNormal(bsp, face, i), norm);
} }
} }
VectorNormalize(norm); VectorNormalize(norm);