scene.h

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#ifndef _SCENEPIC_SCENE_H_
#define _SCENEPIC_SCENE_H_
 
#include "audio_track.h"
#include "camera.h"
#include "canvas2d.h"
#include "canvas3d.h"
#include "color.h"
#include "drop_down_menu.h"
#include "graph.h"
#include "image.h"
#include "mesh.h"
#include "mesh_update.h"
#include "shading.h"
#include "text_panel.h"
#include "ui_parameters.h"
#include "video.h"
 
#include <map>
#include <memory>
#include <string>
#include <vector>
 
namespace scenepic
{
  struct QuantizationInfo
  {
    QuantizationInfo() = default;
 
    QuantizationInfo(
      std::uint32_t keyframe_count,
      float estimated_size_ratio,
      float mean_error,
      float max_error);
 
    std::uint32_t keyframe_count;
 
    float estimated_size_ratio;
 
    float mean_error;
 
    float max_error;
 
    std::string to_string() const;
  };
 
  class Scene
  {
  public:
    Scene(const std::string& scene_id = "");
 
    void grid(
      const std::string& width,
      const std::string& grid_template_rows = "",
      const std::string& grid_template_cols = "");
 
    void place(
      const std::string& canvas_id,
      const std::string& grid_row,
      const std::string& grid_column);
 
    std::shared_ptr<Canvas3D> create_canvas_3d(
      const std::string& canvas_id = "",
      double width = 400,
      double height = 400,
      const std::string& html_id = "",
      const Camera& camera = Camera::None(),
      const Shading& shading = Shading(),
      const UIParameters& ui_parameters = UIParameters(),
      const std::string& media_id = "");
 
    std::shared_ptr<Canvas2D> create_canvas_2d(
      const std::string& canvas_id = "",
      double width = 400,
      double height = 400,
      const std::string& html_id = "",
      const Color& background_color = Colors::Black,
      const std::string& media_id = "");
 
    std::shared_ptr<Graph> create_graph(
      const std::string& canvas_id = "",
      double width = 400,
      double height = 400,
      const std::string& name_align = "left",
      const std::string& value_align = "right",
      const std::string& html_id = "",
      const Color& background_color = Colors::White,
      const Graph::Margin& margin = Graph::Margin(),
      const std::string& font_family = "sans-serif",
      float name_size = 12.0,
      float value_size = 12.0,
      const std::string& media_id = "");
 
    std::shared_ptr<AudioTrack> create_audio(const std::string& audio_id = "");
 
    std::shared_ptr<Video> create_video(const std::string& video_id = "");
 
    std::shared_ptr<Mesh> create_mesh(
      const std::string& mesh_id = "",
      const std::string& layer_id = "",
      bool double_sided = false,
      bool camera_space = false,
      const Color& shared_color = Color::None(),
      const std::string& texture_id = "",
      bool nn_texture = true,
      bool use_texture_alpha = false,
      bool is_billboard = false,
      bool is_label = false);
 
    std::shared_ptr<MeshUpdate> update_mesh(
      const std::string& base_mesh_id,
      const ConstVectorBufferRef& positions,
      const ConstVectorBufferRef& normals,
      const ConstVectorBufferRef& colors,
      const std::string& mesh_id = "");
 
    std::shared_ptr<MeshUpdate> update_instanced_mesh(
      const std::string& base_mesh_id,
      const ConstVectorBufferRef& positions,
      const ConstQuaternionBufferRef& rotations,
      const ConstVectorBufferRef& colors,
      const std::string& mesh_id = "");
 
    std::shared_ptr<MeshUpdate> update_mesh_without_normals(
      const std::string& base_mesh_id,
      const ConstVectorBufferRef& positions,
      const std::string& mesh_id = "");
 
    std::shared_ptr<MeshUpdate> update_mesh_positions(
      const std::string& base_mesh_id,
      const ConstVectorBufferRef& positions,
      const std::string& mesh_id = "");
 
    std::shared_ptr<Image> create_image(const std::string& image_id = "");
 
    std::shared_ptr<Label> create_label(
      const std::string& label_id = "",
      const std::string& text = "Text",
      const Color& color = Colors::White,
      double size_in_pixels = 12.0,
      const std::string& font_family = "sans-serif",
      const std::string& layer_id = "",
      const std::string& horizontal_align = "left",
      const std::string& vertical_align = "middle",
      double offset_distance = 0.1,
      bool camera_space = false);
 
    std::shared_ptr<TextPanel> create_text_panel(
      const std::string& text_panel_id = "",
      const std::string& html_id = "",
      bool add_input_box = false);
 
    std::shared_ptr<DropDownMenu> create_drop_down_menu(
      const std::string& drop_down_menu_id = "",
      const std::string& title = "",
      const std::string& html_id = "");
 
    void configure_user_interface(const UIParameters& ui_parameters);
 
    void link_canvas_events(const std::vector<std::string>& canvas_ids);
 
    void simulate_key_presses(
      const std::string& canvas_id, const std::vector<std::string>& keypresses);
 
    JsonValue to_json() const;
 
    void clear_script();
 
    std::string json() const;
 
    std::string script() const;
 
    float framerate() const;
 
    void framerate(float fps);
 
    const std::string& status_bar_visibility() const;
 
    void status_bar_visibility(const std::string& visibility);
 
    void save_as_json(const std::string& path) const;
 
    void save_as_script(const std::string& path, bool standalone = false) const;
 
    std::map<std::string, QuantizationInfo> quantize_updates(
      float relative_error_threshold = 1e-5,
      float absolute_error_threshold = -1.0,
      const std::string& base_mesh_id = "",
      bool per_frame_range = true);
 
    std::map<std::string, std::size_t> measure_command_size() const;
 
    void save_as_html(
      const std::string& path,
      const std::string& title = "ScenePic",
      const std::string& head_html = "",
      const std::string& body_html = "",
      const std::string& script_path = "",
      const std::string& library_path = "");
 
    bool script_cleared() const;
 
  private:
    template<typename T>
    static void add_commands(
      JsonValue& commands, const std::vector<std::shared_ptr<T>>& entities)
    {
      for (const auto& entity : entities)
      {
        commands.append(entity->to_json());
      }
    }
 
    float compute_mesh_range(const std::string& mesh_id);
 
    std::string m_scene_id;
    std::vector<JsonValue> m_display_order;
    std::vector<std::shared_ptr<Canvas3D>> m_canvas3Ds;
    std::vector<std::shared_ptr<Canvas2D>> m_canvas2Ds;
    std::vector<std::shared_ptr<Graph>> m_graphs;
    std::vector<std::shared_ptr<AudioTrack>> m_audios;
    std::vector<std::shared_ptr<Video>> m_videos;
    std::vector<std::shared_ptr<Mesh>> m_meshes;
    std::map<std::string, std::uint32_t> m_update_counts;
    std::vector<std::shared_ptr<MeshUpdate>> m_mesh_updates;
    std::vector<std::shared_ptr<Image>> m_images;
    std::vector<std::shared_ptr<Label>> m_labels;
    std::vector<std::shared_ptr<TextPanel>> m_text_panels;
    std::vector<std::shared_ptr<DropDownMenu>> m_drop_down_menus;
    std::vector<JsonValue> m_misc;
    float m_fps;
    std::string m_status_bar_visibility;
 
    // These will get out of sync with the above after a call to clear_script()
    // DO NOT REMOVE THESE - they are important
    std::size_t m_num_canvases; // shared UIDs between 2D and 3D
    std::size_t m_num_meshes;
    std::size_t m_num_images;
    std::size_t m_num_audios;
    std::size_t m_num_videos;
    std::size_t m_num_labels;
    std::size_t m_num_text_panels;
    std::size_t m_num_drop_down_menus;
    bool m_script_cleared;
  };
} // namespace scenepic
 
#endif