Handle even-odd fill rule for D3D11

resources/shaders/gl4/d3d11/bin.cs.glsl

@@ -39,46 +39,46 @@ uniform int uMicrolineCount;
 
 uniform int uMaxFillCount;
 
-layout(std430, binding = 0)buffer bMicrolines {
-    restrict readonly uvec4 iMicrolines[];
+restrict readonly layout(std430, binding = 0)buffer bMicrolines {
+    uvec4 iMicrolines[];
 };
 
-layout(std430, binding = 1)buffer bMetadata {
+restrict readonly layout(std430, binding = 1)buffer bMetadata {
 
 
 
 
 
 
-    restrict readonly ivec4 iMetadata[];
+    ivec4 iMetadata[];
 };
 
 
 
 
 
 
-layout(std430, binding = 2)buffer bIndirectDrawParams {
-    restrict uint iIndirectDrawParams[];
+restrict layout(std430, binding = 2)buffer bIndirectDrawParams {
+    uint iIndirectDrawParams[];
 };
 
-layout(std430, binding = 3)buffer bFills {
-    restrict writeonly uint iFills[];
+restrict writeonly layout(std430, binding = 3)buffer bFills {
+    uint iFills[];
 };
 
-layout(std430, binding = 4)buffer bTiles {
+restrict layout(std430, binding = 4)buffer bTiles {
 
 
 
 
-    restrict uint iTiles[];
+    uint iTiles[];
 };
 
-layout(std430, binding = 5)buffer bBackdrops {
+restrict layout(std430, binding = 5)buffer bBackdrops {
 
 
 
-    restrict uint iBackdrops[];
+    uint iBackdrops[];
 };
 
 uint computeTileIndexNoCheck(ivec2 tileCoords, ivec4 pathTileRect, uint pathTileOffset){

resources/shaders/gl4/d3d11/bound.cs.glsl

@@ -32,20 +32,20 @@ layout(local_size_x = 64)in;
 uniform int uPathCount;
 uniform int uTileCount;
 
-layout(std430, binding = 0)buffer bTilePathInfo {
+restrict readonly layout(std430, binding = 0)buffer bTilePathInfo {
 
 
 
 
-    restrict readonly uvec4 iTilePathInfo[];
+    uvec4 iTilePathInfo[];
 };
 
-layout(std430, binding = 1)buffer bTiles {
+restrict layout(std430, binding = 1)buffer bTiles {
 
 
 
 
-    restrict uint iTiles[];
+    uint iTiles[];
 };
 
 void main(){

resources/shaders/gl4/d3d11/dice.cs.glsl

@@ -42,37 +42,37 @@ uniform int uPathCount;
 uniform int uLastBatchSegmentIndex;
 uniform int uMaxMicrolineCount;
 
-layout(std430, binding = 0)buffer bComputeIndirectParams {
+restrict layout(std430, binding = 0)buffer bComputeIndirectParams {
 
 
 
 
-    restrict uint iComputeIndirectParams[];
+    uint iComputeIndirectParams[];
 };
 
 
-layout(std430, binding = 1)buffer bDiceMetadata {
+restrict readonly layout(std430, binding = 1)buffer bDiceMetadata {
 
 
 
 
-    restrict readonly uvec4 iDiceMetadata[];
+    uvec4 iDiceMetadata[];
 };
 
-layout(std430, binding = 2)buffer bPoints {
-    restrict readonly vec2 iPoints[];
+restrict readonly layout(std430, binding = 2)buffer bPoints {
+    vec2 iPoints[];
 };
 
-layout(std430, binding = 3)buffer bInputIndices {
-    restrict readonly uvec2 iInputIndices[];
+restrict readonly layout(std430, binding = 3)buffer bInputIndices {
+    uvec2 iInputIndices[];
 };
 
-layout(std430, binding = 4)buffer bMicrolines {
+restrict layout(std430, binding = 4)buffer bMicrolines {
 
 
 
 
-    restrict uvec4 iMicrolines[];
+    uvec4 iMicrolines[];
 };
 
 void emitMicroline(vec4 microlineSegment, uint pathIndex, uint outputMicrolineIndex){

resources/shaders/gl4/d3d11/fill.cs.glsl

@@ -57,27 +57,33 @@ layout(local_size_x = 16, local_size_y = 4)in;
 
 
 
+
+
+
+
+
+
 layout(rgba8)uniform image2D uDest;
 uniform sampler2D uAreaLUT;
 uniform ivec2 uAlphaTileRange;
 
-layout(std430, binding = 0)buffer bFills {
-    restrict readonly uint iFills[];
+restrict readonly layout(std430, binding = 0)buffer bFills {
+    uint iFills[];
 };
 
-layout(std430, binding = 1)buffer bTiles {
+restrict layout(std430, binding = 1)buffer bTiles {
 
 
 
 
 
-    restrict uint iTiles[];
+    uint iTiles[];
 };
 
-layout(std430, binding = 2)buffer bAlphaTiles {
+restrict readonly layout(std430, binding = 2)buffer bAlphaTiles {
 
 
-    restrict readonly uint iAlphaTiles[];
+    uint iAlphaTiles[];
 };
 
 
@@ -130,10 +136,17 @@ void main(){
     int fillIndex = int(iTiles[tileIndex * 4 + 1]);
     int backdrop = int(iTiles[tileIndex * 4 + 3])>> 24;
 
-
     vec4 coverages = vec4(backdrop);
     coverages += accumulateCoverageForFillList(fillIndex, tileSubCoord);
-    coverages = clamp(abs(coverages), 0.0, 1.0);
+
+    uint tileControlWord = iTiles[tileIndex * 4 + 3];
+    int tileCtrl = int((tileControlWord >> 16)& 0xffu);
+    int maskCtrl =(tileCtrl >> 0)& 0x3;
+    if((maskCtrl & 0x1)!= 0){
+        coverages = clamp(abs(coverages), 0.0, 1.0);
+    } else {
+        coverages = clamp(1.0 - abs(1.0 - mod(coverages, 2.0)), 0.0, 1.0);
+    }
 
 
     int clipTileIndex = int(iAlphaTiles[batchAlphaTileIndex * 2 + 1]);

resources/shaders/gl4/d3d11/propagate.cs.glsl

@@ -32,70 +32,76 @@ layout(local_size_x = 64)in;
 
 
 
+
+
+
+
+
+
 uniform ivec2 uFramebufferTileSize;
 uniform int uColumnCount;
 uniform int uFirstAlphaTileIndex;
 
-layout(std430, binding = 0)buffer bDrawMetadata {
+restrict readonly layout(std430, binding = 0)buffer bDrawMetadata {
 
 
 
 
 
 
-    restrict readonly uvec4 iDrawMetadata[];
+    uvec4 iDrawMetadata[];
 };
 
-layout(std430, binding = 1)buffer bClipMetadata {
+restrict readonly layout(std430, binding = 1)buffer bClipMetadata {
 
 
 
 
 
-    restrict readonly uvec4 iClipMetadata[];
+    uvec4 iClipMetadata[];
 };
 
-layout(std430, binding = 2)buffer bBackdrops {
+restrict readonly layout(std430, binding = 2)buffer bBackdrops {
 
 
 
-    restrict readonly int iBackdrops[];
+    int iBackdrops[];
 };
 
-layout(std430, binding = 3)buffer bDrawTiles {
+restrict layout(std430, binding = 3)buffer bDrawTiles {
 
 
 
 
-    restrict uint iDrawTiles[];
+    uint iDrawTiles[];
 };
 
-layout(std430, binding = 4)buffer bClipTiles {
+restrict layout(std430, binding = 4)buffer bClipTiles {
 
 
 
 
-    restrict uint iClipTiles[];
+    uint iClipTiles[];
 };
 
-layout(std430, binding = 5)buffer bZBuffer {
+restrict layout(std430, binding = 5)buffer bZBuffer {
 
 
 
 
 
 
-    restrict int iZBuffer[];
+    int iZBuffer[];
 };
 
-layout(std430, binding = 6)buffer bFirstTileMap {
-    restrict int iFirstTileMap[];
+restrict layout(std430, binding = 6)buffer bFirstTileMap {
+    int iFirstTileMap[];
 };
 
-layout(std430, binding = 7)buffer bAlphaTiles {
+restrict layout(std430, binding = 7)buffer bAlphaTiles {
 
 
-    restrict uint iAlphaTiles[];
+    uint iAlphaTiles[];
 };
 
 uint calculateTileIndex(uint bufferOffset, uvec4 tileRect, uvec2 tileCoord){
@@ -204,6 +210,16 @@ void main(){
             drawTileWord |(uint(drawTileBackdrop)<< 24);
 
 
+        if(drawTileBackdrop != 0){
+            int tileCtrl = int((drawTileWord >> 16)& 0xffu);
+            int maskCtrl =(tileCtrl >> 0)& 0x3;
+
+            if((maskCtrl & 0x2)!= 0 && mod(abs(drawTileBackdrop), 2)== 0){
+                zWrite = false;
+            }
+        }
+
+
         ivec2 tileCoord = ivec2(tileX, tileY)+ ivec2(drawTileRect . xy);
         int tileMapIndex = tileCoord . y * uFramebufferTileSize . x + tileCoord . x;
         if(zWrite && drawTileBackdrop != 0 && drawAlphaTileIndex < 0)

resources/shaders/gl4/d3d11/sort.cs.glsl

@@ -29,20 +29,20 @@ precision highp float;
 
 uniform int uTileCount;
 
-layout(std430, binding = 0)buffer bTiles {
+restrict layout(std430, binding = 0)buffer bTiles {
 
 
 
 
-    restrict uint iTiles[];
+    uint iTiles[];
 };
 
-layout(std430, binding = 1)buffer bFirstTileMap {
-    restrict int iFirstTileMap[];
+restrict layout(std430, binding = 1)buffer bFirstTileMap {
+    int iFirstTileMap[];
 };
 
-layout(std430, binding = 2)buffer bZBuffer {
-    restrict readonly int iZBuffer[];
+restrict readonly layout(std430, binding = 2)buffer bZBuffer {
+    int iZBuffer[];
 };
 
 layout(local_size_x = 64)in;

resources/shaders/gl4/d3d11/tile.cs.glsl

@@ -695,6 +695,12 @@ void computeTileVaryings(vec2 position,
 
 
 
+
+
+
+
+
+
 uniform int uLoadAction;
 uniform vec4 uClearColor;
 uniform vec2 uTileSize;
@@ -711,17 +717,17 @@ uniform vec2 uFramebufferSize;
 uniform ivec2 uFramebufferTileSize;
 layout(rgba8)uniform image2D uDestImage;
 
-layout(std430, binding = 0)buffer bTiles {
+restrict readonly layout(std430, binding = 0)buffer bTiles {
 
 
 
 
 
-    restrict readonly uint iTiles[];
+    uint iTiles[];
 };
 
-layout(std430, binding = 1)buffer bFirstTileMap {
-    restrict readonly int iFirstTileMap[];
+restrict readonly layout(std430, binding = 1)buffer bFirstTileMap {
+    int iFirstTileMap[];
 };
 
 uint calculateTileIndex(uint bufferOffset, uvec4 tileRect, uvec2 tileCoord){
@@ -772,6 +778,16 @@ void main(){
             } else {
 
                 backdrop = int(tileControlWord)>> 24;
+
+
+                if(backdrop != 0){
+                    int maskCtrl =(tileCtrl >> 0)& 0x3;
+
+                    if((maskCtrl & 0x2)!= 0 && mod(abs(backdrop), 2)== 0){
+                        break;
+                    }
+                }
+
                 maskTileCoord = uvec2(0u);
                 tileCtrl &= ~(0x3 << 0);
             }

resources/shaders/metal/d3d11/bin.cs.metal

@@ -150,8 +150,8 @@ kernel void main0(constant int& uMaxFillCount [[buffer(2)]], constant int& uMicr
     uint pathIndex = param_1;
     float4 lineSegment = _354;
     int4 pathTileRect = _360.iMetadata[(pathIndex * 3u) + 0u];
-    uint pathTileOffset = uint(_360.iMetadata[(pathIndex * 3u) + 1u].x);
-    uint pathBackdropOffset = uint(_360.iMetadata[(pathIndex * 3u) + 2u].x);
+    uint pathTileOffset = uint(((device int*)&_360.iMetadata[(pathIndex * 3u) + 1u])[0u]);
+    uint pathBackdropOffset = uint(((device int*)&_360.iMetadata[(pathIndex * 3u) + 2u])[0u]);
     int2 tileSize = int2(16);
     int4 tileLineSegment = int4(floor(lineSegment / float4(tileSize.xyxy)));
     int2 fromTileCoords = tileLineSegment.xy;