游戏引擎

开发平台：

C++ Builder

llvolume.cpp：源码内容

{
// we don't allow LLVolumes with this many vertices
llwarns << "Couldn't allocate triangle indices" << llendl;
num_indices = 0;
return NULL;
}
S32* index = new S32[expected_num_triangle_indices];
S32 count = 0;
// Let's do this totally diffently, as we don't care about faces...
// Counter-clockwise triangles are forward facing...
BOOL open = getProfile().isOpen();
BOOL hollow = (mParams.getProfileParams().getHollow() > 0);
BOOL path_open = getPath().isOpen();
S32 size_s, size_s_out, size_t;
S32 s, t, i;
size_s = getProfile().getTotal();
size_s_out = getProfile().getTotalOut();
size_t = getPath().mPath.size();
// NOTE -- if the construction of the triangles below ever changes
// then getNumTriangleIndices() method may also have to be updated.
if (open) /* Flawfinder: ignore */
{
if (hollow)
{
// Open hollow -- much like the closed solid, except we
// we need to stitch up the gap between s=0 and s=size_s-1
for (t = 0; t < size_t - 1; t++)
{
// The outer face, first cut, and inner face
for (s = 0; s < size_s - 1; s++)
{
i = s + t*size_s;
index[count++] = i; // x,y
index[count++] = i + 1; // x+1,y
index[count++] = i + size_s; // x,y+1
index[count++] = i + size_s; // x,y+1
index[count++] = i + 1; // x+1,y
index[count++] = i + size_s + 1; // x+1,y+1
}
// The other cut face
index[count++] = s + t*size_s; // x,y
index[count++] = 0 + t*size_s; // x+1,y
index[count++] = s + (t+1)*size_s; // x,y+1
index[count++] = s + (t+1)*size_s; // x,y+1
index[count++] = 0 + t*size_s; // x+1,y
index[count++] = 0 + (t+1)*size_s; // x+1,y+1
}
// Do the top and bottom caps, if necessary
if (path_open)
{
// Top cap
S32 pt1 = 0;
S32 pt2 = size_s-1;
S32 i = (size_t - 1)*size_s;
while (pt2 - pt1 > 1)
{
// Use the profile points instead of the mesh, since you want
// the un-transformed profile distances.
LLVector3 p1 = getProfile().mProfile[pt1];
LLVector3 p2 = getProfile().mProfile[pt2];
LLVector3 pa = getProfile().mProfile[pt1+1];
LLVector3 pb = getProfile().mProfile[pt2-1];
p1.mV[VZ] = 0.f;
p2.mV[VZ] = 0.f;
pa.mV[VZ] = 0.f;
pb.mV[VZ] = 0.f;
// Use area of triangle to determine backfacing
F32 area_1a2, area_1ba, area_21b, area_2ab;
area_1a2 = (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +
(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +
(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);
area_1ba = (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +
(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);
area_21b = (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +
(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
area_2ab = (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +
(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +
(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
BOOL use_tri1a2 = TRUE;
BOOL tri_1a2 = TRUE;
BOOL tri_21b = TRUE;
if (area_1a2 < 0)
{
tri_1a2 = FALSE;
}
if (area_2ab < 0)
{
// Can't use, because it contains point b
tri_1a2 = FALSE;
}
if (area_21b < 0)
{
tri_21b = FALSE;
}
if (area_1ba < 0)
{
// Can't use, because it contains point b
tri_21b = FALSE;
}
if (!tri_1a2)
{
use_tri1a2 = FALSE;
}
else if (!tri_21b)
{
use_tri1a2 = TRUE;
}
else
{
LLVector3 d1 = p1 - pa;
LLVector3 d2 = p2 - pb;
if (d1.magVecSquared() < d2.magVecSquared())
{
use_tri1a2 = TRUE;
}
else
{
use_tri1a2 = FALSE;
}
}
if (use_tri1a2)
{
index[count++] = pt1 + i;
index[count++] = pt1 + 1 + i;
index[count++] = pt2 + i;
pt1++;
}
else
{
index[count++] = pt1 + i;
index[count++] = pt2 - 1 + i;
index[count++] = pt2 + i;
pt2--;
}
}
// Bottom cap
pt1 = 0;
pt2 = size_s-1;
while (pt2 - pt1 > 1)
{
// Use the profile points instead of the mesh, since you want
// the un-transformed profile distances.
LLVector3 p1 = getProfile().mProfile[pt1];
LLVector3 p2 = getProfile().mProfile[pt2];
LLVector3 pa = getProfile().mProfile[pt1+1];
LLVector3 pb = getProfile().mProfile[pt2-1];
p1.mV[VZ] = 0.f;
p2.mV[VZ] = 0.f;
pa.mV[VZ] = 0.f;
pb.mV[VZ] = 0.f;
// Use area of triangle to determine backfacing
F32 area_1a2, area_1ba, area_21b, area_2ab;
area_1a2 = (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +
(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +
(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);
area_1ba = (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +
(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);
area_21b = (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +
(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
area_2ab = (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +
(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +
(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
BOOL use_tri1a2 = TRUE;
BOOL tri_1a2 = TRUE;
BOOL tri_21b = TRUE;
if (area_1a2 < 0)
{
tri_1a2 = FALSE;
}
if (area_2ab < 0)
{
// Can't use, because it contains point b
tri_1a2 = FALSE;
}
if (area_21b < 0)
{
tri_21b = FALSE;
}
if (area_1ba < 0)
{
// Can't use, because it contains point b
tri_21b = FALSE;
}
if (!tri_1a2)
{
use_tri1a2 = FALSE;
}
else if (!tri_21b)
{
use_tri1a2 = TRUE;
}
else
{
LLVector3 d1 = p1 - pa;
LLVector3 d2 = p2 - pb;
if (d1.magVecSquared() < d2.magVecSquared())
{
use_tri1a2 = TRUE;
}
else
{
use_tri1a2 = FALSE;
}
}
if (use_tri1a2)
{
index[count++] = pt1;
index[count++] = pt2;
index[count++] = pt1 + 1;
pt1++;
}
else
{
index[count++] = pt1;
index[count++] = pt2;
index[count++] = pt2 - 1;
pt2--;
}
}
}
}
else
{
// Open solid
for (t = 0; t < size_t - 1; t++)
{
// Outer face + 1 cut face
for (s = 0; s < size_s - 1; s++)
{
i = s + t*size_s;
index[count++] = i; // x,y
index[count++] = i + 1; // x+1,y
index[count++] = i + size_s; // x,y+1
index[count++] = i + size_s; // x,y+1
index[count++] = i + 1; // x+1,y
index[count++] = i + size_s + 1; // x+1,y+1
}
// The other cut face
index[count++] = (size_s - 1) + (t*size_s); // x,y
index[count++] = 0 + t*size_s; // x+1,y
index[count++] = (size_s - 1) + (t+1)*size_s; // x,y+1
index[count++] = (size_s - 1) + (t+1)*size_s; // x,y+1
index[count++] = 0 + (t*size_s); // x+1,y
index[count++] = 0 + (t+1)*size_s; // x+1,y+1
}
// Do the top and bottom caps, if necessary
if (path_open)
{
for (s = 0; s < size_s - 2; s++)
{
index[count++] = s+1;
index[count++] = s;
index[count++] = size_s - 1;
}
// We've got a top cap
S32 offset = (size_t - 1)*size_s;
for (s = 0; s < size_s - 2; s++)
{
// Inverted ordering from bottom cap.
index[count++] = offset + size_s - 1;
index[count++] = offset + s;
index[count++] = offset + s + 1;
}
}
}
}
else if (hollow)
{
// Closed hollow
// Outer face
for (t = 0; t < size_t - 1; t++)
{
for (s = 0; s < size_s_out - 1; s++)
{
i = s + t*size_s;
index[count++] = i; // x,y
index[count++] = i + 1; // x+1,y
index[count++] = i + size_s; // x,y+1
index[count++] = i + size_s; // x,y+1
index[count++] = i + 1; // x+1,y
index[count++] = i + 1 + size_s; // x+1,y+1
}
}
// Inner face
// Invert facing from outer face
for (t = 0; t < size_t - 1; t++)
{
for (s = size_s_out; s < size_s - 1; s++)
{
i = s + t*size_s;
index[count++] = i; // x,y
index[count++] = i + 1; // x+1,y
index[count++] = i + size_s; // x,y+1
index[count++] = i + size_s; // x,y+1
index[count++] = i + 1; // x+1,y
index[count++] = i + 1 + size_s; // x+1,y+1
}
}
// Do the top and bottom caps, if necessary
if (path_open)
{
// Top cap
S32 pt1 = 0;
S32 pt2 = size_s-1;
S32 i = (size_t - 1)*size_s;
while (pt2 - pt1 > 1)
{
// Use the profile points instead of the mesh, since you want
// the un-transformed profile distances.
LLVector3 p1 = getProfile().mProfile[pt1];
LLVector3 p2 = getProfile().mProfile[pt2];
LLVector3 pa = getProfile().mProfile[pt1+1];
LLVector3 pb = getProfile().mProfile[pt2-1];
p1.mV[VZ] = 0.f;
p2.mV[VZ] = 0.f;
pa.mV[VZ] = 0.f;
pb.mV[VZ] = 0.f;
// Use area of triangle to determine backfacing
F32 area_1a2, area_1ba, area_21b, area_2ab;
area_1a2 = (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +
(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +
(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);
area_1ba = (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +
(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);
area_21b = (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +
(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
area_2ab = (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +
(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +
(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
BOOL use_tri1a2 = TRUE;
BOOL tri_1a2 = TRUE;
BOOL tri_21b = TRUE;
if (area_1a2 < 0)
{
tri_1a2 = FALSE;
}
if (area_2ab < 0)
{
// Can't use, because it contains point b
tri_1a2 = FALSE;
}
if (area_21b < 0)
{
tri_21b = FALSE;
}
if (area_1ba < 0)
{
// Can't use, because it contains point b
tri_21b = FALSE;
}
if (!tri_1a2)
{
use_tri1a2 = FALSE;
}
else if (!tri_21b)
{
use_tri1a2 = TRUE;
}
else
{
LLVector3 d1 = p1 - pa;
LLVector3 d2 = p2 - pb;
if (d1.magVecSquared() < d2.magVecSquared())
{
use_tri1a2 = TRUE;
}
else
{
use_tri1a2 = FALSE;
}
}
if (use_tri1a2)
{
index[count++] = pt1 + i;
index[count++] = pt1 + 1 + i;
index[count++] = pt2 + i;
pt1++;
}
else
{
index[count++] = pt1 + i;
index[count++] = pt2 - 1 + i;
index[count++] = pt2 + i;
pt2--;
}
}
// Bottom cap
pt1 = 0;
pt2 = size_s-1;
while (pt2 - pt1 > 1)
{
// Use the profile points instead of the mesh, since you want
// the un-transformed profile distances.
LLVector3 p1 = getProfile().mProfile[pt1];
LLVector3 p2 = getProfile().mProfile[pt2];
LLVector3 pa = getProfile().mProfile[pt1+1];
LLVector3 pb = getProfile().mProfile[pt2-1];
p1.mV[VZ] = 0.f;
p2.mV[VZ] = 0.f;
pa.mV[VZ] = 0.f;
pb.mV[VZ] = 0.f;
// Use area of triangle to determine backfacing
F32 area_1a2, area_1ba, area_21b, area_2ab;
area_1a2 = (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +
(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +
(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);
area_1ba = (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +
(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);
area_21b = (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +
(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
area_2ab = (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +
(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +
(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
BOOL use_tri1a2 = TRUE;
BOOL tri_1a2 = TRUE;
BOOL tri_21b = TRUE;
if (area_1a2 < 0)
{
tri_1a2 = FALSE;
}
if (area_2ab < 0)
{
// Can't use, because it contains point b
tri_1a2 = FALSE;
}
if (area_21b < 0)
{
tri_21b = FALSE;
}
if (area_1ba < 0)
{
// Can't use, because it contains point b
tri_21b = FALSE;
}
if (!tri_1a2)
{
use_tri1a2 = FALSE;
}
else if (!tri_21b)
{
use_tri1a2 = TRUE;
}
else
{
LLVector3 d1 = p1 - pa;
LLVector3 d2 = p2 - pb;
if (d1.magVecSquared() < d2.magVecSquared())
{
use_tri1a2 = TRUE;
}
else
{
use_tri1a2 = FALSE;
}
}
if (use_tri1a2)
{
index[count++] = pt1;
index[count++] = pt2;
index[count++] = pt1 + 1;
pt1++;
}
else
{
index[count++] = pt1;
index[count++] = pt2;
index[count++] = pt2 - 1;
pt2--;
}
}
}
}
else
{
// Closed solid. Easy case.
for (t = 0; t < size_t - 1; t++)
{
for (s = 0; s < size_s - 1; s++)
{
// Should wrap properly, but for now...
i = s + t*size_s;
index[count++] = i; // x,y
index[count++] = i + 1; // x+1,y
index[count++] = i + size_s; // x,y+1
index[count++] = i + size_s; // x,y+1
index[count++] = i + 1; // x+1,y
index[count++] = i + size_s + 1; // x+1,y+1
}
}
// Do the top and bottom caps, if necessary
if (path_open)
{
// bottom cap
for (s = 1; s < size_s - 2; s++)
{
index[count++] = s+1;
index[count++] = s;
index[count++] = 0;
}
// top cap
S32 offset = (size_t - 1)*size_s;
for (s = 1; s < size_s - 2; s++)
{
// Inverted ordering from bottom cap.
index[count++] = offset;
index[count++] = offset + s;
index[count++] = offset + s + 1;
}
}
}
#ifdef LL_DEBUG
// assert that we computed the correct number of indices
if (count != expected_num_triangle_indices )
{
llerrs << "bad index count prediciton:"
<< " expected=" << expected_num_triangle_indices
<< " actual=" << count << llendl;
}
#endif
#if 0
// verify that each index does not point beyond the size of the mesh
S32 num_vertices = mMesh.size();
for (i = 0; i < count; i+=3)
{
llinfos << index[i] << ":" << index[i+1] << ":" << index[i+2] << llendl;
llassert(index[i] < num_vertices);
llassert(index[i+1] < num_vertices);
llassert(index[i+2] < num_vertices);
}
#endif
num_indices = count;
return index;
}
S32 LLVolume::getNumTriangleIndices() const
{
BOOL profile_open = getProfile().isOpen();
BOOL hollow = (mParams.getProfileParams().getHollow() > 0);
BOOL path_open = getPath().isOpen();
S32 size_s, size_s_out, size_t;
size_s = getProfile().getTotal();
size_s_out = getProfile().getTotalOut();
size_t = getPath().mPath.size();
S32 count = 0;
if (profile_open) /* Flawfinder: ignore */
{
if (hollow)
{
// Open hollow -- much like the closed solid, except we
// we need to stitch up the gap between s=0 and s=size_s-1
count = (size_t - 1) * (((size_s -1) * 6) + 6);
}
else
{
count = (size_t - 1) * (((size_s -1) * 6) + 6);
}
}
else if (hollow)
{
// Closed hollow
// Outer face
count = (size_t - 1) * (size_s_out - 1) * 6;
// Inner face
count += (size_t - 1) * ((size_s - 1) - size_s_out) * 6;
}
else
{
// Closed solid. Easy case.
count = (size_t - 1) * (size_s - 1) * 6;
}
if (path_open)
{
S32 cap_triangle_count = size_s - 3;
if ( profile_open
|| hollow )
{
cap_triangle_count = size_s - 2;
}
if ( cap_triangle_count > 0 )
{
// top and bottom caps
count += cap_triangle_count * 2 * 3;
}
}
return count;
}
//-----------------------------------------------------------------------------
// generateSilhouetteVertices()
//-----------------------------------------------------------------------------
void LLVolume::generateSilhouetteVertices(std::vector<LLVector3> &vertices,
std::vector<LLVector3> &normals,
std::vector<S32> &segments,
const LLVector3& obj_cam_vec,
const LLMatrix4& mat,
const LLMatrix3& norm_mat,
S32 face_mask)
{
LLMemType m1(LLMemType::MTYPE_VOLUME);
vertices.clear();
normals.clear();
segments.clear();
S32 cur_index = 0;
//for each face
for (face_list_t::iterator iter = mVolumeFaces.begin();
iter != mVolumeFaces.end(); ++iter)
{
const LLVolumeFace& face = *iter;
if (!(face_mask & (0x1 << cur_index++)))
{
continue;
}
if (face.mTypeMask & (LLVolumeFace::CAP_MASK)) {
}
else {
//==============================================
//DEBUG draw edge map instead of silhouette edge
//==============================================
#if DEBUG_SILHOUETTE_EDGE_MAP
//for each triangle
U32 count = face.mIndices.size();
for (U32 j = 0; j < count/3; j++) {
//get vertices
S32 v1 = face.mIndices[j*3+0];
S32 v2 = face.mIndices[j*3+1];
S32 v3 = face.mIndices[j*3+2];
//get current face center
LLVector3 cCenter = (face.mVertices[v1].mPosition +
face.mVertices[v2].mPosition +
face.mVertices[v3].mPosition) / 3.0f;
//for each edge
for (S32 k = 0; k < 3; k++) {
S32 nIndex = face.mEdge[j*3+k];
if (nIndex <= -1) {
continue;
}
if (nIndex >= (S32) count/3) {
continue;
}
//get neighbor vertices
v1 = face.mIndices[nIndex*3+0];
v2 = face.mIndices[nIndex*3+1];
v3 = face.mIndices[nIndex*3+2];
//get neighbor face center
LLVector3 nCenter = (face.mVertices[v1].mPosition +
face.mVertices[v2].mPosition +
face.mVertices[v3].mPosition) / 3.0f;
//draw line
vertices.push_back(cCenter);
vertices.push_back(nCenter);
normals.push_back(LLVector3(1,1,1));
normals.push_back(LLVector3(1,1,1));
segments.push_back(vertices.size());
}
}
continue;
//==============================================
//DEBUG
//==============================================
//==============================================
//DEBUG draw normals instead of silhouette edge
//==============================================
#elif DEBUG_SILHOUETTE_NORMALS
//for each vertex
for (U32 j = 0; j < face.mVertices.size(); j++) {
vertices.push_back(face.mVertices[j].mPosition);
vertices.push_back(face.mVertices[j].mPosition + face.mVertices[j].mNormal*0.1f);
normals.push_back(LLVector3(0,0,1));
normals.push_back(LLVector3(0,0,1));
segments.push_back(vertices.size());
#if DEBUG_SILHOUETTE_BINORMALS
vertices.push_back(face.mVertices[j].mPosition);
vertices.push_back(face.mVertices[j].mPosition + face.mVertices[j].mBinormal*0.1f);
normals.push_back(LLVector3(0,0,1));
normals.push_back(LLVector3(0,0,1));
segments.push_back(vertices.size());
#endif
}
continue;
#else
//==============================================
//DEBUG
//==============================================
static const U8 AWAY = 0x01,
TOWARDS = 0x02;
//for each triangle
std::vector<U8> fFacing;
vector_append(fFacing, face.mIndices.size()/3);
for (U32 j = 0; j < face.mIndices.size()/3; j++)
{
//approximate normal
S32 v1 = face.mIndices[j*3+0];
S32 v2 = face.mIndices[j*3+1];
S32 v3 = face.mIndices[j*3+2];
LLVector3 norm = (face.mVertices[v1].mPosition - face.mVertices[v2].mPosition) %
(face.mVertices[v2].mPosition - face.mVertices[v3].mPosition);
if (norm.magVecSquared() < 0.00000001f)
{
fFacing[j] = AWAY | TOWARDS;
}
else
{
//get view vector
LLVector3 view = (obj_cam_vec-face.mVertices[v1].mPosition);
bool away = view * norm > 0.0f;
if (away)
{
fFacing[j] = AWAY;
}
else
{
fFacing[j] = TOWARDS;
}
}
}
//for each triangle
for (U32 j = 0; j < face.mIndices.size()/3; j++)
{
if (fFacing[j] == (AWAY | TOWARDS))
{ //this is a degenerate triangle
//take neighbor facing (degenerate faces get facing of one of their neighbors)
// *FIX IF NEEDED: this does not deal with neighboring degenerate faces
for (S32 k = 0; k < 3; k++)
{
S32 index = face.mEdge[j*3+k];
if (index != -1)
{
fFacing[j] = fFacing[index];
break;
}
}
continue; //skip degenerate face
}
//for each edge
for (S32 k = 0; k < 3; k++) {
S32 index = face.mEdge[j*3+k];
if (index != -1 && fFacing[index] == (AWAY | TOWARDS)) {
//our neighbor is degenerate, make him face our direction
fFacing[face.mEdge[j*3+k]] = fFacing[j];
continue;
}
if (index == -1 || //edge has no neighbor, MUST be a silhouette edge
(fFacing[index] & fFacing[j]) == 0) { //we found a silhouette edge
S32 v1 = face.mIndices[j*3+k];
S32 v2 = face.mIndices[j*3+((k+1)%3)];
vertices.push_back(face.mVertices[v1].mPosition*mat);
LLVector3 norm1 = face.mVertices[v1].mNormal * norm_mat;
norm1.normVec();
normals.push_back(norm1);
vertices.push_back(face.mVertices[v2].mPosition*mat);
LLVector3 norm2 = face.mVertices[v2].mNormal * norm_mat;
norm2.normVec();
normals.push_back(norm2);
segments.push_back(vertices.size());
}
}
}
#endif
}
}
}
S32 LLVolume::lineSegmentIntersect(const LLVector3& start, const LLVector3& end,
S32 face,
LLVector3* intersection,LLVector2* tex_coord, LLVector3* normal, LLVector3* bi_normal)
{
S32 hit_face = -1;
S32 start_face;
S32 end_face;
if (face == -1) // ALL_SIDES
{
start_face = 0;
end_face = getNumVolumeFaces() - 1;
}
else
{
start_face = face;
end_face = face;
}
LLVector3 dir = end - start;
F32 closest_t = 2.f; // must be larger than 1
for (S32 i = start_face; i <= end_face; i++)
{
const LLVolumeFace &face = getVolumeFace((U32)i);
LLVector3 box_center = (face.mExtents[0] + face.mExtents[1]) / 2.f;
LLVector3 box_size = face.mExtents[1] - face.mExtents[0];
if (LLLineSegmentBoxIntersect(start, end, box_center, box_size))
{
if (bi_normal != NULL) // if the caller wants binormals, we may need to generate them
{
genBinormals(i);
}
for (U32 tri = 0; tri < face.mIndices.size()/3; tri++)
{
S32 index1 = face.mIndices[tri*3+0];
S32 index2 = face.mIndices[tri*3+1];
S32 index3 = face.mIndices[tri*3+2];
F32 a, b, t;
if (LLTriangleRayIntersect(face.mVertices[index1].mPosition,
face.mVertices[index2].mPosition,
face.mVertices[index3].mPosition,
start, dir, &a, &b, &t, FALSE))
{
if ((t >= 0.f) && // if hit is after start
(t <= 1.f) && // and before end
(t < closest_t)) // and this hit is closer
{
closest_t = t;
hit_face = i;
if (intersection != NULL)
{
*intersection = start + dir * closest_t;
}
if (tex_coord != NULL)
{
*tex_coord = ((1.f - a - b) * face.mVertices[index1].mTexCoord +
a * face.mVertices[index2].mTexCoord +
b * face.mVertices[index3].mTexCoord);
}
if (normal != NULL)
{
*normal = ((1.f - a - b) * face.mVertices[index1].mNormal +
a * face.mVertices[index2].mNormal +
b * face.mVertices[index3].mNormal);
}
if (bi_normal != NULL)
{
*bi_normal = ((1.f - a - b) * face.mVertices[index1].mBinormal +
a * face.mVertices[index2].mBinormal +
b * face.mVertices[index3].mBinormal);
}
}
}
}
}
}
return hit_face;
}
class LLVertexIndexPair
{
public:
LLVertexIndexPair(const LLVector3 &vertex, const S32 index);
LLVector3 mVertex;
S32 mIndex;
};
LLVertexIndexPair::LLVertexIndexPair(const LLVector3 &vertex, const S32 index)
{
mVertex = vertex;
mIndex = index;
}
const F32 VERTEX_SLOP = 0.00001f;
const F32 VERTEX_SLOP_SQRD = VERTEX_SLOP * VERTEX_SLOP;
struct lessVertex
{
bool operator()(const LLVertexIndexPair *a, const LLVertexIndexPair *b)
{
const F32 slop = VERTEX_SLOP;
if (a->mVertex.mV[0] + slop < b->mVertex.mV[0])
{
return TRUE;
}
else if (a->mVertex.mV[0] - slop > b->mVertex.mV[0])
{
return FALSE;
}
if (a->mVertex.mV[1] + slop < b->mVertex.mV[1])
{
return TRUE;
}
else if (a->mVertex.mV[1] - slop > b->mVertex.mV[1])
{
return FALSE;
}
if (a->mVertex.mV[2] + slop < b->mVertex.mV[2])
{
return TRUE;
}
else if (a->mVertex.mV[2] - slop > b->mVertex.mV[2])
{
return FALSE;
}
return FALSE;
}
};
struct lessTriangle
{
bool operator()(const S32 *a, const S32 *b)
{
if (*a < *b)
{
return TRUE;
}
else if (*a > *b)
{
return FALSE;
}
if (*(a+1) < *(b+1))
{
return TRUE;
}
else if (*(a+1) > *(b+1))
{
return FALSE;
}
if (*(a+2) < *(b+2))
{
return TRUE;
}
else if (*(a+2) > *(b+2))
{
return FALSE;
}
return FALSE;
}
};
BOOL equalTriangle(const S32 *a, const S32 *b)
{
if ((*a == *b) && (*(a+1) == *(b+1)) && (*(a+2) == *(b+2)))
{
return TRUE;
}
return FALSE;
}
BOOL LLVolume::cleanupTriangleData( const S32 num_input_vertices,
const std::vector<Point>& input_vertices,
const S32 num_input_triangles,
S32 *input_triangles,
S32 &num_output_vertices,
LLVector3 **output_vertices,
S32 &num_output_triangles,
S32 **output_triangles)
{
LLMemType m1(LLMemType::MTYPE_VOLUME);
/* Testing: avoid any cleanup
static BOOL skip_cleanup = TRUE;
if ( skip_cleanup )
{
num_output_vertices = num_input_vertices;
num_output_triangles = num_input_triangles;
*output_vertices = new LLVector3[num_input_vertices];
for (S32 index = 0; index < num_input_vertices; index++)
{
(*output_vertices)[index] = input_vertices[index].mPos;
}
*output_triangles = new S32[num_input_triangles*3];
memcpy(*output_triangles, input_triangles, 3*num_input_triangles*sizeof(S32)); // Flawfinder: ignore
return TRUE;
}
*/
// Here's how we do this:
// Create a structure which contains the original vertex index and the
// LLVector3 data.
// "Sort" the data by the vectors
// Create an array the size of the old vertex list, with a mapping of
// old indices to new indices.
// Go through triangles, shift so the lowest index is first
// Sort triangles by first index
// Remove duplicate triangles
// Allocate and pack new triangle data.
//LLTimer cleanupTimer;
//llinfos << "In vertices: " << num_input_vertices << llendl;
//llinfos << "In triangles: " << num_input_triangles << llendl;
S32 i;
typedef std::multiset<LLVertexIndexPair*, lessVertex> vertex_set_t;
vertex_set_t vertex_list;
LLVertexIndexPair *pairp = NULL;
for (i = 0; i < num_input_vertices; i++)
{
LLVertexIndexPair *new_pairp = new LLVertexIndexPair(input_vertices[i].mPos, i);
vertex_list.insert(new_pairp);
}
// Generate the vertex mapping and the list of vertices without
// duplicates. This will crash if there are no vertices.
llassert(num_input_vertices > 0); // check for no vertices!
S32 *vertex_mapping = new S32[num_input_vertices];
LLVector3 *new_vertices = new LLVector3[num_input_vertices];
LLVertexIndexPair *prev_pairp = NULL;
S32 new_num_vertices;
new_num_vertices = 0;
for (vertex_set_t::iterator iter = vertex_list.begin(),
end = vertex_list.end();
iter != end; iter++)
{
pairp = *iter;
if (!prev_pairp || ((pairp->mVertex - prev_pairp->mVertex).magVecSquared() >= VERTEX_SLOP_SQRD))
{
new_vertices[new_num_vertices] = pairp->mVertex;
//llinfos << "Added vertex " << new_num_vertices << " : " << pairp->mVertex << llendl;
new_num_vertices++;
// Update the previous
prev_pairp = pairp;
}
else
{
//llinfos << "Removed duplicate vertex " << pairp->mVertex << ", distance magVecSquared() is " << (pairp->mVertex - prev_pairp->mVertex).magVecSquared() << llendl;
}
vertex_mapping[pairp->mIndex] = new_num_vertices - 1;
}
// Iterate through triangles and remove degenerates, re-ordering vertices
// along the way.
S32 *new_triangles = new S32[num_input_triangles * 3];
S32 new_num_triangles = 0;
for (i = 0; i < num_input_triangles; i++)
{
S32 v1 = i*3;
S32 v2 = v1 + 1;
S32 v3 = v1 + 2;
//llinfos << "Checking triangle " << input_triangles[v1] << ":" << input_triangles[v2] << ":" << input_triangles[v3] << llendl;
input_triangles[v1] = vertex_mapping[input_triangles[v1]];
input_triangles[v2] = vertex_mapping[input_triangles[v2]];
input_triangles[v3] = vertex_mapping[input_triangles[v3]];
if ((input_triangles[v1] == input_triangles[v2])
|| (input_triangles[v1] == input_triangles[v3])
|| (input_triangles[v2] == input_triangles[v3]))
{
//llinfos << "Removing degenerate triangle " << input_triangles[v1] << ":" << input_triangles[v2] << ":" << input_triangles[v3] << llendl;
// Degenerate triangle, skip
continue;
}
if (input_triangles[v1] < input_triangles[v2])
{
if (input_triangles[v1] < input_triangles[v3])
{
// (0 < 1) && (0 < 2)
new_triangles[new_num_triangles*3] = input_triangles[v1];
new_triangles[new_num_triangles*3+1] = input_triangles[v2];
new_triangles[new_num_triangles*3+2] = input_triangles[v3];
}
else
{
// (0 < 1) && (2 < 0)
new_triangles[new_num_triangles*3] = input_triangles[v3];
new_triangles[new_num_triangles*3+1] = input_triangles[v1];
new_triangles[new_num_triangles*3+2] = input_triangles[v2];
}
}
else if (input_triangles[v2] < input_triangles[v3])
{
// (1 < 0) && (1 < 2)
new_triangles[new_num_triangles*3] = input_triangles[v2];
new_triangles[new_num_triangles*3+1] = input_triangles[v3];
new_triangles[new_num_triangles*3+2] = input_triangles[v1];
}
else
{
// (1 < 0) && (2 < 1)
new_triangles[new_num_triangles*3] = input_triangles[v3];
new_triangles[new_num_triangles*3+1] = input_triangles[v1];
new_triangles[new_num_triangles*3+2] = input_triangles[v2];
}
new_num_triangles++;
}
if (new_num_triangles == 0)
{
llwarns << "Created volume object with 0 faces." << llendl;
delete[] new_triangles;
delete[] vertex_mapping;
delete[] new_vertices;
return FALSE;
}
typedef std::set<S32*, lessTriangle> triangle_set_t;
triangle_set_t triangle_list;
for (i = 0; i < new_num_triangles; i++)
{
triangle_list.insert(&new_triangles[i*3]);
}
// Sort through the triangle list, and delete duplicates
S32 *prevp = NULL;
S32 *curp = NULL;
S32 *sorted_tris = new S32[new_num_triangles*3];
S32 cur_tri = 0;
for (triangle_set_t::iterator iter = triangle_list.begin(),
end = triangle_list.end();
iter != end; iter++)
{
curp = *iter;
if (!prevp || !equalTriangle(prevp, curp))
{
//llinfos << "Added triangle " << *curp << ":" << *(curp+1) << ":" << *(curp+2) << llendl;
sorted_tris[cur_tri*3] = *curp;
sorted_tris[cur_tri*3+1] = *(curp+1);
sorted_tris[cur_tri*3+2] = *(curp+2);
cur_tri++;
prevp = curp;
}
else
{
//llinfos << "Skipped triangle " << *curp << ":" << *(curp+1) << ":" << *(curp+2) << llendl;
}
}
*output_vertices = new LLVector3[new_num_vertices];
num_output_vertices = new_num_vertices;
for (i = 0; i < new_num_vertices; i++)
{
(*output_vertices)[i] = new_vertices[i];
}
*output_triangles = new S32[cur_tri*3];
num_output_triangles = cur_tri;
memcpy(*output_triangles, sorted_tris, 3*cur_tri*sizeof(S32)); /* Flawfinder: ignore */
/*
llinfos << "Out vertices: " << num_output_vertices << llendl;
llinfos << "Out triangles: " << num_output_triangles << llendl;
for (i = 0; i < num_output_vertices; i++)
{
llinfos << i << ":" << (*output_vertices)[i] << llendl;
}
for (i = 0; i < num_output_triangles; i++)
{
llinfos << i << ":" << (*output_triangles)[i*3] << ":" << (*output_triangles)[i*3+1] << ":" << (*output_triangles)[i*3+2] << llendl;
}
*/
//llinfos << "Out vertices: " << num_output_vertices << llendl;
//llinfos << "Out triangles: " << num_output_triangles << llendl;
delete[] vertex_mapping;
vertex_mapping = NULL;
delete[] new_vertices;
new_vertices = NULL;
delete[] new_triangles;
new_triangles = NULL;
delete[] sorted_tris;
sorted_tris = NULL;
triangle_list.clear();
std::for_each(vertex_list.begin(), vertex_list.end(), DeletePointer());
vertex_list.clear();
return TRUE;
}
BOOL LLVolumeParams::importFile(LLFILE *fp)
{
LLMemType m1(LLMemType::MTYPE_VOLUME);
//llinfos << "importing volume" << llendl;
const S32 BUFSIZE = 16384;
char buffer[BUFSIZE]; /* Flawfinder: ignore */
// *NOTE: changing the size or type of this buffer will require
// changing the sscanf below.
char keyword[256]; /* Flawfinder: ignore */
keyword[0] = 0;
while (!feof(fp))
{
if (fgets(buffer, BUFSIZE, fp) == NULL)
{
buffer[0] = '';
}
sscanf(buffer, " %255s", keyword); /* Flawfinder: ignore */
if (!strcmp("{", keyword))
{
continue;
}
if (!strcmp("}",keyword))
{
break;
}
else if (!strcmp("profile", keyword))
{
mProfileParams.importFile(fp);
}
else if (!strcmp("path",keyword))
{
mPathParams.importFile(fp);
}
else
{
llwarns << "unknown keyword " << keyword << " in volume import" << llendl;
}
}
return TRUE;
}
BOOL LLVolumeParams::exportFile(LLFILE *fp) const
{
fprintf(fp,"tshape 0n");
fprintf(fp,"t{n");
mPathParams.exportFile(fp);
mProfileParams.exportFile(fp);
fprintf(fp, "t}n");
return TRUE;
}
BOOL LLVolumeParams::importLegacyStream(std::istream& input_stream)
{
LLMemType m1(LLMemType::MTYPE_VOLUME);
//llinfos << "importing volume" << llendl;
const S32 BUFSIZE = 16384;
// *NOTE: changing the size or type of this buffer will require
// changing the sscanf below.
char buffer[BUFSIZE]; /* Flawfinder: ignore */
char keyword[256]; /* Flawfinder: ignore */
keyword[0] = 0;
while (input_stream.good())
{
input_stream.getline(buffer, BUFSIZE);
sscanf(buffer, " %255s", keyword);
if (!strcmp("{", keyword))
{
continue;
}
if (!strcmp("}",keyword))
{
break;
}
else if (!strcmp("profile", keyword))
{
mProfileParams.importLegacyStream(input_stream);
}
else if (!strcmp("path",keyword))
{
mPathParams.importLegacyStream(input_stream);
}
else
{
llwarns << "unknown keyword " << keyword << " in volume import" << llendl;
}
}
return TRUE;
}
BOOL LLVolumeParams::exportLegacyStream(std::ostream& output_stream) const
{
LLMemType m1(LLMemType::MTYPE_VOLUME);
output_stream <<"tshape 0n";
output_stream <<"t{n";
mPathParams.exportLegacyStream(output_stream);
mProfileParams.exportLegacyStream(output_stream);
output_stream << "t}n";
return TRUE;
}
LLSD LLVolumeParams::asLLSD() const
{
LLSD sd = LLSD();
sd["path"] = mPathParams;
sd["profile"] = mProfileParams;
return sd;
}
bool LLVolumeParams::fromLLSD(LLSD& sd)
{
mPathParams.fromLLSD(sd["path"]);
mProfileParams.fromLLSD(sd["profile"]);
return true;
}
void LLVolumeParams::reduceS(F32 begin, F32 end)
{
begin = llclampf(begin);
end = llclampf(end);
if (begin > end)
{
F32 temp = begin;
begin = end;
end = temp;
}
F32 a = mProfileParams.getBegin();
F32 b = mProfileParams.getEnd();
mProfileParams.setBegin(a + begin * (b - a));
mProfileParams.setEnd(a + end * (b - a));
}
void LLVolumeParams::reduceT(F32 begin, F32 end)
{
begin = llclampf(begin);
end = llclampf(end);
if (begin > end)
{
F32 temp = begin;
begin = end;
end = temp;
}
F32 a = mPathParams.getBegin();
F32 b = mPathParams.getEnd();
mPathParams.setBegin(a + begin * (b - a));
mPathParams.setEnd(a + end * (b - a));
}
const F32 MIN_CONCAVE_PROFILE_WEDGE = 0.125f; // 1/8 unity
const F32 MIN_CONCAVE_PATH_WEDGE = 0.111111f; // 1/9 unity
// returns TRUE if the shape can be approximated with a convex shape
// for collison purposes
BOOL LLVolumeParams::isConvex() const
{
F32 path_length = mPathParams.getEnd() - mPathParams.getBegin();
F32 hollow = mProfileParams.getHollow();
U8 path_type = mPathParams.getCurveType();
if ( path_length > MIN_CONCAVE_PATH_WEDGE
&& ( mPathParams.getTwist() != mPathParams.getTwistBegin()
|| (hollow > 0.f
&& LL_PCODE_PATH_LINE != path_type) ) )
{
// twist along a "not too short" path is concave
return FALSE;
}
F32 profile_length = mProfileParams.getEnd() - mProfileParams.getBegin();
BOOL same_hole = hollow == 0.f
|| (mProfileParams.getCurveType() & LL_PCODE_HOLE_MASK) == LL_PCODE_HOLE_SAME;
F32 min_profile_wedge = MIN_CONCAVE_PROFILE_WEDGE;
U8 profile_type = mProfileParams.getCurveType() & LL_PCODE_PROFILE_MASK;
if ( LL_PCODE_PROFILE_CIRCLE_HALF == profile_type )
{
// it is a sphere and spheres get twice the minimum profile wedge
min_profile_wedge = 2.f * MIN_CONCAVE_PROFILE_WEDGE;
}
BOOL convex_profile = ( ( profile_length == 1.f
|| profile_length <= 0.5f )
&& hollow == 0.f ) // trivially convex
|| ( profile_length <= min_profile_wedge
&& same_hole ); // effectvely convex (even when hollow)
if (!convex_profile)
{
// profile is concave
return FALSE;
}
if ( LL_PCODE_PATH_LINE == path_type )
{
// straight paths with convex profile
return TRUE;
}
BOOL concave_path = (path_length < 1.0f) && (path_length > 0.5f);
if (concave_path)
{
return FALSE;
}
// we're left with spheres, toroids and tubes
if ( LL_PCODE_PROFILE_CIRCLE_HALF == profile_type )
{
// at this stage all spheres must be convex
return TRUE;
}
// it's a toroid or tube
if ( path_length <= MIN_CONCAVE_PATH_WEDGE )
{
// effectively convex
return TRUE;
}
return FALSE;
}
// debug
void LLVolumeParams::setCube()
{
mProfileParams.setCurveType(LL_PCODE_PROFILE_SQUARE);
mProfileParams.setBegin(0.f);
mProfileParams.setEnd(1.f);
mProfileParams.setHollow(0.f);
mPathParams.setBegin(0.f);
mPathParams.setEnd(1.f);
mPathParams.setScale(1.f, 1.f);
mPathParams.setShear(0.f, 0.f);
mPathParams.setCurveType(LL_PCODE_PATH_LINE);
mPathParams.setTwistBegin(0.f);
mPathParams.setTwistEnd(0.f);
mPathParams.setRadiusOffset(0.f);
mPathParams.setTaper(0.f, 0.f);
mPathParams.setRevolutions(0.f);
mPathParams.setSkew(0.f);
}
LLFaceID LLVolume::generateFaceMask()
{
LLFaceID new_mask = 0x0000;
switch(mParams.getProfileParams().getCurveType() & LL_PCODE_PROFILE_MASK)
{
case LL_PCODE_PROFILE_CIRCLE:
case LL_PCODE_PROFILE_CIRCLE_HALF:
new_mask |= LL_FACE_OUTER_SIDE_0;
break;
case LL_PCODE_PROFILE_SQUARE:
{
for(S32 side = (S32)(mParams.getProfileParams().getBegin() * 4.f); side < llceil(mParams.getProfileParams().getEnd() * 4.f); side++)
{
new_mask |= LL_FACE_OUTER_SIDE_0 << side;
}
}
break;
case LL_PCODE_PROFILE_ISOTRI:
case LL_PCODE_PROFILE_EQUALTRI:
case LL_PCODE_PROFILE_RIGHTTRI:
{
for(S32 side = (S32)(mParams.getProfileParams().getBegin() * 3.f); side < llceil(mParams.getProfileParams().getEnd() * 3.f); side++)
{
new_mask |= LL_FACE_OUTER_SIDE_0 << side;
}
}
break;
default:
llerrs << "Unknown profile!" << llendl;
break;
}
// handle hollow objects
if (mParams.getProfileParams().getHollow() > 0)
{
new_mask |= LL_FACE_INNER_SIDE;
}
// handle open profile curves
if (mProfilep->isOpen())
{
new_mask |= LL_FACE_PROFILE_BEGIN | LL_FACE_PROFILE_END;
}
// handle open path curves
if (mPathp->isOpen())
{
new_mask |= LL_FACE_PATH_BEGIN | LL_FACE_PATH_END;
}
return new_mask;
}
BOOL LLVolume::isFaceMaskValid(LLFaceID face_mask)
{
LLFaceID test_mask = 0;
for(S32 i = 0; i < getNumFaces(); i++)
{
test_mask |= mProfilep->mFaces[i].mFaceID;
}
return test_mask == face_mask;
}
BOOL LLVolume::isConvex() const
{
// mParams.isConvex() may return FALSE even though the final
// geometry is actually convex due to LOD approximations.
// TODO -- provide LLPath and LLProfile with isConvex() methods
// that correctly determine convexity. -- Leviathan
return mParams.isConvex();
}
std::ostream& operator<<(std::ostream &s, const LLProfileParams &profile_params)
{
s << "{type=" << (U32) profile_params.mCurveType;
s << ", begin=" << profile_params.mBegin;
s << ", end=" << profile_params.mEnd;
s << ", hollow=" << profile_params.mHollow;
s << "}";
return s;
}
std::ostream& operator<<(std::ostream &s, const LLPathParams &path_params)
{
s << "{type=" << (U32) path_params.mCurveType;
s << ", begin=" << path_params.mBegin;
s << ", end=" << path_params.mEnd;
s << ", twist=" << path_params.mTwistEnd;
s << ", scale=" << path_params.mScale;
s << ", shear=" << path_params.mShear;
s << ", twist_begin=" << path_params.mTwistBegin;
s << ", radius_offset=" << path_params.mRadiusOffset;
s << ", taper=" << path_params.mTaper;
s << ", revolutions=" << path_params.mRevolutions;
s << ", skew=" << path_params.mSkew;
s << "}";
return s;
}
std::ostream& operator<<(std::ostream &s, const LLVolumeParams &volume_params)
{
s << "{profileparams = " << volume_params.mProfileParams;
s << ", pathparams = " << volume_params.mPathParams;
s << "}";
return s;
}
std::ostream& operator<<(std::ostream &s, const LLProfile &profile)
{
s << " {open=" << (U32) profile.mOpen;
s << ", dirty=" << profile.mDirty;
s << ", totalout=" << profile.mTotalOut;
s << ", total=" << profile.mTotal;
s << "}";
return s;
}
std::ostream& operator<<(std::ostream &s, const LLPath &path)
{
s << "{open=" << (U32) path.mOpen;
s << ", dirty=" << path.mDirty;
s << ", step=" << path.mStep;
s << ", total=" << path.mTotal;
s << "}";
return s;
}
std::ostream& operator<<(std::ostream &s, const LLVolume &volume)
{
s << "{params = " << volume.getParams();
s << ", path = " << *volume.mPathp;
s << ", profile = " << *volume.mProfilep;
s << "}";
return s;
}
std::ostream& operator<<(std::ostream &s, const LLVolume *volumep)
{
s << "{params = " << volumep->getParams();
s << ", path = " << *(volumep->mPathp);
s << ", profile = " << *(volumep->mProfilep);
s << "}";
return s;
}
BOOL LLVolumeFace::create(LLVolume* volume, BOOL partial_build)
{
if (mTypeMask & CAP_MASK)
{
return createCap(volume, partial_build);
}
else if ((mTypeMask & END_MASK) || (mTypeMask & SIDE_MASK))
{
return createSide(volume, partial_build);
}
else
{
llerrs << "Unknown/uninitialized face type!" << llendl;
return FALSE;
}
}
void LerpPlanarVertex(LLVolumeFace::VertexData& v0,
LLVolumeFace::VertexData& v1,
LLVolumeFace::VertexData& v2,
LLVolumeFace::VertexData& vout,
F32 coef01,
F32 coef02)
{
vout.mPosition = v0.mPosition + ((v1.mPosition-v0.mPosition)*coef01)+((v2.mPosition-v0.mPosition)*coef02);
vout.mTexCoord = v0.mTexCoord + ((v1.mTexCoord-v0.mTexCoord)*coef01)+((v2.mTexCoord-v0.mTexCoord)*coef02);
vout.mNormal = v0.mNormal;
vout.mBinormal = v0.mBinormal;
}
BOOL LLVolumeFace::createUnCutCubeCap(LLVolume* volume, BOOL partial_build)
{
LLMemType m1(LLMemType::MTYPE_VOLUME);
const std::vector<LLVolume::Point>& mesh = volume->getMesh();
const std::vector<LLVector3>& profile = volume->getProfile().mProfile;
S32 max_s = volume->getProfile().getTotal();
S32 max_t = volume->getPath().mPath.size();
// S32 i;
S32 num_vertices = 0, num_indices = 0;
S32 grid_size = (profile.size()-1)/4;
S32 quad_count = (grid_size * grid_size);
num_vertices = (grid_size+1)*(grid_size+1);
num_indices = quad_count * 4;
LLVector3& min = mExtents[0];
LLVector3& max = mExtents[1];
S32 offset = 0;
if (mTypeMask & TOP_MASK)
offset = (max_t-1) * max_s;
else
offset = mBeginS;
VertexData corners[4];
VertexData baseVert;
for(int t = 0; t < 4; t++){
corners[t].mPosition = mesh[offset + (grid_size*t)].mPos;
corners[t].mTexCoord.mV[0] = profile[grid_size*t].mV[0]+0.5f;
corners[t].mTexCoord.mV[1] = 0.5f - profile[grid_size*t].mV[1];
}
baseVert.mNormal =
((corners[1].mPosition-corners[0].mPosition) %
(corners[2].mPosition-corners[1].mPosition));
baseVert.mNormal.normVec();
if(!(mTypeMask & TOP_MASK)){
baseVert.mNormal *= -1.0f;
}else{
//Swap the UVs on the U(X) axis for top face
LLVector2 swap;
swap = corners[0].mTexCoord;
corners[0].mTexCoord=corners[3].mTexCoord;
corners[3].mTexCoord=swap;
swap = corners[1].mTexCoord;
corners[1].mTexCoord=corners[2].mTexCoord;
corners[2].mTexCoord=swap;
}
baseVert.mBinormal = calc_binormal_from_triangle(
corners[0].mPosition, corners[0].mTexCoord,
corners[1].mPosition, corners[1].mTexCoord,
corners[2].mPosition, corners[2].mTexCoord);
for(int t = 0; t < 4; t++){
corners[t].mBinormal = baseVert.mBinormal;
corners[t].mNormal = baseVert.mNormal;
}
mHasBinormals = TRUE;
if (partial_build)
{
mVertices.clear();
}
S32 vtop = mVertices.size();
for(int gx = 0;gx<grid_size+1;gx++){
for(int gy = 0;gy<grid_size+1;gy++){
VertexData newVert;
LerpPlanarVertex(
corners[0],
corners[1],
corners[3],
newVert,
(F32)gx/(F32)grid_size,
(F32)gy/(F32)grid_size);
mVertices.push_back(newVert);
if (gx == 0 && gy == 0)
{
min = max = newVert.mPosition;
}
else
{
update_min_max(min,max,newVert.mPosition);
}
}
}
mCenter = (min + max) * 0.5f;
if (!partial_build)
{
int idxs[] = {0,1,(grid_size+1)+1,(grid_size+1)+1,(grid_size+1),0};
for(int gx = 0;gx<grid_size;gx++){
for(int gy = 0;gy<grid_size;gy++){
if (mTypeMask & TOP_MASK){
for(int i=5;i>=0;i--)mIndices.push_back(vtop+(gy*(grid_size+1))+gx+idxs[i]);
}else{
for(int i=0;i<6;i++)mIndices.push_back(vtop+(gy*(grid_size+1))+gx+idxs[i]);
}
}
}
}
return TRUE;
}
BOOL LLVolumeFace::createCap(LLVolume* volume, BOOL partial_build)
{
LLMemType m1(LLMemType::MTYPE_VOLUME);
if (!(mTypeMask & HOLLOW_MASK) &&
!(mTypeMask & OPEN_MASK) &&
((volume->getParams().getPathParams().getBegin()==0.0f)&&
(volume->getParams().getPathParams().getEnd()==1.0f))&&
(volume->getParams().getProfileParams().getCurveType()==LL_PCODE_PROFILE_SQUARE &&
volume->getParams().getPathParams().getCurveType()==LL_PCODE_PATH_LINE)
){
return createUnCutCubeCap(volume, partial_build);
}
S32 num_vertices = 0, num_indices = 0;
const std::vector<LLVolume::Point>& mesh = volume->getMesh();
const std::vector<LLVector3>& profile = volume->getProfile().mProfile;
// All types of caps have the same number of vertices and indices
num_vertices = profile.size();
num_indices = (profile.size() - 2)*3;
mVertices.resize(num_vertices);
if (!partial_build)
{
mIndices.resize(num_indices);
}
S32 max_s = volume->getProfile().getTotal();
S32 max_t = volume->getPath().mPath.size();
mCenter.clearVec();
S32 offset = 0;
if (mTypeMask & TOP_MASK)
{
offset = (max_t-1) * max_s;
}
else
{
offset = mBeginS;
}
// Figure out the normal, assume all caps are flat faces.
// Cross product to get normals.
LLVector2 cuv;
LLVector2 min_uv, max_uv;
LLVector3& min = mExtents[0];
LLVector3& max = mExtents[1];
// Copy the vertices into the array
for (S32 i = 0; i < num_vertices; i++)
{
if (mTypeMask & TOP_MASK)
{
mVertices[i].mTexCoord.mV[0] = profile[i].mV[0]+0.5f;
mVertices[i].mTexCoord.mV[1] = profile[i].mV[1]+0.5f;
}
else
{
// Mirror for underside.
mVertices[i].mTexCoord.mV[0] = profile[i].mV[0]+0.5f;
mVertices[i].mTexCoord.mV[1] = 0.5f - profile[i].mV[1];
}
mVertices[i].mPosition = mesh[i + offset].mPos;
if (i == 0)
{
min = max = mVertices[i].mPosition;
min_uv = max_uv = mVertices[i].mTexCoord;
}
else
{
update_min_max(min,max, mVertices[i].mPosition);
update_min_max(min_uv, max_uv, mVertices[i].mTexCoord);
}
}
mCenter = (min+max)*0.5f;
cuv = (min_uv + max_uv)*0.5f;
LLVector3 binormal = calc_binormal_from_triangle(
mCenter, cuv,
mVertices[0].mPosition, mVertices[0].mTexCoord,
mVertices[1].mPosition, mVertices[1].mTexCoord);
binormal.normVec();
LLVector3 d0;
LLVector3 d1;
LLVector3 normal;
d0 = mCenter-mVertices[0].mPosition;
d1 = mCenter-mVertices[1].mPosition;
normal = (mTypeMask & TOP_MASK) ? (d0%d1) : (d1%d0);
normal.normVec();
VertexData vd;
vd.mPosition = mCenter;
vd.mNormal = normal;
vd.mBinormal = binormal;
vd.mTexCoord = cuv;
if (!(mTypeMask & HOLLOW_MASK) && !(mTypeMask & OPEN_MASK))
{
mVertices.push_back(vd);
num_vertices++;
if (!partial_build)
{
vector_append(mIndices, 3);
}
}
for (S32 i = 0; i < num_vertices; i++)
{
mVertices[i].mBinormal = binormal;
mVertices[i].mNormal = normal;
}
mHasBinormals = TRUE;
if (partial_build)
{
return TRUE;
}
if (mTypeMask & HOLLOW_MASK)
{
if (mTypeMask & TOP_MASK)
{
// HOLLOW TOP
// Does it matter if it's open or closed? - djs
S32 pt1 = 0, pt2 = num_vertices - 1;
S32 i = 0;
while (pt2 - pt1 > 1)
{
// Use the profile points instead of the mesh, since you want
// the un-transformed profile distances.
LLVector3 p1 = profile[pt1];
LLVector3 p2 = profile[pt2];
LLVector3 pa = profile[pt1+1];
LLVector3 pb = profile[pt2-1];
p1.mV[VZ] = 0.f;
p2.mV[VZ] = 0.f;
pa.mV[VZ] = 0.f;
pb.mV[VZ] = 0.f;
// Use area of triangle to determine backfacing
F32 area_1a2, area_1ba, area_21b, area_2ab;
area_1a2 = (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +
(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +
(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);
area_1ba = (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +
(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);
area_21b = (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +
(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
area_2ab = (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +
(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +
(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
BOOL use_tri1a2 = TRUE;
BOOL tri_1a2 = TRUE;
BOOL tri_21b = TRUE;
if (area_1a2 < 0)
{
tri_1a2 = FALSE;
}
if (area_2ab < 0)
{
// Can't use, because it contains point b
tri_1a2 = FALSE;
}
if (area_21b < 0)
{
tri_21b = FALSE;
}
if (area_1ba < 0)
{
// Can't use, because it contains point b
tri_21b = FALSE;
}
if (!tri_1a2)
{
use_tri1a2 = FALSE;
}
else if (!tri_21b)
{
use_tri1a2 = TRUE;
}
else
{
LLVector3 d1 = p1 - pa;
LLVector3 d2 = p2 - pb;
if (d1.magVecSquared() < d2.magVecSquared())
{
use_tri1a2 = TRUE;
}
else
{
use_tri1a2 = FALSE;
}
}
if (use_tri1a2)
{
mIndices[i++] = pt1;
mIndices[i++] = pt1 + 1;
mIndices[i++] = pt2;
pt1++;
}
else
{
mIndices[i++] = pt1;
mIndices[i++] = pt2 - 1;
mIndices[i++] = pt2;
pt2--;
}
}
}
else
{
// HOLLOW BOTTOM
// Does it matter if it's open or closed? - djs
llassert(mTypeMask & BOTTOM_MASK);
S32 pt1 = 0, pt2 = num_vertices - 1;
S32 i = 0;
while (pt2 - pt1 > 1)
{
// Use the profile points instead of the mesh, since you want
// the un-transformed profile distances.
LLVector3 p1 = profile[pt1];
LLVector3 p2 = profile[pt2];
LLVector3 pa = profile[pt1+1];
LLVector3 pb = profile[pt2-1];
p1.mV[VZ] = 0.f;
p2.mV[VZ] = 0.f;
pa.mV[VZ] = 0.f;
pb.mV[VZ] = 0.f;
// Use area of triangle to determine backfacing
F32 area_1a2, area_1ba, area_21b, area_2ab;
area_1a2 = (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +
(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +
(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);
area_1ba = (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +
(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);
area_21b = (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +
(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
area_2ab = (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +
(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +
(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
BOOL use_tri1a2 = TRUE;
BOOL tri_1a2 = TRUE;
BOOL tri_21b = TRUE;
if (area_1a2 < 0)
{
tri_1a2 = FALSE;
}
if (area_2ab < 0)
{
// Can't use, because it contains point b
tri_1a2 = FALSE;
}
if (area_21b < 0)
{
tri_21b = FALSE;
}
if (area_1ba < 0)
{
// Can't use, because it contains point b
tri_21b = FALSE;
}
if (!tri_1a2)
{
use_tri1a2 = FALSE;
}
else if (!tri_21b)
{
use_tri1a2 = TRUE;
}
else
{
LLVector3 d1 = p1 - pa;
LLVector3 d2 = p2 - pb;
if (d1.magVecSquared() < d2.magVecSquared())
{
use_tri1a2 = TRUE;
}
else
{
use_tri1a2 = FALSE;
}
}
// Flipped backfacing from top
if (use_tri1a2)
{
mIndices[i++] = pt1;
mIndices[i++] = pt2;
mIndices[i++] = pt1 + 1;
pt1++;
}
else
{
mIndices[i++] = pt1;
mIndices[i++] = pt2;
mIndices[i++] = pt2 - 1;
pt2--;
}
}
}
}
else
{
// Not hollow, generate the triangle fan.
if (mTypeMask & TOP_MASK)
{
if (mTypeMask & OPEN_MASK)
{
// SOLID OPEN TOP
// Generate indices
// This is a tri-fan, so we reuse the same first point for all triangles.
for (S32 i = 0; i < (num_vertices - 2); i++)
{
mIndices[3*i] = num_vertices - 1;
mIndices[3*i+1] = i;
mIndices[3*i+2] = i + 1;
}
}
else
{
// SOLID CLOSED TOP
for (S32 i = 0; i < (num_vertices - 2); i++)
{
//MSMSM fix these caps but only for the un-cut case
mIndices[3*i] = num_vertices - 1;
mIndices[3*i+1] = i;
mIndices[3*i+2] = i + 1;
}
}
}
else
{
if (mTypeMask & OPEN_MASK)
{
// SOLID OPEN BOTTOM
// Generate indices
// This is a tri-fan, so we reuse the same first point for all triangles.
for (S32 i = 0; i < (num_vertices - 2); i++)
{
mIndices[3*i] = num_vertices - 1;
mIndices[3*i+1] = i + 1;
mIndices[3*i+2] = i;
}
}
else
{
// SOLID CLOSED BOTTOM
for (S32 i = 0; i < (num_vertices - 2); i++)
{
//MSMSM fix these caps but only for the un-cut case
mIndices[3*i] = num_vertices - 1;
mIndices[3*i+1] = i + 1;
mIndices[3*i+2] = i;
}
}
}
}
return TRUE;
}
void LLVolumeFace::createBinormals()
{
LLMemType m1(LLMemType::MTYPE_VOLUME);
if (!mHasBinormals)
{
//generate binormals
for (U32 i = 0; i < mIndices.size()/3; i++)
{ //for each triangle
const VertexData& v0 = mVertices[mIndices[i*3+0]];
const VertexData& v1 = mVertices[mIndices[i*3+1]];
const VertexData& v2 = mVertices[mIndices[i*3+2]];
//calculate binormal
LLVector3 binorm = calc_binormal_from_triangle(v0.mPosition, v0.mTexCoord,
v1.mPosition, v1.mTexCoord,
v2.mPosition, v2.mTexCoord);
for (U32 j = 0; j < 3; j++)
{ //add triangle normal to vertices
mVertices[mIndices[i*3+j]].mBinormal += binorm; // * (weight_sum - d[j])/weight_sum;
}
//even out quad contributions
if (i % 2 == 0)
{
mVertices[mIndices[i*3+2]].mBinormal += binorm;
}
else
{
mVertices[mIndices[i*3+1]].mBinormal += binorm;
}
}
//normalize binormals
for (U32 i = 0; i < mVertices.size(); i++)
{
mVertices[i].mBinormal.normVec();
mVertices[i].mNormal.normVec();
}
mHasBinormals = TRUE;
}
}
BOOL LLVolumeFace::createSide(LLVolume* volume, BOOL partial_build)
{
LLMemType m1(LLMemType::MTYPE_VOLUME);
BOOL flat = mTypeMask & FLAT_MASK;
U8 sculpt_type = volume->getParams().getSculptType();
U8 sculpt_stitching = sculpt_type & LL_SCULPT_TYPE_MASK;
BOOL sculpt_invert = sculpt_type & LL_SCULPT_FLAG_INVERT;
BOOL sculpt_mirror = sculpt_type & LL_SCULPT_FLAG_MIRROR;
BOOL sculpt_reverse_horizontal = (sculpt_invert ? !sculpt_mirror : sculpt_mirror); // XOR
S32 num_vertices, num_indices;
const std::vector<LLVolume::Point>& mesh = volume->getMesh();
const std::vector<LLVector3>& profile = volume->getProfile().mProfile;
const std::vector<LLPath::PathPt>& path_data = volume->getPath().mPath;
S32 max_s = volume->getProfile().getTotal();
S32 s, t, i;
F32 ss, tt;
num_vertices = mNumS*mNumT;
num_indices = (mNumS-1)*(mNumT-1)*6;
mVertices.resize(num_vertices);
if (!partial_build)
{
mIndices.resize(num_indices);
mEdge.resize(num_indices);
}
else
{
mHasBinormals = FALSE;
}
LLVector3& face_min = mExtents[0];
LLVector3& face_max = mExtents[1];
mCenter.clearVec();
S32 begin_stex = llfloor( profile[mBeginS].mV[2] );
S32 num_s = ((mTypeMask & INNER_MASK) && (mTypeMask & FLAT_MASK) && mNumS > 2) ? mNumS/2 : mNumS;
S32 cur_vertex = 0;
// Copy the vertices into the array
for (t = mBeginT; t < mBeginT + mNumT; t++)
{
tt = path_data[t].mTexT;
for (s = 0; s < num_s; s++)
{
if (mTypeMask & END_MASK)
{
if (s)
{
ss = 1.f;
}
else
{
ss = 0.f;
}
}
else
{
// Get s value for tex-coord.
if (!flat)
{
ss = profile[mBeginS + s].mV[2];
}
else
{
ss = profile[mBeginS + s].mV[2] - begin_stex;
}
}
if (sculpt_reverse_horizontal)
{
ss = 1.f - ss;
}
// Check to see if this triangle wraps around the array.
if (mBeginS + s >= max_s)
{
// We're wrapping
i = mBeginS + s + max_s*(t-1);
}
else
{
i = mBeginS + s + max_s*t;
}
mVertices[cur_vertex].mPosition = mesh[i].mPos;
mVertices[cur_vertex].mTexCoord = LLVector2(ss,tt);
mVertices[cur_vertex].mNormal = LLVector3(0,0,0);
mVertices[cur_vertex].mBinormal = LLVector3(0,0,0);
if (cur_vertex == 0)
{
face_min = face_max = mesh[i].mPos;
}
else
{
update_min_max(face_min, face_max, mesh[i].mPos);
}
cur_vertex++;
if ((mTypeMask & INNER_MASK) && (mTypeMask & FLAT_MASK) && mNumS > 2 && s > 0)
{
mVertices[cur_vertex].mPosition = mesh[i].mPos;
mVertices[cur_vertex].mTexCoord = LLVector2(ss,tt);
mVertices[cur_vertex].mNormal = LLVector3(0,0,0);
mVertices[cur_vertex].mBinormal = LLVector3(0,0,0);
cur_vertex++;
}
}
if ((mTypeMask & INNER_MASK) && (mTypeMask & FLAT_MASK) && mNumS > 2)
{
if (mTypeMask & OPEN_MASK)
{
s = num_s-1;
}
else
{
s = 0;
}
i = mBeginS + s + max_s*t;
ss = profile[mBeginS + s].mV[2] - begin_stex;
mVertices[cur_vertex].mPosition = mesh[i].mPos;
mVertices[cur_vertex].mTexCoord = LLVector2(ss,tt);
mVertices[cur_vertex].mNormal = LLVector3(0,0,0);
mVertices[cur_vertex].mBinormal = LLVector3(0,0,0);
update_min_max(face_min,face_max,mesh[i].mPos);
cur_vertex++;
}
}
mCenter = (face_min + face_max) * 0.5f;
S32 cur_index = 0;
S32 cur_edge = 0;
BOOL flat_face = mTypeMask & FLAT_MASK;
if (!partial_build)
{
// Now we generate the indices.
for (t = 0; t < (mNumT-1); t++)
{
for (s = 0; s < (mNumS-1); s++)
{
mIndices[cur_index++] = s + mNumS*t; //bottom left
mIndices[cur_index++] = s+1 + mNumS*(t+1); //top right
mIndices[cur_index++] = s + mNumS*(t+1); //top left
mIndices[cur_index++] = s + mNumS*t; //bottom left
mIndices[cur_index++] = s+1 + mNumS*t; //bottom right
mIndices[cur_index++] = s+1 + mNumS*(t+1); //top right
mEdge[cur_edge++] = (mNumS-1)*2*t+s*2+1; //bottom left/top right neighbor face
if (t < mNumT-2) { //top right/top left neighbor face
mEdge[cur_edge++] = (mNumS-1)*2*(t+1)+s*2+1;
}
else if (mNumT <= 3 || volume->getPath().isOpen() == TRUE) { //no neighbor
mEdge[cur_edge++] = -1;
}
else { //wrap on T
mEdge[cur_edge++] = s*2+1;
}
if (s > 0) { //top left/bottom left neighbor face
mEdge[cur_edge++] = (mNumS-1)*2*t+s*2-1;
}
else if (flat_face || volume->getProfile().isOpen() == TRUE) { //no neighbor
mEdge[cur_edge++] = -1;
}
else { //wrap on S
mEdge[cur_edge++] = (mNumS-1)*2*t+(mNumS-2)*2+1;
}
if (t > 0) { //bottom left/bottom right neighbor face
mEdge[cur_edge++] = (mNumS-1)*2*(t-1)+s*2;
}
else if (mNumT <= 3 || volume->getPath().isOpen() == TRUE) { //no neighbor
mEdge[cur_edge++] = -1;
}
else { //wrap on T
mEdge[cur_edge++] = (mNumS-1)*2*(mNumT-2)+s*2;
}
if (s < mNumS-2) { //bottom right/top right neighbor face
mEdge[cur_edge++] = (mNumS-1)*2*t+(s+1)*2;
}
else if (flat_face || volume->getProfile().isOpen() == TRUE) { //no neighbor
mEdge[cur_edge++] = -1;
}
else { //wrap on S
mEdge[cur_edge++] = (mNumS-1)*2*t;
}
mEdge[cur_edge++] = (mNumS-1)*2*t+s*2; //top right/bottom left neighbor face
}
}
}
//generate normals
for (U32 i = 0; i < mIndices.size()/3; i++) //for each triangle
{
const S32 i0 = mIndices[i*3+0];
const S32 i1 = mIndices[i*3+1];
const S32 i2 = mIndices[i*3+2];
const VertexData& v0 = mVertices[i0];
const VertexData& v1 = mVertices[i1];
const VertexData& v2 = mVertices[i2];
//calculate triangle normal
LLVector3 norm = (v0.mPosition-v1.mPosition) % (v0.mPosition-v2.mPosition);
for (U32 j = 0; j < 3; j++)
{ //add triangle normal to vertices
const S32 idx = mIndices[i*3+j];
mVertices[idx].mNormal += norm; // * (weight_sum - d[j])/weight_sum;
}
//even out quad contributions
if ((i & 1) == 0)
{
mVertices[i2].mNormal += norm;
}
else
{
mVertices[i1].mNormal += norm;
}
}
// adjust normals based on wrapping and stitching
BOOL s_bottom_converges = ((mVertices[0].mPosition - mVertices[mNumS*(mNumT-2)].mPosition).magVecSquared() < 0.000001f);
BOOL s_top_converges = ((mVertices[mNumS-1].mPosition - mVertices[mNumS*(mNumT-2)+mNumS-1].mPosition).magVecSquared() < 0.000001f);
if (sculpt_stitching == LL_SCULPT_TYPE_NONE) // logic for non-sculpt volumes
{
if (volume->getPath().isOpen() == FALSE)
{ //wrap normals on T
for (S32 i = 0; i < mNumS; i++)
{
LLVector3 norm = mVertices[i].mNormal + mVertices[mNumS*(mNumT-1)+i].mNormal;
mVertices[i].mNormal = norm;
mVertices[mNumS*(mNumT-1)+i].mNormal = norm;
}
}
if ((volume->getProfile().isOpen() == FALSE) && !(s_bottom_converges))
{ //wrap normals on S
for (S32 i = 0; i < mNumT; i++)
{
LLVector3 norm = mVertices[mNumS*i].mNormal + mVertices[mNumS*i+mNumS-1].mNormal;
mVertices[mNumS * i].mNormal = norm;
mVertices[mNumS * i+mNumS-1].mNormal = norm;
}
}
if (volume->getPathType() == LL_PCODE_PATH_CIRCLE &&
((volume->getProfileType() & LL_PCODE_PROFILE_MASK) == LL_PCODE_PROFILE_CIRCLE_HALF))
{
if (s_bottom_converges)
{ //all lower S have same normal
for (S32 i = 0; i < mNumT; i++)
{
mVertices[mNumS*i].mNormal = LLVector3(1,0,0);
}
}
if (s_top_converges)
{ //all upper S have same normal
for (S32 i = 0; i < mNumT; i++)
{
mVertices[mNumS*i+mNumS-1].mNormal = LLVector3(-1,0,0);
}
}
}
}
else // logic for sculpt volumes
{
BOOL average_poles = FALSE;
BOOL wrap_s = FALSE;
BOOL wrap_t = FALSE;
if (sculpt_stitching == LL_SCULPT_TYPE_SPHERE)
average_poles = TRUE;
if ((sculpt_stitching == LL_SCULPT_TYPE_SPHERE) ||
(sculpt_stitching == LL_SCULPT_TYPE_TORUS) ||
(sculpt_stitching == LL_SCULPT_TYPE_CYLINDER))
wrap_s = TRUE;
if (sculpt_stitching == LL_SCULPT_TYPE_TORUS)
wrap_t = TRUE;
if (average_poles)
{
// average normals for north pole
LLVector3 average(0.0, 0.0, 0.0);
for (S32 i = 0; i < mNumS; i++)
{
average += mVertices[i].mNormal;
}
// set average
for (S32 i = 0; i < mNumS; i++)
{
mVertices[i].mNormal = average;
}
// average normals for south pole
average = LLVector3(0.0, 0.0, 0.0);
for (S32 i = 0; i < mNumS; i++)
{
average += mVertices[i + mNumS * (mNumT - 1)].mNormal;
}
// set average
for (S32 i = 0; i < mNumS; i++)
{
mVertices[i + mNumS * (mNumT - 1)].mNormal = average;
}
}
if (wrap_s)
{
for (S32 i = 0; i < mNumT; i++)
{
LLVector3 norm = mVertices[mNumS*i].mNormal + mVertices[mNumS*i+mNumS-1].mNormal;
mVertices[mNumS * i].mNormal = norm;
mVertices[mNumS * i+mNumS-1].mNormal = norm;
}
}
if (wrap_t)
{
for (S32 i = 0; i < mNumS; i++)
{
LLVector3 norm = mVertices[i].mNormal + mVertices[mNumS*(mNumT-1)+i].mNormal;
mVertices[i].mNormal = norm;
mVertices[mNumS*(mNumT-1)+i].mNormal = norm;
}
}
}
return TRUE;
}
// Finds binormal based on three vertices with texture coordinates.
// Fills in dummy values if the triangle has degenerate texture coordinates.
LLVector3 calc_binormal_from_triangle(
const LLVector3& pos0,
const LLVector2& tex0,
const LLVector3& pos1,
const LLVector2& tex1,
const LLVector3& pos2,
const LLVector2& tex2)
{
LLVector3 rx0( pos0.mV[VX], tex0.mV[VX], tex0.mV[VY] );
LLVector3 rx1( pos1.mV[VX], tex1.mV[VX], tex1.mV[VY] );
LLVector3 rx2( pos2.mV[VX], tex2.mV[VX], tex2.mV[VY] );
LLVector3 ry0( pos0.mV[VY], tex0.mV[VX], tex0.mV[VY] );
LLVector3 ry1( pos1.mV[VY], tex1.mV[VX], tex1.mV[VY] );
LLVector3 ry2( pos2.mV[VY], tex2.mV[VX], tex2.mV[VY] );
LLVector3 rz0( pos0.mV[VZ], tex0.mV[VX], tex0.mV[VY] );
LLVector3 rz1( pos1.mV[VZ], tex1.mV[VX], tex1.mV[VY] );
LLVector3 rz2( pos2.mV[VZ], tex2.mV[VX], tex2.mV[VY] );
LLVector3 r0 = (rx0 - rx1) % (rx0 - rx2);
LLVector3 r1 = (ry0 - ry1) % (ry0 - ry2);
LLVector3 r2 = (rz0 - rz1) % (rz0 - rz2);
if( r0.mV[VX] && r1.mV[VX] && r2.mV[VX] )
{
LLVector3 binormal(
-r0.mV[VZ] / r0.mV[VX],
-r1.mV[VZ] / r1.mV[VX],
-r2.mV[VZ] / r2.mV[VX]);
// binormal.normVec();
return binormal;
}
else
{
return LLVector3( 0, 1 , 0 );
}
}