Struct Editor 

pub struct Editor {

    pub edit: SceneEdit,
    pub files: Files,
    pub history: History,
    pub viewport: Box<Viewport>,
    pub sources: BTreeMap<PathBuf, Source>,
    pub problems: Vec<Diagnostic>,
    pub outline: Outline,
    pub raw: Raw,
    pub rows: Vec<Row>,
    pub selection: Option<Item>,
    pub trace: bool,
    pub trace_samples: u32,
    pub play: Play,
    pub log: Log,
    pub app: String,
    pub pgpu: Option<String>,
    pub muted: bool,
    pub sound_available: bool,
    pub sound: Option<String>,
    pub screen: Rect,
    pub texture: Option<TextureId>,
    pub revision: u64,
    pub layout: Layout,
    pub texts: BTreeMap<String, String>,
    pub saves: Vec<PathBuf>,
    pub outside: bool,
    pub project: Option<Project>,
    pub tunables: Tunables,
    pub live: BTreeMap<String, Value>,
    pub level: Level,
    /* private fields */
}

Fields

edit: SceneEdit

files: Files

history: History

viewport: Box<Viewport>

sources: BTreeMap<PathBuf, Source>

problems: Vec<Diagnostic>

outline: Outline

raw: Raw

rows: Vec<Row>

selection: Option<Item>

trace: bool

trace_samples: u32

play: Play

log: Log

app: String

pgpu: Option<String>

muted: bool

sound_available: bool

sound: Option<String>

screen: Rect

texture: Option<TextureId>

revision: u64

layout: Layout

texts: BTreeMap<String, String>

saves: Vec<PathBuf>

outside: bool

project: Option<Project>

tunables: Tunables

live: BTreeMap<String, Value>

level: Level

Implementations

impl Editor

pub fn open(path: impl AsRef<Path>) -> Result<Editor, String>

pub fn scene(&self) -> &Scene

pub fn path(&self) -> &Path

pub fn project_root(&self) -> &Path

pub fn name(&self) -> String

pub fn files(&self) -> Vec<PathBuf>

pub fn refresh(&mut self)

pub fn select(&mut self, item: Option<Item>)

pub fn open_scene(&mut self, scene: PathBuf)

pub fn set_project(&mut self, project: Project)

pub fn frame_project(&mut self)

pub fn selected_object(&self) -> Option<&str>

pub fn editable(&self) -> bool

pub fn dry(&mut self, change: &Change) -> Result<PatchGroup, String>

pub fn play_edit(&mut self, session: &mut PlaySession, change: &Change) -> bool

pub fn stopped(&mut self, keep: Option<&Pending>)

pub fn keep(&mut self, pending: &Pending)

pub fn change(&mut self, change: Change, group: Group)

pub fn land(&mut self, group: PatchGroup)

pub fn end_group(&mut self)

pub fn grouping(&self) -> bool

pub fn save(&mut self, changed: &Changed) -> bool

pub fn wrote(&mut self, changed: &Changed)

pub fn undo(&mut self)

pub fn redo(&mut self)

pub fn typed(&mut self, changed: Option<Changed>)

pub fn reloaded(&mut self)

pub fn events(&mut self)

pub fn source(&mut self, file: &Path) -> &mut Source

pub fn toggle_view(&mut self)

pub fn focus(&mut self)

pub fn request(&mut self, request: Request)

pub fn take_requests(&mut self) -> Vec<Request>

pub fn step_selection(&mut self, by: isize)

pub fn play_pressed(&mut self)

impl Editor

pub fn relative(&self, file: &Path) -> String

pub fn layers(&self) -> Vec<Tiles>

pub fn is_cell(&self, object: &str) -> bool

pub fn surfaces(&mut self) -> Option<&Surfaces>

pub fn lens(&self) -> Option<Lens>

pub fn extent(&mut self, asset: &Path) -> Result<[[f32; 3]; 2], String>

pub fn aim(&mut self, asset: &Path, at: Pos2) -> Result<Aim, String>

pub fn place(&mut self, asset: &Path, at: Pos2) -> Option<String>

pub fn place_at( &mut self, asset: &Path, at: [f32; 3], rotate: [f32; 3], ) -> Result<String, String>

pub fn picked(&self) -> Vec<String>

pub fn pick_more(&mut self, name: &str)

pub fn duplicate(&mut self) -> Vec<String>

pub fn align(&mut self, axis: usize, to_last: bool) -> bool

pub fn distribute(&mut self, axis: usize) -> bool

pub fn brush_layer(&self) -> Option<Tiles>

pub fn brush_prefab(&mut self) -> Option<String>

pub fn cell_under(&mut self, at: Pos2) -> Option<[i32; 2]>

pub fn paint( &mut self, cells: &[[i32; 2]], erase: bool, ) -> Result<usize, String>

pub fn pick_cell(&mut self, cell: [i32; 2]) -> Option<String>

pub fn finish_stroke(&mut self)

pub fn toggle_brush(&mut self)

impl Editor

pub fn ui(&mut self, ui: &mut Ui)

impl Editor

pub fn level_keys(&mut self, ctx: &Context, inside: bool)

pub fn snap_gizmo(&mut self)

pub fn level_viewport(&mut self, ui: &mut Ui, image: Rect)

pub fn level_panel(&mut self, ui: &mut Ui) -> bool