Diferencias de carga de la textura del iPad (32 bits vs. 64 bits)

Estoy trabajando en una aplicación de dibujo y noto diferencias significativas en las texturas cargadas en un iPad de 32 bits frente a un iPad de 64 bits.

Aquí está la textura dibujada en un iPad de 32 bits:

introduzca la descripción de la imagen aquí

Aquí está la textura dibujada en un iPad de 64 bits:

introduzca la descripción de la imagen aquí

El 64 bits es lo que deseo, pero parece que tal vez está perdiendo algunos datos.

Creo una textura de pincel pnetworkingeterminada con este código:

UIGraphicsBeginImageContext(CGSizeMake(64, 64)); CGContextRef defBrushTextureContext = UIGraphicsGetCurrentContext(); UIGraphicsPushContext(defBrushTextureContext); size_t num_locations = 3; CGFloat locations[3] = { 0.0, 0.8, 1.0 }; CGFloat components[12] = { 1.0,1.0,1.0, 1.0, 1.0,1.0,1.0, 1.0, 1.0,1.0,1.0, 0.0 }; CGColorSpaceRef myColorspace = CGColorSpaceCreateDeviceRGB(); CGGradientRef myGradient = CGGradientCreateWithColorComponents (myColorspace, components, locations, num_locations); CGPoint myCentrePoint = CGPointMake(32, 32); float myRadius = 20; CGGradientDrawingOptions options = kCGGradientDrawsBeforeStartLocation | kCGGradientDrawsAfterEndLocation; CGContextDrawRadialGradient (UIGraphicsGetCurrentContext(), myGradient, myCentrePoint, 0, myCentrePoint, myRadius, options); CFRelease(myGradient); CFRelease(myColorspace); UIGraphicsPopContext(); [self setBrushTexture:UIGraphicsGetImageFromCurrentImageContext()]; UIGraphicsEndImageContext(); 

Y luego, de hecho, establece la textura del pincel como esta:

 -(void) setBrushTexture:(UIImage*)brushImage{ // save our current texture. currentTexture = brushImage; // first, delete the old texture if needed if (brushTexture){ glDeleteTextures(1, &brushTexture); brushTexture = 0; } // fetch the cgimage for us to draw into a texture CGImageRef brushCGImage = brushImage.CGImage; // Make sure the image exists if(brushCGImage) { // Get the width and height of the image GLint width = CGImageGetWidth(brushCGImage); GLint height = CGImageGetHeight(brushCGImage); // Texture dimensions must be a power of 2. If you write an application that allows users to supply an image, // you'll want to add code that checks the dimensions and takes appropriate action if they are not a power of 2. // Allocate memory needed for the bitmap context GLubyte* brushData = (GLubyte *) calloc(width * height * 4, sizeof(GLubyte)); // Use the bitmatp creation function provided by the Core Graphics framework. CGContextRef brushContext = CGBitmapContextCreate(brushData, width, height, 8, width * 4, CGImageGetColorSpace(brushCGImage), kCGImageAlphaPremultipliedLast); // After you create the context, you can draw the image to the context. CGContextDrawImage(brushContext, CGRectMake(0.0, 0.0, (CGFloat)width, (CGFloat)height), brushCGImage); // You don't need the context at this point, so you need to release it to avoid memory leaks. CGContextRelease(brushContext); // Use OpenGL ES to generate a name for the texture. glGenTextures(1, &brushTexture); // Bind the texture name. glBindTexture(GL_TEXTURE_2D, brushTexture); // Set the texture parameters to use a minifying filter and a linear filer (weighted average) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // Specify a 2D texture image, providing the a pointer to the image data in memory glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, brushData); // Release the image data; it's no longer needed free(brushData); } } 

Actualizar:

He actualizado CGFloats para ser GLfloats sin éxito. ¿Tal vez hay un problema con este código de representación?

 if(frameBuffer){ // draw the stroke element [self prepOpenGLStateForFBO:frameBuffer]; [self prepOpenGLBlendModeForColor:element.color]; CheckGLError(); } // find our screen scale so that we can convert from // points to pixels GLfloat scale = self.contentScaleFactor; // fetch the vertex data from the element struct Vertex* vertexBuffer = [element generatedVertexArrayWithPreviousElement:previousElement forScale:scale]; glLineWidth(2); // if the element has any data, then draw it if(vertexBuffer){ glVertexPointer(2, GL_FLOAT, sizeof(struct Vertex), &vertexBuffer[0].Position[0]); glColorPointer(4, GL_FLOAT, sizeof(struct Vertex), &vertexBuffer[0].Color[0]); glTexCoordPointer(2, GL_FLOAT, sizeof(struct Vertex), &vertexBuffer[0].Texture[0]); glDrawArrays(GL_TRIANGLES, 0, (GLint)[element numberOfSteps] * (GLint)[element numberOfVerticesPerStep]); CheckGLError(); } if(frameBuffer){ [self unprepOpenGLState]; } 

La estructura de vértice es la siguiente:

 struct Vertex{ GLfloat Position[2]; // x,y position GLfloat Color [4]; // rgba color GLfloat Texture[2]; // x,y texture coord }; 

Actualizar:

El problema en realidad no parece ser de 32 bits, basado en 64 bits, sino algo diferente de los controlleres A7 GPU y GL. Descubrí esto ejecutando una compilation de 32 bits y compilation de 64 bits en el iPad de 64 bits. Las texturas terminaron pareciendo exactamente iguales en ambas versiones de la aplicación.

Me gustaría que verifiques dos cosas.

  1. Verifique su lógica (u opción) de mezcla alfa en OpenGL.

  2. Verifique su lógica de interpolación, que es proporcional a la velocidad de arrastre.

Parece que no tienes segundo ni no es efectivo lo que se requiere para dibujar la aplicación

No creo que el problema esté en la textura sino en el búfer de fotogtwigs al que compiló los elementos de línea.

Sus fragments de código parecen dibujar segmentos por segmento, por lo que hay varios segmentos superpuestos dibujados uno encima del otro. Si la profundidad de la memory intermedia de cuadros es baja, habrá artefactos, especialmente en las regiones más claras de las áreas combinadas.

Puede verificar el búfer de ttwig utilizando el depurador de OpenGL de Xcode. Actívelo ejecutando tu código en el dispositivo y haz clic en el pequeño button "Captura de OpenGL ES Frame": Captura marco OpenGL ES .

Seleccione un command "glBindFramebuffer" en el "Debug Navigator" y observe la descripción del búfer de ttwig en el área de la console:

descripción del búfer de fotograma

La parte interesante es GL_FRAMEBUFFER_INTERNAL_FORMAT .

En mi opinión, el problema está en el modo de fusión que usa al componer pases de imágenes diferentes. Supongo que carga la textura solo para mostrar y mantiene la image en memory donde compuso diferentes operaciones de dibujo, o lee el contenido de la image usando glReadPixels? Básicamente, sus segundas imágenes aparecen como una image alfa recta dibujada como una image alfa pre-multiplicada. Para asegurarse de que no es un problema de textura, guarde una NSImage en el file antes de cargarla en la textura, y verifique que la image sea realmente correcta.