vtkGLTFImporter.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkGLTFImporter_h
#define vtkGLTFImporter_h
 
#include "vtkIOImportModule.h" // For export macro
#include "vtkImporter.h"
#include "vtkResourceStream.h" // For Stream
#include "vtkSmartPointer.h"   // For SmartPointer
#include "vtkURILoader.h"      // For URILoader
 
#include <map>    // For map
#include <vector> // For vector
 
VTK_ABI_NAMESPACE_BEGIN
 
// Forward declarations
class vtkActor;
class vtkCamera;
class vtkGLTFDocumentLoader;
class vtkTexture;
class vtkURILoader;
 
class VTKIOIMPORT_EXPORT vtkGLTFImporter : public vtkImporter
{
public:
  static vtkGLTFImporter* New();
 
  vtkTypeMacro(vtkGLTFImporter, vtkImporter);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetFilePathMacro(FileName);
  vtkGetFilePathMacro(FileName);
 
 
  vtkSetSmartPointerMacro(Stream, vtkResourceStream);
  vtkGetSmartPointerMacro(Stream, vtkResourceStream);
 
 
  vtkSetSmartPointerMacro(StreamURILoader, vtkURILoader);
  vtkGetSmartPointerMacro(StreamURILoader, vtkURILoader);
 
 
  vtkSetMacro(StreamIsBinary, bool);
  vtkGetMacro(StreamIsBinary, bool);
  vtkBooleanMacro(StreamIsBinary, bool);
 
  vtkSmartPointer<vtkCamera> GetCamera(unsigned int id);
 
  std::string GetOutputsDescription() override { return this->OutputsDescription; }
 
  bool UpdateAtTimeValue(double timeValue) override;
 
  vtkIdType GetNumberOfAnimations() override;
 
  std::string GetAnimationName(vtkIdType animationIndex) override;
 
 
  void EnableAnimation(vtkIdType animationIndex) override;
  void DisableAnimation(vtkIdType animationIndex) override;
  bool IsAnimationEnabled(vtkIdType animationIndex) override;
 
  vtkIdType GetNumberOfCameras() override;
 
  std::string GetCameraName(vtkIdType camIndex) override;
 
  void SetCamera(vtkIdType camIndex) override;
 
  bool GetTemporalInformation(vtkIdType animationIndex, double frameRate, int& nbTimeSteps,
    double timeRange[2], vtkDoubleArray* timeSteps) override;
 
protected:
  vtkGLTFImporter() = default;
  ~vtkGLTFImporter() override;
 
  virtual void InitializeLoader();
 
  int ImportBegin() override;
  void ImportActors(vtkRenderer* renderer) override;
  void ImportCameras(vtkRenderer* renderer) override;
  void ImportLights(vtkRenderer* renderer) override;
 
  void ApplySkinningMorphing();
 
  virtual void ApplyArmatureProperties(vtkActor* actor);
 
  char* FileName = nullptr;
  vtkSmartPointer<vtkResourceStream> Stream;
  vtkSmartPointer<vtkURILoader> StreamURILoader;
  bool StreamIsBinary = false;
 
  std::map<int, vtkSmartPointer<vtkCamera>> Cameras;
  std::map<int, vtkSmartPointer<vtkTexture>> Textures;
  std::map<int, std::vector<vtkSmartPointer<vtkActor>>> Actors;
  vtkSmartPointer<vtkGLTFDocumentLoader> Loader;
  std::string OutputsDescription;
  std::vector<bool> EnabledAnimations;
  vtkIdType EnabledCamera = -1;
 
private:
  vtkGLTFImporter(const vtkGLTFImporter&) = delete;
  void operator=(const vtkGLTFImporter&) = delete;
 
  std::map<int, vtkSmartPointer<vtkActor>> ArmatureActors;
};
 
VTK_ABI_NAMESPACE_END
#endif