82 lines
2.5 KiB
C++
82 lines
2.5 KiB
C++
/* -----------------------------------------------------------------------------
|
|
GSFramework
|
|
Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
|
|
----------------------------------------------------------------------------- */
|
|
|
|
|
|
#include "core/geometry.h"
|
|
#include "log/log.h"
|
|
|
|
using namespace GS;
|
|
using namespace GS::Core;
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
bool Geometry::ComputePolygonNormal(bool force)
|
|
{
|
|
if (!pol.GetCount() || !vtx.GetCount())
|
|
return false;
|
|
|
|
if (!force && (pol_normal.GetCount() == pol.GetCount()))
|
|
return true;
|
|
|
|
if (!pol_normal.Allocate(pol.GetCount()))
|
|
__ERR__(__LOG_E__ << "Geometry::ComputePolygonNormal() failed to allocate buffer.\n", false)
|
|
|
|
for (uint c = 0; c < pol.GetCount(); ++c)
|
|
if (pol[c].vtx_count > 2)
|
|
{
|
|
Vector4 va = vtx[pol[c].binding[2]] - vtx[pol[c].binding[0]],
|
|
vb = vtx[pol[c].binding[1]] - vtx[pol[c].binding[0]];
|
|
pol_normal[c] = vb.Cross(va).Normalized();
|
|
}
|
|
else
|
|
pol_normal[c].Set();
|
|
|
|
return true;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
bool Geometry::ComputeVertexNormal(Array <Vector4> &buffer, float msa)
|
|
{
|
|
if (!pol.GetCount() || !vtx.GetCount())
|
|
return false;
|
|
|
|
if (!ComputePolygonNormal())
|
|
return false;
|
|
|
|
Array <VertexToPolygon> vtx_to_pol;
|
|
ComputeVertexToPolygon(vtx_to_pol);
|
|
|
|
// Allocate full blown edge normal array.
|
|
__LOG__ << "Compute vertex normal for " << name << ".\n";
|
|
|
|
if (!binding.GetCount())
|
|
__ERR__(__LOG_E__ << "The total binding count is wrong. Check that the importer did properly update this flag.\n", false)
|
|
if (!vtx_normal.Allocate(binding.GetCount()))
|
|
__ERR__(__LOG_E__ << "Failed to allocate vertex normal buffer.\n", false)
|
|
|
|
for (uint cp = 0, ttp = 0; cp < pol.GetCount(); cp++)
|
|
for (uint cv = 0; cv < pol[cp].vtx_count; cv++)
|
|
{
|
|
uint gv = pol[cp].binding[cv];
|
|
|
|
Vector4 normal(0, 0, 0);
|
|
for (uint cg = 0; cg < vtx_to_pol[gv].pol_count; cg++)
|
|
if (pol_normal[cp].Dot(pol_normal[vtx_to_pol[gv].pol_index[cg]]) > msa) // MSA test.
|
|
normal += pol_normal[vtx_to_pol[gv].pol_index[cg]];
|
|
|
|
vtx_normal[ttp++] = normal.Normalized();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
bool Geometry::ComputeVertexNormal(float msa, bool force)
|
|
{
|
|
if (!force && (vtx_normal.GetCount() == binding.GetCount()))
|
|
return true;
|
|
return ComputeVertexNormal(vtx_normal, msa);
|
|
}
|
|
//------------------------------------------------------------------------------
|