diff --git a/sample/src/main.rs b/sample/src/main.rs index 02d3f2f4ef..2862abc475 100644 --- a/sample/src/main.rs +++ b/sample/src/main.rs @@ -84,7 +84,7 @@ fn main() { .. Default::default() }; - let (mut renderer, sender) = webrender::renderer::Renderer::new(opts); + let (mut renderer, sender) = webrender::renderer::Renderer::new(opts).unwrap(); let api = sender.create_api(); let notifier = Box::new(Notifier::new(window.create_window_proxy())); diff --git a/webrender/src/debug_render.rs b/webrender/src/debug_render.rs index f185de69a7..ea8bf4e517 100644 --- a/webrender/src/debug_render.rs +++ b/webrender/src/debug_render.rs @@ -28,8 +28,8 @@ pub struct DebugRenderer { impl DebugRenderer { pub fn new(device: &mut Device) -> DebugRenderer { - let font_program_id = device.create_program("debug_font", "shared_other", VertexFormat::DebugFont); - let color_program_id = device.create_program("debug_color", "shared_other", VertexFormat::DebugColor); + let font_program_id = device.create_program("debug_font", "shared_other", VertexFormat::DebugFont).unwrap(); + let color_program_id = device.create_program("debug_color", "shared_other", VertexFormat::DebugColor).unwrap(); let font_vao = device.create_vao(VertexFormat::DebugFont, 32); let line_vao = device.create_vao(VertexFormat::DebugColor, 32); diff --git a/webrender/src/device.rs b/webrender/src/device.rs index 2d2117102a..42364908cd 100644 --- a/webrender/src/device.rs +++ b/webrender/src/device.rs @@ -375,8 +375,7 @@ impl Program { fn attach_and_bind_shaders(&mut self, vs_id: gl::GLuint, fs_id: gl::GLuint, - vertex_format: VertexFormat, - panic_on_fail: bool) -> bool { + vertex_format: VertexFormat) -> Result<(), ShaderError> { gl::attach_shader(self.id, vs_id); gl::attach_shader(self.id, fs_id); @@ -417,17 +416,14 @@ impl Program { gl::link_program(self.id); if gl::get_program_iv(self.id, gl::LINK_STATUS) == (0 as gl::GLint) { - println!("Failed to link shader program: {}", gl::get_program_info_log(self.id)); + let error_log = gl::get_program_info_log(self.id); + println!("Failed to link shader program: {}", error_log); gl::detach_shader(self.id, vs_id); gl::detach_shader(self.id, fs_id); - if panic_on_fail { - panic!("-- Program link failed - exiting --"); - } - false - } else { - //println!("{}", gl::get_program_info_log(self.id)); - true + return Err(ShaderError::Link(error_log)); } + + Ok(()) } } @@ -793,6 +789,12 @@ pub struct Capabilities { pub supports_multisampling: bool, } +#[derive(Clone, Debug)] +pub enum ShaderError { + Compilation(String, String), // name, error mssage + Link(String), // error message +} + pub struct Device { // device state bound_textures: [TextureId; 16], @@ -871,9 +873,8 @@ impl Device { pub fn compile_shader(name: &str, source_str: &str, shader_type: gl::GLenum, - shader_preamble: &[String], - panic_on_fail: bool) - -> Option { + shader_preamble: &[String]) + -> Result { debug!("compile {:?}", name); let mut s = String::new(); @@ -891,16 +892,12 @@ impl Device { let log = gl::get_shader_info_log(id); if gl::get_shader_iv(id, gl::COMPILE_STATUS) == (0 as gl::GLint) { println!("Failed to compile shader: {:?}\n{}", name, log); - if panic_on_fail { - panic!("-- Shader compile failed - exiting --"); - } - - None + Err(ShaderError::Compilation(name.to_string(), log)) } else { if !log.is_empty() { println!("Warnings detected on shader: {:?}\n{}", name, log); } - Some(id) + Ok(id) } } @@ -1334,7 +1331,7 @@ impl Device { pub fn create_program(&mut self, base_filename: &str, include_filename: &str, - vertex_format: VertexFormat) -> ProgramId { + vertex_format: VertexFormat) -> Result { self.create_program_with_prefix(base_filename, &[include_filename], None, vertex_format) } @@ -1342,7 +1339,7 @@ impl Device { base_filename: &str, include_filenames: &[&str], prefix: Option, - vertex_format: VertexFormat) -> ProgramId { + vertex_format: VertexFormat) -> Result { debug_assert!(self.inside_frame); let pid = gl::create_program(); @@ -1379,16 +1376,15 @@ impl Device { debug_assert!(self.programs.contains_key(&program_id) == false); self.programs.insert(program_id, program); - self.load_program(program_id, include, vertex_format, true); + try!{ self.load_program(program_id, include, vertex_format) }; - program_id + Ok(program_id) } fn load_program(&mut self, program_id: ProgramId, include: String, - vertex_format: VertexFormat, - panic_on_fail: bool) { + vertex_format: VertexFormat) -> Result<(), ShaderError> { debug_assert!(self.inside_frame); let program = self.programs.get_mut(&program_id).unwrap(); @@ -1411,127 +1407,114 @@ impl Device { fs_preamble.push(include); // todo(gw): store shader ids so they can be freed! - let vs_id = Device::compile_shader(&program.name, - &program.vs_source, - gl::VERTEX_SHADER, - &vs_preamble, - panic_on_fail); - let fs_id = Device::compile_shader(&program.name, - &program.fs_source, - gl::FRAGMENT_SHADER, - &fs_preamble, - panic_on_fail); - - match (vs_id, fs_id) { - (Some(vs_id), None) => { - println!("FAILED to load fs - falling back to previous!"); + let vs_id = try!{ Device::compile_shader(&program.name, + &program.vs_source, + gl::VERTEX_SHADER, + &vs_preamble) }; + let fs_id = try!{ Device::compile_shader(&program.name, + &program.fs_source, + gl::FRAGMENT_SHADER, + &fs_preamble) }; + + if let Some(vs_id) = program.vs_id { + gl::detach_shader(program.id, vs_id); + } + + if let Some(fs_id) = program.fs_id { + gl::detach_shader(program.id, fs_id); + } + + if let Err(bind_error) = program.attach_and_bind_shaders(vs_id, fs_id, vertex_format) { + if let (Some(vs_id), Some(fs_id)) = (program.vs_id, program.fs_id) { + try! { program.attach_and_bind_shaders(vs_id, fs_id, vertex_format) }; + } else { + return Err(bind_error); + } + } else { + if let Some(vs_id) = program.vs_id { gl::delete_shader(vs_id); } - (None, Some(fs_id)) => { - println!("FAILED to load vs - falling back to previous!"); + + if let Some(fs_id) = program.fs_id { gl::delete_shader(fs_id); } - (None, None) => { - println!("FAILED to load vs/fs - falling back to previous!"); - } - (Some(vs_id), Some(fs_id)) => { - if let Some(vs_id) = program.vs_id { - gl::detach_shader(program.id, vs_id); - } - - if let Some(fs_id) = program.fs_id { - gl::detach_shader(program.id, fs_id); - } - - if program.attach_and_bind_shaders(vs_id, fs_id, vertex_format, panic_on_fail) { - if let Some(vs_id) = program.vs_id { - gl::delete_shader(vs_id); - } - - if let Some(fs_id) = program.fs_id { - gl::delete_shader(fs_id); - } - program.vs_id = Some(vs_id); - program.fs_id = Some(fs_id); - } else { - let vs_id = program.vs_id.unwrap(); - let fs_id = program.fs_id.unwrap(); - program.attach_and_bind_shaders(vs_id, fs_id, vertex_format, true); - } + program.vs_id = Some(vs_id); + program.fs_id = Some(fs_id); + } - program.u_transform = gl::get_uniform_location(program.id, "uTransform"); - program.u_device_pixel_ratio = gl::get_uniform_location(program.id, "uDevicePixelRatio"); + program.u_transform = gl::get_uniform_location(program.id, "uTransform"); + program.u_device_pixel_ratio = gl::get_uniform_location(program.id, "uDevicePixelRatio"); - program_id.bind(); - let u_color_0 = gl::get_uniform_location(program.id, "sColor0"); - if u_color_0 != -1 { - gl::uniform_1i(u_color_0, TextureSampler::Color0 as i32); - } - let u_color1 = gl::get_uniform_location(program.id, "sColor1"); - if u_color1 != -1 { - gl::uniform_1i(u_color1, TextureSampler::Color1 as i32); - } - let u_color_2 = gl::get_uniform_location(program.id, "sColor2"); - if u_color_2 != -1 { - gl::uniform_1i(u_color_2, TextureSampler::Color2 as i32); - } - let u_mask = gl::get_uniform_location(program.id, "sMask"); - if u_mask != -1 { - gl::uniform_1i(u_mask, TextureSampler::Mask as i32); - } + program_id.bind(); + let u_color_0 = gl::get_uniform_location(program.id, "sColor0"); + if u_color_0 != -1 { + gl::uniform_1i(u_color_0, TextureSampler::Color0 as i32); + } + let u_color1 = gl::get_uniform_location(program.id, "sColor1"); + if u_color1 != -1 { + gl::uniform_1i(u_color1, TextureSampler::Color1 as i32); + } + let u_color_2 = gl::get_uniform_location(program.id, "sColor2"); + if u_color_2 != -1 { + gl::uniform_1i(u_color_2, TextureSampler::Color2 as i32); + } + let u_mask = gl::get_uniform_location(program.id, "sMask"); + if u_mask != -1 { + gl::uniform_1i(u_mask, TextureSampler::Mask as i32); + } - let u_cache = gl::get_uniform_location(program.id, "sCache"); - if u_cache != -1 { - gl::uniform_1i(u_cache, TextureSampler::Cache as i32); - } + let u_cache = gl::get_uniform_location(program.id, "sCache"); + if u_cache != -1 { + gl::uniform_1i(u_cache, TextureSampler::Cache as i32); + } - let u_layers = gl::get_uniform_location(program.id, "sLayers"); - if u_layers != -1 { - gl::uniform_1i(u_layers, TextureSampler::Layers as i32); - } + let u_layers = gl::get_uniform_location(program.id, "sLayers"); + if u_layers != -1 { + gl::uniform_1i(u_layers, TextureSampler::Layers as i32); + } - let u_tasks = gl::get_uniform_location(program.id, "sRenderTasks"); - if u_tasks != -1 { - gl::uniform_1i(u_tasks, TextureSampler::RenderTasks as i32); - } + let u_tasks = gl::get_uniform_location(program.id, "sRenderTasks"); + if u_tasks != -1 { + gl::uniform_1i(u_tasks, TextureSampler::RenderTasks as i32); + } - let u_prim_geom = gl::get_uniform_location(program.id, "sPrimGeometry"); - if u_prim_geom != -1 { - gl::uniform_1i(u_prim_geom, TextureSampler::Geometry as i32); - } + let u_prim_geom = gl::get_uniform_location(program.id, "sPrimGeometry"); + if u_prim_geom != -1 { + gl::uniform_1i(u_prim_geom, TextureSampler::Geometry as i32); + } - let u_data16 = gl::get_uniform_location(program.id, "sData16"); - if u_data16 != -1 { - gl::uniform_1i(u_data16, TextureSampler::Data16 as i32); - } + let u_data16 = gl::get_uniform_location(program.id, "sData16"); + if u_data16 != -1 { + gl::uniform_1i(u_data16, TextureSampler::Data16 as i32); + } - let u_data32 = gl::get_uniform_location(program.id, "sData32"); - if u_data32 != -1 { - gl::uniform_1i(u_data32, TextureSampler::Data32 as i32); - } + let u_data32 = gl::get_uniform_location(program.id, "sData32"); + if u_data32 != -1 { + gl::uniform_1i(u_data32, TextureSampler::Data32 as i32); + } - let u_data64 = gl::get_uniform_location(program.id, "sData64"); - if u_data64 != -1 { - gl::uniform_1i(u_data64, TextureSampler::Data64 as i32); - } + let u_data64 = gl::get_uniform_location(program.id, "sData64"); + if u_data64 != -1 { + gl::uniform_1i(u_data64, TextureSampler::Data64 as i32); + } - let u_data128 = gl::get_uniform_location(program.id, "sData128"); - if u_data128 != -1 { - gl::uniform_1i(u_data128, TextureSampler::Data128 as i32); - } + let u_data128 = gl::get_uniform_location(program.id, "sData128"); + if u_data128 != -1 { + gl::uniform_1i(u_data128, TextureSampler::Data128 as i32); + } - let u_resource_rects = gl::get_uniform_location(program.id, "sResourceRects"); - if u_resource_rects != -1 { - gl::uniform_1i(u_resource_rects, TextureSampler::ResourceRects as i32); - } + let u_resource_rects = gl::get_uniform_location(program.id, "sResourceRects"); + if u_resource_rects != -1 { + gl::uniform_1i(u_resource_rects, TextureSampler::ResourceRects as i32); + } - let u_gradients = gl::get_uniform_location(program.id, "sGradients"); - if u_gradients != -1 { - gl::uniform_1i(u_gradients, TextureSampler::Gradients as i32); - } - } + let u_gradients = gl::get_uniform_location(program.id, "sGradients"); + if u_gradients != -1 { + gl::uniform_1i(u_gradients, TextureSampler::Gradients as i32); } + + Ok(()) } /* diff --git a/webrender/src/renderer.rs b/webrender/src/renderer.rs index c65f437b87..4f19ed05b3 100644 --- a/webrender/src/renderer.rs +++ b/webrender/src/renderer.rs @@ -12,7 +12,7 @@ use debug_colors; use debug_render::DebugRenderer; use device::{DepthFunction, Device, ProgramId, TextureId, VertexFormat, GpuMarker, GpuProfiler}; -use device::{TextureFilter, VAOId, VertexUsageHint, FileWatcherHandler, TextureTarget}; +use device::{TextureFilter, VAOId, VertexUsageHint, FileWatcherHandler, TextureTarget, ShaderError}; use euclid::Matrix4D; use fnv::FnvHasher; use gpu_store::{GpuStore, GpuStoreLayout}; @@ -25,6 +25,7 @@ use profiler::{Profiler, BackendProfileCounters}; use profiler::{GpuProfileTag, RendererProfileTimers, RendererProfileCounters}; use record::ApiRecordingReceiver; use render_backend::RenderBackend; +use std; use std::cmp; use std::collections::HashMap; use std::f32; @@ -180,7 +181,7 @@ impl LazilyCompiledShader { name: &'static str, features: &[&'static str], device: &mut Device, - precache: bool) -> LazilyCompiledShader { + precache: bool) -> Result { let mut shader = LazilyCompiledShader { id: None, name: name, @@ -189,35 +190,37 @@ impl LazilyCompiledShader { }; if precache { - shader.get(device); + try!{ shader.get(device) }; } - shader + Ok(shader) } - fn get(&mut self, device: &mut Device) -> ProgramId { + fn get(&mut self, device: &mut Device) -> Result { if self.id.is_none() { - let id = match self.kind { - ShaderKind::Primitive => { - create_prim_shader(self.name, - device, - &self.features, - VertexFormat::Triangles) - } - ShaderKind::Cache(format) => { - create_prim_shader(self.name, - device, - &self.features, - format) - } - ShaderKind::ClipCache => { - create_clip_shader(self.name, device) + let id = try!{ + match self.kind { + ShaderKind::Primitive => { + create_prim_shader(self.name, + device, + &self.features, + VertexFormat::Triangles) + } + ShaderKind::Cache(format) => { + create_prim_shader(self.name, + device, + &self.features, + format) + } + ShaderKind::ClipCache => { + create_clip_shader(self.name, device) + } } }; self.id = Some(id); } - self.id.unwrap() + Ok(self.id.unwrap()) } } @@ -254,31 +257,35 @@ impl PrimitiveShader { fn new(name: &'static str, device: &mut Device, features: &[&'static str], - precache: bool) -> PrimitiveShader { - let simple = LazilyCompiledShader::new(ShaderKind::Primitive, - name, - features, - device, - precache); + precache: bool) -> Result { + let simple = try!{ + LazilyCompiledShader::new(ShaderKind::Primitive, + name, + features, + device, + precache) + }; let mut transform_features = features.to_vec(); transform_features.push(TRANSFORM_FEATURE); - let transform = LazilyCompiledShader::new(ShaderKind::Primitive, - name, - &transform_features, - device, - precache); + let transform = try!{ + LazilyCompiledShader::new(ShaderKind::Primitive, + name, + &transform_features, + device, + precache) + }; - PrimitiveShader { + Ok(PrimitiveShader { simple: simple, transform: transform, - } + }) } fn get(&mut self, device: &mut Device, - transform_kind: TransformedRectKind) -> ProgramId { + transform_kind: TransformedRectKind) -> Result { match transform_kind { TransformedRectKind::AxisAligned => self.simple.get(device), TransformedRectKind::Complex => self.transform.get(device), @@ -289,7 +296,7 @@ impl PrimitiveShader { fn create_prim_shader(name: &'static str, device: &mut Device, features: &[&'static str], - vertex_format: VertexFormat) -> ProgramId { + vertex_format: VertexFormat) -> Result { let mut prefix = format!("#define WR_MAX_VERTEX_TEXTURE_WIDTH {}\n", MAX_VERTEX_TEXTURE_WIDTH); @@ -297,29 +304,21 @@ fn create_prim_shader(name: &'static str, prefix.push_str(&format!("#define WR_FEATURE_{}\n", feature)); } - let includes = &["prim_shared"]; - let program_id = device.create_program_with_prefix(name, - includes, - Some(prefix), - vertex_format); debug!("PrimShader {}", name); - program_id + let includes = &["prim_shared"]; + device.create_program_with_prefix(name, includes, Some(prefix), vertex_format) } -fn create_clip_shader(name: &'static str, device: &mut Device) -> ProgramId { +fn create_clip_shader(name: &'static str, device: &mut Device) -> Result { let prefix = format!("#define WR_MAX_VERTEX_TEXTURE_WIDTH {}\n #define WR_FEATURE_TRANSFORM", MAX_VERTEX_TEXTURE_WIDTH); - let includes = &["prim_shared", "clip_shared"]; - let program_id = device.create_program_with_prefix(name, - includes, - Some(prefix), - VertexFormat::Clip); debug!("ClipShader {}", name); - program_id + let includes = &["prim_shared", "clip_shared"]; + device.create_program_with_prefix(name, includes, Some(prefix), VertexFormat::Clip) } struct GpuDataTextures { @@ -465,6 +464,20 @@ pub struct Renderer { vr_compositor_handler: Arc>>> } +#[derive(Debug)] +pub enum InitError { + Shader(ShaderError), + Thread(std::io::Error), +} + +impl From for InitError { + fn from(err: ShaderError) -> Self { InitError::Shader(err) } +} + +impl From for InitError { + fn from(err: std::io::Error) -> Self { InitError::Thread(err) } +} + impl Renderer { /// Initializes webrender and creates a Renderer and RenderApiSender. /// @@ -484,9 +497,9 @@ impl Renderer { /// }; /// let (renderer, sender) = Renderer::new(opts); /// ``` - pub fn new(options: RendererOptions) -> (Renderer, RenderApiSender) { - let (api_tx, api_rx) = channel::msg_channel().unwrap(); - let (payload_tx, payload_rx) = channel::payload_channel().unwrap(); + pub fn new(options: RendererOptions) -> Result<(Renderer, RenderApiSender), InitError> { + let (api_tx, api_rx) = try!{ channel::msg_channel() }; + let (payload_tx, payload_rx) = try!{ channel::payload_channel() }; let (result_tx, result_rx) = channel(); let notifier = Arc::new(Mutex::new(None)); @@ -501,94 +514,145 @@ impl Renderer { // device-pixel ratio doesn't matter here - we are just creating resources. device.begin_frame(1.0); - let cs_box_shadow = LazilyCompiledShader::new(ShaderKind::Cache(VertexFormat::Triangles), - "cs_box_shadow", - &[], - &mut device, - options.precache_shaders); - let cs_text_run = LazilyCompiledShader::new(ShaderKind::Cache(VertexFormat::Triangles), - "cs_text_run", - &[], - &mut device, - options.precache_shaders); - let cs_blur = LazilyCompiledShader::new(ShaderKind::Cache(VertexFormat::Blur), - "cs_blur", - &[], - &mut device, - options.precache_shaders); - - let cs_clip_rectangle = LazilyCompiledShader::new(ShaderKind::ClipCache, - "cs_clip_rectangle", - &[], - &mut device, - options.precache_shaders); - let cs_clip_image = LazilyCompiledShader::new(ShaderKind::ClipCache, - "cs_clip_image", - &[], - &mut device, - options.precache_shaders); - - let ps_rectangle = PrimitiveShader::new("ps_rectangle", - &mut device, - &[], - options.precache_shaders); - let ps_rectangle_clip = PrimitiveShader::new("ps_rectangle", - &mut device, - &[ CLIP_FEATURE ], - options.precache_shaders); - let ps_text_run = PrimitiveShader::new("ps_text_run", - &mut device, - &[], - options.precache_shaders); - let ps_text_run_subpixel = PrimitiveShader::new("ps_text_run", - &mut device, - &[ SUBPIXEL_AA_FEATURE ], - options.precache_shaders); - let ps_image = PrimitiveShader::new("ps_image", - &mut device, - &[], - options.precache_shaders); - let ps_yuv_image = PrimitiveShader::new("ps_yuv_image", - &mut device, - &[], - options.precache_shaders); - let ps_border = PrimitiveShader::new("ps_border", - &mut device, - &[], - options.precache_shaders); - - let ps_box_shadow = PrimitiveShader::new("ps_box_shadow", - &mut device, - &[], - options.precache_shaders); - - let ps_gradient = PrimitiveShader::new("ps_gradient", - &mut device, - &[], - options.precache_shaders); - let ps_angle_gradient = PrimitiveShader::new("ps_angle_gradient", - &mut device, - &[], - options.precache_shaders); - let ps_radial_gradient = PrimitiveShader::new("ps_radial_gradient", - &mut device, - &[], - options.precache_shaders); - let ps_cache_image = PrimitiveShader::new("ps_cache_image", - &mut device, - &[], - options.precache_shaders); - - let ps_blend = LazilyCompiledShader::new(ShaderKind::Primitive, - "ps_blend", - &[], - &mut device, - options.precache_shaders); - let ps_composite = LazilyCompiledShader::new(ShaderKind::Primitive, - "ps_composite", - &[], - &mut device, - options.precache_shaders); + let cs_box_shadow = try!{ + LazilyCompiledShader::new(ShaderKind::Cache(VertexFormat::Triangles), + "cs_box_shadow", + &[], + &mut device, + options.precache_shaders) + }; + + let cs_text_run = try!{ + LazilyCompiledShader::new(ShaderKind::Cache(VertexFormat::Triangles), + "cs_text_run", + &[], + &mut device, + options.precache_shaders) + }; + + let cs_blur = try!{ + LazilyCompiledShader::new(ShaderKind::Cache(VertexFormat::Blur), + "cs_blur", + &[], + &mut device, + options.precache_shaders) + }; + + let cs_clip_rectangle = try!{ + LazilyCompiledShader::new(ShaderKind::ClipCache, + "cs_clip_rectangle", + &[], + &mut device, + options.precache_shaders) + }; + + let cs_clip_image = try!{ + LazilyCompiledShader::new(ShaderKind::ClipCache, + "cs_clip_image", + &[], + &mut device, + options.precache_shaders) + }; + + let ps_rectangle = try!{ + PrimitiveShader::new("ps_rectangle", + &mut device, + &[], + options.precache_shaders) + }; + + let ps_rectangle_clip = try!{ + PrimitiveShader::new("ps_rectangle", + &mut device, + &[ CLIP_FEATURE ], + options.precache_shaders) + }; + + let ps_text_run = try!{ + PrimitiveShader::new("ps_text_run", + &mut device, + &[], + options.precache_shaders) + }; + + let ps_text_run_subpixel = try!{ + PrimitiveShader::new("ps_text_run", + &mut device, + &[ SUBPIXEL_AA_FEATURE ], + options.precache_shaders) + }; + + let ps_image = try!{ + PrimitiveShader::new("ps_image", + &mut device, + &[], + options.precache_shaders) + }; + + let ps_yuv_image = try!{ + PrimitiveShader::new("ps_yuv_image", + &mut device, + &[], + options.precache_shaders) + }; + + let ps_border = try!{ + PrimitiveShader::new("ps_border", + &mut device, + &[], + options.precache_shaders) + }; + + let ps_box_shadow = try!{ + PrimitiveShader::new("ps_box_shadow", + &mut device, + &[], + options.precache_shaders) + }; + + let ps_gradient = try!{ + PrimitiveShader::new("ps_gradient", + &mut device, + &[], + options.precache_shaders) + }; + + let ps_angle_gradient = try!{ + PrimitiveShader::new("ps_angle_gradient", + &mut device, + &[], + options.precache_shaders) + }; + + let ps_radial_gradient = try!{ + PrimitiveShader::new("ps_radial_gradient", + &mut device, + &[], + options.precache_shaders) + }; + + let ps_cache_image = try!{ + PrimitiveShader::new("ps_cache_image", + &mut device, + &[], + options.precache_shaders) + }; + + let ps_blend = try!{ + LazilyCompiledShader::new(ShaderKind::Primitive, + "ps_blend", + &[], + &mut device, + options.precache_shaders) + }; + + let ps_composite = try!{ + LazilyCompiledShader::new(ShaderKind::Primitive, + "ps_composite", + &[], + &mut device, + options.precache_shaders) + }; let mut texture_cache = TextureCache::new(); @@ -691,7 +755,7 @@ impl Renderer { let render_target_debug = options.render_target_debug; let payload_tx_for_backend = payload_tx.clone(); let recorder = options.recorder; - thread::Builder::new().name("RenderBackend".to_string()).spawn(move || { + try!{ thread::Builder::new().name("RenderBackend".to_string()).spawn(move || { let mut backend = RenderBackend::new(api_rx, payload_rx, payload_tx_for_backend, @@ -707,7 +771,7 @@ impl Renderer { backend_main_thread_dispatcher, backend_vr_compositor); backend.run(); - }).unwrap(); + })}; let renderer = Renderer { result_rx: result_rx, @@ -760,7 +824,7 @@ impl Renderer { }; let sender = RenderApiSender::new(api_tx, payload_tx); - (renderer, sender) + Ok((renderer, sender)) } /// Sets the new RenderNotifier. @@ -1082,6 +1146,8 @@ impl Renderer { } }; + let shader = shader.unwrap(); + let _gm = self.gpu_profile.add_marker(marker); let vao = self.prim_vao_id; self.draw_instanced_batch(data, @@ -1093,7 +1159,7 @@ impl Renderer { PrimitiveBatchData::Composite(ref instance) => { let _gm = self.gpu_profile.add_marker(GPU_TAG_PRIM_COMPOSITE); let vao = self.prim_vao_id; - let shader = self.ps_composite.get(&mut self.device); + let shader = self.ps_composite.get(&mut self.device).unwrap(); // TODO(gw): This code branch is all a bit hacky. We rely // on pulling specific values from the render target data @@ -1236,7 +1302,7 @@ impl Renderer { let vao = self.blur_vao_id; self.device.set_blend(false); - let shader = self.cs_blur.get(&mut self.device); + let shader = self.cs_blur.get(&mut self.device).unwrap(); self.draw_instanced_batch(&target.vertical_blurs, vao, @@ -1255,7 +1321,7 @@ impl Renderer { self.device.set_blend(false); let _gm = self.gpu_profile.add_marker(GPU_TAG_CACHE_BOX_SHADOW); let vao = self.prim_vao_id; - let shader = self.cs_box_shadow.get(&mut self.device); + let shader = self.cs_box_shadow.get(&mut self.device).unwrap(); self.draw_instanced_batch(&target.box_shadow_cache_prims, vao, shader, @@ -1273,7 +1339,7 @@ impl Renderer { // draw rounded cornered rectangles if !target.clip_batcher.rectangles.is_empty() { let _gm2 = GpuMarker::new("clip rectangles"); - let shader = self.cs_clip_rectangle.get(&mut self.device); + let shader = self.cs_clip_rectangle.get(&mut self.device).unwrap(); self.draw_instanced_batch(&target.clip_batcher.rectangles, vao, shader, @@ -1285,7 +1351,7 @@ impl Renderer { let _gm2 = GpuMarker::new("clip images"); let texture_id = self.resolve_source_texture(mask_texture_id); self.device.bind_texture(TextureSampler::Mask, texture_id); - let shader = self.cs_clip_image.get(&mut self.device); + let shader = self.cs_clip_image.get(&mut self.device).unwrap(); self.draw_instanced_batch(items, vao, shader, @@ -1306,7 +1372,7 @@ impl Renderer { let _gm = self.gpu_profile.add_marker(GPU_TAG_CACHE_TEXT_RUN); let vao = self.prim_vao_id; - let shader = self.cs_text_run.get(&mut self.device); + let shader = self.cs_text_run.get(&mut self.device).unwrap(); self.draw_instanced_batch(&target.text_run_cache_prims, vao, diff --git a/wrench/src/wrench.rs b/wrench/src/wrench.rs index 3641b484cb..d996fcc1d8 100644 --- a/wrench/src/wrench.rs +++ b/wrench/src/wrench.rs @@ -174,7 +174,7 @@ impl Wrench { .. Default::default() }; - let (renderer, sender) = webrender::renderer::Renderer::new(opts); + let (renderer, sender) = webrender::renderer::Renderer::new(opts).unwrap(); let api = sender.create_api(); let proxy = window.create_window_proxy();