Src/LibQtGeoViewerCore/SceneMain.cpp

   1 #include "StdAfx.h"
   2 #include "SceneMain.h"
   3
   4 #include <LibGeo/Path.h>
   5
   6 #include <C2/graph/MaterialSamples.h>
   7 #include <C2/gl/GlApiExt.h>
   8
   9 #include <C2/util/string_util.h>
  10
  11 #include <QFileInfo>
  12
  13 #include <sstream>
  14 #include <map>
  15
  16 #include <boost/algorithm/string.hpp>
  17
  18 #include "Format/GeomReaderBuilder.h"
  19
  20
  21
  22 SceneMain::SceneMain(void)
  23 {
  24         m_CurFrame = 0;
  25         m_ConstantColorStrength = 1.0f;
  26 }
  27
  28 void SceneMain::Initialize(void)
  29 {
  30         m_DefaultMaterial = lib_graph::MaterialSamples::GetSilver();
  31
  32         m_DefaultAlphaMaterial = m_DefaultMaterial;
  33         m_DefaultAlphaMaterial.SetAlphaAll( 0.75f );
  34
  35         m_DefaultTexture.InitializeTexture();
  36
  37         ClearObjects();
  38
  39         m_EnvImg.InitEnvMap();
  40 }
  41
  42 void SceneMain::FinalizeScene(void)
  43 {
  44         m_DefaultTexture.FinalizeTexture();
  45
  46         m_Observers.clear();
  47
  48         m_EnvImg.ClearEnv();
  49 }
  50
  51 void SceneMain::ClearObjects(void)
  52 {
  53         for (GeomObject& obj : m_Objects)
  54         {
  55                 obj.ClearObject();
  56         }
  57
  58         m_Objects.clear();
  59         m_Cursor3d.ResetCloseFace();
  60
  61         ReportDoneEditGeometry();
  62 }
  63
  64
  65 void SceneMain::ImportFileAutoFmt(const QString& path)
  66 {
  67         geom::GeomFileFormat fmt = FormatType::GetGeomFileTypeFromPath(path);
  68         if (fmt == GeomFileFormat::None)
  69                 throw FileLoadErrorException("Unknown format");
  70
  71         std::string f = path.toLocal8Bit().data();
  72         if (!ImportFile(f, fmt))
  73                 throw FileLoadErrorException("Failed Load Geometry");
  74 }
  75
  76 bool SceneMain::ImportFile(const std::string& filename, geom::GeomFileFormat fmt)
  77 {
  78         std::auto_ptr<GeomFileReader> reader;
  79         reader.reset(GeomReaderBuilder::Create(fmt));
  80         if (reader.get() == NULL)
  81         {
  82                 assert(false);
  83                 return false;
  84         }
  85
  86         RefreshObjectIndex();
  87
  88         return reader->Load(*this, filename);
  89 }
  90
  91 GeomObject* SceneMain::CreateNewGeometry(void)
  92 {
  93         GeomObject* geom = new GeomObject();
  94         m_Objects.push_back(geom);
  95         RefreshObjectIndex();
  96
  97         return geom;
  98 }
  99
 100
 101 void SceneMain::SetFrame(int frame)
 102 {
 103         m_CurFrame = frame;
 104         for (GeomObject& g : m_Objects)
 105         {
 106                 g.SetFrame(frame);
 107         }
 108
 109         UpdateTransform();
 110 }
 111
 112
 113 void SceneMain::UpdateTransform(void)
 114 {
 115         SceneTransform& t = m_WorldTransform;
 116
 117         t.SetScale(1.0);
 118         t.m_Translate.set_zero();
 119
 120         if (m_Config.m_EnableAutoCentering)
 121         {
 122                 lm::range3f r = GetSceneBBox();
 123                 if (r.is_valid())
 124                         t.m_Translate = -r.mid_point();
 125         }
 126
 127         if (m_Config.m_EnableAutoReisze)
 128         {
 129                 lm::range3f r = GetSceneBBoxIni();
 130                 if (r.is_valid())
 131                         t.SetScale(1.0f / r.max_length());
 132         }
 133 }
 134
 135
 136 void SceneMain::LoadDefaultMatTexture(const std::string& filename)
 137 {
 138         m_DefaultTexture.LoadTextureFromFile(filename.c_str(), true);
 139         m_DefaultTexture.SetTextureGLAndReleaseImage(m_TexConfig);
 140 }
 141
 142
 143 //! \83I\83u\83T\81[\83o\82ð\83Z\83b\83g.
 144 //! \8f\8a\97L\8c \82Í\8e\9d\82½\82È\82¢.
 145 void SceneMain::AddObserver(SceneObserver* observer)
 146 {
 147         m_Observers.push_back(observer);
 148 }
 149
 150 bool SceneMain::RemoveObserver(size_t idx)
 151 {
 152         assert(idx < m_Observers.size());
 153         if (idx < m_Observers.size())
 154                 return false;
 155
 156         std::vector<SceneObserver*>::iterator i = m_Observers.begin();
 157         std::advance(i, idx);
 158         m_Observers.erase(i);
 159
 160         return true;
 161 }
 162
 163 bool SceneMain::RemoveObserver(SceneObserver* registered_observer)
 164 {
 165         for (size_t i = 0; i < m_Observers.size(); ++i)
 166         {
 167                 if (m_Observers[i] == registered_observer)
 168                         return RemoveObserver(i);
 169         }
 170
 171         assert(false);
 172         return false;
 173 }
 174
 175
 176 void SceneMain::ReportDoneEditGeometry(void)
 177 {
 178         for (SceneObserver* o : m_Observers)
 179         {
 180                 o->OnGeometryBuild(*this);
 181         }
 182 }
 183
 184 lm::range3f SceneMain::GetSceneBBox(void) const
 185 {
 186         lm::range3f bbox;
 187         bbox.clear();
 188
 189         for (const GeomObject& obj : m_Objects)
 190         {
 191                 bbox.expand(obj.GetGeomBBox(false));
 192         }
 193
 194         return bbox;
 195 }
 196
 197 lm::range3f SceneMain::GetSceneBBoxIni(void) const
 198 {
 199         lm::range3f bbox;
 200         bbox.clear();
 201
 202         for (const GeomObject& obj : m_Objects)
 203         {
 204                 bbox.expand(obj.GetGeomBBox(true));
 205         }
 206
 207         return bbox;
 208 }
 209
 210
 211 lm::range3f SceneMain::GetSceneTransformedBBox(void) const
 212 {
 213         lm::range3f bbox = GetSceneBBox();
 214
 215         lm::range3f tbb;
 216         tbb.clear();
 217         tbb.expand(m_WorldTransform.TransformVec(bbox.min_point()));
 218         tbb.expand(m_WorldTransform.TransformVec(bbox.max_point()));
 219
 220         return tbb;
 221 }
 222
 223
 224 GeomObject* SceneMain::GetPrimaryObject(void)
 225 {
 226         if (!m_Sels.IsObjectSelected())
 227                 return NULL;
 228
 229         if (m_Objects.empty())
 230                 return NULL;
 231
 232         return &m_Objects[m_Sels.GetSelObjectIdx()];
 233 }
 234
 235 const GeomObject* SceneMain::GetPrimaryObject(void) const
 236 {
 237         if (!m_Sels.IsObjectSelected())
 238                 return NULL;
 239
 240         if (m_Objects.empty())
 241                 return NULL;
 242
 243         return &m_Objects[m_Sels.GetSelObjectIdx()];
 244 }
 245
 246
 247 void SceneMain::GetSelectedMeshes(std::vector<MeshBuf*>& meshes)
 248 {
 249         GeomObject* obj = GetPrimaryObject();
 250         if (obj == NULL)
 251                 return;
 252
 253         if (m_Sels.IsMBufSelected())
 254         {
 255                 meshes.resize(1, &obj->m_MeshAry[m_Sels.GetMBufIdx()]);
 256         }
 257         else
 258         {
 259                 meshes.reserve(obj->m_MeshAry.size());
 260                 for (MeshBuf& m : obj->m_MeshAry)
 261                 {
 262                         meshes.push_back(&m);
 263                 }
 264         }
 265 }
 266
 267 MeshBuf* SceneMain::GetPrimaryMeshbuf(void)
 268 {
 269         GeomObject* obj = GetPrimaryObject();
 270         if (obj == NULL)
 271                 return NULL;
 272
 273         if (!m_Sels.IsMBufSelected())
 274                 return NULL;
 275
 276         return &obj->m_MeshAry[m_Sels.GetMBufIdx()];
 277 }
 278
 279 const MeshBuf* SceneMain::GetPrimaryMeshbuf(void) const
 280 {
 281         const GeomObject* obj = GetPrimaryObject();
 282         if (obj == NULL)
 283                 return NULL;
 284
 285         if (!m_Sels.IsMBufSelected())
 286                 return NULL;
 287
 288         return &obj->m_MeshAry[m_Sels.GetMBufIdx()];
 289 }
 290
 291 GeomTextureSet* SceneMain::GetSelectedTexture(void)
 292 {
 293         int idx = GetSelectedMatIdx();
 294         if (idx == -1)
 295                 return NULL;
 296
 297         return GetPrimaryMeshbuf()->GetTexture(idx);
 298 }
 299
 300 lib_geo::BaseMaterial* SceneMain::GetSelectedMaterial(void)
 301 {
 302         int idx = GetSelectedMatIdx();
 303         if (idx == -1)
 304                 return NULL;
 305
 306         return GetPrimaryMeshbuf()->GetMaterial(idx);
 307 }
 308
 309 int SceneMain::GetSelectedMatIdx(void)
 310 {
 311         MeshBuf* mbuf = GetPrimaryMeshbuf();
 312         if (mbuf == NULL)
 313                 return -1;
 314
 315         int idx = m_Sels.GetSelMat();
 316         if (!mbuf->IsValidMaterialIdx(idx))
 317                 return -1;
 318
 319         return idx;
 320 }
 321
 322
 323 void SceneMain::RemoveItem(int sel_idx)
 324 {
 325         boost::ptr_vector<GeomObject>::iterator i;
 326         i = m_Objects.begin();
 327         i += sel_idx;
 328
 329         if (i->IsInChild(m_Cursor3d.CloseFaceMBuf))
 330                 m_Cursor3d.ResetCloseFace();
 331
 332         m_Objects.erase(i);
 333
 334         m_Sels.ClearSelect();
 335
 336         RefreshObjectIndex();
 337 }
 338
 339
 340 void SceneMain::CreateSampleTexture(SampleTextureBuilder::TextureType tex_type)
 341 {
 342         SDL_Surface* tex = SampleTextureBuilder::CreateTexture(tex_type, 256);
 343         if(tex == NULL)
 344                 return;
 345
 346         m_DefaultTexture.SetFromSDLSurface( tex );
 347         m_DefaultTexture.SetTextureGLAndReleaseImage(m_TexConfig);
 348 }
 349
 350
 351 void SceneMain::RefreshObjectIndex(void)
 352 {
 353         size_t io = 0;
 354         for (size_t i = 0; i < m_Objects.size(); ++i)
 355         {
 356                 GeomObject& o = m_Objects[i];
 357                 o.SetObjectIndex((int)i);
 358                 for (size_t j = 0; j < o.m_MeshAry.size(); ++j)
 359                 {
 360                         MeshBuf& m = o.m_MeshAry[j];
 361                         m.m_MBufIdx = (int)j;
 362                         m.m_WholeIndex = (int)(j + io);
 363                 }
 364                 io += o.m_MeshAry.size();
 365         }
 366 }
 367
 368
 369 bool SceneMain::ReloadObject(GeomObject* obj)
 370 {
 371         if(!obj->IsFileObject())
 372                 return false;
 373
 374         int idx = FindObjectIdx(obj);
 375         if (idx == -1)
 376         {
 377                 assert(false);
 378                 return false;
 379         }
 380
 381         geom::GeomFileFormat fmt = obj->m_FileFormat;
 382         const std::string filename = obj->m_FilePath;
 383
 384         RemoveItem(idx);
 385
 386         return ImportFile(filename, fmt);
 387 }
 388
 389 int SceneMain::FindObjectIdx(const GeomObject* obj) const
 390 {
 391         for (const GeomObject& o : m_Objects)
 392         {
 393                 if(&o == obj)
 394                         return o.GetObjectIndex();
 395         }
 396
 397         return -1;
 398 }
 399
 400
 401 void SceneMain::ShowAllObject(void)
 402 {
 403         for (GeomObject& o : m_Objects)
 404         {
 405                 o.m_Visible = true;
 406                 for (MeshBuf& m : o.m_MeshAry)
 407                         m.m_Visible = true;
 408         }
 409 }
 410
 411 void SceneMain::HideAllObject(void)
 412 {
 413         for (GeomObject& o : m_Objects)
 414         {
 415                 o.m_Visible = false;
 416                 for (MeshBuf& m : o.m_MeshAry)
 417                         m.m_Visible = false;
 418         }
 419 }
 420
 421 void SceneMain::ClearAllVertSelect(void)
 422 {
 423         for (GeomObject& obj : m_Objects)
 424         {
 425                 for (MeshBuf& mbuf : obj.m_MeshAry)
 426                 {
 427                         mbuf.ClearSelect();
 428                 }
 429         }
 430 }
 431
 432
 433 void SceneMain::AddCrossSectionRecord()
 434 {
 435         UpdateCrossSectionIfRequire(true);
 436
 437         for (GeomObject& obj : m_Objects)
 438         {
 439                 for (MeshBuf& mbuf : obj.m_MeshAry)
 440                 {
 441                         mbuf.m_CrossSectionLog.push_back(lib_geo::CrossSection());
 442                         std::swap(mbuf.m_CrossSectionLog.back(), mbuf.m_CrossSection);
 443                 }
 444         }
 445 }
 446
 447 void SceneMain::ClearCrossSectionRecord()
 448 {
 449         for (GeomObject& obj : m_Objects)
 450         {
 451                 for (MeshBuf& mbuf : obj.m_MeshAry)
 452                 {
 453                         mbuf.m_CrossSectionLog.clear();
 454                 }
 455         }
 456 }
 457
 458 void SceneMain::GetFreeCutParam(lm::vec3f& p, lm::vec3f& n)
 459 {
 460         Cursor3D& c = m_Cursor3d;
 461         p = c.CursorPos;
 462         n = c.MeasureNorm;
 463 }
 464
 465 void SceneMain::UpdateCrossSectionIfRequire(bool force_update)
 466 {
 467         const CrossSectionConfig& conf = m_CrossSectionConfig;
 468
 469         if (!force_update)
 470         {
 471                 if (!conf.IsRequireUpdateCS())
 472                         return;
 473         }
 474
 475         lib_geo::Plane cutplane;
 476
 477         if (conf.IsFreeCut())
 478                 GetFreeCutParam(cutplane.origin, cutplane.normal);
 479         else
 480                 conf.GetCutPlane(GetSceneBBox(), cutplane);
 481
 482         bool cs_group = conf.m_EnableCrossSectionGroup;
 483
 484         for (GeomObject& obj : m_Objects)
 485         {
 486                 for (MeshBuf& mbuf : obj.m_MeshAry)
 487                 {
 488                         mbuf.UpdateCrossSection(cs_group, cutplane);
 489                 }
 490         }
 491 }
 492
 493 std::vector<MeshBuf*> SceneMain::GetCurSelMeshes(void)
 494 {
 495         MeshBuf* mbuf = GetPrimaryMeshbuf();
 496         if (mbuf != NULL)
 497                 std::vector<MeshBuf*>(1, mbuf);
 498
 499         GeomObject* geo = GetPrimaryObject();
 500         std::vector<MeshBuf*> mv;
 501         if (geo != NULL)
 502         {
 503                 for (MeshBuf& m : geo->m_MeshAry)
 504                 {
 505                         mv.push_back(&m);
 506                 }
 507         }
 508
 509         return mv;
 510 }
 511
 512 void SceneMain::FlipCurselFace(bool normal_only)
 513 {
 514         std::vector<MeshBuf*> mv = GetCurSelMeshes();
 515         for (MeshBuf* m : mv)
 516         {
 517                 m->FlipFace(normal_only);
 518         }
 519 }
 520
 521 int SceneMain::GetKeyframeMax(void) const
 522 {
 523         int kf = 0;
 524         for (const GeomObject& obj : m_Objects)
 525         {
 526                 kf = (std::max)(kf, obj.m_Nodes.GetKeyframeMax());
 527         }
 528
 529         return kf;
 530 }
 531
 532 float SceneMain::GetCursorSphereClipLen(void) const
 533 {
 534         return GetCursorSphereClipLen(GetSceneBBox());
 535 }
 536
 537 float SceneMain::GetCursorSphereClipLen(const lm::range3f& scene_bb) const
 538 {
 539         return m_Cursor3d.GetSphereClipLen(scene_bb);
 540 }
 541
 542 bool SceneMain::IsOutOfSphereClip(const lm::vec3f& v) const
 543 {
 544         return IsOutOfSphereClip(GetSceneBBox(), v);
 545 }
 546
 547 bool SceneMain::IsOutOfSphereClip(const lm::range3f& scene_bb, const lm::vec3f& v) const
 548 {
 549         float l = GetCursorSphereClipLen(scene_bb);
 550         float lsq = l * l;
 551         float dsq = (v - m_Cursor3d.CursorPos).square_length();
 552
 553         if (m_Cursor3d.SphereClip == SphereClipType::Hole)
 554                 return (lsq > dsq);
 555         if (m_Cursor3d.SphereClip == SphereClipType::ShowAround)
 556                 return (lsq < dsq);
 557
 558         return false;
 559 }