Merge #1514

1514: Add render target example r=kvark a=pengowen123

This example also demonstrates the use of geometry shaders, and manual creation of resources when there is no suitable method on `Factory`. Unfortunately, I am not familiar with HLSL, so I did not add shaders for it.

Fixes #1512

Author: bors[bot]

Cargo.toml

@@ -143,6 +143,10 @@ path = "examples/particle/main.rs"
 name = "trianglell"
 path = "examples/trianglell/main.rs"
 
+[[example]]
+name = "render_target"
+path = "examples/render_target/main.rs"
+
 [dev-dependencies]
 cgmath = "0.14"
 gfx_gl = "0.3"

examples/render_target/README.md

@@ -0,0 +1,23 @@
+<!--
+    Copyright 2016 The Gfx-rs Developers.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+
+# Render target
+
+A small example demonstrating rendering to a render target.
+
+## Screenshot
+
+![Render Target Example](screenshot.png)

examples/render_target/compile.cmd

@@ -0,0 +1,5 @@
+@echo off
+set FXC="%DXSDK_DIR%\Utilities\bin\x64\fxc.exe" -nologo
+if not exist data mkdir data
+%FXC% /T vs_4_0 /E Vertex /Fo data/vertex.fx shader/cubemap.hlsl
+%FXC% /T ps_4_0 /E Pixel /Fo data/pixel.fx shader/cubemap.hlsl

examples/render_target/data/pixel.fx

@@ -0,0 +1,349 @@
+// Copyright 2016 The Gfx-rs Developers.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#[macro_use]
+extern crate gfx;
+extern crate gfx_app;
+extern crate cgmath;
+
+pub use gfx_app::ColorFormat;
+pub use gfx::format::{Depth, Rgba8};
+
+use cgmath::{Deg, Matrix4};
+use gfx::{Bundle, texture, memory, format, handle, state};
+use std::time::Instant;
+
+gfx_defines!{
+    vertex Vertex {
+        pos: [f32; 2] = "a_Pos",
+    }
+
+    constant Locals {
+        inv_proj: [[f32; 4]; 4] = "u_InvProj",
+        view: [[f32; 4]; 4] = "u_WorldToCamera",
+    }
+
+    pipeline pipe {
+        vbuf: gfx::VertexBuffer<Vertex> = (),
+        cubemap: gfx::TextureSampler<[f32; 4]> = "t_Cubemap",
+        locals: gfx::ConstantBuffer<Locals> = "Locals",
+        out: gfx::RenderTarget<ColorFormat> = "Target0",
+    }
+}
+
+gfx_defines! {
+    vertex VertexRender {
+        pos: [f32; 3] = "a_Pos",
+    }
+
+    constant LocalsRender {
+        pos: [f32; 3] = "pos",
+        far_plane: f32 = "farPlane",
+    }
+    
+    constant Matrix {
+        matrix: [[f32; 4]; 4] = "matrix",
+    }
+
+    pipeline pipe_render {
+        vbuf: gfx::VertexBuffer<VertexRender> = (),
+        locals: gfx::ConstantBuffer<LocalsRender> = "Locals",
+        matrices: gfx::ConstantBuffer<Matrix> = "u_Matrices",
+        out_depth: gfx::DepthTarget<DepthFormat> = gfx::preset::depth::LESS_EQUAL_WRITE,
+    }
+}
+
+impl From<cgmath::Matrix4<f32>> for Matrix {
+    fn from(m: cgmath::Matrix4<f32>) -> Self {
+        Matrix { matrix: m.into() }
+    }
+}
+
+impl Vertex {
+    fn new(p: [f32; 2]) -> Vertex {
+        Vertex { pos: p }
+    }
+}
+
+impl VertexRender {
+    fn new(p: [f32; 3]) -> VertexRender {
+        VertexRender { pos: p }
+    }
+}
+
+pub struct DepthFormat;
+
+impl format::Formatted for DepthFormat {
+    type Surface = format::D24_S8;
+    type Channel = format::Unorm;
+    type View = [f32; 4];
+
+    fn get_format() -> format::Format {
+        format::Format(format::SurfaceType::D24_S8, format::ChannelType::Unorm)
+    }
+}
+
+fn create_cubemap<R, F, DF>(
+    factory: &mut F,
+    size: texture::Size,
+) -> Result<
+    (handle::ShaderResourceView<R, DF::View>, handle::DepthStencilView<R, DF>),
+    gfx::CombinedError,
+>
+where
+    R: gfx::Resources,
+    F: gfx::Factory<R>,
+    DF: format::DepthFormat + format::TextureFormat,
+{
+    // Get texture info
+    let kind = texture::Kind::Cube(size);
+    let levels = 1;
+    let bind = gfx::DEPTH_STENCIL | gfx::SHADER_RESOURCE;
+    let channel_type = <DF::Channel as format::ChannelTyped>::get_channel_type();
+
+    // Create texture
+    let texture = factory.create_texture(
+        kind,
+        levels,
+        bind,
+        memory::Usage::Data,
+        Some(channel_type),
+    )?;
+
+    // View the texture as a shader resource
+    let srv = factory.view_texture_as_shader_resource::<DF>(
+        &texture,
+        (0, 0),
+        format::Swizzle::new(),
+    )?;
+
+    // View the texture as a depth stencil
+    let dsv = factory.view_texture_as_depth_stencil_trivial(&texture)?;
+
+    Ok((srv, dsv))
+}
+
+struct App<R: gfx::Resources> {
+    bundle: Bundle<R, pipe::Data<R>>,
+    bundle_render_cubemap: Bundle<R, pipe_render::Data<R>>,
+    projection: Matrix4<f32>,
+    proj_render: Matrix4<f32>,
+    far_plane: f32,
+    start_time: Instant,
+}
+
+impl<R: gfx::Resources> gfx_app::Application<R> for App<R> {
+    fn new<F: gfx::Factory<R>>(
+        factory: &mut F,
+        backend: gfx_app::shade::Backend,
+        window_targets: gfx_app::WindowTargets<R>,
+    ) -> Self {
+        use gfx::traits::FactoryExt;
+
+        let proj = cgmath::perspective(Deg(90.0f32), window_targets.aspect_ratio, 0.01, 100.0);
+
+        let (bundle_skybox, dsv) = {
+            let vs = gfx_app::shade::Source {
+                glsl_150: include_bytes!("shader/cubemap_150.glslv"),
+                hlsl_40: include_bytes!("data/vertex.fx"),
+                ..gfx_app::shade::Source::empty()
+            };
+            let ps = gfx_app::shade::Source {
+                glsl_150: include_bytes!("shader/cubemap_150.glslf"),
+                hlsl_40: include_bytes!("data/pixel.fx"),
+                ..gfx_app::shade::Source::empty()
+            };
+
+            let vertex_data = [
+                Vertex::new([-1.0, -1.0]),
+                Vertex::new([3.0, -1.0]),
+                Vertex::new([-1.0, 3.0]),
+            ];
+            let (vbuf, slice) = factory.create_vertex_buffer_with_slice(&vertex_data, ());
+
+            let (cubemap, dsv) = create_cubemap::<_, _, DepthFormat>(factory, 1024).unwrap();
+
+            let sampler = factory.create_sampler_linear();
+
+            let pso = factory
+                .create_pipeline_simple(
+                    vs.select(backend).unwrap(),
+                    ps.select(backend).unwrap(),
+                    pipe::new(),
+                )
+                .unwrap();
+
+            let data = pipe::Data {
+                vbuf: vbuf,
+                cubemap: (cubemap, sampler),
+                locals: factory.create_constant_buffer(1),
+                out: window_targets.color,
+            };
+
+            (Bundle::new(slice, pso, data), dsv)
+        };
+
+        let bundle_render_cubemap = {
+            let vs = gfx_app::shade::Source {
+                glsl_150: include_bytes!("shader/render_150.glslv"),
+                ..gfx_app::shade::Source::empty()
+            };
+            let gs = gfx_app::shade::Source {
+                glsl_150: include_bytes!("shader/render_150.glslg"),
+                ..gfx_app::shade::Source::empty()
+            };
+            let ps = gfx_app::shade::Source {
+                glsl_150: include_bytes!("shader/render_150.glslf"),
+                ..gfx_app::shade::Source::empty()
+            };
+
+            let vertex_data = [
+                VertexRender::new([0.0, 0.0, 1.0]),
+                VertexRender::new([1.0, 1.0, 0.0]),
+                VertexRender::new([1.0, -1.0, 0.0]),
+            ];
+
+            let (vbuf, slice) = factory.create_vertex_buffer_with_slice(&vertex_data, ());
+
+            let vs = factory
+                .create_shader_vertex(&vs.select(backend).unwrap())
+                .unwrap();
+            let gs = factory
+                .create_shader_geometry(&gs.select(backend).unwrap())
+                .unwrap();
+            let ps = factory
+                .create_shader_pixel(&ps.select(backend).unwrap())
+                .unwrap();
+            let set = gfx::ShaderSet::Geometry(vs, gs, ps);
+
+            let pso = factory
+                .create_pipeline_state(
+                    &set,
+                    gfx::Primitive::TriangleList,
+                    state::Rasterizer::new_fill(),
+                    pipe_render::new(),
+                )
+                .unwrap();
+
+            let data = pipe_render::Data {
+                vbuf: vbuf,
+                locals: factory.create_constant_buffer(1),
+                matrices: factory.create_constant_buffer(6),
+                out_depth: dsv,
+            };
+
+            Bundle::new(slice, pso, data)
+
+        };
+
+        let far_plane = 10.0;
+        let proj_render = cgmath::perspective(
+            cgmath::Deg(90.0),
+            window_targets.aspect_ratio,
+            0.1,
+            far_plane,
+        );
+
+        App {
+            bundle: bundle_skybox,
+            bundle_render_cubemap,
+            projection: proj,
+            start_time: Instant::now(),
+            proj_render: proj_render,
+            far_plane,
+        }
+    }
+
+    fn render<C: gfx::CommandBuffer<R>>(&mut self, encoder: &mut gfx::Encoder<R, C>) {
+        use cgmath::{Matrix4, Point3, SquareMatrix, Vector3, vec3};
+
+        encoder.clear(&self.bundle.data.out, [0.3, 0.3, 0.3, 1.0]);
+        self.bundle.encode(encoder);
+
+        // Render to the render target
+        {
+            encoder.clear_depth(&self.bundle_render_cubemap.data.out_depth, 1.0);
+
+            let far_plane = 10.0;
+            let pos = Point3::new(0.0, 0.0, 0.0);
+
+            let mut matrices: [Matrix; 6] =
+                [
+                    Matrix4::look_at(pos, pos + vec3(1.0, 0.0, 0.0), vec3(0.0, -1.0, 0.0)).into(),
+                    Matrix4::look_at(pos, pos + vec3(-1.0, 0.0, 0.0), vec3(0.0, -1.0, 0.0)).into(),
+                    Matrix4::look_at(pos, pos + vec3(0.0, 1.0, 0.0), vec3(0.0, 0.0, 1.0)).into(),
+                    Matrix4::look_at(pos, pos + vec3(0.0, -1.0, 0.0), vec3(0.0, 0.0, -1.0)).into(),
+                    Matrix4::look_at(pos, pos + vec3(0.0, 0.0, 1.0), vec3(0.0, -1.0, 0.0)).into(),
+                    Matrix4::look_at(pos, pos + vec3(0.0, 0.0, -1.0), vec3(0.0, -1.0, 0.0)).into(),
+                ];
+
+            for m in &mut matrices {
+                m.matrix = (self.proj_render * Matrix4::from(m.matrix)).into();
+            }
+
+            let locals = LocalsRender {
+                pos: pos.into(),
+                far_plane,
+            };
+
+            encoder.update_constant_buffer(&self.bundle_render_cubemap.data.locals, &locals);
+            encoder
+                .update_buffer(&self.bundle_render_cubemap.data.matrices, &matrices, 0)
+                .unwrap();
+        }
+
+        encoder.clear_depth(&self.bundle_render_cubemap.data.out_depth, 1.0);
+        self.bundle_render_cubemap.encode(encoder);
+
+        // Display the render target as a skybox
+        {
+            // Update camera position
+            let elapsed = self.start_time.elapsed();
+            let time = (elapsed.as_secs() as f32 + elapsed.subsec_nanos() as f32 / 1000_000_000.0) *
+                0.75;
+            let x = time.sin();
+            let z = time.cos();
+
+            let view = Matrix4::look_at(
+                Point3::new(x, x / 2.0, z),
+                Point3::new(0.0, 0.0, 0.0),
+                Vector3::unit_y(),
+            );
+
+            let locals = Locals {
+                inv_proj: self.projection.invert().unwrap().into(),
+                view: view.into(),
+            };
+            encoder.update_constant_buffer(&self.bundle.data.locals, &locals);
+        }
+    }
+
+    fn on_resize(&mut self, window_targets: gfx_app::WindowTargets<R>) {
+        self.bundle.data.out = window_targets.color;
+        self.projection =
+            cgmath::perspective(Deg(90.0f32), window_targets.aspect_ratio, 0.01, 100.0);
+
+        self.proj_render = cgmath::perspective(
+            cgmath::Deg(90.0),
+            window_targets.aspect_ratio,
+            0.1,
+            self.far_plane,
+        );
+    }
+}
+
+pub fn main() {
+    use gfx_app::Application;
+    App::launch_simple("Render target example");
+}