(针对这个问题,我正在尝试研究解决this other one的想法)

如果我在内存中有一个标准的2D数组,其尺寸为width和height,则可以将其转换为一个长度为width * height的一维数组,然后通过index = x y * width对其进行索引.在为阵列分配和释放内存时,此映射非常有用,因为内存管理器无需担心以2D打包结构,而只需担心以1D表示的每个已分配数组的总长度.

我正在尝试查看是否可以将这种方法用于OpenGL纹理的图像内存管理.这个想法(如上面的链接问题所述)是通过将bin-packing将一堆所需的纹理(即,将它们彼此相邻绘制)组合到一个较大的纹理中.这有助于最小化渲染过程中昂贵的纹理绑定操作.

假设我的大纹理是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内存块中,则可以在纹理内部按如下方式排列图像：

????8×8纹理：

| 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提供的矩阵转换来实现此映射？