Issue with Open GL VBO & Texturing (I guess)

Code:
// Sets up an array of values to use as the sprite vertices.

const GLfloat spriteVertices[] = {

-16.f, -16.f,

16.f, -16.f,

-16.f,  16.f,

16.f,  16.f

};



// Sets up an array of values for the texture coordinates.

const GLshort spriteTexcoords[] = {

0, 0,

1, 0,

0, -1,

1, -1,

};



const GLushort spriteIndexes[] = { 0, 1, 2, 3 };



- (void)setupView

{

    CGImageRef spriteImage;

    CGContextRef spriteContext;

    GLubyte *spriteData;

    size_t    width, height;

    

    // Sets up matrices and transforms for OpenGL ES

    glViewport(0, 0, backingWidth, backingHeight);

    

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    glOrthof(0.f, 480.0f, 320.0f, 0.0f, -1.0f, 1.0f);

    glMatrixMode(GL_MODELVIEW);

    

    glEnableClientState(GL_TEXTURE_COORD_ARRAY);

    glEnableClientState(GL_VERTEX_ARRAY);

    



    // Clears the view with black

    glClearColor(0.0f,0.0f, 0.0f, 1.0f);

    

    

    // Sets up pointers and enables states needed for using vertex arrays and textures

    glGenBuffers(1, &elementVerticesID);

    glBindBuffer(GL_ARRAY_BUFFER, elementVerticesID); 

    glBufferData(GL_ARRAY_BUFFER, sizeof(spriteVertices), spriteVertices, GL_STATIC_DRAW);   

    

    NSLog(@"sizeof texture coordinates: %d", sizeof(spriteTexcoords));

    glGenBuffers(1, &elementTextureCoordinatesID);

    glBindBuffer(GL_ARRAY_BUFFER, elementTextureCoordinatesID);

    glBufferData(GL_ARRAY_BUFFER, sizeof(spriteTexcoords), spriteTexcoords, GL_STATIC_DRAW);



    // Indexes

    glGenBuffers(1, &elementIndexesID);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementIndexesID);

    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(spriteIndexes), spriteIndexes, GL_STATIC_DRAW);

    

    // Creates a Core Graphics image from an image file

    spriteImage = [UIImage imageNamed:@"flower_green.png"].CGImage;

    

    // 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.



    if( spriteImage ) {

        // Get the width and height of the image

        width = CGImageGetWidth(spriteImage);

        height = CGImageGetHeight(spriteImage);

        

        if ( width < 64 || height < 64 ) width = height = 64;

        //NSLog(@"%d, %d", width, height);



        

        // Allocated memory needed for the bitmap context

        spriteData = (GLubyte *) malloc(width * height * 4);

        // Uses the bitmatp creation function provided by the Core Graphics framework. 

        //

        spriteContext = CGBitmapContextCreate(spriteData, width, height, 8, width * 4, CGImageGetColorSpace(spriteImage), kCGImageAlphaNoneSkipLast); //kCGImageAlphaPremultipliedLast);

        // After you create the context, you can draw the sprite image to the context.

        CGContextDrawImage(spriteContext, CGRectMake(0.0, 0.0, (CGFloat)width, (CGFloat)height), spriteImage);

        // You don't need the context at this point, so you need to release it to avoid memory leaks.

        CGContextRelease(spriteContext);

        

        // Use OpenGL ES to generate a name for the texture.

        glGenTextures(1, &spriteTextureID);

        // Bind the texture name. 

        glBindTexture(GL_TEXTURE_2D, spriteTextureID);

        // Speidfy a 2D texture image, provideing the a pointer to the image data in memory

        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_SHORT, spriteData);

        // Release the image data

        free(spriteData);

        

        // 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);

        

        // Enable use of the texture

        glEnable(GL_TEXTURE_2D);

        // Set a blending function to use

        glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

        // Enable blending

        glEnable(GL_BLEND);

    }

    



    

    glBindBuffer(GL_ARRAY_BUFFER, elementVerticesID); 

    glVertexPointer(2, GL_FLOAT, 0, 0); 

    

    glBindBuffer(GL_ARRAY_BUFFER, elementTextureCoordinatesID);

    glTexCoordPointer(2, GL_SHORT, 0, 0);

    

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementIndexesID);

}



int step;

// Updates the OpenGL view when the timer fires

- (void)drawView

{

    // Make sure that you are drawing to the current context

    [EAGLContext setCurrentContext:context];

    

    glBindFramebufferOES(GL_FRAMEBUFFER_OES, viewFramebuffer);

    glClear(GL_COLOR_BUFFER_BIT);



    for(int i = 0; i < 12; ++i)

    {

        for (int j = 0; j < 8; ++j)

        {

            glPushMatrix();



            glTranslatef((i * 40.) + 20., (j * 40.) + 20., 0.f);

            glRotatef((i + 1) * step, .0f, .0f, 1.0f);

            glScalef(1. + (i / 10.), 1. + (i / 10.), 1. + (i / 10.));

            

            glColor4f(1.f, 1.f, 1.f, 1.f);

            glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_SHORT, 0);

            

            glPopMatrix();

        }

    }

    

    glBindRenderbufferOES(GL_RENDERBUFFER_OES, viewRenderbuffer);

    [context presentRenderbuffer:GL_RENDERBUFFER_OES];

    

    ++step;

}