ExporterHelper.h

/*
 * GDevelop JS Platform
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#pragma once
 
#include <map>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "GDCore/IDE/CaptureOptions.h"
#include "GDCore/String.h"
namespace gd {
class Project;
class Layout;
class ExternalLayout;
class SerializerElement;
class AbstractFileSystem;
class ResourcesContainer;
class SourceFileMetadata;
class WholeProjectDiagnosticReport;
class CaptureOptions;
class Screenshot;
class InGameEditorResourceMetadata;
}  // namespace gd
 
namespace gdjs {
 
struct PreviewExportOptions {
  PreviewExportOptions(gd::Project &project_, const gd::String &exportPath_)
      : project(project_),
        exportPath(exportPath_),
        useWindowMessageDebuggerClient(false),
        useMinimalDebuggerClient(false),
        nativeMobileApp(false),
        fullLoadingScreen(false),
        isDevelopmentEnvironment(false),
        isInGameEdition(false),
        nonRuntimeScriptsCacheBurst(0),
        inAppTutorialMessageInPreview(""),
        inAppTutorialMessagePositionInPreview(""),
        fallbackAuthorId(""),
        fallbackAuthorUsername(""),
        playerId(""),
        playerUsername(""),
        playerToken(""),
        allowAuthenticationUsingIframeForPreview(false) {};
 
  PreviewExportOptions &UseWebsocketDebuggerClientWithServerAddress(
      const gd::String &address, const gd::String &port) {
    websocketDebuggerServerAddress = address;
    websocketDebuggerServerPort = port;
    return *this;
  }
 
  PreviewExportOptions &SetInAppTutorialMessageInPreview(
      const gd::String &message, const gd::String &position) {
    inAppTutorialMessageInPreview = message;
    inAppTutorialMessagePositionInPreview = position;
    return *this;
  }
 
  PreviewExportOptions &SetFallbackAuthor(const gd::String &id,
                                          const gd::String &username) {
    fallbackAuthorId = id;
    fallbackAuthorUsername = username;
    return *this;
  }
 
  PreviewExportOptions &SetAuthenticatedPlayer(const gd::String &id,
                                               const gd::String &username,
                                               const gd::String &token) {
    playerId = id;
    playerUsername = username;
    playerToken = token;
    return *this;
  }
 
  PreviewExportOptions &UseWindowMessageDebuggerClient() {
    useWindowMessageDebuggerClient = true;
    return *this;
  }
 
  PreviewExportOptions &UseMinimalDebuggerClient() {
    useMinimalDebuggerClient = true;
    return *this;
  }
 
  PreviewExportOptions &SetNativeMobileApp(bool enable) {
    nativeMobileApp = enable;
    return *this;
  }
 
  PreviewExportOptions &SetLayoutName(const gd::String &layoutName_) {
    layoutName = layoutName_;
    return *this;
  }
 
  PreviewExportOptions &SetExternalLayoutName(
      const gd::String &externalLayoutName_) {
    externalLayoutName = externalLayoutName_;
    return *this;
  }
 
  PreviewExportOptions &SetEventsBasedObjectType(
      const gd::String &eventsBasedObjectType_) {
    eventsBasedObjectType = eventsBasedObjectType_;
    return *this;
  }
 
  PreviewExportOptions &SetEventsBasedObjectVariantName(
      const gd::String &eventsBasedObjectVariantName_) {
    eventsBasedObjectVariantName = eventsBasedObjectVariantName_;
    return *this;
  }
 
  PreviewExportOptions &SetIncludeFileHash(const gd::String &includeFile,
                                           int hash) {
    includeFileHashes[includeFile] = hash;
    return *this;
  }
 
  PreviewExportOptions &SetShouldClearExportFolder(bool enable) {
    shouldClearExportFolder = enable;
    return *this;
  }
 
  PreviewExportOptions &SetShouldReloadProjectData(bool enable) {
    shouldReloadProjectData = enable;
    return *this;
  }
 
  PreviewExportOptions &SetShouldReloadLibraries(bool enable) {
    shouldReloadLibraries = enable;
    return *this;
  }
 
  PreviewExportOptions &SetShouldGenerateScenesEventsCode(bool enable) {
    shouldGenerateScenesEventsCode = enable;
    return *this;
  }
 
  PreviewExportOptions &SetFullLoadingScreen(bool enable) {
    fullLoadingScreen = enable;
    return *this;
  }
 
  PreviewExportOptions &SetIsDevelopmentEnvironment(bool enable) {
    isDevelopmentEnvironment = enable;
    return *this;
  }
 
  PreviewExportOptions &SetIsInGameEdition(bool enable) {
    isInGameEdition = enable;
    return *this;
  }
 
  PreviewExportOptions &SetInGameEditorSettingsJson(const gd::String &inGameEditorSettingsJson_) {
    inGameEditorSettingsJson = inGameEditorSettingsJson_;
    return *this;
  }
 
  PreviewExportOptions &SetEditorId(const gd::String &editorId_) {
    editorId = editorId_;
    return *this;
  }
 
  PreviewExportOptions &
  SetEditorCameraState3D(const gd::String &cameraMode, double positionX,
                         double positionY, double positionZ,
                         double rotationAngle, double elevationAngle,
                         double distance) {
    editorCamera3DCameraMode = cameraMode;
    editorCamera3DPositionX = positionX;
    editorCamera3DPositionY = positionY;
    editorCamera3DPositionZ = positionZ;
    editorCamera3DRotationAngle = rotationAngle;
    editorCamera3DElevationAngle = elevationAngle;
    editorCamera3DDistance = distance;
    return *this;
  }
 
  PreviewExportOptions &SetNonRuntimeScriptsCacheBurst(unsigned int value) {
    nonRuntimeScriptsCacheBurst = value;
    return *this;
  }
 
  PreviewExportOptions &SetElectronRemoteRequirePath(
      const gd::String &electronRemoteRequirePath_) {
    electronRemoteRequirePath = electronRemoteRequirePath_;
    return *this;
  }
 
  PreviewExportOptions &SetGDevelopResourceToken(
      const gd::String &gdevelopResourceToken_) {
    gdevelopResourceToken = gdevelopResourceToken_;
    return *this;
  }
 
  PreviewExportOptions &SetAllowAuthenticationUsingIframeForPreview(
      bool allowAuthenticationUsingIframeForPreview_) {
    allowAuthenticationUsingIframeForPreview =
        allowAuthenticationUsingIframeForPreview_;
    return *this;
  }
 
  PreviewExportOptions &SetCrashReportUploadLevel(
      const gd::String &crashReportUploadLevel_) {
    crashReportUploadLevel = crashReportUploadLevel_;
    return *this;
  }
 
  PreviewExportOptions &SetPreviewContext(const gd::String &previewContext_) {
    previewContext = previewContext_;
    return *this;
  }
 
  PreviewExportOptions &SetGDevelopVersionWithHash(
      const gd::String &gdevelopVersionWithHash_) {
    gdevelopVersionWithHash = gdevelopVersionWithHash_;
    return *this;
  }
 
  PreviewExportOptions &SetProjectTemplateSlug(
      const gd::String &projectTemplateSlug_) {
    projectTemplateSlug = projectTemplateSlug_;
    return *this;
  }
 
  PreviewExportOptions &SetSourceGameId(const gd::String &sourceGameId_) {
    sourceGameId = sourceGameId_;
    return *this;
  }
 
  PreviewExportOptions &AddScreenshotCapture(int delayTimeInSeconds,
                                             const gd::String &signedUrl,
                                             const gd::String &publicUrl) {
    gd::Screenshot screenshot;
    screenshot.SetDelayTimeInSeconds(delayTimeInSeconds);
    screenshot.SetSignedUrl(signedUrl);
    screenshot.SetPublicUrl(publicUrl);
    captureOptions.AddScreenshot(screenshot);
    return *this;
  }
 
  gd::Project &project;
  gd::String exportPath;
  gd::String websocketDebuggerServerAddress;
  gd::String websocketDebuggerServerPort;
  bool useWindowMessageDebuggerClient;
  bool useMinimalDebuggerClient;
  gd::String layoutName;
  gd::String externalLayoutName;
  gd::String eventsBasedObjectType;
  gd::String eventsBasedObjectVariantName;
  gd::String fallbackAuthorUsername;
  gd::String fallbackAuthorId;
  gd::String playerId;
  gd::String playerUsername;
  gd::String playerToken;
  gd::String inAppTutorialMessageInPreview;
  gd::String inAppTutorialMessagePositionInPreview;
  bool nativeMobileApp;
  std::map<gd::String, int> includeFileHashes;
  bool shouldClearExportFolder = true;
  bool shouldReloadProjectData = true;
  bool shouldReloadLibraries = true;
  bool shouldGenerateScenesEventsCode = true;
  bool fullLoadingScreen;
  bool isDevelopmentEnvironment;
  bool isInGameEdition;
  gd::String editorId;
  gd::String editorCamera3DCameraMode;
  gd::String inGameEditorSettingsJson;
  double editorCamera3DPositionX = 0;
  double editorCamera3DPositionY = 0;
  double editorCamera3DPositionZ = 0;
  double editorCamera3DRotationAngle = 0;
  double editorCamera3DElevationAngle = 0;
  double editorCamera3DDistance = 0;
  unsigned int nonRuntimeScriptsCacheBurst;
  gd::String electronRemoteRequirePath;
  gd::String gdevelopResourceToken;
  bool allowAuthenticationUsingIframeForPreview;
  gd::String crashReportUploadLevel;
  gd::String previewContext;
  gd::String gdevelopVersionWithHash;
  gd::String projectTemplateSlug;
  gd::String sourceGameId;
  gd::CaptureOptions captureOptions;
};
 
struct ExportOptions {
  ExportOptions(gd::Project &project_, const gd::String &exportPath_)
      : project(project_),
        exportPath(exportPath_),
        target(""),
        fallbackAuthorId(""),
        fallbackAuthorUsername("") {};
 
  ExportOptions &SetFallbackAuthor(const gd::String &id,
                                   const gd::String &username) {
    fallbackAuthorId = id;
    fallbackAuthorUsername = username;
    return *this;
  }
 
  ExportOptions &SetTarget(const gd::String &target_) {
    target = target_;
    return *this;
  }
 
  gd::Project &project;
  gd::String exportPath;
  gd::String target;
  gd::String fallbackAuthorUsername;
  gd::String fallbackAuthorId;
};
 
class ExporterHelper {
 public:
  ExporterHelper(gd::AbstractFileSystem &fileSystem,
                 gd::String gdjsRoot_,
                 gd::String codeOutputDir);
  virtual ~ExporterHelper() {};
 
  const gd::String &GetLastError() const { return lastError; };
 
  static gd::String ExportProjectData(
      gd::AbstractFileSystem &fs, gd::Project &project, gd::String filename,
      const gd::SerializerElement &runtimeGameOptions, bool isInGameEdition,
      const std::vector<gd::InGameEditorResourceMetadata> &inGameEditorResources);
 
  static void SerializeProjectData(gd::AbstractFileSystem &fs,
                                   const gd::Project &project,
                                   const PreviewExportOptions &options,
                                   gd::SerializerElement &projectDataElement,
                                   const std::vector<gd::InGameEditorResourceMetadata> &inGameEditorResources);
 
  static void
  SerializeRuntimeGameOptions(gd::AbstractFileSystem &fs,
                              const gd::String &gdjsRoot,
                              const PreviewExportOptions &options,
                              std::vector<gd::String> &includesFiles,
                              gd::SerializerElement &runtimeGameOptionsElement);
 
  static void ExportResources(gd::AbstractFileSystem &fs,
                              gd::Project &project,
                              gd::String exportDir);
 
  void AddLibsInclude(bool pixiRenderers,
                      bool pixiInThreeRenderers,
                      bool isInGameEdition,
                      bool includeWebsocketDebuggerClient,
                      bool includeWindowMessageDebuggerClient,
                      bool includeMinimalDebuggerClient,
                      bool includeCaptureManager,
                      bool includeInAppTutorialMessage,
                      gd::String gdevelopLogoStyle,
                      std::vector<gd::String> &includesFiles);
 
  void RemoveIncludes(bool pixiRenderers,
                      std::vector<gd::String> &includesFiles);
 
  bool ExportIncludesAndLibs(const std::vector<gd::String> &includesFiles,
                             gd::String exportDir,
                             bool exportSourceMaps);
 
  bool ExportScenesEventsCode(
      const gd::Project &project,
      gd::String outputDir,
      std::vector<gd::String> &includesFiles,
      gd::WholeProjectDiagnosticReport &wholeProjectDiagnosticReport,
      bool exportForPreview);
 
  bool ExportEffectIncludes(gd::Project &project,
                            std::vector<gd::String> &includesFiles);
 
  bool ExportIndexFile(const gd::Project &project,
                       gd::String source,
                       gd::String exportDir,
                       const std::vector<gd::String> &includesFiles,
                       const std::vector<gd::SourceFileMetadata> &sourceFiles,
                       unsigned int nonRuntimeScriptsCacheBurst,
                       gd::String additionalSpec = "");
 
  bool CompleteIndexFile(gd::String &indexFileContent,
                         gd::String exportDir,
                         const std::vector<gd::String> &includesFiles,
                         unsigned int nonRuntimeScriptsCacheBurst,
                         gd::String additionalSpec);
 
  const gd::String GenerateWebManifest(const gd::Project &project);
 
  bool ExportCordovaFiles(const gd::Project &project,
                          gd::String exportDir,
                          std::set<gd::String> usedExtensions);
 
  bool ExportElectronFiles(const gd::Project &project,
                           gd::String exportDir,
                           std::set<gd::String> usedExtensions);
 
  bool ExportBuildResourcesElectronFiles(const gd::Project &project,
                                         gd::String exportDir);
 
  bool ExportFacebookInstantGamesFiles(const gd::Project &project,
                                       gd::String exportDir);
 
  bool ExportHtml5Files(const gd::Project &project, gd::String exportDir);
 
  bool ExportProjectForPixiPreview(const PreviewExportOptions &options,
                                   std::vector<gd::String> &includesFiles);
 
  static gd::String GetExportedIncludeFilename(
      gd::AbstractFileSystem &fs, const gd::String &gdjsRoot,
      const gd::String &include, unsigned int nonRuntimeScriptsCacheBurst = 0);
 
  void SetCodeOutputDirectory(gd::String codeOutputDir_) {
    codeOutputDir = codeOutputDir_;
  }
 
  static void AddDeprecatedFontFilesToFontResources(
      gd::AbstractFileSystem &fs,
      gd::ResourcesContainer &resourcesManager,
      const gd::String &exportDir,
      gd::String urlPrefix = "");
 
  gd::AbstractFileSystem
      &fs;  
  gd::String lastError;  
  gd::String
      gdjsRoot;  
  gd::String codeOutputDir;  
 
 private:
   static void
   SerializeUsedResources(gd::SerializerElement &rootElement,
                          std::set<gd::String> &projectUsedResources,
                          std::unordered_map<gd::String, std::set<gd::String>>
                              &layersUsedResources,
                          std::unordered_map<gd::String, std::set<gd::String>>
                              &eventsBasedObjectVariantsUsedResources);
 
   static void StripAndSerializeProjectData(gd::Project &project,
                                             gd::SerializerElement &rootElement,
                                             bool isInGameEdition,
                                             const std::vector<gd::InGameEditorResourceMetadata> &inGameEditorResources);
 
   static void
   AddInGameEditorResources(gd::Project &project,
                            std::set<gd::String> &projectUsedResources,
                            const std::vector<gd::InGameEditorResourceMetadata> &inGameEditorResources);
};
 
}  // namespace gdjs