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