init

shaders/dynamic_primitive_clipping/glsl/primitive_clipping.frag

@@ -0,0 +1,38 @@
+#version 450
+/* Copyright (c) 2024, Mobica Limited
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * 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.
+ */
+
+
+layout (location = 0) in vec3 inNormal;
+
+layout (binding = 0) uniform Ubo
+{
+    mat4 projection;
+    mat4 view;
+    mat4 model;
+    vec4 colorTransformation;
+    ivec2 sceneTransformation;
+} ubo;
+
+layout (location = 0) out vec4 outColor;
+
+void main()
+{
+    outColor = vec4( 0.5 * inNormal + vec3(0.5), 1);
+
+    outColor.xyz = ubo.colorTransformation.x * outColor.xyz + vec3(ubo.colorTransformation.y);
+}

shaders/dynamic_primitive_clipping/glsl/primitive_clipping.vert

@@ -0,0 +1,109 @@
+#version 450
+/* Copyright (c) 2024, Mobica Limited
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * 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.
+ */
+
+layout (location = 0) in vec3 inPos;
+layout (location = 1) in vec3 inNormal;
+layout (location = 2) in vec2 inUV;
+
+// In a fixed pipeline approach which you can still find in OpenGL implementations you could define 
+// up to maximum 6 clipping half-spaces and a distance to each clipping half-space was stored in gl_ClipDistance.
+// That's why gl_ClipDistance[] is an array which maximum size is limited by maxClipDistances.
+//
+// In our example we show you how to define such half-spaces using plane equation: Ax+By+Cz+D=0
+// You could transmit information about values of A,B,C and D using UBO for example, but for simplicity we will use const declaration:
+
+const vec4 planeValues = vec4(0.0, 1.0, 0.0, 0.0);
+
+// Additionally we will show you that you can use more than half-spaces only. 
+// We will use some more advanced math functions to calculate gl_ClipDistance.
+
+out gl_PerVertex 
+{
+    vec4  gl_Position;
+    float gl_ClipDistance[1];
+};
+
+layout (binding = 0) uniform Ubo
+{
+    mat4 projection;
+    mat4 view;
+    mat4 model;
+    vec4 colorTransformation;
+    ivec2 sceneTransformation;
+    float usePrimitiveClipping;
+} ubo;
+
+layout (location = 0) out vec3 outNormal;
+
+// Cases 0 and 1 present how to use world space coordinates with more advanced functions
+// Case 2 shows how to use half-space in world space coordinates
+// Case 3 shows how to use half-space in clip space coordinates
+// Cases 4-6 present how to use clip space coordinates with more advanced functions
+// Cases 0,1,4,5 use sin() function to create strips in which values of gl_ClipDistance below 0 cause triangle primitives
+// to be clipped according to Vulkan specification chapter 27.4
+// Cases 6-8 use different types of distance functions from center of the screen ( Euclidean, Manhattan, Chebyshev )
+
+void main()
+{
+    vec4 worldPosition =  ubo.model * vec4(inPos, 1.0);
+    gl_Position        = ubo.projection * ubo.view * worldPosition;
+
+    float clipResult = 1.0, tmp;
+    float distance = 0.4;
+
+    // Primitive clipping does not have any vkCmd* command that turns it off.
+    // If we want to turn it off - we have to transfer this information to shader through UBO variable and
+    // then use code similar to this:
+    if(ubo.usePrimitiveClipping > 0.0)
+    {
+        switch(ubo.sceneTransformation.x)
+        {
+        case 0:
+            clipResult = sin(worldPosition.x * 0.1 * 2.0 * 3.1415);
+            break;
+        case 1:
+            clipResult = sin(worldPosition.y * 0.1 * 2.0 * 3.1415);
+            break;
+        case 2:
+            clipResult = dot(worldPosition, planeValues );
+            break;
+        case 3:
+            clipResult = dot(gl_Position, planeValues);
+            break;
+        case 4:
+            clipResult = sin(gl_Position.x / gl_Position.w * 3.0 * 2.0 * 3.1415);
+            break;
+        case 5:
+            clipResult = sin(gl_Position.y / gl_Position.w * 3.0 * 2.0 * 3.1415);
+            break;
+        case 6:
+            clipResult = (gl_Position.x*gl_Position.x + gl_Position.y*gl_Position.y) / (gl_Position.w*gl_Position.w) - distance*distance;
+            break;
+        case 7:
+            clipResult = (abs(gl_Position.x) + abs(gl_Position.y)) / gl_Position.w - distance;
+            break;
+        case 8:
+            clipResult = max(abs(gl_Position.x), abs(gl_Position.y)) / gl_Position.w - distance;
+            break;
+        }
+
+        gl_ClipDistance[0] = clipResult * float(ubo.sceneTransformation.y);
+    }
+
+    outNormal = normalize(mat3(ubo.view * ubo.model) * inNormal);
+}