test: Move misc sample shaders to test/samples

Change-Id: I72d25393e499f85733232043fd492c2705e35c68
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/51223
Commit-Queue: Ben Clayton <bclayton@chromium.org>
Reviewed-by: David Neto <dneto@google.com>

test/samples/compute_boids.wgsl

@@ -0,0 +1,134 @@
+// Copyright 2020 The Tint Authors.
+//
+// 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.
+
+// vertex shader
+
+[[stage(vertex)]]
+fn vert_main([[location(0)]] a_particlePos : vec2<f32>,
+             [[location(1)]] a_particleVel : vec2<f32>,
+             [[location(2)]] a_pos : vec2<f32>)
+          -> [[builtin(position)]] vec4<f32> {
+  var angle : f32 = -atan2(a_particleVel.x, a_particleVel.y);
+  var pos : vec2<f32> = vec2<f32>(
+      (a_pos.x * cos(angle)) - (a_pos.y * sin(angle)),
+      (a_pos.x * sin(angle)) + (a_pos.y * cos(angle)));
+  return vec4<f32>(pos + a_particlePos, 0.0, 1.0);
+}
+
+// fragment shader
+
+[[stage(fragment)]]
+fn frag_main() -> [[location(0)]] vec4<f32> {
+  return vec4<f32>(1.0, 1.0, 1.0, 1.0);
+}
+
+// compute shader
+struct Particle {
+  pos : vec2<f32>;
+  vel : vec2<f32>;
+};
+
+[[block]] struct SimParams {
+  deltaT : f32;
+  rule1Distance : f32;
+  rule2Distance : f32;
+  rule3Distance : f32;
+  rule1Scale : f32;
+  rule2Scale : f32;
+  rule3Scale : f32;
+};
+
+[[block]] struct Particles {
+  particles : array<Particle, 5>;
+};
+
+[[binding(0), group(0)]] var<uniform> params : SimParams;
+[[binding(1), group(0)]] var<storage> particlesA : [[access(read_write)]] Particles;
+[[binding(2), group(0)]] var<storage> particlesB : [[access(read_write)]] Particles;
+
+// https://github.com/austinEng/Project6-Vulkan-Flocking/blob/master/data/shaders/computeparticles/particle.comp
+[[stage(compute)]]
+fn comp_main(
+  [[builtin(global_invocation_id)]] gl_GlobalInvocationID : vec3<u32>) {
+  var index : u32 = gl_GlobalInvocationID.x;
+  if (index >= 5u) {
+    return;
+  }
+
+  var vPos : vec2<f32> = particlesA.particles[index].pos;
+  var vVel : vec2<f32> = particlesA.particles[index].vel;
+
+  var cMass : vec2<f32> = vec2<f32>(0.0, 0.0);
+  var cVel : vec2<f32> = vec2<f32>(0.0, 0.0);
+  var colVel : vec2<f32> = vec2<f32>(0.0, 0.0);
+  var cMassCount : i32 = 0;
+  var cVelCount : i32 = 0;
+
+  var pos : vec2<f32>;
+  var vel : vec2<f32>;
+  for(var i : u32 = 0u; i < 5u; i = i + 1u) {
+    if (i == index) {
+      continue;
+    }
+
+    pos = particlesA.particles[i].pos.xy;
+    vel = particlesA.particles[i].vel.xy;
+
+    if (distance(pos, vPos) < params.rule1Distance) {
+      cMass = cMass + pos;
+      cMassCount = cMassCount + 1;
+    }
+    if (distance(pos, vPos) < params.rule2Distance) {
+      colVel = colVel - (pos - vPos);
+    }
+    if (distance(pos, vPos) < params.rule3Distance) {
+      cVel = cVel + vel;
+      cVelCount = cVelCount + 1;
+    }
+  }
+  if (cMassCount > 0) {
+    cMass =
+      (cMass / vec2<f32>(f32(cMassCount), f32(cMassCount))) - vPos;
+  }
+  if (cVelCount > 0) {
+    cVel = cVel / vec2<f32>(f32(cVelCount), f32(cVelCount));
+  }
+
+  vVel = vVel + (cMass * params.rule1Scale) + (colVel * params.rule2Scale) +
+      (cVel * params.rule3Scale);
+
+  // clamp velocity for a more pleasing simulation
+  vVel = normalize(vVel) * clamp(length(vVel), 0.0, 0.1);
+
+  // kinematic update
+  vPos = vPos + (vVel * params.deltaT);
+
+  // Wrap around boundary
+  if (vPos.x < -1.0) {
+    vPos.x = 1.0;
+  }
+  if (vPos.x > 1.0) {
+    vPos.x = -1.0;
+  }
+  if (vPos.y < -1.0) {
+    vPos.y = 1.0;
+  }
+  if (vPos.y > 1.0) {
+    vPos.y = -1.0;
+  }
+
+  // Write back
+  particlesB.particles[index].pos = vPos;
+  particlesB.particles[index].vel = vVel;
+}

test/samples/cube.wgsl

@@ -0,0 +1,46 @@
+// Copyright 2020 The Tint Authors.
+//
+// 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.
+
+// Vertex shader
+[[block]] struct Uniforms {
+  modelViewProjectionMatrix : mat4x4<f32>;
+};
+
+[[binding(0), group(0)]] var<uniform> uniforms : Uniforms;
+
+struct VertexInput {
+  [[location(0)]] cur_position : vec4<f32>;
+  [[location(1)]] color : vec4<f32>;
+};
+
+struct VertexOutput {
+  [[location(0)]] vtxFragColor : vec4<f32>;
+  [[builtin(position)]] Position : vec4<f32>;
+};
+
+[[stage(vertex)]]
+fn vtx_main(input : VertexInput) -> VertexOutput {
+  var output : VertexOutput;
+  output.Position = uniforms.modelViewProjectionMatrix * input.cur_position;
+  output.vtxFragColor = input.color;
+  return output;
+}
+
+// Fragment shader
+
+[[stage(fragment)]]
+fn frag_main([[location(0)]] fragColor : vec4<f32>)
+          -> [[location(0)]] vec4<f32> {
+  return fragColor;
+}

test/samples/function.wgsl

@@ -0,0 +1,22 @@
+// Copyright 2020 The Tint Authors.
+//
+// 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.
+
+fn main() -> f32 {
+    return ((2. * 3.) - 4.) / 5.;
+}
+
+[[stage(compute)]]
+[[workgroup_size(2)]]
+fn ep() {
+}

test/samples/simple.wgsl

@@ -0,0 +1,23 @@
+// Copyright 2020 The Tint Authors.
+//
+// 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.
+
+fn bar() {
+}
+
+[[stage(fragment)]]
+fn main() -> [[location(0)]] vec4<f32> {
+    var a : vec2<f32> = vec2<f32>();
+    bar();
+    return vec4<f32>(0.4, 0.4, 0.8, 1.0);
+}

test/samples/simple_vertex.spvasm

@@ -0,0 +1,52 @@
+; #version 450
+;
+; void main() {
+;   gl_Position = vec4(0.0);
+; }
+
+
+; SPIR-V
+; Version: 1.0
+; Generator: Google Shaderc over Glslang; 10
+; Bound: 20
+; Schema: 0
+                            OpCapability Shader
+                       %1 = OpExtInstImport "GLSL.std.450"
+                            OpMemoryModel Logical GLSL450
+                            OpEntryPoint Vertex %main "main" %_
+                            OpSource GLSL 450
+                            OpSourceExtension "GL_GOOGLE_cpp_style_line_directive"
+                            OpSourceExtension "GL_GOOGLE_include_directive"
+                            OpName %main "main"
+                            OpName %gl_PerVertex "gl_PerVertex"
+                            OpMemberName %gl_PerVertex 0 "gl_Position"
+                            OpMemberName %gl_PerVertex 1 "gl_PointSize"
+                            OpMemberName %gl_PerVertex 2 "gl_ClipDistance"
+                            OpMemberName %gl_PerVertex 3 "gl_CullDistance"
+                            OpName %_ ""
+                            OpMemberDecorate %gl_PerVertex 0 BuiltIn Position
+                            OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize
+                            OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance
+                            OpMemberDecorate %gl_PerVertex 3 BuiltIn CullDistance
+                            OpDecorate %gl_PerVertex Block
+                    %void = OpTypeVoid
+                       %3 = OpTypeFunction %void
+                   %float = OpTypeFloat 32
+                 %v4float = OpTypeVector %float 4
+                    %uint = OpTypeInt 32 0
+                  %uint_1 = OpConstant %uint 1
+       %_arr_float_uint_1 = OpTypeArray %float %uint_1
+            %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1 %_arr_float_uint_1
+%_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex
+                       %_ = OpVariable %_ptr_Output_gl_PerVertex Output
+                     %int = OpTypeInt 32 1
+                   %int_0 = OpConstant %int 0
+                 %float_0 = OpConstant %float 0
+                      %17 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0
+     %_ptr_Output_v4float = OpTypePointer Output %v4float
+                    %main = OpFunction %void None %3
+                       %5 = OpLabel
+                      %19 = OpAccessChain %_ptr_Output_v4float %_ %int_0
+                            OpStore %19 %17
+                            OpReturn
+                            OpFunctionEnd

test/samples/triangle.wgsl

@@ -0,0 +1,31 @@
+// Copyright 2020 The Tint Authors.
+//
+// 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.
+
+// Vertex shader
+let pos : array<vec2<f32>, 3> = array<vec2<f32>, 3>(
+    vec2<f32>(0.0, 0.5),
+    vec2<f32>(-0.5, -0.5),
+    vec2<f32>(0.5, -0.5));
+
+[[stage(vertex)]]
+fn vtx_main([[builtin(vertex_index)]] VertexIndex : i32)
+         -> [[builtin(position)]] vec4<f32> {
+  return vec4<f32>(pos[VertexIndex], 0.0, 1.0);
+}
+
+// Fragment shader
+[[stage(fragment)]]
+fn frag_main() -> [[location(0)]] vec4<f32> {
+  return vec4<f32>(1.0, 0.0, 0.0, 1.0);
+}