ios - ¿Cómo convierto este matemático de puntero OpenGL a Swift?

opengl-es glkit

Question

Estoy siguiendo este tutorial sobre OpenGL / GLKit para iOS pero tratando de implementarlo en Swift. Todo va bien hasta que llegue a esta parte:

- (void)render { 

// 1
self.effect.texture2d0.name = self.textureInfo.name;
self.effect.texture2d0.enabled = YES;

// 2    
[self.effect prepareToDraw];

// 3
glEnableVertexAttribArray(GLKVertexAttribPosition);
glEnableVertexAttribArray(GLKVertexAttribTexCoord0);

//---------------- This is where things break down...
long offset = (long)&_quad;        
glVertexAttribPointer(GLKVertexAttribPosition, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedVertex), (void *) (offset + offsetof(TexturedVertex, geometryVertex)));
glVertexAttribPointer(GLKVertexAttribTexCoord0, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedVertex), (void *) (offset + offsetof(TexturedVertex, textureVertex)));

// 5    
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

}

@end

Tengo una propiedad self.quad que es una estructura Swift como esta:

struct TexturedVertex {
let geometryVertex: CGPoint
let textureVertex: CGPoint
}

struct TexturedQuad {

let bottomLeft: TexturedVertex
let bottomRight: TexturedVertex
let topLeft: TexturedVertex
let topRight: TexturedVertex
}

Es una estructura bastante sencilla, pero no sé cómo pasarla al último argumento de glVertexAttribPointer . ¡Cualquier ayuda sería estelar!

Answer 1

En Swift, puede usar la estructura genérica UnsafePointer para realizar aritmética y fundición de puntero. Swift no tiene offsetof , pero puedes offsetof limpiamente tomando los UnsafePointer de los elementos geometryVertex y textureVertex directamente.

El siguiente código se compila en un área de juegos para iOS. No lo he probado más allá de eso, pero creo que funcionará:

import OpenGLES
import GLKit

struct TexturedVertex {
    var geometryVertex = GLKVector2()
    var textureVertex = GLKVector2()
}

struct TexturedQuad {
    var bl = TexturedVertex()
    var br = TexturedVertex()
    var tl = TexturedVertex()
    var tr = TexturedVertex()
    init() { }
}

var _quad = TexturedQuad()
withUnsafePointer(&_quad.bl.geometryVertex) { (pointer) -> Void in
    glVertexAttribPointer(GLuint(GLKVertexAttrib.Position.rawValue),
        2, GLenum(GL_FLOAT), GLboolean(GL_FALSE),
        GLsizei(sizeof(TexturedVertex)), pointer)
}
withUnsafePointer(&_quad.bl.textureVertex) { (pointer) -> Void in
    glVertexAttribPointer(GLuint(GLKVertexAttrib.TexCoord0.rawValue),
        2, GLenum(GL_FLOAT), GLboolean(GL_FALSE),
        GLsizei(sizeof(TexturedVertex)), pointer)
}

Por cierto, usar CGPoint como lo hizo en su pregunta es peligroso, porque CGFloat cambia de tamaño dependiendo de su objetivo (32 bits o 64 bits), pero GL_FLOAT siempre significa 32 bits. El tutorial que estás siguiendo se escribió antes de que saliera iOS de 64 bits.