Animated LowLevelTexture extruded text RealityView that according to the text's bounds

animatedTextureShader.metal

#include <metal_stdlib>
using namespace metal;

kernel void animatedTextureShader(
    texture2d<half, access::write> outTexture [[texture(0)]],
    uint2 gid [[thread_position_in_grid]],
    constant float &time [[buffer(0)]])
{
    float2 texCoord = float2(gid) / float2(outTexture.get_width(), outTexture.get_height());
    float t = time * 0.1;
    float lines = 0.5 + 0.5 * sin(texCoord.y * 50.0 + t * 5.0);
    lines = smoothstep(0.4, 0.6, lines);
    float hue = fract(texCoord.y + t * 0.1);
    float3 color = float3(
        0.5 + 0.5 * cos(6.28318 * (hue + 0.0)),
        0.5 + 0.5 * cos(6.28318 * (hue + 0.333)),
        0.5 + 0.5 * cos(6.28318 * (hue + 0.666))
    );
    color *= lines;
    outTexture.write(half4(half3(color), 1.0), gid);
}

LowLevelTextureTextView.swift

import RealityKit
import SwiftUI

struct LowLevelTextureTextView: View {
    let commandQueue: MTLCommandQueue
    let computePipeline: MTLComputePipelineState
    @State private var texture: LowLevelTexture?
    let timer = Timer.publish(every: 1.0 / 120.0, on: .main, in: .common).autoconnect()
    @State private var time: Float = 0
    
    init(shaderFunctionName: String = "animatedTextureShader") {
        let device = MTLCreateSystemDefaultDevice()!
        self.commandQueue = device.makeCommandQueue()!
        
        let library = device.makeDefaultLibrary()!
        
        let updateFunction = library.makeFunction(name: shaderFunctionName)!
        self.computePipeline = try! device.makeComputePipelineState(function: updateFunction)
    }
    
    var attributedString: AttributedString {
        var textString = AttributedString("WOW")
        textString.font = .systemFont(ofSize: 15)
        let paragraphStyle = NSMutableParagraphStyle()
        paragraphStyle.alignment = .center
        let centerAttributes = AttributeContainer([.paragraphStyle: paragraphStyle])
        textString.mergeAttributes(centerAttributes)
        return textString
    }
    
    var textureDescriptor: LowLevelTexture.Descriptor {
        var desc = LowLevelTexture.Descriptor()
        desc.textureType = .type2D
        desc.arrayLength = 1
        desc.width = 2048
        desc.height = 2048
        desc.depth = 1
        desc.mipmapLevelCount = 1
        desc.pixelFormat = .bgra8Unorm
        desc.textureUsage = [.shaderRead, .shaderWrite]
        desc.swizzle = .init(red: .red, green: .green, blue: .blue, alpha: .alpha)
        return desc
    }
    
    var body: some View {
        RealityView { content in
            let entity = try! getEntity()
            content.add(entity)
        }
        .onReceive(timer) { input in
            time+=0.25
            updateTexture()
        }
    }
    
    func getEntity() throws -> Entity {
        let resource = try getMeshResource()
        let modelComponent = ModelComponent(mesh: resource, materials:  getMaterials())
        let entity = ModelEntity()
        entity.components.set(modelComponent)
        centerTextEntity(entity)
        return entity
    }
    
    func centerTextEntity(_ entity: ModelEntity) {
        guard let bounds = entity.model?.mesh.bounds else { return }
        let minX = bounds.min.x
        let maxX = bounds.max.x
        let minY = bounds.min.y
        let maxY = bounds.max.y
        entity.transform.translation.x -= (maxX-minX) * 0.5
        entity.transform.translation.y -= (maxY-minY) * 0.5
    }
    
    func getMeshResource() throws -> MeshResource {
        var extrusionOptions = MeshResource.ShapeExtrusionOptions()
        extrusionOptions.extrusionMethod = .linear(depth: 0.4)
        extrusionOptions.materialAssignment = .init(front: 0, back: 0, extrusion: 1, frontChamfer: 1, backChamfer: 1)
        extrusionOptions.chamferRadius = 0.4
        return try MeshResource(extruding: attributedString, extrusionOptions: extrusionOptions)
    }
    
    func getMaterials() -> [RealityKit.Material] {
        var material = PhysicallyBasedMaterial()
        material.baseColor.tint = .init(red: 0.0, green: 0.0, blue: 0.0, alpha: 1.0)
        material.roughness.scale = 0.0
        material.metallic.scale = 1.0
        material.faceCulling = .none
        return [getTextureMaterial(), material]
    }
    
    func getTextureMaterial() -> RealityKit.Material {
        let texture = try! LowLevelTexture(descriptor: textureDescriptor)
        self.texture = texture
        let resource = try! TextureResource(from: texture)
        var material = UnlitMaterial()
        material.color.texture = .init(resource)
        material.textureCoordinateTransform.scale = [1,3]
        material.faceCulling = .none
        return material
    }
    
    func updateTexture() {
        guard let texture else { return }
        guard let commandBuffer = commandQueue.makeCommandBuffer(),
              let computeEncoder = commandBuffer.makeComputeCommandEncoder() else {
            return
        }
        commandBuffer.enqueue()
        computeEncoder.setComputePipelineState(computePipeline)
        let outTexture: MTLTexture = texture.replace(using: commandBuffer)
        computeEncoder.setTexture(outTexture, index: 0)
        var timeBuffer = [time]
        computeEncoder.setBytes(&timeBuffer, length: MemoryLayout<Float>.size, index: 0)
        let w = computePipeline.threadExecutionWidth
        let h = computePipeline.maxTotalThreadsPerThreadgroup / w
        let threadGroupSize = MTLSizeMake(w, h, 1)
        
        let threadGroupCount = MTLSizeMake(
            (textureDescriptor.width + threadGroupSize.width - 1) / threadGroupSize.width,
            (textureDescriptor.height + threadGroupSize.height - 1) / threadGroupSize.height,
            1)
        computeEncoder.dispatchThreadgroups(
            threadGroupCount,
            threadsPerThreadgroup: threadGroupSize)
        computeEncoder.endEncoding()
        commandBuffer.commit()
    }
}

#Preview {
    LowLevelTextureTextView()
}