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 "vtkDeprecation.h"    // For VTK_DEPRECATED_IN_9_7_0
#include "vtkIOImportModule.h" // For export macro
#include "vtkImporter.h"
#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;


  vtkSetSmartPointerMacro(StreamURILoader, vtkURILoader);
  vtkGetSmartPointerMacro(StreamURILoader, vtkURILoader);


  VTK_DEPRECATED_IN_9_7_0("Do not use, binary stream is automatically detected")
  void SetStreamIsBinary(bool val);
  VTK_DEPRECATED_IN_9_7_0("Do not use, binary stream is automatically detected")
  bool GetStreamIsBinary();
  VTK_DEPRECATED_IN_9_7_0("Do not use, binary stream is automatically detected")
  void StreamIsBinaryOn();
  VTK_DEPRECATED_IN_9_7_0("Do not use, binary stream is automatically detected")
  void StreamIsBinaryOff();


  static bool CanReadFile(vtkResourceStream* stream);
  static bool CanReadFile(const std::string& filename);

  vtkSmartPointer<vtkCamera> GetCamera(unsigned int id);

  std::string GetOutputsDescription() override { return this->OutputsDescription; }

  bool UpdateAtTimeValue(double timeValue) override;

  AnimationSupportLevel GetAnimationSupportLevel() override { return AnimationSupportLevel::MULTI; }

  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 timeRange[2], int& nbTimeSteps,
    vtkDoubleArray* timeSteps) override;

  InterpolateAnimationSupportLevel GetInterpolateAnimationSupportLevel() override
  {
    return InterpolateAnimationSupportLevel::CAPABLE;
  }
 
protected:
  vtkGLTFImporter() = default;
  ~vtkGLTFImporter() override = default;

  virtual void InitializeLoader();
 
  int ImportBegin() override;
  void ImportActors(vtkRenderer* renderer) override;
  void ImportCameras(vtkRenderer* renderer) override;
  void ImportLights(vtkRenderer* renderer) override;
  void ImportEnd() override;
 
  void ApplySkinningMorphing();

  virtual void ApplyArmatureProperties(vtkActor* actor);
 
  vtkSmartPointer<vtkURILoader> StreamURILoader;
 
  VTK_DEPRECATED_IN_9_7_0("Do not use, binary stream is automatically detected")
  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;

  void GuessCamerasFocalPoints();
};
 
VTK_ABI_NAMESPACE_END
#endif