arrays - 我应该从结构和类切换到数组吗？

Question

所以我有一个程序。我正在尝试用复杂的力矩逻辑来模拟大量的移动粒子，出于多种原因，我不想在 CGP 上进行这些逻辑。当然，我将在 GPU 上绘制这一切。

现在，我最初认为在模拟大量粒子时，GPU 延迟会成为问题，而不是 CPU。不幸的是，我以高达 6fps 的速度运行 500 个粒子:(。

我已经跟踪了如何将顶点发送到粒子模拟器的延迟。甚至不是缓冲区的创建，只是我如何构建数组。基本上我有数组，我清除每一帧，然后遍历粒子数组中的每个粒子并为每个粒子创建数组。这导致大约 17500 次附加调用(有 500 个粒子)。所以我需要一种不同的方法来做到这一点，因为如果不构建这些阵列，它就会以 60fps 的速度运行，没有 CPU 延迟。大多数这些追加调用都会调用结构体的成员。

目前，每个粒子都是基于类对象制成的。它具有存储在结构中的位置和颜色等信息。将结构切换为数组会不会让我烦恼？或者也许我应该将所有内容都切换到数组？显然，这样做会使编程变得更加困难。但这值得吗？

一个大问题是我需要将每个粒子绘制为胶囊。我会用两个点和一条粗线来制作它。不幸的是 OpenGL es 2.0 不支持粗线，所以我必须用两个点和两个三角形来绘制它:(。正如你所看到的，函数“calculateSquare”使这两个三角形基于两个点。它也非常滞后，但这不是唯一的问题，稍后我会尝试寻找不同的方法。

你有什么想法？

注意:根据 xcode，RAM 使用量仅为 10 mb。然而CPU帧时间是141毫秒。

这是代码顺便说一句:

func buildParticleArrays()
    {
        lineStrip = []
        lineStripColors = []
        lineStripsize = []
        s_vertes = []
        s_color = []
        s_size = []
        for cparticle in particles
        {
            let pp = cparticle.lastPosition
            let np = cparticle.position
            if (cparticle.frozen == true)
            {
                addPoint(cparticle.position, color: cparticle.color, size: cparticle.size)
            }
            else
            {
                let s = cparticle.size / 2.0

                //Add point merely adds the data in array format
                addPoint(cparticle.position, color: cparticle.color, size: cparticle.size)
                addPoint(cparticle.lastPosition, color: cparticle.color, size: cparticle.size)

                lineStrip += calculateSquare(pp, pp2: np, size: s)


                for var i = 0; i < 6; i++
                {
                    let rgb = hsvtorgb(cparticle.color)
                    lineStripColors.append(GLfloat(rgb.r))
                    lineStripColors.append(GLfloat(rgb.g))
                    lineStripColors.append(GLfloat(rgb.b))
                    lineStripColors.append(GLfloat(rgb.a))
                    lineStripsize.append(GLfloat(cparticle.size))
                }
            }



        }
    }
func addPoint(theObject: point, color: colorhsv, size: CGFloat)
    {

        let rgb = hsvtorgb(color)
        s_vertes += [GLfloat(theObject.x), GLfloat(theObject.y), GLfloat(theObject.z)]
        s_color += [GLfloat(rgb.r), GLfloat(rgb.g), GLfloat(rgb.b), GLfloat(rgb.a)]
        s_size.append(GLfloat(size))
    }

func calculateSquare(pp1: point, pp2: point, size: CGFloat) -> [GLfloat]
{

    let p1 = pp1
    var p2 = pp2
    var s1 = point()
    var s2 = point()
    let center = CGPointMake((p1.x + p2.x) / 2.0, (p1.y + p2.y) / 2.0)


    var angle:CGFloat = 0
    if ((p1.x == p2.x) && (p1.y == p2.y))
    {
        //They are ontop of eachother
        angle = CGFloat(M_PI) / 2.0
        p2.x += 0.0001
        p2.y += 0.0001
    }
    else
    {
        if(p1.x == p2.x)
        {
            //UH OH x axis is equal
            if (p1.y < p2.y)
            {
                //RESULT: p1 is lower so should be first
                s1 = p1
                s2 = p2
            }
            else
            {
                //RESULT: p2 is lower and should be first
                s1 = p2
                s2 = p1
            }
        }
        else
        {
            //We could be all good
            if (p1.y == p2.y)
            {
                //Uh oh y axis is equal
                if (p1.x < p2.x)
                {
                    //RESULT: p1 is left so should be first
                    s1 = p1
                    s2 = p2
                }
                else
                {
                    //RESULT: p2 is to the right so should be first
                    s1 = p2
                    s2 = p1
                }
            }
            else
            {
                //Feuf everything is ok
                if ((p1.x < p2.x) && (p1.y < p2.y)) //First point is left and below
                {
                    //P1 should be first
                    s1 = p1
                    s2 = p2
                }
                else //First point is right and top
                {
                    //P2 should be first
                    s1 = p2
                    s2 = p1
                }
            }

        }
        angle = angle2p(s1, p2: s2)
    }


    if (angle < 0)
    {
        angle += CGFloat(M_PI) * 2.0
    }

    let yh = size / 2.0
    let distance = dist(p1, p2: p2)
    let xh = distance / 2.0

    let tl = rotateVector(CGPointMake(-xh, yh), angle: angle) + center
    let tr = rotateVector(CGPointMake(xh, yh), angle: angle) + center
    let bl = rotateVector(CGPointMake(-xh, -yh), angle: angle) + center
    let br = rotateVector(CGPointMake(xh, -yh), angle: angle) + center

    let c1:[GLfloat] = [GLfloat(bl.x), GLfloat(bl.y), 0]
    let c2:[GLfloat] = [GLfloat(tl.x), GLfloat(tl.y), 0]
    let c3:[GLfloat] = [GLfloat(br.x), GLfloat(br.y), 0]
    let c4:[GLfloat] = [GLfloat(tr.x), GLfloat(tr.y), 0]
    let part1 = c1 + c2 + c3
    let part2 = c2 + c3 + c4
    return part1 + part2
}

Answer 1

你真的需要系统 RAM 中的所有粒子吗？例如对于与场景中其他对象相关的一些物理碰撞计算？否则，您可以只创建一个粒子，将其发送到 GPU 并在 GPU 着色器中进行计算。