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         int idx = GetPrimaryObjectIdx();
 227         if (idx == -1)
 228                 return NULL;
 229
 230         return &m_Objects[idx];
 231 }
 232
 233 const GeomObject* SceneMain::GetPrimaryObject(void) const
 234 {
 235         int idx = GetPrimaryObjectIdx();
 236         if (idx == -1)
 237                 return NULL;
 238
 239         return &m_Objects[idx];
 240 }
 241
 242 int SceneMain::GetPrimaryObjectIdx(void) const
 243 {
 244         if (m_Objects.empty())
 245                 return -1;
 246
 247         return m_Sels.GetSelObjectIdx();
 248 }
 249
 250
 251 void SceneMain::GetSelectedMeshes(std::vector<MeshBuf*>& meshes)
 252 {
 253         GeomObject* obj = GetPrimaryObject();
 254         if (obj == NULL)
 255                 return;
 256
 257         if (m_Sels.IsMBufSelected())
 258         {
 259                 meshes.resize(1, &obj->m_MeshAry[m_Sels.GetMBufIdx()]);
 260         }
 261         else
 262         {
 263                 meshes.reserve(obj->m_MeshAry.size());
 264                 for (MeshBuf& m : obj->m_MeshAry)
 265                 {
 266                         meshes.push_back(&m);
 267                 }
 268         }
 269 }
 270
 271 MeshBuf* SceneMain::GetPrimaryMeshbuf(void)
 272 {
 273         int idx = GetPrimaryMeshbufIdx();
 274         if (idx == -1)
 275                 return NULL;
 276
 277         return &GetPrimaryObject()->m_MeshAry[idx];
 278 }
 279
 280 const MeshBuf* SceneMain::GetPrimaryMeshbuf(void) const
 281 {
 282         int idx = GetPrimaryMeshbufIdx();
 283         if (idx == -1)
 284                 return NULL;
 285
 286         return &GetPrimaryObject()->m_MeshAry[idx];
 287 }
 288
 289 int SceneMain::GetPrimaryMeshbufIdx(void) const
 290 {
 291         if (GetPrimaryObject() == NULL)
 292                 return -1;
 293
 294         if (!m_Sels.IsMBufSelected())
 295                 return -1;
 296
 297         return m_Sels.GetMBufIdx();
 298 }
 299
 300 MeshBuf* SceneMain::GetSelOrFirstMeshbuf(void)
 301 {
 302         GeomObject* o = GetPrimaryObject();
 303         if (o == NULL)
 304                 return NULL;
 305         if (o->m_MeshAry.empty())
 306                 return NULL;
 307
 308         if (m_Sels.IsMBufSelected())
 309                 return &o->m_MeshAry[m_Sels.GetMBufIdx()];
 310
 311         return &o->m_MeshAry[0];
 312 }
 313
 314 const MeshBuf* SceneMain::GetSelOrFirstMeshbuf(void) const
 315 {
 316         const GeomObject* o = GetPrimaryObject();
 317         if (o == NULL)
 318                 return NULL;
 319         if (o->m_MeshAry.empty())
 320                 return NULL;
 321
 322         if (m_Sels.IsMBufSelected())
 323                 return &o->m_MeshAry[m_Sels.GetMBufIdx()];
 324
 325         return &o->m_MeshAry[0];
 326 }
 327
 328 GeomTextureSet* SceneMain::GetSelectedTexture(void)
 329 {
 330         MeshBuf* mbuf = GetSelOrFirstMeshbuf();
 331         if (mbuf == NULL)
 332                 return NULL;
 333
 334         return mbuf->GeSeltTexture();
 335 }
 336
 337 lib_geo::BaseMaterial* SceneMain::GetSelectedMaterial(void)
 338 {
 339         MeshBuf* mbuf = GetSelOrFirstMeshbuf();
 340         if (mbuf == NULL)
 341                 return NULL;
 342
 343         return mbuf->GetSelMaterial();
 344 }
 345
 346
 347 void SceneMain::RemoveItem(int sel_idx)
 348 {
 349         boost::ptr_vector<GeomObject>::iterator i;
 350         i = m_Objects.begin();
 351         i += sel_idx;
 352
 353         if (i->IsInChild(m_Cursor3d.CloseFaceMBuf))
 354                 m_Cursor3d.ResetCloseFace();
 355
 356         m_Objects.erase(i);
 357
 358         m_Sels.ClearSelect();
 359
 360         RefreshObjectIndex();
 361 }
 362
 363
 364 void SceneMain::CreateSampleTexture(SampleTextureBuilder::TextureType tex_type)
 365 {
 366         SDL_Surface* tex = SampleTextureBuilder::CreateTexture(tex_type, 256);
 367         if(tex == NULL)
 368                 return;
 369
 370         m_DefaultTexture.SetFromSDLSurface( tex );
 371         m_DefaultTexture.SetTextureGLAndReleaseImage(m_TexConfig);
 372 }
 373
 374
 375 void SceneMain::RefreshObjectIndex(void)
 376 {
 377         size_t io = 0;
 378         for (size_t i = 0; i < m_Objects.size(); ++i)
 379         {
 380                 GeomObject& o = m_Objects[i];
 381                 o.SetObjectIndex((int)i);
 382                 for (size_t j = 0; j < o.m_MeshAry.size(); ++j)
 383                 {
 384                         MeshBuf& m = o.m_MeshAry[j];
 385                         m.m_MBufIdx = (int)j;
 386                         m.m_WholeIndex = (int)(j + io);
 387                 }
 388                 io += o.m_MeshAry.size();
 389         }
 390 }
 391
 392
 393 bool SceneMain::ReloadObject(GeomObject* obj)
 394 {
 395         if(!obj->IsFileObject())
 396                 return false;
 397
 398         int idx = FindObjectIdx(obj);
 399         if (idx == -1)
 400         {
 401                 assert(false);
 402                 return false;
 403         }
 404
 405         geom::GeomFileFormat fmt = obj->m_FileFormat;
 406         const std::string filename = obj->m_FilePath;
 407
 408         RemoveItem(idx);
 409
 410         return ImportFile(filename, fmt);
 411 }
 412
 413 int SceneMain::FindObjectIdx(const GeomObject* obj) const
 414 {
 415         for (const GeomObject& o : m_Objects)
 416         {
 417                 if(&o == obj)
 418                         return o.GetObjectIndex();
 419         }
 420
 421         return -1;
 422 }
 423
 424
 425 void SceneMain::ShowAllObject(void)
 426 {
 427         for (GeomObject& o : m_Objects)
 428         {
 429                 o.m_Visible = true;
 430                 for (MeshBuf& m : o.m_MeshAry)
 431                         m.m_Visible = true;
 432         }
 433 }
 434
 435 void SceneMain::HideAllObject(void)
 436 {
 437         for (GeomObject& o : m_Objects)
 438         {
 439                 o.m_Visible = false;
 440                 for (MeshBuf& m : o.m_MeshAry)
 441                         m.m_Visible = false;
 442         }
 443 }
 444
 445 void SceneMain::ClearAllVertSelect(void)
 446 {
 447         for (GeomObject& obj : m_Objects)
 448         {
 449                 for (MeshBuf& mbuf : obj.m_MeshAry)
 450                 {
 451                         mbuf.ClearSelect();
 452                 }
 453         }
 454 }
 455
 456
 457 void SceneMain::AddCrossSectionRecord()
 458 {
 459         UpdateCrossSectionIfRequire(true);
 460
 461         for (GeomObject& obj : m_Objects)
 462         {
 463                 for (MeshBuf& mbuf : obj.m_MeshAry)
 464                 {
 465                         mbuf.m_CrossSectionLog.push_back(lib_geo::CrossSection());
 466                         std::swap(mbuf.m_CrossSectionLog.back(), mbuf.m_CrossSection);
 467                 }
 468         }
 469 }
 470
 471 void SceneMain::ClearCrossSectionRecord()
 472 {
 473         for (GeomObject& obj : m_Objects)
 474         {
 475                 for (MeshBuf& mbuf : obj.m_MeshAry)
 476                 {
 477                         mbuf.m_CrossSectionLog.clear();
 478                 }
 479         }
 480 }
 481
 482 void SceneMain::UpdateCrossSectionIfRequire(bool force_update)
 483 {
 484         const CrossSectionConfig& conf = m_CrossSectionConfig;
 485
 486         if (!force_update)
 487         {
 488                 if (!conf.IsRequireUpdateCS())
 489                         return;
 490         }
 491
 492         lib_geo::Plane cutplane;
 493
 494         if (conf.IsFreeCut())
 495                 m_Cursor3d.GetFreeCutParam(cutplane.origin, cutplane.normal);
 496         else
 497                 conf.GetCutPlane(GetSceneBBox(), cutplane);
 498
 499         bool cs_group = conf.m_EnableCrossSectionGroup;
 500
 501         for (GeomObject& obj : m_Objects)
 502         {
 503                 for (MeshBuf& mbuf : obj.m_MeshAry)
 504                 {
 505                         mbuf.UpdateCrossSection(cs_group, cutplane);
 506                 }
 507         }
 508 }
 509
 510 std::vector<MeshBuf*> SceneMain::GetCurSelMeshes(void)
 511 {
 512         MeshBuf* mbuf = GetPrimaryMeshbuf();
 513         if (mbuf != NULL)
 514                 std::vector<MeshBuf*>(1, mbuf);
 515
 516         GeomObject* geo = GetPrimaryObject();
 517         std::vector<MeshBuf*> mv;
 518         if (geo != NULL)
 519         {
 520                 for (MeshBuf& m : geo->m_MeshAry)
 521                 {
 522                         mv.push_back(&m);
 523                 }
 524         }
 525
 526         return mv;
 527 }
 528
 529 void SceneMain::FlipCurselFace(bool normal_only)
 530 {
 531         std::vector<MeshBuf*> mv = GetCurSelMeshes();
 532         for (MeshBuf* m : mv)
 533         {
 534                 m->FlipFace(normal_only);
 535         }
 536 }
 537
 538 void SceneMain::RebuildCurselNormal(void)
 539 {
 540         GeomObject* geo = GetPrimaryObject();
 541         if (geo == NULL)
 542                 return;
 543
 544         geo->ResetSmoothNormal();
 545 }
 546
 547 int SceneMain::GetKeyframeMax(void) const
 548 {
 549         int kf = 0;
 550         for (const GeomObject& obj : m_Objects)
 551         {
 552                 kf = (std::max)(kf, obj.m_Nodes.GetKeyframeMax());
 553         }
 554
 555         return kf;
 556 }
 557
 558 float SceneMain::GetCursorSphereClipLen(void) const
 559 {
 560         return GetCursorSphereClipLen(GetSceneBBox());
 561 }
 562
 563 float SceneMain::GetCursorSphereClipLen(const lm::range3f& scene_bb) const
 564 {
 565         return m_Cursor3d.GetSphereClipLen(scene_bb);
 566 }
 567
 568 bool SceneMain::IsOutOfSphereClip(const lm::vec3f& v) const
 569 {
 570         return IsOutOfSphereClip(GetSceneBBox(), v);
 571 }
 572
 573 bool SceneMain::IsOutOfSphereClip(const lm::range3f& scene_bb, const lm::vec3f& v) const
 574 {
 575         float l = GetCursorSphereClipLen(scene_bb);
 576         float lsq = l * l;
 577         float dsq = (v - m_Cursor3d.CursorPos).square_length();
 578
 579         if (m_Cursor3d.SphereClip == SphereClipType::Hole)
 580                 return (lsq > dsq);
 581         if (m_Cursor3d.SphereClip == SphereClipType::ShowAround)
 582                 return (lsq < dsq);
 583
 584         return false;
 585 }