Texture du carrelage dans le shader

Question

Je passe aux textures de vertex shader (glsl) 2: à partir de l'écran et plus petit, normalmap. Normalmap est mis à l'échelle pour la taille de l'écran. Donc, si la première texture est 1152×864 pixels et normalmap est 256×256, elle sera mise à l'échelle de sa taille à la plus grande.

Comment puis-je le faire en mosaïque? Par exemple. faire la taille comme 256×256 et carreler à travers toute la texture.

---

UPD:

Par exemple, mon principal (grand) texture est mappée comme ceci:

[0.17, 0.61, 0.33, 0.83] 

Au lieu de:

[0, 0, 1, 1] 

De cette façon, ma normale la texture est mappée pour les premières coordonnées aussi. Je vois donc un petit rectangle mappé. Comment puis-je le mapper en shader pour la taille réelle?

Answer 1

sa taille sera agrandie.

Non, ce n'est certainement pas le cas. C'est un malentendu commun sur les textures. Les textures ne sont rien de plus que des tables de recherche sophistiquées. Les textures ne sont pas "mises à l'échelle" les unes par rapport aux autres; c'est simplement une question de coordonnées de texture que vous utilisez.

Selon toute probabilité, ce que vous faites est d'utiliser la même coordonnée de texture pour la texture de l'écran que votre carte normale. Comme nous parlons probablement de coordonnées de texture normalisées, cela signifie que vous mappez la même plage [0, 1] sur les deux. Pour obtenir l'effet dont vous parlez, vous devez calculer les coordonnées de texture pour votre texture normale et faire ce que vous avez besoin de faire. Donc, si vous avez une coordonnée de texture qui est relative à la texture de l'écran, vous devez la transformer en l'espace que vous voulez pour la texture normale.

Il y a plusieurs façons de le faire. La méthode manuelle consiste à calculer le rapport des tailles des textures entre elles sur la CPU, puis à les passer au shader. En utilisant les nombres que vous avez donnés, les rapports de taille seraient:

(1152.0/256.0, 864.0/256.0) = (4.5, 3.375). 

Assurez-vous que cela est fait en mathématiques à virgule flottante. Une fois cela fait, il suffit de passer le long de cette manière uniforme et multiplier les coordonnées de texture de ce rapport dans le shader avant l'échantillonnage:

uniform vec2 textureRatio; 

void main() { 
//Get the texture coordinate. 
vec4 screenTexColor = texture(screenTex, texCoord); 
vec2 normTexCoord = textureRatio * texCoord; 
vec4 normalValue = texture(normalTex, normTexCoord); 
//Do something with these. 
} 

La façon automatique dans GLSL est de le faire directement dans le matériau. Cela nécessite GLSL 1.30 ou mieux. Fondamentalement, vous utilisez les fonctions disponibles de la langue pour calculer le rapport:

void main() { 
//Get the texture coordinate. 
vec2 textureRatio = textureSize(screenTex)/textureSize(normalTex); 
vec4 screenTexColor = texture(screenTex, texCoord); 
vec2 normTexCoord = textureRatio * texCoord; 
vec4 normalValue = texture(normalTex, normTexCoord); 
//Do something with these. 
} 

Dans ces deux cas, je suppose que votre GL_TEXTURE_WRAP_S/T sont mis à GL_REPEAT avec des paramètres de texture ou échantillonneur appropriés. Notez que le calcul du ratio sur le processeur et son passage en tant qu'adaptateur seront probablement plus rapides que le calcul dans le shader. Particulièrement pour les shaders fragmentés, qui seront très bien gérés.