Add Chromium-only Blender WebEngine parity work

blender-5.2.0/extern/opensubdiv-source/examples/glFVarViewer/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.
+#
+
+# *** glFVarViewer ***
+
+set(SHADER_FILES
+     shader.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(glFVarViewer "examples"
+    glFVarViewer.cpp
+    "${SHADER_FILES}"
+    "${INC_FILES}"
+    $<TARGET_OBJECTS:regression_common_obj>
+    $<TARGET_OBJECTS:regression_far_utils_obj>
+    $<TARGET_OBJECTS:examples_common_gl_obj>
+)
+
+target_link_libraries(glFVarViewer
+    ${PLATFORM_LIBRARIES}
+)
+
+install(TARGETS glFVarViewer DESTINATION "${CMAKE_BINDIR_BASE}")

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

@@ -0,0 +1,72 @@
+//
+//   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() {
+
+    //
+    //  Note that any shapes added here must have UVs -- loading a shape without UVs is a fatal
+    //  error and will result in termination when it is selected.
+    //
+    g_defaultShapes.push_back(ShapeDesc("catmark_toroidal_tet",     catmark_toroidal_tet,     kCatmark));
+    g_defaultShapes.push_back(ShapeDesc("catmark_cube",             catmark_cube,             kCatmark));
+    g_defaultShapes.push_back(ShapeDesc("catmark_cubes_semisharp",  catmark_cubes_semisharp,  kCatmark));
+    g_defaultShapes.push_back(ShapeDesc("catmark_cubes_infsharp",   catmark_cubes_infsharp,   kCatmark));
+    g_defaultShapes.push_back(ShapeDesc("catmark_pyramid",          catmark_pyramid,          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_fvar_bound0",      catmark_fvar_bound0,      kCatmark));
+    g_defaultShapes.push_back(ShapeDesc("catmark_fvar_bound1",      catmark_fvar_bound1,      kCatmark));
+    g_defaultShapes.push_back(ShapeDesc("catmark_fvar_bound2",      catmark_fvar_bound2,      kCatmark));
+    g_defaultShapes.push_back(ShapeDesc("catmark_fvar_bound3",      catmark_fvar_bound3,      kCatmark));
+    g_defaultShapes.push_back(ShapeDesc("catmark_fvar_bound4",      catmark_fvar_bound4,      kCatmark));
+    g_defaultShapes.push_back(ShapeDesc("catmark_fvar_project0",    catmark_fvar_project0,    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_xord_interior",    catmark_xord_interior,    kCatmark));
+    g_defaultShapes.push_back(ShapeDesc("catmark_xord_boundary",    catmark_xord_boundary,    kCatmark));
+    g_defaultShapes.push_back(ShapeDesc("catmark_nonquads",         catmark_nonquads,         kCatmark));
+    g_defaultShapes.push_back(ShapeDesc("catmark_nonman_verts",     catmark_nonman_verts,     kCatmark));
+    g_defaultShapes.push_back(ShapeDesc("catmark_nonman_edges",     catmark_nonman_edges,     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("loop_toroidal_tet",        loop_toroidal_tet,        kLoop));
+    g_defaultShapes.push_back(ShapeDesc("loop_tetrahedron",         loop_tetrahedron,         kLoop));
+    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_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));
+    g_defaultShapes.push_back(ShapeDesc("loop_fvar_bound0",         loop_fvar_bound0,         kLoop));
+    g_defaultShapes.push_back(ShapeDesc("loop_fvar_bound1",         loop_fvar_bound1,         kLoop));
+    g_defaultShapes.push_back(ShapeDesc("loop_fvar_bound2",         loop_fvar_bound2,         kLoop));
+    g_defaultShapes.push_back(ShapeDesc("loop_fvar_bound3",         loop_fvar_bound3,         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_nonman_verts",        loop_nonman_verts,        kLoop));
+    g_defaultShapes.push_back(ShapeDesc("loop_nonman_edges",        loop_nonman_edges,        kLoop));
+
+    g_defaultShapes.push_back(ShapeDesc("bilinear_cube",            bilinear_cube,            kBilinear));
+    g_defaultShapes.push_back(ShapeDesc("bilinear_nonplanar",       bilinear_nonplanar,       kBilinear));
+    g_defaultShapes.push_back(ShapeDesc("bilinear_nonquads0",       bilinear_nonquads0,       kBilinear));
+    g_defaultShapes.push_back(ShapeDesc("bilinear_nonquads1",       bilinear_nonquads1,       kBilinear));
+}
+//------------------------------------------------------------------------------

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

@@ -0,0 +1,381 @@
+//
+//   Copyright 2013 Pixar
+//
+//   Licensed under the terms set forth in the LICENSE.txt file available at
+//   https://opensubdiv.org/license.
+//
+
+#undef OSD_USER_VARYING_DECLARE
+#define OSD_USER_VARYING_DECLARE \
+    vec3 color;
+
+#undef OSD_USER_VARYING_ATTRIBUTE_DECLARE
+#define OSD_USER_VARYING_ATTRIBUTE_DECLARE \
+    layout(location = 1) in vec3 color;
+
+#undef OSD_USER_VARYING_PER_VERTEX
+#define OSD_USER_VARYING_PER_VERTEX() \
+    outpt.color = color
+
+#undef OSD_USER_VARYING_PER_CONTROL_POINT
+#define OSD_USER_VARYING_PER_CONTROL_POINT(ID_OUT, ID_IN) \
+    outpt[ID_OUT].color = inpt[ID_IN].color
+
+#undef OSD_USER_VARYING_PER_EVAL_POINT
+#define OSD_USER_VARYING_PER_EVAL_POINT(UV, a, b, c, d) \
+    outpt.color = \
+        mix(mix(inpt[a].color, inpt[b].color, UV.x), \
+            mix(inpt[c].color, inpt[d].color, UV.x), UV.y)
+
+//--------------------------------------------------------------
+// Uniform Blocks
+//--------------------------------------------------------------
+
+layout(std140) uniform Transform {
+    mat4 ModelViewMatrix;
+    mat4 ProjectionMatrix;
+    mat4 ModelViewProjectionMatrix;
+    mat4 ModelViewInverseMatrix;
+    mat4 UvViewMatrix;
+};
+
+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;
+}
+
+//--------------------------------------------------------------
+// Vertex Shader
+//--------------------------------------------------------------
+#ifdef VERTEX_SHADER
+
+layout (location=0) in vec4 position;
+OSD_USER_VARYING_ATTRIBUTE_DECLARE
+
+out block {
+    OutputVertex v;
+    OSD_USER_VARYING_DECLARE
+} outpt;
+
+void main()
+{
+    outpt.v.position = ModelViewMatrix * position;
+
+    // We don't actually want to write all these, but some
+    // compilers complain during about failing to fully write
+    // outpt.v if they are excluded.
+    outpt.v.normal = vec3(0);
+    outpt.v.tangent = vec3(0);
+    outpt.v.bitangent = vec3(0);
+    outpt.v.patchCoord = vec4(0);
+    outpt.v.tessCoord = vec2(0);
+#if defined OSD_COMPUTE_NORMAL_DERIVATIVES
+    outpt.v.Nu = vec3(0);
+    outpt.v.Nv = vec3(0);
+#endif
+    // --
+
+    OSD_USER_VARYING_PER_VERTEX();
+}
+
+#endif
+
+//--------------------------------------------------------------
+// Geometry Shader
+//--------------------------------------------------------------
+#ifdef GEOMETRY_SHADER
+
+#ifdef PRIM_QUAD
+
+    layout(lines_adjacency) in;
+
+    #define EDGE_VERTS 4
+
+#endif // PRIM_QUAD
+
+#ifdef  PRIM_TRI
+
+    layout(triangles) in;
+
+    #define EDGE_VERTS 3
+
+#endif // PRIM_TRI
+
+
+layout(triangle_strip, max_vertices = EDGE_VERTS) out;
+in block {
+    OutputVertex v;
+    OSD_USER_VARYING_DECLARE
+} inpt[EDGE_VERTS];
+
+out block {
+    OutputVertex v;
+    noperspective out vec4 edgeDistance;
+    OSD_USER_VARYING_DECLARE
+} outpt;
+
+uniform isamplerBuffer OsdFVarParamBuffer;
+layout(std140) uniform OsdFVarArrayData {
+    OsdPatchArray fvarPatchArray[2];
+};
+
+vec2
+interpolateFaceVarying(vec2 uv, int fvarOffset)
+{
+    int patchIndex = OsdGetPatchIndex(gl_PrimitiveID);
+
+    OsdPatchArray array = fvarPatchArray[0];
+
+    ivec3 fvarPatchParam = texelFetch(OsdFVarParamBuffer, patchIndex).xyz;
+    OsdPatchParam param = OsdPatchParamInit(fvarPatchParam.x,
+                                            fvarPatchParam.y,
+                                            fvarPatchParam.z);
+
+    int patchType = OsdPatchParamIsRegular(param) ? array.regDesc : array.desc;
+
+    float wP[20], wDu[20], wDv[20], wDuu[20], wDuv[20], wDvv[20];
+    int numPoints = OsdEvaluatePatchBasisNormalized(patchType, param,
+                uv.s, uv.t, wP, wDu, wDv, wDuu, wDuv, wDvv);
+
+    int primOffset = patchIndex * array.stride;
+
+    vec2 result = vec2(0);
+    for (int i=0; i<numPoints; ++i) {
+        int index = (primOffset+i)*OSD_FVAR_WIDTH + fvarOffset;
+        vec2 cv = vec2(texelFetch(OsdFVarDataBuffer, index).s,
+                       texelFetch(OsdFVarDataBuffer, index + 1).s);
+        result += wP[i] * cv;
+    }
+
+    return result;
+}
+
+void emit(int index, vec3 normal)
+{
+    outpt.v.position = inpt[index].v.position;
+#ifdef SMOOTH_NORMALS
+    outpt.v.normal = inpt[index].v.normal;
+#else
+    outpt.v.normal = normal;
+#endif
+
+#ifdef SHADING_FACEVARYING_UNIFORM_SUBDIVISION
+    // interpolate fvar data at refined tri or quad vertex locations
+#ifdef PRIM_TRI
+    vec2 trist[3] = vec2[](vec2(0,0), vec2(1,0), vec2(0,1));
+    vec2 st = trist[index];
+#endif
+#ifdef PRIM_QUAD
+    vec2 quadst[4] = vec2[](vec2(0,0), vec2(1,0), vec2(1,1), vec2(0,1));
+    vec2 st = quadst[index];
+#endif
+#else
+    // interpolate fvar data at tessellated vertex locations
+    vec2 st = inpt[index].v.tessCoord;
+#endif
+
+    vec2 uv = interpolateFaceVarying(st, /*fvarOffset*/0);
+
+    outpt.color = vec3(uv.s, uv.t, 0);
+
+#ifdef GEOMETRY_UV_VIEW
+    uv = 2 * uv - vec2(1);
+    gl_Position = UvViewMatrix * vec4(uv.s, uv.y, 0, 1);
+#else
+    gl_Position = ProjectionMatrix * inpt[index].v.position;
+#endif
+    EmitVertex();
+}
+
+#if defined(GEOMETRY_OUT_WIRE) || defined(GEOMETRY_OUT_LINE)
+const float VIEWPORT_SCALE = 512.0;
+
+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, vec3 normal, vec4 edgeVerts[EDGE_VERTS])
+{
+    outpt.edgeDistance[0] =
+        edgeDistance(edgeVerts[index], edgeVerts[0], edgeVerts[1]);
+    outpt.edgeDistance[1] =
+        edgeDistance(edgeVerts[index], edgeVerts[1], edgeVerts[2]);
+#ifdef PRIM_TRI
+    outpt.edgeDistance[2] =
+        edgeDistance(edgeVerts[index], edgeVerts[2], edgeVerts[0]);
+#endif
+#ifdef PRIM_QUAD
+    outpt.edgeDistance[2] =
+        edgeDistance(edgeVerts[index], edgeVerts[2], edgeVerts[3]);
+    outpt.edgeDistance[3] =
+        edgeDistance(edgeVerts[index], edgeVerts[3], edgeVerts[0]);
+#endif
+
+    emit(index, normal);
+}
+#endif
+
+void main()
+{
+    gl_PrimitiveID = gl_PrimitiveIDIn;
+
+#ifdef PRIM_QUAD
+    vec3 A = (inpt[0].v.position - inpt[1].v.position).xyz;
+    vec3 B = (inpt[3].v.position - inpt[1].v.position).xyz;
+    vec3 C = (inpt[2].v.position - inpt[1].v.position).xyz;
+    vec3 n0 = normalize(cross(B, A));
+
+#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[3] = ProjectionMatrix * inpt[3].v.position;
+
+    edgeVerts[0].xy /= edgeVerts[0].w;
+    edgeVerts[1].xy /= edgeVerts[1].w;
+    edgeVerts[2].xy /= edgeVerts[2].w;
+    edgeVerts[3].xy /= edgeVerts[3].w;
+
+    emit(0, n0, edgeVerts);
+    emit(1, n0, edgeVerts);
+    emit(3, n0, edgeVerts);
+    emit(2, n0, edgeVerts);
+#else
+    emit(0, n0);
+    emit(1, n0);
+    emit(3, n0);
+    emit(2, n0);
+#endif
+#endif // PRIM_QUAD
+
+#ifdef PRIM_TRI
+    vec3 A = (inpt[1].v.position - inpt[0].v.position).xyz;
+    vec3 B = (inpt[2].v.position - inpt[0].v.position).xyz;
+    vec3 n0 = normalize(cross(B, A));
+
+#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, n0, edgeVerts);
+    emit(1, n0, edgeVerts);
+    emit(2, n0, edgeVerts);
+#else
+    emit(0, n0);
+    emit(1, n0);
+    emit(2, n0);
+#endif
+#endif // PRIM_TRI
+
+    EndPrimitive();
+}
+
+#endif
+
+//--------------------------------------------------------------
+// Fragment Shader
+//--------------------------------------------------------------
+#ifdef FRAGMENT_SHADER
+
+in block {
+    OutputVertex v;
+    noperspective in vec4 edgeDistance;
+    OSD_USER_VARYING_DECLARE
+} inpt;
+
+out vec4 outColor;
+
+vec4
+edgeColor(vec4 Cfill)
+{
+#if defined(GEOMETRY_OUT_WIRE) || defined(GEOMETRY_OUT_LINE)
+#ifdef PRIM_TRI
+    float d =
+        min(inpt.edgeDistance[0], min(inpt.edgeDistance[1], inpt.edgeDistance[2]));
+#endif
+#ifdef PRIM_QUAD
+    float d =
+        min(min(inpt.edgeDistance[0], inpt.edgeDistance[1]),
+            min(inpt.edgeDistance[2], inpt.edgeDistance[3]));
+#endif
+    vec4 Cedge = vec4(1.0, 1.0, 0.0, 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;
+}
+
+#if defined(PRIM_QUAD) || defined(PRIM_TRI)
+void
+main()
+{
+#ifdef GEOMETRY_UV_VIEW
+    outColor = edgeColor(vec4(0.9));
+    return;
+
+#else
+    vec3 N = (gl_FrontFacing ? inpt.v.normal : -inpt.v.normal);
+
+    // generating a checkerboard pattern
+    int checker = int(floor(20*inpt.color.r)+floor(20*inpt.color.g))&1;
+    vec4 color = vec4(inpt.color.rg*checker, 1-checker, 1);
+
+#if defined(GEOMETRY_OUT_WIRE) || defined(GEOMETRY_OUT_LINE)
+    color = edgeColor(color);
+#endif
+    outColor = color;
+#endif
+}
+#endif
+
+#endif