Comment puis-je ajuster la teinte pour plusieurs UIImageVIews sur l'iPhone?

Question

Je suis tombé sur ce qui semblait être un problème très simple, mais j'ai passé de nombreuses heures à essayer de comprendre et de ne pas trouver de solution.

Je travaille avec l'exemple de code GLImageProcessing d'Apple et l'ai simplifié pour afficher un EAGLView avec un UISlider qui ajuste la teinte d'une image. J'ai modifié EAGLView pour hériter de UIImageView afin que je puisse avoir un peu plus de contrôle sur l'image affichée. Cela fonctionne bien. Le problème vient quand j'essaye d'ajouter une deuxième image à l'écran. Idéalement, j'aimerais avoir une image de fond et plusieurs autres images affichées et que le curseur de teinte change simultanément la teinte de chacune d'entre elles. Cependant, lorsque j'essaie d'ajouter une deuxième image à l'écran, la première image devient une simple vue en noir et devient une ombre de violet lorsque je bouge le curseur, mais je ne réponds pas. La nouvelle vue fonctionne comme prévu. Si je devais ajouter un troisième, les deux premiers seraient non fonctionnels, et le troisième fonctionnerait correctement.

Je pense que ce que je veux faire est d'avoir un EAGLView et d'ajouter des textures pour les nouvelles images, mais rien ne semble fonctionner. Toute aide pour me diriger dans la bonne direction serait très appréciée. Merci!

De ViewController.h. Code pour ajouter une nouvelle sous-vue EAGLView dans la méthode viewDidLoad. Il y a déjà une autre vue chargée de la pointe:

- (void)viewDidLoad 
{ 

    UIImage *img = [UIImage imageNamed:@"Image.png"]; 
    EAGLView *newView = [[EAGLView alloc] initWithImage:img texID:0]; 
    self.view2 = newView; 
    self.view2.frame = CGRectMake(110, 110, 100, 100); 
    [self.view addSubview:self.view2]; 
    [newView release]; 

} 

Et simple IBAction tiré sur la valeur modifiée:

- (void)sliderAction:(id)sender 
{ 
    [self.imageView drawViewWithSliderValue:self.slider.value]; 
    [self.view2 drawViewWithSliderValue:self.slider.value]; 
} 

De EAGLView.h, c'est le EAGLView code d'initialisation et le code de tirage. Il est presque le même que l'exemple de code, sauf qu'il vous permet de passer d'une image dans votre InitGL:

-(id) initializeEAGLwithTexID:(int)texID{ 
    // Get the layer 
    CAEAGLLayer *eaglLayer = (CAEAGLLayer *)self.layer; 
    eaglLayer.opaque = YES; 
    eaglLayer.drawableProperties = [NSDictionary dictionaryWithObjectsAndKeys: 
              [NSNumber numberWithBool:NO], kEAGLDrawablePropertyRetainedBacking, 
              kEAGLColorFormatRGBA8, kEAGLDrawablePropertyColorFormat, 
              nil]; 

    context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES1];   
    if (!context || ![EAGLContext setCurrentContext:context]) 
    { 
      [self release]; 
      return nil; 
    } 

    // Create system framebuffer object. The backing will be allocated in -reshapeFramebuffer 
    glGenFramebuffersOES(1, &viewFramebuffer[texID]); 
    glGenRenderbuffersOES(1, &viewRenderbuffer[texID]); 
    glBindFramebufferOES(GL_FRAMEBUFFER_OES, viewFramebuffer[texID]); 
    glBindRenderbufferOES(GL_RENDERBUFFER_OES, viewRenderbuffer[texID]); 
    glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, viewRenderbuffer[texID]); 

    // Perform additional one-time GL initialization 
    UIImage *myImage = self.image; 
    NSLog(@"holding image of width: %f height %f", myImage.size.width, myImage.size.height); 
    CGImageRef imageRef = myImage.CGImage; 
    initGL(imageRef, texID); 
    return self; 
} 

-(id) initWithImage:(UIImage *)image texID:(int)texID{ 
    if((self = [super initWithImage:image])){ 
      self.opaque = YES; 
      self.contentMode = UIViewContentModeScaleToFill; 
      [self initializeEAGLwithTexID:texID]; 

    } 
    return self; 
} 

- (void)drawViewWithSliderValue:(float)value; 
{ 
    drawGL(backingWidth, backingHeight, value, currentID); 
    [context presentRenderbuffer:GL_RENDERBUFFER_OES]; 
} 

De Imaging.c, le code InitGL et drawGL. J'ai modifié le code pour gérer les tableaux pour traiter plusieurs textures. Je suis relativement sûr un tas de tableaux créés ici ne sont pas nécessaires, mais comme ils ne sont pas quoi que ce soit mal, ne l'ai pas essayé d'enlever tout encore:

void initGL(CGImageRef myImage, int currID) 
{ 
    int i; 

    // Query renderer capabilities that affect this app's rendering paths 
    renderer[currID].extension[APPLE_texture_2D_limited_npot] = 
      (0 != strstr((char *)glGetString(GL_EXTENSIONS), "GL_APPLE_texture_2D_limited_npot")); 
    renderer[currID].extension[IMG_texture_format_BGRA8888] = 
      (0 != strstr((char *)glGetString(GL_EXTENSIONS), "GL_IMG_texture_format_BGRA8888")); 

    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &renderer[currID].maxTextureSize); 

    // Constant state for the lifetime of the app-- position and unit0 are always used 
    glEnableClientState(GL_VERTEX_ARRAY); 
    glEnableClientState(GL_TEXTURE_COORD_ARRAY); 
    glEnable(GL_TEXTURE_2D); 
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 

    // Load image into texture 
    loadTexture(myImage, &Input[currID], &renderer[currID], currID); 

    // Modify quad texcoords to match (possibly padded) image 
    for (i = 0; i < 4; i++) 
    { 
      fullquad[i].s *= Input[currID].s; 
      fullquad[i].t *= Input[currID].t; 
      flipquad[i].s *= Input[currID].s; 
      flipquad[i].t *= Input[currID].t; 
    } 

    // Create 1x1 for default constant texture 
    // To enable a texture unit, a valid texture has to be bound even if the combine modes do not access it 
    GLubyte half[3][4] = {{ 0x80, 0x80, 0x80, 0x80 },{ 0x80, 0x80, 0x80, 0x80 },{ 0x80, 0x80, 0x80, 0x80 }}; 
    glActiveTexture(GL_TEXTURE1); 


    glGenTextures(1, &Half[currID].texID); 
    Half[currID].wide = Half[currID].high = 1; 
    Half[currID].s = Half[currID].t = 1.0; 
    glBindTexture(GL_TEXTURE_2D, Half[currID].texID); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 


    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, half[currID]); 
    glActiveTexture(GL_TEXTURE0); 

    // Remember the FBO being used for the display framebuffer 
    glGetIntegerv(GL_FRAMEBUFFER_BINDING_OES, (GLint *)&SystemFBO[currID]); 

    // Create scratch textures and FBOs 
    glGenTextures(1, &Degen[currID].texID); 
    Degen[currID].wide = Input[currID].wide; 
    Degen[currID].high = Input[currID].high; 
    Degen[currID].s = Input[currID].s; 
    Degen[currID].t = Input[currID].t; 
    glBindTexture(GL_TEXTURE_2D, Degen[currID].texID); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, Degen[currID].wide, Degen[currID].high, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 
    glGenFramebuffersOES(1, &DegenFBO[currID]); 
    glBindFramebufferOES(GL_FRAMEBUFFER_OES, DegenFBO[currID]); 
    glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_TEXTURE_2D, Degen[currID].texID, 0); 

    glGenTextures(1, &Scratch[currID].texID); 
    Scratch[currID].wide = Input[currID].wide; 
    Scratch[currID].high = Input[currID].high; 
    Scratch[currID].s = Input[currID].s; 
    Scratch[currID].t = Input[currID].t; 
    glBindTexture(GL_TEXTURE_2D, Scratch[currID].texID); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, Scratch[currID].wide, Scratch[currID].high, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 
    glGenFramebuffersOES(1, &ScratchFBO[currID]); 
    glBindFramebufferOES(GL_FRAMEBUFFER_OES, ScratchFBO[currID]); 
    glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_TEXTURE_2D, Scratch[currID].texID, 0); 
    glBindFramebufferOES(GL_FRAMEBUFFER_OES, SystemFBO[currID]); 
} 

void drawGL(int wide, int high, float val, int currID) 
{ 

    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity(); 
    glOrthof(0, wide, 0, high, -1, 1); 
    glMatrixMode(GL_MODELVIEW); 
    glLoadIdentity(); 
    glScalef(wide, high, 1); 

    glBindTexture(GL_TEXTURE_2D, Input[currID].texID); 

    // Render filtered image to system framebuffer 
    glViewport(0, 0, wide, high); 

    hue(flipquad, val); 

} 

Answer 1

Peut-être que l'iPhone OS prend en charge qu'une seule vue Open GL à temps?