3

（带着这个问题，我试图调查我解决另一个问题的想法）

如果我在内存中有一个标准的二维数组宽度和高度，我可以把它变成一个长度的一维数组宽度*高度的一维数组，然后通过index = x + y * width对其进行索引。这种映射在为数组分配和释放内存时非常有用，因为内存管理器不需要担心以 2D 形式打包结构，而只需要担心以 1D 表示的每个分配数组的总长度。

我正在尝试查看是否可以使用相同的方法对 OpenGL 纹理进行图像内存管理。这个想法（如上面链接的问题中所述）是将一大堆所需的纹理组合成一个更大的纹理，方法是将它们打包（即，将它们彼此相邻绘制）到大纹理中。这有助于在渲染过程中最大限度地减少昂贵的纹理绑定操作。

假设我的大纹理是 8×8 像素（即总共 64 像素）：

8x8 texture:                5x5 image:            4x5 image:

   | 0 1 2 3 4 5 6 7           | 0 1 2 3 4           | 0 1 2 3
---+-----------------       ---+-----------       ---+---------
 0 | . . . . . . . .         0 | A B C D E         0 | a b c d
 1 | . . . . . . . .         1 | F G H I J         1 | e f g h
 2 | . . . . . . . .         2 | K L M N O         2 | i j k l
 3 | . . . . . . . .         3 | P Q R S T         3 | m n o p
 4 | . . . . . . . .         4 | U V W X Y         4 | q r s t
 5 | . . . . . . . .
 6 | . . . . . . . .
 7 | . . . . . . . .

我想在其中存储一个 5×5 图像和一个 4×5 图像（即总共 25 + 20 = 45 个像素）。从技术上讲，我有很多可用的像素，但我不能将这些图像彼此相邻放置到大纹理中，因为这需要一个方向的最小尺寸为 9，而另一个方向的最小尺寸为 5。

如果我可以简单地将我的 8×8 纹理视为 64 个连续像素的内存并将两个图像映射到其中的 1D 内存块中，我可以在纹理中按如下方式排列图像： 8x8 纹理： 

   | 0 1 2 3 4 5 6 7
---+-----------------
 0 | A B C D E F G H
 1 | I J K L M N O P             
 2 | Q R S T U V W X
 3 | Y a b c d e f g             
 4 | h i j k l m n o             
 5 | p q r s t . . .
 6 | . . . . . . . .
 7 | . . . . . . . .

如果我以 1:1 的比例绘制所有图像，即任何地方都没有小数像素坐标，也不需要任何线性过滤或其他像素混合，是否可以提出一个可以用来绘制 4 ×5 图像使用此纹理？

使用顶点和片段着色器，这看起来可能相当容易（除非我忘记了什么；我还没有尝试过）：

  • 顶点着色器将要绘制的图像的四个角映射到以 64×1 图像表示的纹理：

    • a: (0, 0) → (0 + 0*4 + 25, 0) = (25, 0) 其中 25 是 4×5 图像的偏移量
    • d: (3, 0) → (3 + 0*4 + 25, 0) = (28, 0)
    • q: (0, 4) → (0 + 4*4 + 25, 0) = (41, 0)
    • t: (3, 4) → (3 + 4*4 + 25, 0) = (44, 0)

    纹理内其他坐标的插值应该（？）然后也映射到沿着这条线的正确偏移以获取整数坐标

  • 片段着色器通过简单地将除以 8 的商和余数，将这个 64×1 坐标转换为最终的 8×8 坐标，例如：
    • a: (0, 25) → (25 % 8, 25 / 8) = (1, 3)
    • d: (0, 28) → (28 % 8, 28 / 8) = (4, 3)
    • k: (0, 35) → (35 % 8, 35 / 8) = (3, 4)
    • q: (0, 41) → (41 % 8, 41 / 8) = (1, 5)
    • t: (0, 44) → (44 % 8, 44 / 8) = (4, 5)

不幸的是，自定义着色器需要 OpenGL ES v2.0 或更高版本，并非在所有设备上都可用。

是否有可能仅通过 OpenGL ES 1.1 提供的矩阵转换来实现这种映射？

4

1 回答 1

0

我还没有尝试过，但我想把它作为一个想法扔出去：

更新：我现在试过了，它只需一个小改动就可以很好地工作（见评论）！

假设我的大纹理具有宽度size，而我要绘制的图像具有宽度width并且从offset大纹理内部的偏移开始，偏移offset的一维表示在哪里，即x+ y* size。

那么，下面的 4x4 矩阵几乎可以实现这个映射：

     _                                           _
    |      1        width        offset      0    |
    |                                             |
    |   1/size   width/size   offset/size    0    |
M = |                                             |
    |      0          0            0         0    |
    |                                             |
    |_     0          0            0         1   _|

因此，在上面的示例中，要绘制 4×5 图像，矩阵将是

 _                    _
|   1    4    25    0  |
|  1/8  1/2  25/8   0  |
|   0    0     0    0  |
|_  0    0     0    1 _|

然后需要使用 4-vector 指定图像坐标，其中包含

( x, y, 1, 1 )

因此，例如k(ie (2,2)) 的坐标将映射到：

M*( 2, 2, 1, 1 ) => ( 35, 4.375, 0, 1 )

这将被解释为纹理坐标 (35, 4.375)。

如果我们现在打开最近邻作为插值规则并在 x 方向启用纹理环绕，这应该对应于：

( 3, 4 )

（我在这里使用整数坐标，而在最终实现中，最终坐标需要在 0 到 1 的范围内浮动。这可能很容易通过将1矩阵右下角的替换为 来实现size，因为这将最终在输出向量的第四个位置，从而划分其他三个。正如@chbaker0 指出的那样，这只有在纹理坐标受到通常的透视划分的情况下才有效。如果不是，整个矩阵M需要除size以来达到预期的结果。）

这听起来是否合理，或者在我继续尝试实施之前有人能看到这个问题吗？（可能需要几天时间，因为我必须先做一些其他事情才能获得可测试的应用程序......）

于 2015-05-21T04:11:33.963 回答