Add Chromium-only Blender WebEngine parity work

blender-5.2.0/extern/opensubdiv-source/examples/glPaintTest/CMakeLists.txt

@@ -0,0 +1,48 @@
+#
+#   Copyright 2013 Pixar
+#
+#   Licensed under the terms set forth in the LICENSE.txt file available at
+#   https://opensubdiv.org/license.
+#
+
+# *** glPaintTest ***
+
+set(SHADER_FILES
+     shader.glsl
+     paintShader.glsl
+)
+
+include_directories(
+    "${OPENSUBDIV_INCLUDE_DIR}"
+    "${OPENGL_LOADER_INCLUDE_DIRS}"
+    "${GLFW_INCLUDE_DIR}"
+)
+
+list(APPEND PLATFORM_LIBRARIES
+    "${OSD_LINK_TARGET}"
+    "${OPENGL_LOADER_LIBRARIES}"
+    "${GLFW_LIBRARIES}"
+)
+
+if (OPENCL_FOUND)
+    include_directories("${OPENCL_INCLUDE_DIRS}")
+    list(APPEND PLATFORM_LIBRARIES OpenGL::GL)
+endif()
+
+osd_stringify("${SHADER_FILES}" INC_FILES)
+
+include_directories("${CMAKE_CURRENT_BINARY_DIR}")
+
+osd_add_glfw_executable(glPaintTest "examples"
+    glPaintTest.cpp
+    "${SHADER_FILES}"
+    "${INC_FILES}"
+    $<TARGET_OBJECTS:regression_common_obj>
+    $<TARGET_OBJECTS:examples_common_gl_obj>
+)
+
+target_link_libraries(glPaintTest
+    ${PLATFORM_LIBRARIES}
+)
+
+install(TARGETS glPaintTest DESTINATION "${CMAKE_BINDIR_BASE}")

blender-5.2.0/extern/opensubdiv-source/examples/glPaintTest/init_shapes.h

@@ -0,0 +1,66 @@
+//
+//   Copyright 2013 Pixar
+//
+//   Licensed under the terms set forth in the LICENSE.txt file available at
+//   https://opensubdiv.org/license.
+//
+
+#include "../../regression/common/shape_utils.h"
+#include "../../regression/shapes/all.h"
+
+
+static std::vector<ShapeDesc> g_defaultShapes;
+
+//------------------------------------------------------------------------------
+static void initShapes() {
+    g_defaultShapes.push_back( ShapeDesc("catmark_cube",             catmark_cube,             kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_cube_corner0",     catmark_cube_corner0,     kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_cube_corner1",     catmark_cube_corner1,     kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_cube_corner2",     catmark_cube_corner2,     kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_cube_corner3",     catmark_cube_corner3,     kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_cube_corner4",     catmark_cube_corner4,     kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_cube_creases0",    catmark_cube_creases0,    kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_cube_creases1",    catmark_cube_creases1,    kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_dart_edgecorner",  catmark_dart_edgecorner,  kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_dart_edgeonly",    catmark_dart_edgeonly,    kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_edgecorner",       catmark_edgecorner,       kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_edgeonly",         catmark_edgeonly,         kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_edgenone",         catmark_edgenone,         kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_quadstrips",       catmark_quadstrips,       kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_fan",              catmark_fan,              kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_gregory_test1",    catmark_gregory_test1,    kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_gregory_test2",    catmark_gregory_test2,    kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_gregory_test3",    catmark_gregory_test3,    kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_gregory_test4",    catmark_gregory_test4,    kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_hole_test1",       catmark_hole_test1,       kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_hole_test2",       catmark_hole_test2,       kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_pyramid_creases0", catmark_pyramid_creases0, kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_pyramid_creases1", catmark_pyramid_creases1, kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_pyramid",          catmark_pyramid,          kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_tent_creases0",    catmark_tent_creases0,    kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_tent_creases1",    catmark_tent_creases1 ,   kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_tent",             catmark_tent,             kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_torus",            catmark_torus,            kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_torus_creases0",   catmark_torus_creases0,   kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_bishop",           catmark_bishop,           kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_car",              catmark_car,              kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_helmet",           catmark_helmet,           kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_pawn",             catmark_pawn,             kCatmark ) );
+    g_defaultShapes.push_back( ShapeDesc("catmark_rook",             catmark_rook,             kCatmark ) );
+
+    g_defaultShapes.push_back( ShapeDesc("loop_cube",                loop_cube,                kLoop ) );
+    g_defaultShapes.push_back( ShapeDesc("loop_cubes_semisharp",     loop_cubes_semisharp,     kLoop ) );
+    g_defaultShapes.push_back( ShapeDesc("loop_cubes_infsharp",      loop_cubes_infsharp,      kLoop ) );
+    g_defaultShapes.push_back( ShapeDesc("loop_cube_asymmetric",     loop_cube_asymmetric,     kLoop ) );
+    g_defaultShapes.push_back( ShapeDesc("loop_triangle_edgecorner", loop_triangle_edgecorner, kLoop ) );
+    g_defaultShapes.push_back( ShapeDesc("loop_triangle_edgeonly",   loop_triangle_edgeonly,   kLoop ) );
+    g_defaultShapes.push_back( ShapeDesc("loop_triangle_edgenone",   loop_triangle_edgenone,   kLoop ) );
+    g_defaultShapes.push_back( ShapeDesc("loop_xord_interior",       loop_xord_interior,       kLoop ) );
+    g_defaultShapes.push_back( ShapeDesc("loop_xord_boundary",       loop_xord_boundary,       kLoop ) );
+    g_defaultShapes.push_back( ShapeDesc("loop_icosahedron",         loop_icosahedron,         kLoop ) );
+    g_defaultShapes.push_back( ShapeDesc("loop_icos_semisharp",      loop_icos_semisharp,      kLoop ) );
+    g_defaultShapes.push_back( ShapeDesc("loop_icos_infsharp",       loop_icos_infsharp,       kLoop ) );
+
+    //  REMEMBER:  no Bilinear shapes here -- application requires a tessellation shader
+}
+//------------------------------------------------------------------------------

blender-5.2.0/extern/opensubdiv-source/examples/glPaintTest/paintShader.glsl

@@ -0,0 +1,200 @@
+//
+//   Copyright 2013 Pixar
+//
+//   Licensed under the terms set forth in the LICENSE.txt file available at
+//   https://opensubdiv.org/license.
+//
+
+vec4 PTexLookup(vec4 patchCoord,
+                sampler2DArray data,
+                samplerBuffer packings,
+                isamplerBuffer pages)
+{
+    vec2 uv = patchCoord.xy;
+    int faceID = int(patchCoord.w);
+    int page = texelFetch(pages, faceID).x;
+    vec4 packing = texelFetch(packings, faceID);
+    vec3 coords = vec3( packing.x + uv.x * packing.z,
+                        packing.y + uv.y * packing.w,
+                        page);
+
+    return texture(data, coords);
+}
+
+uniform sampler2DArray textureImage_Data;
+uniform samplerBuffer textureImage_Packing;
+uniform isamplerBuffer textureImage_Pages;
+
+vec4 displacement(vec4 position, vec3 normal, vec4 patchCoord)
+{
+    float disp = PTexLookup(patchCoord,
+                            textureImage_Data,
+                            textureImage_Packing,
+                            textureImage_Pages).x;
+    return position + 0.01*vec4(disp * normal, 0);
+}
+
+//--------------------------------------------------------------
+// Uniform Blocks
+//--------------------------------------------------------------
+
+layout(std140) uniform Transform {
+    mat4 ModelViewMatrix;
+    mat4 ProjectionMatrix;
+    mat4 ModelViewProjectionMatrix;
+    mat4 ModelViewInverseMatrix;
+    mat4 ProjectionWithoutPickMatrix;
+};
+
+layout(std140) uniform Tessellation {
+    float TessLevel;
+};
+
+uniform int GregoryQuadOffsetBase;
+uniform int PrimitiveIdBase;
+
+//--------------------------------------------------------------
+// Osd external functions
+//--------------------------------------------------------------
+
+mat4 OsdModelViewMatrix()
+{
+    return ModelViewMatrix;
+}
+mat4 OsdProjectionMatrix()
+{
+    return ProjectionMatrix;
+}
+mat4 OsdModelViewProjectionMatrix()
+{
+    return ModelViewProjectionMatrix;
+}
+float OsdTessLevel()
+{
+    return TessLevel;
+}
+int OsdGregoryQuadOffsetBase()
+{
+    return GregoryQuadOffsetBase;
+}
+int OsdPrimitiveIdBase()
+{
+    return PrimitiveIdBase;
+}
+
+//--------------------------------------------------------------
+// Vertex Shader
+//--------------------------------------------------------------
+#ifdef VERTEX_SHADER
+
+layout (location=0) in vec4 position;
+
+out block {
+    OutputVertex v;
+} outpt;
+
+void main()
+{
+    outpt.v.position = ModelViewMatrix * position;
+}
+
+#endif
+
+//--------------------------------------------------------------
+// Geometry Shader
+//--------------------------------------------------------------
+#ifdef GEOMETRY_SHADER
+
+layout(triangles) in;
+
+layout(triangle_strip, max_vertices = 3) out;
+
+in block {
+   OutputVertex v;
+} inpt[3];
+
+out block {
+    OutputVertex v;
+    vec4 depthPosition;
+} outpt;
+
+void emit(int index, vec4 position)
+{
+    vec2 uv = vec2(inpt[index].v.patchCoord.xy);
+    outpt.v.position    = ProjectionMatrix * position;
+    outpt.depthPosition = ProjectionWithoutPickMatrix * position;
+    outpt.v.patchCoord  = inpt[index].v.patchCoord;
+    gl_Position          = vec4(uv*2-vec2(1.0), 0, 1);
+    EmitVertex();
+}
+
+void main()
+{
+    gl_PrimitiveID = gl_PrimitiveIDIn;
+
+    vec4 patchCoord[3];
+    vec4 position[3];
+
+    // patch coords are computed in tessellation shader
+    patchCoord[0] = inpt[0].v.patchCoord;
+    patchCoord[1] = inpt[1].v.patchCoord;
+    patchCoord[2] = inpt[2].v.patchCoord;
+
+#ifdef USE_PTEX_DISPLACEMENT
+    position[0] = displacement(inpt[0].v.position, inpt[0].v.normal, patchCoord[0]);
+    position[1] = displacement(inpt[1].v.position, inpt[1].v.normal, patchCoord[1]);
+    position[2] = displacement(inpt[2].v.position, inpt[2].v.normal, patchCoord[2]);
+#else
+    position[0] = inpt[0].v.position;
+    position[1] = inpt[1].v.position;
+    position[2] = inpt[2].v.position;
+#endif
+
+    emit(0, position[0]);
+    emit(1, position[1]);
+    emit(2, position[2]);
+    EndPrimitive();
+}
+
+#endif
+
+//--------------------------------------------------------------
+// Fragment Shader
+//--------------------------------------------------------------
+#ifdef FRAGMENT_SHADER
+
+in block {
+    OutputVertex v;
+    vec4 depthPosition;
+} inpt;
+
+layout(size1x32) uniform image2DArray outTextureImage;
+uniform sampler2D paintTexture;
+uniform sampler2D depthTexture;
+uniform int imageSize = 256;
+
+void
+main()
+{
+    vec4 p = inpt.v.position;
+    p.xyz /= p.w;
+
+    vec4 wp = inpt.depthPosition;
+    wp.z -= 0.001;
+    wp.xyz /= wp.w;
+
+    vec4 c = texture(paintTexture, p.xy*0.5+0.5);
+    float depth = texture(depthTexture, wp.xy*0.5+0.5).x;
+    if (wp.z*0.5+0.5 >= depth) return;
+    
+    ivec3 pos = ivec3(inpt.v.patchCoord.x * imageSize,
+                      inpt.v.patchCoord.y * imageSize,
+                      int(inpt.v.patchCoord.w));
+
+    vec4 d = imageLoad(outTextureImage, pos);
+    c = c + d;
+    imageStore(outTextureImage, pos, c);
+    discard;
+}
+
+#endif

blender-5.2.0/extern/opensubdiv-source/examples/glPaintTest/shader.glsl

@@ -0,0 +1,328 @@
+//
+//   Copyright 2013 Pixar
+//
+//   Licensed under the terms set forth in the LICENSE.txt file available at
+//   https://opensubdiv.org/license.
+//
+
+vec4 PTexLookup(vec4 patchCoord,
+                sampler2DArray data,
+                samplerBuffer packings,
+                isamplerBuffer pages)
+{
+    vec2 uv = patchCoord.xy;
+    int faceID = int(patchCoord.w);
+    int page = texelFetch(pages, faceID).x;
+    vec4 packing = texelFetch(packings, faceID);
+    vec3 coords = vec3( packing.x + uv.x * packing.z,
+                        packing.y + uv.y * packing.w,
+                        page);
+
+    return texture(data, coords);
+}
+
+uniform sampler2DArray textureImage_Data;
+uniform samplerBuffer textureImage_Packing;
+uniform isamplerBuffer textureImage_Pages;
+
+vec4 displacement(vec4 position, vec3 normal, vec4 patchCoord)
+{
+    float disp = PTexLookup(patchCoord,
+                            textureImage_Data,
+                            textureImage_Packing,
+                            textureImage_Pages).x;
+    return position + 0.01*vec4(disp * normal, 0);
+}
+
+//--------------------------------------------------------------
+// Uniform Blocks
+//--------------------------------------------------------------
+
+layout(std140) uniform Transform {
+    mat4 ModelViewMatrix;
+    mat4 ProjectionMatrix;
+    mat4 ModelViewProjectionMatrix;
+    mat4 ModelViewInverseMatrix;
+    mat4 ProjectionWithoutPickMatrix;
+};
+
+layout(std140) uniform Tessellation {
+    float TessLevel;
+};
+
+uniform int GregoryQuadOffsetBase;
+uniform int PrimitiveIdBase;
+
+//--------------------------------------------------------------
+// Osd external functions
+//--------------------------------------------------------------
+
+mat4 OsdModelViewMatrix()
+{
+    return ModelViewMatrix;
+}
+mat4 OsdProjectionMatrix()
+{
+    return ProjectionMatrix;
+}
+mat4 OsdModelViewProjectionMatrix()
+{
+    return ModelViewProjectionMatrix;
+}
+float OsdTessLevel()
+{
+    return TessLevel;
+}
+int OsdGregoryQuadOffsetBase()
+{
+    return GregoryQuadOffsetBase;
+}
+int OsdPrimitiveIdBase()
+{
+    return PrimitiveIdBase;
+}
+int OsdBaseVertex()
+{
+    return 0;
+}
+
+//--------------------------------------------------------------
+// Geometry Shader
+//--------------------------------------------------------------
+#ifdef GEOMETRY_SHADER
+
+    layout(triangles) in;
+
+    layout(triangle_strip, max_vertices = 3) out;
+
+    #define EDGE_VERTS 3
+
+    in block {
+        OutputVertex v;
+    } inpt[3];
+
+out block {
+    OutputVertex v;
+    noperspective out vec4 edgeDistance;
+} outpt;
+
+void emit(int index, vec4 position, vec3 normal, vec4 patchCoord)
+{
+    outpt.v.position = position;
+    outpt.v.patchCoord = patchCoord;
+    outpt.v.normal = normal;
+
+    gl_Position = ProjectionMatrix * outpt.v.position;
+    EmitVertex();
+}
+
+const float VIEWPORT_SCALE = 1024.0; // XXXdyu
+
+float edgeDistance(vec4 p, vec4 p0, vec4 p1)
+{
+    return VIEWPORT_SCALE *
+        abs((p.x - p0.x) * (p1.y - p0.y) -
+            (p.y - p0.y) * (p1.x - p0.x)) / length(p1.xy - p0.xy);
+}
+
+void emit(int index, vec4 position, vec3 normal, vec4 patchCoord, vec4 edgeVerts[EDGE_VERTS])
+{
+    outpt.edgeDistance[0] =
+        edgeDistance(edgeVerts[index], edgeVerts[0], edgeVerts[1]);
+    outpt.edgeDistance[1] =
+        edgeDistance(edgeVerts[index], edgeVerts[1], edgeVerts[2]);
+    outpt.edgeDistance[2] =
+        edgeDistance(edgeVerts[index], edgeVerts[2], edgeVerts[0]);
+    emit(index, position, normal, patchCoord);
+}
+
+// --------------------------------------
+
+void main()
+{
+    gl_PrimitiveID = gl_PrimitiveIDIn;
+
+    vec4 position[3];
+    vec4 patchCoord[3];
+    vec3 normal[3];
+
+    // patch coords are computed in tessellation shader
+    patchCoord[0] = inpt[0].v.patchCoord;
+    patchCoord[1] = inpt[1].v.patchCoord;
+    patchCoord[2] = inpt[2].v.patchCoord;
+
+#ifdef USE_PTEX_DISPLACEMENT
+    position[0] = displacement(inpt[0].v.position, inpt[0].v.normal, patchCoord[0]);
+    position[1] = displacement(inpt[1].v.position, inpt[1].v.normal, patchCoord[1]);
+    position[2] = displacement(inpt[2].v.position, inpt[2].v.normal, patchCoord[2]);
+#else
+    position[0] = inpt[0].v.position;
+    position[1] = inpt[1].v.position;
+    position[2] = inpt[2].v.position;
+#endif
+
+    normal[0] = inpt[0].v.normal;
+    normal[1] = inpt[1].v.normal;
+    normal[2] = inpt[2].v.normal;
+
+#if defined(GEOMETRY_OUT_WIRE) || defined(GEOMETRY_OUT_LINE)
+    vec4 edgeVerts[EDGE_VERTS];
+    edgeVerts[0] = ProjectionMatrix * inpt[0].v.position;
+    edgeVerts[1] = ProjectionMatrix * inpt[1].v.position;
+    edgeVerts[2] = ProjectionMatrix * inpt[2].v.position;
+
+    edgeVerts[0].xy /= edgeVerts[0].w;
+    edgeVerts[1].xy /= edgeVerts[1].w;
+    edgeVerts[2].xy /= edgeVerts[2].w;
+
+    emit(0, position[0], normal[0], patchCoord[0], edgeVerts);
+    emit(1, position[1], normal[1], patchCoord[1], edgeVerts);
+    emit(2, position[2], normal[2], patchCoord[2], edgeVerts);
+#else
+    emit(0, position[0], normal[0], patchCoord[0]);
+    emit(1, position[1], normal[1], patchCoord[1]);
+    emit(2, position[2], normal[2], patchCoord[2]);
+#endif
+
+    EndPrimitive();
+}
+
+#endif
+
+//--------------------------------------------------------------
+// Fragment Shader
+//--------------------------------------------------------------
+#ifdef FRAGMENT_SHADER
+
+in block {
+    OutputVertex v;
+    noperspective in vec4 edgeDistance;
+} inpt;
+
+out vec4 outColor;
+
+#define NUM_LIGHTS 2
+
+struct LightSource {
+    vec4 position;
+    vec4 ambient;
+    vec4 diffuse;
+    vec4 specular;
+};
+
+layout(std140) uniform Lighting {
+    LightSource lightSource[NUM_LIGHTS];
+};
+
+uniform vec4 diffuseColor = vec4(1);
+uniform vec4 ambientColor = vec4(1);
+
+vec4
+lighting(vec4 diffuse, vec3 Peye, vec3 Neye)
+{
+    vec4 color = vec4(0);
+
+    for (int i = 0; i < NUM_LIGHTS; ++i) {
+
+        vec4 Plight = lightSource[i].position;
+
+        vec3 l = (Plight.w == 0.0)
+                    ? normalize(Plight.xyz) : normalize(Plight.xyz - Peye);
+
+        vec3 n = normalize(Neye);
+        vec3 h = normalize(l + vec3(0,0,1));    // directional viewer
+
+        float d = max(0.0, dot(n, l));
+        float s = pow(max(0.0, dot(n, h)), 500.0f);
+
+        color += lightSource[i].ambient * ambientColor
+            + d * lightSource[i].diffuse * diffuse
+            + s * lightSource[i].specular;
+    }
+
+    color.a = 1;
+    return color;
+}
+
+#ifdef USE_PTEX_DISPLACEMENT
+vec3
+perturbNormalFromDisplacement(vec3 position, vec3 normal, vec4 patchCoord)
+{
+    // by Morten S. Mikkelsen
+    // http://jbit.net/~sparky/sfgrad_bump/mm_sfgrad_bump.pdf
+    // slightly modified for ptex guttering
+
+    vec3 vSigmaS = dFdx(position);
+    vec3 vSigmaT = dFdy(position);
+    vec3 vN = normal;
+    vec3 vR1 = cross(vSigmaT, vN);
+    vec3 vR2 = cross(vN, vSigmaS);
+    float fDet = dot(vSigmaS, vR1);
+
+    vec2 texDx = dFdx(patchCoord.xy);
+    vec2 texDy = dFdy(patchCoord.xy);
+    
+    // limit forward differencing to the width of ptex gutter
+    const float resolution = 128.0;
+    float d = (0.5/resolution)/max(length(texDx), length(texDy));
+    
+    vec4 STll = patchCoord;
+    vec4 STlr = patchCoord + d * vec4(texDx.x, texDx.y, 0, 0);
+    vec4 STul = patchCoord + d * vec4(texDy.x, texDy.y, 0, 0);
+    float Hll = PTexLookup(STll, textureImage_Data, textureImage_Packing, textureImage_Pages).x;
+    float Hlr = PTexLookup(STlr, textureImage_Data, textureImage_Packing, textureImage_Pages).x;
+    float Hul = PTexLookup(STul, textureImage_Data, textureImage_Packing, textureImage_Pages).x;
+    float dBs = (Hlr - Hll)/d;
+    float dBt = (Hul - Hll)/d;
+    
+    vec3 vSurfGrad = sign(fDet) * (dBs * vR1 + dBt * vR2);
+    return normalize(abs(fDet) * vN - vSurfGrad);
+}
+#endif // USE_PTEX_NORMAL
+
+vec4
+edgeColor(vec4 Cfill, vec4 edgeDistance)
+{
+#if defined(GEOMETRY_OUT_WIRE) || defined(GEOMETRY_OUT_LINE)
+    float d =
+        min(inpt.edgeDistance[0], min(inpt.edgeDistance[1], inpt.edgeDistance[2]));
+    vec4 Cedge = vec4(0.5, 0.5, 0.5, 1.0);
+    float p = exp2(-2 * d * d);
+
+#if defined(GEOMETRY_OUT_WIRE)
+    if (p < 0.25) discard;
+#endif
+
+    Cfill.rgb = mix(Cfill.rgb, Cedge.rgb, p);
+#endif
+    return Cfill;
+}
+
+void
+main()
+{
+    vec3 N = (gl_FrontFacing ? inpt.v.normal : -inpt.v.normal);
+#ifdef USE_PTEX_DISPLACEMENT
+    N = perturbNormalFromDisplacement(inpt.v.position.xyz,
+                                      N,
+                                      inpt.v.patchCoord);
+#endif
+
+    vec4 Cf = vec4(1.0);
+#if defined(GEOMETRY_OUT_WIRE) || defined(GEOMETRY_OUT_LINE)
+    Cf = edgeColor(Cf, inpt.edgeDistance);
+#endif
+
+#ifdef USE_PTEX_COLOR
+    Cf = Cf * (vec4(1) - vec4(PTexLookup(inpt.v.patchCoord,
+                                    textureImage_Data,
+                                    textureImage_Packing,
+                                         textureImage_Pages).x));
+#endif
+
+    Cf = lighting(Cf, inpt.v.position.xyz, N);
+
+    outColor = Cf;
+}
+
+#endif