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 int SceneMain::GetMaxFrame(void) const
 113 {
 114         size_t max_frame = 0;
 115         //for (const GeomObject& g : m_Objects)
 116         //{
 117         //      for (const MeshBuf& m : g.m_MeshAry)
 118         //      {
 119         //              for (const Bone& b : m.m_Bones.m_Bones)
 120         //              {
 121         //                      max_frame = (std::max)(max_frame, b.m_Translate.size());
 122         //                      max_frame = (std::max)(max_frame, b.m_Scale.size());
 123         //                      max_frame = (std::max)(max_frame, b.m_Rotate.size());
 124         //              }
 125         //      }
 126         //}
 127
 128         return max_frame;
 129 }
 130
 131
 132 void SceneMain::UpdateTransform(void)
 133 {
 134         SceneTransform& t = m_WorldTransform;
 135
 136         t.SetScale(1.0);
 137         t.m_Translate.set_zero();
 138
 139         if (m_Config.m_EnableAutoCentering)
 140         {
 141                 lm::range3f r = GetSceneBBox();
 142                 if (r.is_valid())
 143                         t.m_Translate = -r.mid_point();
 144         }
 145
 146         if (m_Config.m_EnableAutoReisze)
 147         {
 148                 lm::range3f r = GetSceneBBoxIni();
 149                 if (r.is_valid())
 150                         t.SetScale(1.0f / r.max_length());
 151         }
 152 }
 153
 154
 155 void SceneMain::LoadDefaultMatTexture(const std::string& filename)
 156 {
 157         m_DefaultTexture.LoadTextureFromFile(filename.c_str(), true);
 158         m_DefaultTexture.SetTextureGLAndReleaseImage(m_TexConfig);
 159 }
 160
 161
 162 //! \83I\83u\83T\81[\83o\82ð\83Z\83b\83g.
 163 //! \8f\8a\97L\8c \82Í\8e\9d\82½\82È\82¢.
 164 void SceneMain::AddObserver(SceneObserver* observer)
 165 {
 166         m_Observers.push_back(observer);
 167 }
 168
 169 bool SceneMain::RemoveObserver(size_t idx)
 170 {
 171         assert(idx < m_Observers.size());
 172         if (idx < m_Observers.size())
 173                 return false;
 174
 175         std::vector<SceneObserver*>::iterator i = m_Observers.begin();
 176         std::advance(i, idx);
 177         m_Observers.erase(i);
 178
 179         return true;
 180 }
 181
 182 bool SceneMain::RemoveObserver(SceneObserver* registered_observer)
 183 {
 184         for (size_t i = 0; i < m_Observers.size(); ++i)
 185         {
 186                 if (m_Observers[i] == registered_observer)
 187                         return RemoveObserver(i);
 188         }
 189
 190         assert(false);
 191         return false;
 192 }
 193
 194
 195 void SceneMain::ReportDoneEditGeometry(void)
 196 {
 197         for (SceneObserver* o : m_Observers)
 198         {
 199                 o->OnGeometryBuild(*this);
 200         }
 201 }
 202
 203 lm::range3f SceneMain::GetSceneBBox(void) const
 204 {
 205         lm::range3f bbox;
 206         bbox.clear();
 207
 208         for (const GeomObject& obj : m_Objects)
 209         {
 210                 bbox.expand(obj.GetGeomBBox(false));
 211         }
 212
 213         return bbox;
 214 }
 215
 216 lm::range3f SceneMain::GetSceneBBoxIni(void) const
 217 {
 218         lm::range3f bbox;
 219         bbox.clear();
 220
 221         for (const GeomObject& obj : m_Objects)
 222         {
 223                 bbox.expand(obj.GetGeomBBox(true));
 224         }
 225
 226         return bbox;
 227 }
 228
 229
 230 lm::range3f SceneMain::GetSceneTransformedBBox(void) const
 231 {
 232         lm::range3f bbox = GetSceneBBox();
 233
 234         lm::range3f tbb;
 235         tbb.clear();
 236         tbb.expand(m_WorldTransform.TransformVec(bbox.min_point()));
 237         tbb.expand(m_WorldTransform.TransformVec(bbox.max_point()));
 238
 239         return tbb;
 240 }
 241
 242
 243 GeomObject* SceneMain::GetPrimaryObject(void)
 244 {
 245         if (!m_Sels.IsObjectSelected())
 246                 return NULL;
 247
 248         if (m_Objects.empty())
 249                 return NULL;
 250
 251         return &m_Objects[m_Sels.GetSelObjectIdx()];
 252 }
 253
 254 const GeomObject* SceneMain::GetPrimaryObject(void) const
 255 {
 256         if (!m_Sels.IsObjectSelected())
 257                 return NULL;
 258
 259         if (m_Objects.empty())
 260                 return NULL;
 261
 262         return &m_Objects[m_Sels.GetSelObjectIdx()];
 263 }
 264
 265
 266 void SceneMain::GetSelectedMeshes(std::vector<MeshBuf*>& meshes)
 267 {
 268         GeomObject* obj = GetPrimaryObject();
 269         if (obj == NULL)
 270                 return;
 271
 272         if (m_Sels.IsMBufSelected())
 273         {
 274                 meshes.resize(1, &obj->m_MeshAry[m_Sels.GetMBufIdx()]);
 275         }
 276         else
 277         {
 278                 meshes.reserve(obj->m_MeshAry.size());
 279                 for (MeshBuf& m : obj->m_MeshAry)
 280                 {
 281                         meshes.push_back(&m);
 282                 }
 283         }
 284 }
 285
 286 MeshBuf* SceneMain::GetPrimaryMeshbuf(void)
 287 {
 288         GeomObject* obj = GetPrimaryObject();
 289         if (obj == NULL)
 290                 return NULL;
 291
 292         if (!m_Sels.IsMBufSelected())
 293                 return NULL;
 294
 295         return &obj->m_MeshAry[m_Sels.GetMBufIdx()];
 296 }
 297
 298 const MeshBuf* SceneMain::GetPrimaryMeshbuf(void) const
 299 {
 300         const GeomObject* obj = GetPrimaryObject();
 301         if (obj == NULL)
 302                 return NULL;
 303
 304         if (!m_Sels.IsMBufSelected())
 305                 return NULL;
 306
 307         return &obj->m_MeshAry[m_Sels.GetMBufIdx()];
 308 }
 309
 310 GeomTextureSet* SceneMain::GetSelectedTexture(void)
 311 {
 312         int idx = GetSelectedMatIdx();
 313         if (idx == -1)
 314                 return NULL;
 315
 316         return GetPrimaryMeshbuf()->GetTexture(idx);
 317 }
 318
 319 lib_geo::BaseMaterial* SceneMain::GetSelectedMaterial(void)
 320 {
 321         int idx = GetSelectedMatIdx();
 322         if (idx == -1)
 323                 return NULL;
 324
 325         return GetPrimaryMeshbuf()->GetMaterial(idx);
 326 }
 327
 328 int SceneMain::GetSelectedMatIdx(void)
 329 {
 330         MeshBuf* mbuf = GetPrimaryMeshbuf();
 331         if (mbuf == NULL)
 332                 return -1;
 333
 334         int idx = m_Sels.GetSelMat();
 335         if (!mbuf->IsValidMaterialIdx(idx))
 336                 return -1;
 337
 338         return idx;
 339 }
 340
 341
 342 void SceneMain::RemoveItem(int sel_idx)
 343 {
 344         boost::ptr_vector<GeomObject>::iterator i;
 345         i = m_Objects.begin();
 346         i += sel_idx;
 347
 348         if (i->IsInChild(m_Cursor3d.CloseFaceMBuf))
 349                 m_Cursor3d.ResetCloseFace();
 350
 351         m_Objects.erase(i);
 352
 353         m_Sels.ClearSelect();
 354
 355         RefreshObjectIndex();
 356 }
 357
 358
 359 void SceneMain::CreateSampleTexture(SampleTextureBuilder::TextureType tex_type)
 360 {
 361         SDL_Surface* tex = SampleTextureBuilder::CreateTexture(tex_type, 256);
 362         if(tex == NULL)
 363                 return;
 364
 365         m_DefaultTexture.SetFromSDLSurface( tex );
 366         m_DefaultTexture.SetTextureGLAndReleaseImage(m_TexConfig);
 367 }
 368
 369
 370 void SceneMain::RefreshObjectIndex(void)
 371 {
 372         for (size_t i = 0; i < m_Objects.size(); ++i)
 373         {
 374                 GeomObject& o = m_Objects[i];
 375                 o.m_ObjectIndex = (int)i;
 376                 for (size_t j = 0; j < o.m_MeshAry.size(); ++j)
 377                 {
 378                         MeshBuf& m = o.m_MeshAry[j];
 379                         m.m_MBufIdx = (int)j;
 380                 }
 381         }
 382 }
 383
 384
 385 bool SceneMain::ReloadObject(GeomObject* obj)
 386 {
 387         if(!obj->IsFileObject())
 388                 return false;
 389
 390         int idx = FindObjectIdx(obj);
 391         if (idx == -1)
 392         {
 393                 assert(false);
 394                 return false;
 395         }
 396
 397         geom::GeomFileFormat fmt = obj->m_FileFormat;
 398         const std::string filename = obj->m_FilePath;
 399
 400         RemoveItem(idx);
 401
 402         return ImportFile(filename, fmt);
 403 }
 404
 405 int SceneMain::FindObjectIdx(const GeomObject* obj) const
 406 {
 407         for (const GeomObject& o : m_Objects)
 408         {
 409                 if(&o == obj)
 410                         return o.GetObjectIndex();
 411         }
 412
 413         return -1;
 414 }
 415
 416
 417 void SceneMain::ShowAllObject(void)
 418 {
 419         for (GeomObject& o : m_Objects)
 420         {
 421                 o.m_Visible = true;
 422                 for (MeshBuf& m : o.m_MeshAry)
 423                         m.m_Visible = true;
 424         }
 425 }
 426
 427 void SceneMain::HideAllObject(void)
 428 {
 429         for (GeomObject& o : m_Objects)
 430         {
 431                 o.m_Visible = false;
 432                 for (MeshBuf& m : o.m_MeshAry)
 433                         m.m_Visible = false;
 434         }
 435 }
 436
 437 void SceneMain::ClearAllVertSelect(void)
 438 {
 439         for (GeomObject& obj : m_Objects)
 440         {
 441                 for (MeshBuf& mbuf : obj.m_MeshAry)
 442                 {
 443                         mbuf.ClearSelect();
 444                 }
 445         }
 446 }
 447
 448
 449 void SceneMain::AddCrossSectionRecord()
 450 {
 451         UpdateCrossSectionIfRequire(true);
 452
 453         for (GeomObject& obj : m_Objects)
 454         {
 455                 for (MeshBuf& mbuf : obj.m_MeshAry)
 456                 {
 457                         mbuf.m_CrossSectionLog.push_back(lib_geo::CrossSection());
 458                         std::swap(mbuf.m_CrossSectionLog.back(), mbuf.m_CrossSection);
 459                 }
 460         }
 461 }
 462
 463 void SceneMain::ClearCrossSectionRecord()
 464 {
 465         for (GeomObject& obj : m_Objects)
 466         {
 467                 for (MeshBuf& mbuf : obj.m_MeshAry)
 468                 {
 469                         mbuf.m_CrossSectionLog.clear();
 470                 }
 471         }
 472 }
 473
 474 void SceneMain::GetFreeCutParam(lm::vec3f& p, lm::vec3f& n)
 475 {
 476         Cursor3D& c = m_Cursor3d;
 477         p = c.CursorPos;
 478         n = c.MeasureNorm;
 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                 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 int SceneMain::GetKeyframeMax(void) const
 538 {
 539         int kf = 0;
 540         return kf;
 541 }