gfx/wgpu_bindings/src/identity.rs

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 use wgc::id;
   6
   7 pub type FactoryParam = *mut std::ffi::c_void;
   8
   9 #[derive(Debug)]
  10 pub struct IdentityRecycler<I> {
  11     fun: extern "C" fn(I, FactoryParam),
  12     param: FactoryParam,
  13     kind: &'static str,
  14 }
  15
  16 impl<I: id::TypedId + Clone + std::fmt::Debug> wgc::hub::IdentityHandler<I>
  17     for IdentityRecycler<I>
  18 {
  19     type Input = I;
  20     fn process(&self, id: I, _backend: wgt::Backend) -> I {
  21         log::debug!("process {} {:?}", self.kind, id);
  22         //debug_assert_eq!(id.unzip().2, backend);
  23         id
  24     }
  25     fn free(&self, id: I) {
  26         log::debug!("free {} {:?}", self.kind, id);
  27         (self.fun)(id, self.param);
  28     }
  29 }
  30
  31 //TODO: remove this in favor of `DropAction` that could be sent over IPC.
  32 #[repr(C)]
  33 pub struct IdentityRecyclerFactory {
  34     param: FactoryParam,
  35     free_adapter: extern "C" fn(id::AdapterId, FactoryParam),
  36     free_device: extern "C" fn(id::DeviceId, FactoryParam),
  37     free_pipeline_layout: extern "C" fn(id::PipelineLayoutId, FactoryParam),
  38     free_shader_module: extern "C" fn(id::ShaderModuleId, FactoryParam),
  39     free_bind_group_layout: extern "C" fn(id::BindGroupLayoutId, FactoryParam),
  40     free_bind_group: extern "C" fn(id::BindGroupId, FactoryParam),
  41     free_command_buffer: extern "C" fn(id::CommandBufferId, FactoryParam),
  42     free_render_bundle: extern "C" fn(id::RenderBundleId, FactoryParam),
  43     free_render_pipeline: extern "C" fn(id::RenderPipelineId, FactoryParam),
  44     free_compute_pipeline: extern "C" fn(id::ComputePipelineId, FactoryParam),
  45     free_query_set: extern "C" fn(id::QuerySetId, FactoryParam),
  46     free_buffer: extern "C" fn(id::BufferId, FactoryParam),
  47     free_texture: extern "C" fn(id::TextureId, FactoryParam),
  48     free_texture_view: extern "C" fn(id::TextureViewId, FactoryParam),
  49     free_sampler: extern "C" fn(id::SamplerId, FactoryParam),
  50     free_surface: extern "C" fn(id::SurfaceId, FactoryParam),
  51 }
  52
  53 impl wgc::hub::IdentityHandlerFactory<id::AdapterId> for IdentityRecyclerFactory {
  54     type Filter = IdentityRecycler<id::AdapterId>;
  55     fn spawn(&self) -> Self::Filter {
  56         IdentityRecycler {
  57             fun: self.free_adapter,
  58             param: self.param,
  59             kind: "adapter",
  60         }
  61     }
  62 }
  63 impl wgc::hub::IdentityHandlerFactory<id::DeviceId> for IdentityRecyclerFactory {
  64     type Filter = IdentityRecycler<id::DeviceId>;
  65     fn spawn(&self) -> Self::Filter {
  66         IdentityRecycler {
  67             fun: self.free_device,
  68             param: self.param,
  69             kind: "device",
  70         }
  71     }
  72 }
  73 impl wgc::hub::IdentityHandlerFactory<id::PipelineLayoutId> for IdentityRecyclerFactory {
  74     type Filter = IdentityRecycler<id::PipelineLayoutId>;
  75     fn spawn(&self) -> Self::Filter {
  76         IdentityRecycler {
  77             fun: self.free_pipeline_layout,
  78             param: self.param,
  79             kind: "pipeline_layout",
  80         }
  81     }
  82 }
  83 impl wgc::hub::IdentityHandlerFactory<id::ShaderModuleId> for IdentityRecyclerFactory {
  84     type Filter = IdentityRecycler<id::ShaderModuleId>;
  85     fn spawn(&self) -> Self::Filter {
  86         IdentityRecycler {
  87             fun: self.free_shader_module,
  88             param: self.param,
  89             kind: "shader_module",
  90         }
  91     }
  92 }
  93 impl wgc::hub::IdentityHandlerFactory<id::BindGroupLayoutId> for IdentityRecyclerFactory {
  94     type Filter = IdentityRecycler<id::BindGroupLayoutId>;
  95     fn spawn(&self) -> Self::Filter {
  96         IdentityRecycler {
  97             fun: self.free_bind_group_layout,
  98             param: self.param,
  99             kind: "bind_group_layout",
 100         }
 101     }
 102 }
 103 impl wgc::hub::IdentityHandlerFactory<id::BindGroupId> for IdentityRecyclerFactory {
 104     type Filter = IdentityRecycler<id::BindGroupId>;
 105     fn spawn(&self) -> Self::Filter {
 106         IdentityRecycler {
 107             fun: self.free_bind_group,
 108             param: self.param,
 109             kind: "bind_group",
 110         }
 111     }
 112 }
 113 impl wgc::hub::IdentityHandlerFactory<id::CommandBufferId> for IdentityRecyclerFactory {
 114     type Filter = IdentityRecycler<id::CommandBufferId>;
 115     fn spawn(&self) -> Self::Filter {
 116         IdentityRecycler {
 117             fun: self.free_command_buffer,
 118             param: self.param,
 119             kind: "command_buffer",
 120         }
 121     }
 122 }
 123 impl wgc::hub::IdentityHandlerFactory<id::RenderBundleId> for IdentityRecyclerFactory {
 124     type Filter = IdentityRecycler<id::RenderBundleId>;
 125     fn spawn(&self) -> Self::Filter {
 126         IdentityRecycler {
 127             fun: self.free_render_bundle,
 128             param: self.param,
 129             kind: "render_bundle",
 130         }
 131     }
 132 }
 133 impl wgc::hub::IdentityHandlerFactory<id::RenderPipelineId> for IdentityRecyclerFactory {
 134     type Filter = IdentityRecycler<id::RenderPipelineId>;
 135     fn spawn(&self) -> Self::Filter {
 136         IdentityRecycler {
 137             fun: self.free_render_pipeline,
 138             param: self.param,
 139             kind: "render_pipeline",
 140         }
 141     }
 142 }
 143 impl wgc::hub::IdentityHandlerFactory<id::ComputePipelineId> for IdentityRecyclerFactory {
 144     type Filter = IdentityRecycler<id::ComputePipelineId>;
 145     fn spawn(&self) -> Self::Filter {
 146         IdentityRecycler {
 147             fun: self.free_compute_pipeline,
 148             param: self.param,
 149             kind: "compute_pipeline",
 150         }
 151     }
 152 }
 153 impl wgc::hub::IdentityHandlerFactory<id::QuerySetId> for IdentityRecyclerFactory {
 154     type Filter = IdentityRecycler<id::QuerySetId>;
 155     fn spawn(&self) -> Self::Filter {
 156         IdentityRecycler {
 157             fun: self.free_query_set,
 158             param: self.param,
 159             kind: "query_set",
 160         }
 161     }
 162 }
 163 impl wgc::hub::IdentityHandlerFactory<id::BufferId> for IdentityRecyclerFactory {
 164     type Filter = IdentityRecycler<id::BufferId>;
 165     fn spawn(&self) -> Self::Filter {
 166         IdentityRecycler {
 167             fun: self.free_buffer,
 168             param: self.param,
 169             kind: "buffer",
 170         }
 171     }
 172 }
 173 impl wgc::hub::IdentityHandlerFactory<id::TextureId> for IdentityRecyclerFactory {
 174     type Filter = IdentityRecycler<id::TextureId>;
 175     fn spawn(&self) -> Self::Filter {
 176         IdentityRecycler {
 177             fun: self.free_texture,
 178             param: self.param,
 179             kind: "texture",
 180         }
 181     }
 182 }
 183 impl wgc::hub::IdentityHandlerFactory<id::TextureViewId> for IdentityRecyclerFactory {
 184     type Filter = IdentityRecycler<id::TextureViewId>;
 185     fn spawn(&self) -> Self::Filter {
 186         IdentityRecycler {
 187             fun: self.free_texture_view,
 188             param: self.param,
 189             kind: "texture_view",
 190         }
 191     }
 192 }
 193 impl wgc::hub::IdentityHandlerFactory<id::SamplerId> for IdentityRecyclerFactory {
 194     type Filter = IdentityRecycler<id::SamplerId>;
 195     fn spawn(&self) -> Self::Filter {
 196         IdentityRecycler {
 197             fun: self.free_sampler,
 198             param: self.param,
 199             kind: "sampler",
 200         }
 201     }
 202 }
 203 impl wgc::hub::IdentityHandlerFactory<id::SurfaceId> for IdentityRecyclerFactory {
 204     type Filter = IdentityRecycler<id::SurfaceId>;
 205     fn spawn(&self) -> Self::Filter {
 206         IdentityRecycler {
 207             fun: self.free_surface,
 208             param: self.param,
 209             kind: "surface",
 210         }
 211     }
 212 }
 213
 214 impl wgc::hub::GlobalIdentityHandlerFactory for IdentityRecyclerFactory {}