#include <boost/algorithm/string.hpp>
#include "Format/GeomReaderBuilder.h"
+#include "Format/AssimpReader.h"
SceneMain::SceneMain(void)
{
+ m_CurFrame = 0;
m_ConstantColorStrength = 1.0f;
}
void SceneMain::Initialize(void)
{
- m_DefaultMaterial = lib_graph::MaterialSamples::GetSilver();
+ m_DefaultMaterial = lgr::MaterialSamples::GetSilver();
m_DefaultAlphaMaterial = m_DefaultMaterial;
m_DefaultAlphaMaterial.SetAlphaAll( 0.75f );
m_DefaultTexture.InitializeTexture();
- ClearObjects();
-
m_EnvImg.InitEnvMap();
}
if (fmt == GeomFileFormat::None)
throw FileLoadErrorException("Unknown format");
- if (!ImportFile(path.toLocal8Bit().data(), fmt))
+ std::string f = path.toLocal8Bit().data();
+ if (!ImportFile(f, fmt))
throw FileLoadErrorException("Failed Load Geometry");
}
RefreshObjectIndex();
- return reader->Load(*this, filename);
+ if (!reader->Load(*this, filename))
+ return false;
+
+ UpdateCrossSectionIfRequire(false);
+
+ return true;
}
GeomObject* SceneMain::CreateNewGeometry(void)
}
-void AppendWeight(std::vector<float>& vw, std::vector<lm::vec3f>& vp, lm::matrix4f& mat_parent, GeomObject& g, Bone* b, int frame)
-{
- lm::matrix4f md;
- if(frame == -1)
- md = b->m_NodeTrans;
- else
- md = b->GetFrameMatrix(frame);
-
- md = md * mat_parent;
-
- for(size_t j = 0; j < b->m_Weights.size(); ++j)
- {
- int vid = b->m_Weights[j].m_Vid;
- float weight = b->m_Weights[j].m_Weight;
-
- lm::vec3f v = g.m_BoneAnimation.m_SrcVertPos[vid];
-
- v = v * b->m_Offset * md;
- vw[vid] += weight;
- vp[vid] += v * weight;
- }
-
- for(size_t i = 0; i < b->m_Children.size(); ++i)
- {
- AppendWeight(vw, vp, md, g, b->m_Children[i], frame);
- }
-}
-
void SceneMain::SetFrame(int frame)
{
- GeomObject& g = m_Objects[0];
- lib_geo::BaseMesh& m = g.m_MeshAry[0].m_Mesh;
-
- m.m_Verts = g.m_BoneAnimation.m_SrcVertPos;
-
- std::vector<float> vw(m.m_Verts.size(), 0.0f);
- std::vector<lm::vec3f> vp(m.m_Verts.size());
-
- for (BoneRoot& br : g.m_BoneAnimation.m_RootNodes)
- {
- lm::matrix4f mi = br.m_Transform;
- AppendWeight(vw, vp, mi, g, br.m_Bone, frame);
- }
+ m_CurFrame = frame;
- for (size_t i = 0; i < m.m_Verts.size(); ++i)
+ for (GeomObject& g : m_Objects)
{
- if(vw[i] > 0.0f)
- m.m_Verts[i] = vp[i] / vw[i];
+ g.SetFrameShape(frame);
}
- m.UpdateNormal();
-}
-
-int SceneMain::GetMaxFrame(void) const
-{
- size_t max_frame = 0;
- for (const GeomObject& g : m_Objects)
- {
- for (const Bone& b : g.m_BoneAnimation.m_Bones)
- {
- max_frame = (std::max)(max_frame, b.m_Translate.size());
- max_frame = (std::max)(max_frame, b.m_Scale.size());
- max_frame = (std::max)(max_frame, b.m_Rotate.size());
- }
- }
+ m_Camera.SetFrame(frame);
- return max_frame;
+ UpdateTransform();
}
t.SetScale(1.0);
t.m_Translate.set_zero();
- lm::range3f r = GetSceneBBox();
- if (!r.is_valid())
- return;
-
- if( m_Config.m_EnableAutoCentering )
+ if (m_Config.m_EnableAutoCentering)
{
- t.m_Translate = -r.mid_point();
+ lm::range3f r = GetSceneBBox();
+ if (r.is_valid())
+ t.m_Translate = -r.mid_point();
}
- if( m_Config.m_EnableAutoReisze )
+ if (m_Config.m_EnableAutoReisze)
{
- t.SetScale(1.0f / r.max_length());
+ lm::range3f r = GetSceneBBoxIni();
+ if (r.is_valid())
+ t.SetScale(1.0f / r.max_length());
}
}
//! \8f\8a\97L\8c \82Í\8e\9d\82½\82È\82¢.
void SceneMain::AddObserver(SceneObserver* observer)
{
- m_Observers.push_back( observer );
+ m_Observers.push_back(observer);
}
bool SceneMain::RemoveObserver(size_t idx)
{
- assert( idx < m_Observers.size() );
- if( idx < m_Observers.size() )
+ assert(idx < m_Observers.size());
+ if (idx < m_Observers.size())
return false;
std::vector<SceneObserver*>::iterator i = m_Observers.begin();
- std::advance( i , idx );
- m_Observers.erase( i );
+ std::advance(i, idx);
+ m_Observers.erase(i);
return true;
}
bool SceneMain::RemoveObserver(SceneObserver* registered_observer)
{
- for( size_t i = 0 ; i < m_Observers.size() ; ++i )
+ for (size_t i = 0; i < m_Observers.size(); ++i)
{
- if( m_Observers[i] == registered_observer )
- return RemoveObserver( i );
+ if (m_Observers[i] == registered_observer)
+ return RemoveObserver(i);
}
assert(false);
void SceneMain::ReportDoneEditGeometry(void)
{
- for( size_t i = 0 ; i < m_Observers.size() ; ++i )
+ for (SceneObserver* o : m_Observers)
{
- m_Observers[i]->OnGeometryBuild(*this);
+ o->OnGeometryBuild(*this);
}
}
for (const GeomObject& obj : m_Objects)
{
- bbox.expand(obj.GetBBox());
+ bbox.expand(obj.GetGeomBBox(false));
}
return bbox;
}
+lm::range3f SceneMain::GetSceneBBoxIni(void) const
+{
+ lm::range3f bbox;
+ bbox.clear();
+
+ for (const GeomObject& obj : m_Objects)
+ {
+ bbox.expand(obj.GetGeomBBox(true));
+ }
+
+ return bbox;
+}
+
+
lm::range3f SceneMain::GetSceneTransformedBBox(void) const
{
lm::range3f bbox = GetSceneBBox();
GeomObject* SceneMain::GetPrimaryObject(void)
{
- if (!m_Sels.IsObjectSelected())
+ int idx = GetPrimaryObjectIdx();
+ if (idx == -1)
return NULL;
- return &m_Objects[m_Sels.GetSelObjectIdx()];
+ return &m_Objects[idx];
}
const GeomObject* SceneMain::GetPrimaryObject(void) const
{
- if (!m_Sels.IsObjectSelected())
+ int idx = GetPrimaryObjectIdx();
+ if (idx == -1)
return NULL;
- return &m_Objects[m_Sels.GetSelObjectIdx()];
+ return &m_Objects[idx];
}
+int SceneMain::GetPrimaryObjectIdx(void) const
+{
+ if (m_Objects.empty())
+ return -1;
-MeshBuf* SceneMain::GetPrimaryMeshbuf(void)
+ return m_Sels.GetSelObjectIdx();
+}
+
+
+void SceneMain::GetSelectedMeshes(std::vector<MeshBuf*>& meshes)
{
GeomObject* obj = GetPrimaryObject();
if (obj == NULL)
- return NULL;
+ return;
- if (!m_Sels.IsMBufSelected())
+ if (m_Sels.IsMBufSelected())
+ {
+ meshes.resize(1, &obj->m_MeshAry[m_Sels.GetMBufIdx()]);
+ }
+ else
+ {
+ meshes.reserve(obj->m_MeshAry.size());
+ for (MeshBuf& m : obj->m_MeshAry)
+ {
+ meshes.push_back(&m);
+ }
+ }
+}
+
+MeshBuf* SceneMain::GetPrimaryMeshbuf(void)
+{
+ int idx = GetPrimaryMeshbufIdx();
+ if (idx == -1)
return NULL;
- return &obj->m_MeshAry[m_Sels.GetMBufIdx()];
+ return &GetPrimaryObject()->m_MeshAry[idx];
}
const MeshBuf* SceneMain::GetPrimaryMeshbuf(void) const
{
- const GeomObject* obj = GetPrimaryObject();
- if (obj == NULL)
+ int idx = GetPrimaryMeshbufIdx();
+ if (idx == -1)
return NULL;
+ return &GetPrimaryObject()->m_MeshAry[idx];
+}
+
+int SceneMain::GetPrimaryMeshbufIdx(void) const
+{
+ if (GetPrimaryObject() == NULL)
+ return -1;
+
if (!m_Sels.IsMBufSelected())
- return NULL;
+ return -1;
- return &obj->m_MeshAry[m_Sels.GetMBufIdx()];
+ return m_Sels.GetMBufIdx();
}
-GeomTextureSet* SceneMain::GetSelectedTexture(void)
+MeshBuf* SceneMain::GetSelOrFirstMeshbuf(void)
{
- int idx = GetSelectedMatIdx();
- if (idx == -1)
+ GeomObject* o = GetPrimaryObject();
+ if (o == NULL)
return NULL;
+ if (o->m_MeshAry.empty())
+ return NULL;
+
+ if (m_Sels.IsMBufSelected())
+ return &o->m_MeshAry[m_Sels.GetMBufIdx()];
- return GetPrimaryMeshbuf()->GetTexture(idx);
+ return &o->m_MeshAry[0];
}
-lib_geo::BaseMaterial* SceneMain::GetSelectedMaterial(void)
+const MeshBuf* SceneMain::GetSelOrFirstMeshbuf(void) const
{
- int idx = GetSelectedMatIdx();
- if (idx == -1)
+ const GeomObject* o = GetPrimaryObject();
+ if (o == NULL)
+ return NULL;
+ if (o->m_MeshAry.empty())
return NULL;
- return GetPrimaryMeshbuf()->GetMaterial(idx);
+ if (m_Sels.IsMBufSelected())
+ return &o->m_MeshAry[m_Sels.GetMBufIdx()];
+
+ return &o->m_MeshAry[0];
}
-int SceneMain::GetSelectedMatIdx(void)
+GeomTextureSet* SceneMain::GetSelectedTexture(void)
{
- MeshBuf* mbuf = GetPrimaryMeshbuf();
+ MeshBuf* mbuf = GetSelOrFirstMeshbuf();
if (mbuf == NULL)
- return -1;
+ return NULL;
- int idx = m_Sels.GetSelMat();
- if (!mbuf->IsValidMaterialIdx(idx))
- return -1;
+ return mbuf->GeSeltTexture();
+}
- return idx;
+lib_geo::BaseMaterial* SceneMain::GetSelectedMaterial(void)
+{
+ MeshBuf* mbuf = GetSelOrFirstMeshbuf();
+ if (mbuf == NULL)
+ return NULL;
+
+ return mbuf->GetSelMaterial();
}
i += sel_idx;
if (i->IsInChild(m_Cursor3d.CloseFaceMBuf))
- {
m_Cursor3d.ResetCloseFace();
- }
m_Objects.erase(i);
+ m_Sels.ClearSelect();
+
RefreshObjectIndex();
}
void SceneMain::RefreshObjectIndex(void)
{
+ size_t io = 0;
for (size_t i = 0; i < m_Objects.size(); ++i)
{
GeomObject& o = m_Objects[i];
- o.m_ObjectIndex = (int)i;
+ o.SetObjectIndex((int)i);
for (size_t j = 0; j < o.m_MeshAry.size(); ++j)
{
MeshBuf& m = o.m_MeshAry[j];
m.m_MBufIdx = (int)j;
+ m.m_WholeIndex = (int)(j + io);
}
+ io += o.m_MeshAry.size();
}
}
bool SceneMain::ReloadObject(GeomObject* obj)
{
- if(!obj->IsFileObject())
+ if (!obj->IsFileObject())
return false;
int idx = FindObjectIdx(obj);
return false;
}
+ if (obj->IsInChild(m_Cursor3d.CloseFaceMBuf))
+ m_Cursor3d.ResetCloseFace();
+
geom::GeomFileFormat fmt = obj->m_FileFormat;
const std::string filename = obj->m_FilePath;
- RemoveItem(idx);
+ boost::ptr_vector<GeomObject>::iterator i;
+ i = m_Objects.begin();
+ i += idx;
+ m_Objects.erase(i);
+
+ m_Sels.ClearSelect();
+
+ std::auto_ptr<GeomFileReader> reader;
+ reader.reset(GeomReaderBuilder::Create(fmt));
+ if (reader.get() == NULL)
+ {
+ assert(false);
+ return false;
+ }
+
+ RefreshObjectIndex();
- return ImportFile(filename, fmt);
+ if (!reader->Load(*this, filename))
+ return false;
+
+ UpdateCrossSectionIfRequire(false);
+
+ return true;
}
int SceneMain::FindObjectIdx(const GeomObject* obj) const
{
for (const GeomObject& o : m_Objects)
{
- if(&o == obj)
+ if (&o == obj)
return o.GetObjectIndex();
}
}
-void SceneMain::ShowAllObjects(void)
+void SceneMain::ShowAllObject(void)
{
- for (GeomObject& obj : m_Objects)
+ for (GeomObject& o : m_Objects)
{
- obj.m_Visible = false;
+ o.m_Visible = true;
+ for (MeshBuf& m : o.m_MeshAry)
+ m.m_Visible = true;
}
}
-void SceneMain::ClearAllVertSelect(void)
+void SceneMain::HideAllObject(void)
{
- for (GeomObject& obj : m_Objects)
+ for (GeomObject& o : m_Objects)
{
- for (MeshBuf& mbuf : obj.m_MeshAry)
- {
- mbuf.ClearSelect();
- }
+ o.m_Visible = false;
+ for (MeshBuf& m : o.m_MeshAry)
+ m.m_Visible = false;
}
}
-std::vector<GeomObject*> SceneMain::GetVisibleObjects(void)
+void SceneMain::ClearAllVertSelect(void)
{
- std::vector<GeomObject*> ov;
- ov.reserve(m_Objects.size());
-
for (GeomObject& obj : m_Objects)
{
- if (obj.m_Visible)
- ov.push_back(&obj);
+ for (MeshBuf& mbuf : obj.m_MeshAry)
+ {
+ mbuf.ClearSelect();
+ }
}
-
- return ov;
}
}
}
-void SceneMain::GetFreeCutParam(lm::vec3f& p, lm::vec3f& n)
-{
- Cursor3D& c = m_Cursor3d;
- p = c.CursorPos;
- n = c.MeasureNorm;
-}
-
void SceneMain::UpdateCrossSectionIfRequire(bool force_update)
{
const CrossSectionConfig& conf = m_CrossSectionConfig;
lib_geo::Plane cutplane;
if (conf.IsFreeCut())
- GetFreeCutParam(cutplane.origin, cutplane.normal);
+ m_Cursor3d.GetFreeCutParam(cutplane.origin, cutplane.normal);
else
conf.GetCutPlane(GetSceneBBox(), cutplane);
}
}
}
+
+std::vector<MeshBuf*> SceneMain::GetCurSelMeshes(void)
+{
+ MeshBuf* mbuf = GetPrimaryMeshbuf();
+ if (mbuf != NULL)
+ std::vector<MeshBuf*>(1, mbuf);
+
+ GeomObject* geo = GetPrimaryObject();
+ std::vector<MeshBuf*> mv;
+ if (geo != NULL)
+ {
+ for (MeshBuf& m : geo->m_MeshAry)
+ {
+ mv.push_back(&m);
+ }
+ }
+
+ return mv;
+}
+
+void SceneMain::FlipCurselFace(bool normal_only)
+{
+ std::vector<MeshBuf*> mv = GetCurSelMeshes();
+ for (MeshBuf* m : mv)
+ {
+ m->FlipFace(normal_only);
+ }
+}
+
+void SceneMain::RebuildCurselNormal(void)
+{
+ GeomObject* geo = GetPrimaryObject();
+ if (geo == NULL)
+ return;
+
+ geo->ResetSmoothNormal();
+}
+
+int SceneMain::GetKeyframeMax(void) const
+{
+ int kf = 0;
+ for (const GeomObject& obj : m_Objects)
+ {
+ kf = (std::max)(kf, obj.m_GTree.GetKeyframeMax());
+ }
+
+ kf = (std::max)(kf, m_Camera.m_SeqTrans.GetNumframes());
+
+ return kf;
+}
+
+float SceneMain::GetCursorSphereClipLen(void) const
+{
+ return GetCursorSphereClipLen(GetSceneBBox());
+}
+
+float SceneMain::GetCursorSphereClipLen(const lm::range3f& scene_bb) const
+{
+ return m_Cursor3d.GetSphereClipLen(scene_bb);
+}
+
+bool SceneMain::IsOutOfSphereClip(const lm::vec3f& v) const
+{
+ return IsOutOfSphereClip(GetSceneBBox(), v);
+}
+
+bool SceneMain::IsOutOfSphereClip(const lm::range3f& scene_bb, const lm::vec3f& v) const
+{
+ float l = GetCursorSphereClipLen(scene_bb);
+ float lsq = l * l;
+ float dsq = (v - m_Cursor3d.CursorPos).square_length();
+
+ if (m_Cursor3d.SphereClip == SphereClipType::Hole)
+ return (lsq > dsq);
+ if (m_Cursor3d.SphereClip == SphereClipType::ShowAround)
+ return (lsq < dsq);
+
+ return false;
+}
+
+bool SceneMain::LoadCameraSeq(const char* filename)
+{
+ AssimpReader reader;
+ return reader.LoadCamera(*this, filename);
+}
OSDN Git Service
