ponko 0.0.1

A fast 2D game engine for simulating millions of things: ECS on all cores, hot reload, an in-game inspector, AI-agent control, and a C++ API.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Builds without the `window` feature have no GPU: `Renderer` has no
//! values, so `Ctx::renderer` is always `None` and these are never called.

use glam::Mat4;

use super::batch::DrawList;
use super::{FrameStatus, RenderStats, Screenshot};
use crate::color::Color;

pub(crate) enum Renderer {}

impl Renderer {
    pub fn stats(&self) -> RenderStats {
        match *self {}
    }
    pub fn take_screenshot(&mut self) -> Option<Screenshot> {
        match *self {}
    }
    #[cfg(feature = "3d")]
    pub fn mesh_costs(&self) -> Vec<(u32, usize, usize, usize, usize)> {
        match *self {}
    }
    pub fn set_draw_hidden(&mut self, _on: bool, _always: bool) {
        match *self {}
    }
    pub fn gpu_passes(&self) -> &[crate::profiler::GpuPass] {
        match *self {}
    }
    pub fn gpu_frame(&self) -> Option<(&[crate::profiler::PassSpan], u64)> {
        match *self {}
    }
    pub fn display_wait_ms(&self) -> f32 {
        match *self {}
    }
    pub fn max_texture_size(&self) -> u32 {
        match *self {}
    }
    pub fn create_texture(&mut self, _width: u32, _height: u32, _rgba: &[u8]) -> u32 {
        match *self {}
    }
    #[cfg(feature = "3d")]
    pub fn create_render_target(&mut self, _width: u32, _height: u32) -> u32 {
        match *self {}
    }
    pub fn update_texture(&mut self, _id: u32, _width: u32, _height: u32, _rgba: &[u8]) {
        match *self {}
    }
    pub fn set_filter(&mut self, _id: u32, _nearest: bool) {
        match *self {}
    }
    pub fn update_texture_region(&mut self, _id: u32, _at: [u32; 2], _size: [u32; 2], _rgba: &[u8]) {
        match *self {}
    }
    #[cfg(feature = "3d")]
    pub fn create_material(&mut self, _desc: &crate::three::GpuMaterialDesc) -> u32 {
        match *self {}
    }
    #[cfg(feature = "3d")]
    pub fn update_material(&mut self, _id: u32, _desc: &crate::three::GpuMaterialDesc) {
        match *self {}
    }
    #[cfg(feature = "3d")]
    pub fn supports_decals(&self) -> bool {
        match *self {}
    }
    #[cfg(feature = "3d")]
    pub fn supports_gi(&self) -> bool {
        match *self {}
    }
    #[cfg(feature = "3d")]
    pub fn max_texture_array_size(&self) -> (u32, u32) {
        match *self {}
    }
    #[cfg(feature = "3d")]
    pub fn create_texture_array(&mut self, _width: u32, _height: u32, _layers: &[&[u8]], _linear: bool) -> u32 {
        match *self {}
    }

    #[cfg(feature = "3d")]
    pub fn create_gpu_buffer(&mut self, _: u32, _: u32, _: &[crate::Vec4]) {}
    #[cfg(feature = "3d")]
    pub fn free_gpu_buffer(&mut self, _: u32) {}
    #[cfg(feature = "3d")]
    pub fn write_gpu_buffer(&mut self, _: u32, _: u32, _: &[crate::Vec4]) {}
    #[cfg(feature = "3d")]
    pub fn set_instance_batch(&mut self, _: u32, _: Option<&crate::three::instances::Batch>) {}
    pub fn set_mesh_gpu_buffer(&mut self, _: u32, _: u32, _: u32) {}
    #[cfg(feature = "3d")]
    pub fn create_compute(&mut self, _name: &str, _source: &str) -> Result<u32, String> {
        match *self {}
    }
    #[cfg(feature = "3d")]
    pub fn replace_compute(&mut self, _id: u32, _name: &str, _source: &str) -> Result<(), String> {
        match *self {}
    }
    #[cfg(feature = "3d")]
    pub fn create_effect(&mut self, _name: &str, _source: &str) -> Result<u32, String> {
        match *self {}
    }
    #[cfg(feature = "3d")]
    pub fn replace_effect(&mut self, _id: u32, _name: &str, _source: &str) -> Result<(), String> {
        match *self {}
    }
    #[cfg(feature = "3d")]
    pub fn create_shader(&mut self, _name: &str, _source: &str) -> Result<u32, String> {
        match *self {}
    }
    #[cfg(feature = "3d")]
    pub fn replace_shader(&mut self, _id: u32, _name: &str, _source: &str) -> Result<(), String> {
        match *self {}
    }
    #[cfg(feature = "3d")]
    pub fn create_mesh(
        &mut self,
        _id: u32,
        _data: &crate::MeshData,
        _parts: &[(std::ops::Range<u32>, crate::Material)],
        _skinned: bool,
    ) {
        match *self {}
    }
    #[cfg(feature = "3d")]
    pub fn free_mesh(&mut self, _id: u32) {
        match *self {}
    }
    #[cfg(feature = "3d")]
    pub fn take_occlusion(&mut self) -> Option<crate::three::occlusion::OcclusionGrid> {
        match *self {}
    }
    #[cfg(feature = "3d")]
    pub fn prepare_3d(&mut self, _scene: &crate::three::Scene3D<'_>, _collect_ms: f32) {
        match *self {}
    }
    #[allow(clippy::too_many_arguments)]
    pub fn render(
        &mut self,
        _world: &mut DrawList,
        _ui: &mut DrawList,
        _panels: &mut [super::batch::PanelDraw],
        _clear: Color,
        _world_view: Mat4,
        _ui_view: Mat4,
        _capture: bool,
    ) -> FrameStatus {
        match *self {}
    }
}