Mappage des couleurs d'une texture en opengl

Question

J'affiche une texture que je souhaite manipuler sans affecter les données d'image. Je souhaite pouvoir verrouiller les valeurs de texel de sorte que tout ce qui se trouve en dessous de la valeur inférieure devienne 0, tout ce qui se trouve au-dessus de la valeur supérieure devienne 0 et tout ce qui se trouve entre les deux est mappé linéairement de 0 à 1.

À l'origine, pour afficher mon image, j'utilisais glDrawPixels. Et pour résoudre le problème ci-dessus, je créerais une carte de couleurs en utilisant glPixelMap. Cela a fonctionné à merveille. Cependant, pour des raisons de performances, j'ai commencé à utiliser des textures pour afficher mon image. L'approche glPixelMap ne semble plus fonctionner. Eh bien, cette approche peut fonctionner mais j’ai été incapable de la faire fonctionner.

J'ai ensuite essayé d'utiliser glPixelTransfer pour définir des échelles et des biais. Cela semblait avoir une sorte d'effet (pas nécessairement souhaité) au premier passage, mais lorsque les contraintes supérieures et inférieures étaient modifiées, aucun effet n'était visible.

On m'a alors dit que les fragmenteurs fonctionneraient. Mais après un appel à glGetString (GL_EXTENSIONS), j'ai constaté que GL_ARB_fragment_shader n'était pas pris en charge. De plus, un appel à glCreateShaderObjectARB provoque une exception nullreference.

Alors maintenant, je suis désemparé. Que devrais-je faire? S'il vous plaît aider.

Quel que soit le résultat, je suis disposé à essayer. Le fournisseur est Intel et le moteur de rendu est Intel 945G. Je suis malheureusement limité à une carte graphique intégrée à la carte mère et qui n’a que gl 1.4.

Merci pour votre réponse jusqu'à présent.

Answer 1

À moins que vous n'ayez une carte graphique assez ancienne, il est surprenant de ne pas avoir le support de fragment shader. Je vous suggèrerais d'essayer de vérifier à l'aide de this .

De plus, êtes-vous sûr de vouloir que tout ce qui dépasse la valeur maximale soit 0? Peut-être que vous vouliez dire 1? Si vous ne vouliez dire que 1 et non 0, il existe des moyens assez longs de faire ce que vous demandez.

La réponse condensée est que vous utilisez plusieurs passes de rendu. D'abord, vous rendez l'image à une intensité normale. Ensuite, vous utilisez un mélange soustractif (recherchez glBlendEquation) pour soustraire votre valeur minimale. Ensuite, vous utilisez un mélange additif pour tout multiplier par 1 / (max-min) (qui peut nécessiter plusieurs passes).

Si vous voulez vraiment faire cela, envoyez en retour le GL_VENDOR et le GL_RENDERER pour votre carte graphique.

Modifier: Hmm. Les processeurs Intel 945G ne disposent pas de ARB_fragment_shader , mais du ARB_fragment_program qui fera également l'affaire.

Votre fragment-code devrait ressembler à quelque chose comme ça (mais ça fait longtemps que je n’ai pas écrit, donc ça a probablement été buggé)

!!ARBfp1.0
ATTRIB tex = fragment.texcoord[0]
PARAM cbias = program.local[0]
PARAM cscale = program.local[1]
OUTPUT cout = result.color

TEMP tmp
TXP tmp, tex, texture[0], 2D
SUB tmp, tmp, cbias
MUL cout, tmp, cscale

END 

Vous chargez ceci dans OpenGL comme suit:

GLuint prog;
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glGenProgramsARB(1, &prog);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prog);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(src), src);
glDisable(GL_FRAGMENT_PROGRAM_ARB);

Ensuite, avant de rendre votre géométrie, procédez comme suit:

glEnable(GL_FRAGMENT_PROGRAM_ARB);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prog);
colour4f cbias = cmin;
colour4f cscale = 1.0f / (cmax-cmin);
glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 0, cbias.r, cbias.g, cbias.b, cbias.a);
glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 1, cscale.r, cscale.g, cscale.b, cscale.a);

//Draw your textured geometry

glDisable(GL_FRAGMENT_PROGRAM_ARB);

Answer 2

Vérifiez également si l'extension GL_ARB_fragment_program est prise en charge. Cette extension prend en charge les programmes fragmentés de style ASM. Cela est supposé être supporté dans OpenGL 1.4.

Answer 3

Il est vraiment regrettable que vous utilisiez une version aussi ancienne d’OpenGL. Pouvez-vous mettre à niveau avec votre carte?

Pour un OGL 2.x plus moderne, c’est exactement le type de programme pour lequel GLSL est conçu. Une excellente documentation peut être trouvée ici:

Documentation OpenGL

Langage d'ombrage OpenGL