Swift 快速金属着色问题

几个小时以来，我一直在努力使以下用opengl编写的着色器在metal swift中工作： 我在着色器函数中使用内核方法，下面是生成视频的一个输出帧。

我还写了一些其他着色器，它们也能成功工作，但在这个着色器上坚持了5个多小时

当前代码：

#include <metal_stdlib>
using namespace metal;
float2 zoom(float2 uv, float amount)

{
    return 0.5f + ((uv - 0.5f) * (1.0f - amount));
}

float4 getColor(texture2d<float, access::sample> tex2d, float2 uv)

{
    constexpr sampler sampler2d(coord::normalized,

                                address::clamp_to_edge,

                                filter::linear,

                                mip_filter::linear

                                );

    return tex2d.sample(sampler2d, float2(uv.x, 1.0f - uv.y));
}

float4 transition(texture2d<float, access::sample> fromTexture,
                  texture2d<float, access::sample> toTexture,
                  float nQuick,
                  float progress,
                  float2 uv
                  )
{

    uv.x /= fromTexture.get_width();
    uv.y /= fromTexture.get_height();
    uv.y = 1.0f - uv.y;

    float4 fromColor = getColor(fromTexture, zoom(uv, smoothstep(0.0f, nQuick, progress)));
    float4 toColor = getColor(toTexture, uv);

    return mix (fromColor, toColor, smoothstep(nQuick-0.2f, 1.0f, progress));
}



kernel void transition_simplezoom(texture2d<float, access::sample> inTexture [[ texture(0) ]],

                            texture2d<float, access::sample> inTexture2 [[ texture(1) ]],

                            texture2d<float, access::write> outTexture [[ texture(2) ]],

                            device const float *progress [[ buffer(1) ]],

                            device float *result [[buffer(0)]],

                            device const float *zoom_quickness [[buffer(2)]],

                            uint2 gid [[ thread_position_in_grid ]])
{
    float zoomQuickness = *zoom_quickness;

    float prog = *progress;

    prog = 1.0 - prog;

    float2 ngid = float2(gid);``

    float nQuick = clamp(zoomQuickness, 0.2, 1.0);

    return outTexture.write(transition(inTexture, inTexture2, nQuick, prog, float2(ngid)),

                            gid);
}

预期产出：

---

在转换此着色器时，我试图尽可能接近原始着色器的精神和结构。但是，由于GLSL和MSL之间存在显著差异，我不得不采取一些自由：

• 假设制服和其他全局变量将以

  常量

  缓冲区的形式到达
• 将参数从片段着色器向下传递到实用程序函数，而不是作为全局函数访问它们

话虽如此，以下是我对金属材质球的最佳尝试，该材质球可以实现您想要的缩放效果：

struct VertexIn {
    float2 position  [[attribute(0)]];
    float2 texCoords [[attribute(1)]];
};

struct VertexOut {
    float4 position [[position]];
    float2 texCoords;
};

float4 getColor(texture2d<float, access::sample> tex2d, float2 uv) {
    constexpr sampler sampler2d(coord::normalized,
                                address::clamp_to_edge,
                                filter::linear,
                                mip_filter::linear);

    return tex2d.sample(sampler2d, float2(uv.x, 1.0f - uv.y));
}

float2 zoom(float2 uv, float amount) {
    return 0.5f + ((uv - 0.5f) * (1.0f - amount));
}

float4 transition (texture2d<float, access::sample> fromTexture,
                   texture2d<float, access::sample> toTexture,
                   float nQuick,
                   float progress,
                   float2 uv)
{
    float4 fromColor = getColor(fromTexture, zoom(uv, smoothstep(0.0f, nQuick, progress)));
    float4 toColor = getColor(toTexture, uv);
    return mix(fromColor, toColor, smoothstep(nQuick - 0.2f, 1.0f, progress));
}

vertex VertexOut textured_vertex(VertexIn in [[stage_in]]) {
    VertexOut out;
    out.position = float4(in.position, 0.0f, 1.0f);
    out.texCoords = in.texCoords;
    return out;
}

fragment float4 zoomed_textured_fragment(VertexOut in [[stage_in]],
                                         constant float& zoom_quickness [[buffer(0)]],
                                         constant float& progress       [[buffer(1)]],
                                         texture2d<float, access::sample> fromTexture [[texture(0)]],
                                         texture2d<float, access::sample> toTexture   [[texture(1)]])
{
    float nQuick = clamp(zoom_quickness, 0.2 , 1.0);
    return transition(fromTexture, toTexture, nQuick, progress, in.texCoords);
}

struct VertexIn{
浮动2位置[[属性（0）]；
float2 texCoords[[属性（1）]；
};
结构顶点输出{
浮动4位[[位]]；
2个texCoords；
};
float4 getColor（纹理2D tex2d，浮动2 uv）{
constexpr取样器取样器2D（坐标：：标准化，
地址：夹钳到边缘，
过滤器：：线性，
mip_滤波器：：线性）；
返回tex2d.sample（sampler2d，float2（uv.x，1.0f-uv.y））；
}
浮动2缩放（浮动2 uv、浮动量）{
返回0.5f+（（uv-0.5f）*（1.0f-量））；
}
浮动4过渡（纹理2D从纹理，
纹理2D图腾纹理，
飘浮在水面上，
浮动进度，
浮标（2紫外线）
{
float4 fromColor=getColor（fromTexture，缩放（uv，smoothstep（0.0f，nClick，progress））；
float4 toColor=getColor（toTexture，uv）；
返回混合（fromColor、toColor、smoothstep（nClick-0.2f、1.0f、progress））；
}
顶点顶点顶点输出纹理化顶点（顶点在[[阶段在]]中）{
垂直输出；
out.position=float4（in.position，0.0f，1.0f）；
out.texCoords=in.texCoords；
返回；
}
片段浮动4缩放的\u纹理\u片段（顶点退出[[stage\u in]]，
恒定浮动和缩放速度[[缓冲区（0）]，
固定浮动和进度[[缓冲区（1）]，
纹理2D fromTexture[[纹理（0）]，
纹理2D图腾纹理[[纹理（1）]）
{
float nQuick=钳制（缩放速度，0.2,1.0）；
返回转换（fromTexture、toTexture、nQuick、progress、in.texCoords）；
}

您似乎已经有了渲染代码，所以我只需要注意，我使用以下Swift代码将参数作为单个常量缓冲区传入：

var zoomSpeed: Float = 0.5
renderCommandEncoder.setFragmentBytes(&zoomSpeed, length: MemoryLayout<Float>.size, index: 0)

renderCommandEncoder.setFragmentBytes(&progress, length: MemoryLayout<Float>.size, index: 1)

var zoomSpeed:Float=0.5
renderCommandEncoder.setFragmentBytes（&zoomSpeed，长度：MemoryLayout.size，索引：0）
renderCommandEncoder.setFragmentBytes（&progress，长度：MemoryLayout.size，索引：1）

---

<> > <代码>进度<代码>是<代码>浮点var，它随时间变化以执行缩放动画。

将来，考虑发布代码的相关部分，以便其他人指出具体问题。此外，从您的问题中还不能立即看出预期的输出是什么，因此包含一个示例，说明当事情正常运行时，您希望看到什么是非常有帮助的。@warrenm我已经更新了我的问题。请看一看。您能否共享用于分派计算工作的Swift代码（即您的线程组大小和计数计算）？是不是网格的高度实际上与“from”视频帧的高度匹配？@warrenm添加了代码，我的两个视频都是1280720的尺寸。@warrenm在着色器中交换纹理变量时，缩放效果很好，就像在开始时一样，输出纹理是texture1，在转换过程中，它从texture2到texture1，具有正确的缩放效果，然后返回到texture2。如果我在着色器中不交换变量就从texture2转换到texture1，也会弄糟。很抱歉之前没有发布代码，我已经在我的内核方法中重写了您的代码，但结果与以前相同。

var zoomSpeed: Float = 0.5
renderCommandEncoder.setFragmentBytes(&zoomSpeed, length: MemoryLayout<Float>.size, index: 0)

renderCommandEncoder.setFragmentBytes(&progress, length: MemoryLayout<Float>.size, index: 1)