骨磨削可视化¶

vec3 texCoordToworldPos(vec3 tc) {
   vec3 voxelCoords = tc * vec3(gridSize);
   vec3 worldPos = (voxelCoords - 0.5) * gridSpacing + gridOrigin;
   return worldPos;
}

float sdSphere(vec3 worldPos)
{
    vec3 pLocal = (world2ToolMatrix * vec4(worldPos, 1.0)).xyz;
    return length(pLocal) - toolSize.x;
}

void main()
{
    // 获取当前线程处理的体素坐标（3D 并行，自动遍历所有层）
    ivec3 voxelCoord = ivec3(gl_GlobalInvocationID.xyz);

    // 边界检查
    if (any(greaterThanEqual(voxelCoord, gridSize))) {
        return;
    }

    // 计算纹理坐标（归一化到 [0,1]）
    vec3 toolTexCoord = (vec3(voxelCoord) + 0.5) / vec3(gridSize);

    // 读取旧的距离值
    float odist = imageLoad(texDist, voxelCoord).x;

    // 计算世界坐标
    vec3 worldPos = texCoordToworldPos(toolTexCoord);

    // 计算新的 SDF 距离
    float ndist = sdSphere(worldPos);

    // 更新距离值
    if (ndist < odist) {
        imageStore(texDist, voxelCoord, vec4(ndist, 0, 0, 0));
    }
}

struct ABufferNode {
    vec4 worldPos;    // 16 bytes 
    vec4 normalVC;    // 16 bytes
    float depth;      // 4 bytes
    uint next;        // 4 bytes
    vec2 _padding;    // 8 bytes
};

void main()
{
    // 检查像素坐标
    ivec2 coord = ivec2(gl_FragCoord.xy);
    if (coord.x < 0 || coord.x >= windowSize.x ||
        coord.y < 0 || coord.y >= windowSize.y) {
        discard;
    }

    vec4 vertexVC = vertexVCVSOutput;

    // 计算法向量（View Space）
    vec3 normalVC = normalize(normalVCVSOutput);

    // 分配新节点
    uint newNodeIndex = atomicCounterIncrement(nodeCounter);
    uint maxNodes = uint(windowSize.x) * uint(windowSize.y) * uint(maxLayers);

    if (newNodeIndex >= maxNodes) {
        discard;
        return;
    }

    // 存储几何信息
    uint previousHead = imageAtomicExchange(headPointers, coord, newNodeIndex);
    nodes[newNodeIndex].worldPos = vec4(worldPosVSOutput.xyz, 1.0);
    nodes[newNodeIndex].normalVC = vec4(normalVC, 0.0);
    nodes[newNodeIndex].depth = gl_FragCoord.z;
    nodes[newNodeIndex].next = previousHead;

    discard;
}

void main()
{
    ivec2 coord = ivec2(gl_FragCoord.xy);

    // 像素坐标是否有效
    if (coord.x < 0 || coord.x >= windowSize.x || coord.y < 0 || coord.y >= windowSize.y) {
        discard;
        return;
    }

    // 收集片元
    ABufferNode fragments[64];
    int fragmentCount = collectFragments(coord, fragments);
    if (fragmentCount == 0) {
        discard;
    }
    ABufferNode frontNode, backNode;
    if (!findNearestTwo(fragments, fragmentCount, frontNode, backNode)) {
        // 片元数量异常检查
        vec4 debugColor;
        if (isFragmentCountAbnormal(fragmentCount, debugColor)) {
            fragOutput0 = debugColor;
            gl_FragDepth = fragments[0].depth;
        }
        discard;
        return;
    }

    vec3 startPos = frontNode.worldPos.xyz;
    vec3 endPos = backNode.worldPos.xyz;

    float sdf = sampleSDF(startPos);
    if (sdf >= 0) { // 原始表面（未切割区域）
        vec3 normalVC = normalize(frontNode.normalVC.xyz);
        vec3 clr = getCutColor(startPos, true);
        fragOutput0 = computeSimplifiedLighting(normalVC, clr);
        gl_FragDepth = frontNode.depth;
        return;
    }

    // 切面 Raymarch
    vec3 rd = normalize(endPos - startPos);

    float voxel = min(gridSpacing.x, min(gridSpacing.y, gridSpacing.z));
    float pad = voxel * 2.0;

    vec3 ro = startPos - rd * pad;
    float maxd = distance(endPos, startPos) + 2.0 * pad;
    vec3 hitp, hitn;
    float hitd = 0;
    bool face = false;

    if (!raymarch(startPos, rd, maxd, hitp, hitn, hitd, voxel, face)) {
        // Raymarch 失败，退回原始 front
        vec3 normalVC = normalize(frontNode.normalVC.xyz);
        vec3 clr = getCutColor(startPos, true);

        fragOutput0 = computeSimplifiedLighting(normalVC, clr);
        gl_FragDepth = frontNode.depth;
        return;
    }

    float sdepth = frontNode.depth;
    float tdepth = backNode.depth - sdepth;

    float ndepth = sdepth + tdepth * hitd / maxd;
    vec3 cutColor = getCutColor(hitp, face);
    vec3 hitnWS = hitn;
    vec3 hitnVC = normalize(normalMatrix * hitnWS);

    fragOutput0 = computeSimplifiedLighting(hitnVC, cutColor);
    gl_FragDepth = ndepth;
}

// composite.vert
#version 430 core

out vec2 texCoord;

void main() {
    vec2 pos = vec2((gl_VertexID << 1) & 2, gl_VertexID & 2);
    texCoord = pos;
    gl_Position = vec4(pos * 2.0 - 1.0, 0.0, 1.0);
}

// 根据坐标计算颜色
vec3 getCutColor(vec3 worldPos, bool isFace)
{
    if (useRegionLayering == 0) {
        return baseColor;
    }

    vec3 regionCenter = regionMatrix[3].xyz;
    float dist = length(worldPos - regionCenter) - regionRadius;

    vec3 clr;
    if (isFace && dist > resectThreshold) {
        clr = baseColor;
    } else if (dist <= resectThreshold) {
        clr = resectColor;
    } else if (dist <= overcutThreshold) {
        clr = resectIdealColor;
    } else if (dist > overcutThreshold) {
        clr = overcutColor;
    }

    return clr;
}

vec4 computeSimplifiedLighting(vec3 normalVC, vec3 baseColor)
{
    vec3 ambientColor = ambientIntensity * baseColor;
    vec3 diffuseColor = diffuseIntensity * baseColor;
    vec3 specularColor = specularIntensity * baseColor;
    float specularPower = specularPowerUniform;

    // 使用法向量 Z 分量作为光照强度
    float df = max(0.000001, normalVC.z);
    float sf = pow(df, specularPower);

    vec3 diffuse = df * diffuseColor * lightColor0;
    vec3 specular = sf * specularColor * lightColor0;

    return vec4(ambientColor + diffuse + specular, 1.0);
}



vec3 normalVC = normalize(frontNode.normalVC.xyz);
vec3 clr = getCutColor(startPos, true);
fragOutput0 = computeSimplifiedLighting(normalVC, clr);
gl_FragDepth = frontNode.depth;