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