RSS

(root)/iphone/common : 74 : source/VertexArray.m

To get this branch, use:
bzr branch /browse/iphone/common

« back to all changes in this revision

Viewing changes to source/VertexArray.m

Dömötör Gulyás
2010-08-14 00:28:38
Revision ID: dognotdog@gmail.com-20100813222838-6csktimwtfzq66fl
fixes CGPoint rotation; makes VertexArray accept other vertex formats

Show diffs side-by-side

added added

removed removed

source/VertexArray.m
421
421
        if (osVersion >= 4.0f)
422
422
                useVAO = YES;
423
423
 
 
424
        needsVertexBufferUpdate = YES;
 
425
        needsIndexBufferUpdate = YES;
 
426
 
424
427
        return self;
425
428
}
426
429
 
465
468
        if (osVersion >= 4.0f)
466
469
                useVAO = YES;
467
470
 
 
471
        needsVertexBufferUpdate = YES;
 
472
        needsIndexBufferUpdate = YES;
 
473
 
468
474
        return self;
469
475
}
470
476
 
575
581
        if (!vertexBufferName)
576
582
        {
577
583
                glGenBuffers(1, &vertexBufferName);
 
584
        }
 
585
        if (needsVertexBufferUpdate)
 
586
        {
578
587
                glBindBuffer(GL_ARRAY_BUFFER, vertexBufferName);
579
588
                glBufferData(GL_ARRAY_BUFFER, _sizeofFormat(vertexFormat)*numVertices, _vertices, usageHint);
580
589
                glBindBuffer(GL_ARRAY_BUFFER, 0);
581
 
                
582
 
                if (numIndices)
583
 
                {
584
 
                        glGenBuffers(1, &indexBufferName);
585
 
                        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferName);
586
 
                        glBufferData(GL_ELEMENT_ARRAY_BUFFER, 2*numIndices, indices, usageHint);
587
 
                        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
588
 
                }
589
 
        }
 
590
                needsVertexBufferUpdate = NO;
 
591
        }
 
592
        if (!indexBufferName && numIndices)
 
593
        {
 
594
                glGenBuffers(1, &indexBufferName);
 
595
        }
 
596
        if (indexBufferName && needsIndexBufferUpdate)
 
597
        {
 
598
                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferName);
 
599
                glBufferData(GL_ELEMENT_ARRAY_BUFFER, 2*numIndices, indices, usageHint);
 
600
                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 
601
                needsIndexBufferUpdate = NO;
 
602
        }
 
603
 
590
604
        if (!vertexArrayObject && useVAO)
591
605
        {
592
606
                glGenVertexArraysOES(1, &vertexArrayObject);
603
617
 
604
618
- (void) convertTriangleIndicesToLines
605
619
{
606
 
        uint16_t* tris = indices;
607
 
        indices = calloc(sizeof(*indices), numIndices*2);
608
 
        
609
 
        for (size_t i = 0; i < numIndices/3; ++i)
 
620
        uint16_t* tris = NULL;
 
621
        @synchronized(self)
610
622
        {
611
 
                indices[6*i+0] = tris[3*i+0];
612
 
                indices[6*i+1] = tris[3*i+1];
613
 
                indices[6*i+2] = tris[3*i+1];
614
 
                indices[6*i+3] = tris[3*i+2];
615
 
                indices[6*i+4] = tris[3*i+2];
616
 
                indices[6*i+5] = tris[3*i+0];
 
623
                tris = indices;
 
624
                indices = calloc(sizeof(*indices), numIndices*2);
 
625
                
 
626
                for (size_t i = 0; i < numIndices/3; ++i)
 
627
                {
 
628
                        indices[6*i+0] = tris[3*i+0];
 
629
                        indices[6*i+1] = tris[3*i+1];
 
630
                        indices[6*i+2] = tris[3*i+1];
 
631
                        indices[6*i+3] = tris[3*i+2];
 
632
                        indices[6*i+4] = tris[3*i+2];
 
633
                        indices[6*i+5] = tris[3*i+0];
 
634
                }
 
635
                numIndices *= 2;
 
636
                mode = GL_LINES;
 
637
                needsIndexBufferUpdate = YES;
617
638
        }
618
 
        numIndices *= 2;
619
 
        mode = GL_LINES;
620
639
        free(tris);
621
640
}
622
641
- (void) convertPseudoQuadIndicesToLines
623
642
{
624
 
        uint16_t* tris = indices;
625
 
        indices = calloc(sizeof(*indices), numIndices*2);
626
 
        size_t ii = 0;
627
 
        for (size_t i = 0; i < numIndices/3; ++i)
 
643
        uint16_t* tris = NULL;
 
644
        @synchronized(self)
628
645
        {
629
 
                indices[ii++] = tris[3*i+0];
630
 
                indices[ii++] = tris[3*i+1];
631
 
                indices[ii++] = tris[3*i+2];
632
 
                indices[ii++] = tris[3*i+0];
 
646
                tris = indices;
 
647
                indices = calloc(sizeof(*indices), numIndices*2);
 
648
                size_t ii = 0;
 
649
                for (size_t i = 0; i < numIndices/3; ++i)
 
650
                {
 
651
                        indices[ii++] = tris[3*i+0];
 
652
                        indices[ii++] = tris[3*i+1];
 
653
                        indices[ii++] = tris[3*i+2];
 
654
                        indices[ii++] = tris[3*i+0];
 
655
                }
 
656
                numIndices = ii;
 
657
                mode = GL_LINES;
 
658
                needsIndexBufferUpdate = YES;
633
659
        }
634
 
        numIndices = ii;
635
 
        mode = GL_LINES;
636
660
        free(tris);
637
661
}
638
662
 
639
663
 
640
664
- (void) draw
641
665
{
642
 
        if (!vertexBufferName)
 
666
        @synchronized(self)
 
667
        {
 
668
 
643
669
                [self generateVBO];
644
670
 
645
 
        if (useVAO)
646
 
        {
647
 
                glBindVertexArrayOES(vertexArrayObject);
648
 
        }
649
 
        else
650
 
        {
651
 
                [self setupArrayState];
652
 
        }
653
 
        
654
 
        if (!indexBufferName)
655
 
                glDrawArrays(mode, 0, numVertices);
656
 
        else
657
 
                glDrawElements(mode, numIndices, GL_UNSIGNED_SHORT, (void*)0);
658
 
                
659
 
                
 
671
                if (useVAO)
 
672
                {
 
673
                        glBindVertexArrayOES(vertexArrayObject);
 
674
                }
 
675
                else
 
676
                {
 
677
                        [self setupArrayState];
 
678
                }
 
679
                
 
680
                if (!indexBufferName)
 
681
                        glDrawArrays(mode, 0, numVertices);
 
682
                else
 
683
                        glDrawElements(mode, numIndices, GL_UNSIGNED_SHORT, (void*)0);
 
684
                
 
685
        }
 
686
 
660
687
        if (useVAO)
661
688
                glBindVertexArrayOES(0);
662
689
        
669
696
 
670
697
- (void) applyVertexTransform: (m16) m
671
698
{
672
 
        switch (vertexFormat)
 
699
        @synchronized(self)
673
700
        {
674
 
                case VA_FORMAT_POS3F_NORMAL3F_TEX2F:
675
 
                {
676
 
                        PositionNormalTex3f3f2f* vertices = _vertices;
677
 
                        for (size_t i = 0; i < numVertices; ++i)
678
 
                        {
679
 
                                v3 v = {{vertices[i].pos[0], vertices[i].pos[1], vertices[i].pos[2]}};
680
 
                                v = mtransformpos3(m, v);
681
 
                                vertices[i].pos[0] = v.a[0];
682
 
                                vertices[i].pos[1] = v.a[1];
683
 
                                vertices[i].pos[2] = v.a[2];
684
 
                        }
685
 
                        
686
 
                        break;
687
 
                }
688
 
                case VA_FORMAT_POS3F_TEX2F:
689
 
                {
690
 
                        PositionTex3f2f* vertices = _vertices;
691
 
                        for (size_t i = 0; i < numVertices; ++i)
692
 
                        {
693
 
                                v3 v = {{vertices[i].pos[0], vertices[i].pos[1], vertices[i].pos[2]}};
694
 
                                v = mtransformpos3(m, v);
695
 
                                vertices[i].pos[0] = v.a[0];
696
 
                                vertices[i].pos[1] = v.a[1];
697
 
                                vertices[i].pos[2] = v.a[2];
698
 
                        }
699
 
                        
700
 
                        break;
701
 
                }
702
 
                case VA_FORMAT_POS3F:
703
 
                {
704
 
                        Position3f* vertices = _vertices;
705
 
                        for (size_t i = 0; i < numVertices; ++i)
706
 
                        {
707
 
                                v3 v = {{vertices[i].pos[0], vertices[i].pos[1], vertices[i].pos[2]}};
708
 
                                v = mtransformpos3(m, v);
709
 
                                vertices[i].pos[0] = v.a[0];
710
 
                                vertices[i].pos[1] = v.a[1];
711
 
                                vertices[i].pos[2] = v.a[2];
712
 
                        }
713
 
                        
714
 
                        break;
715
 
                }
716
 
                default:
717
 
                        assert(0);
 
701
                switch (vertexFormat)
 
702
                {
 
703
                        case VA_FORMAT_POS3F_NORMAL3F_TEX2F:
 
704
                        {
 
705
                                PositionNormalTex3f3f2f* vertices = _vertices;
 
706
                                for (size_t i = 0; i < numVertices; ++i)
 
707
                                {
 
708
                                        v3 v = {{vertices[i].pos[0], vertices[i].pos[1], vertices[i].pos[2]}};
 
709
                                        v = mtransformpos3(m, v);
 
710
                                        vertices[i].pos[0] = v.a[0];
 
711
                                        vertices[i].pos[1] = v.a[1];
 
712
                                        vertices[i].pos[2] = v.a[2];
 
713
                                }
 
714
                                
 
715
                                break;
 
716
                        }
 
717
                        case VA_FORMAT_POS3F_TEX2F:
 
718
                        {
 
719
                                PositionTex3f2f* vertices = _vertices;
 
720
                                for (size_t i = 0; i < numVertices; ++i)
 
721
                                {
 
722
                                        v3 v = {{vertices[i].pos[0], vertices[i].pos[1], vertices[i].pos[2]}};
 
723
                                        v = mtransformpos3(m, v);
 
724
                                        vertices[i].pos[0] = v.a[0];
 
725
                                        vertices[i].pos[1] = v.a[1];
 
726
                                        vertices[i].pos[2] = v.a[2];
 
727
                                }
 
728
                                
 
729
                                break;
 
730
                        }
 
731
                        case VA_FORMAT_POS3F:
 
732
                        {
 
733
                                Position3f* vertices = _vertices;
 
734
                                for (size_t i = 0; i < numVertices; ++i)
 
735
                                {
 
736
                                        v3 v = {{vertices[i].pos[0], vertices[i].pos[1], vertices[i].pos[2]}};
 
737
                                        v = mtransformpos3(m, v);
 
738
                                        vertices[i].pos[0] = v.a[0];
 
739
                                        vertices[i].pos[1] = v.a[1];
 
740
                                        vertices[i].pos[2] = v.a[2];
 
741
                                }
 
742
                                
 
743
                                break;
 
744
                        }
 
745
                        default:
 
746
                                assert(0);
 
747
                }
 
748
                needsVertexBufferUpdate = YES;
718
749
        }
719
 
        if (vertexBufferName)
720
 
                glDeleteBuffers(1, &vertexBufferName);
721
 
        vertexBufferName = 0;
722
 
        if (indexBufferName)
723
 
                glDeleteBuffers(1, &indexBufferName);
724
 
        indexBufferName = 0;
725
750
}
726
751
 
727
752
- (void) disposeOfNormals
728
753
{
729
 
        switch (vertexFormat)
 
754
        @synchronized(self)
730
755
        {
731
 
                case VA_FORMAT_POS3F_NORMAL3F_TEX2F:
732
 
                {
733
 
                        PositionNormalTex3f3f2f* vertices = _vertices;
734
 
                        PositionTex3f2f* nvertices = calloc(_sizeofFormat(VA_FORMAT_POS3F_TEX2F),numVertices);
735
 
                        for (size_t i = 0; i < numVertices; ++i)
736
 
                        {
737
 
                                nvertices[i].pos[0] = vertices[i].pos[0];
738
 
                                nvertices[i].pos[1] = vertices[i].pos[1];
739
 
                                nvertices[i].pos[2] = vertices[i].pos[2];
740
 
                                nvertices[i].texcoord[0] = vertices[i].texcoord[0];
741
 
                                nvertices[i].texcoord[1] = vertices[i].texcoord[1];
742
 
                        }
743
 
                        free(vertices);
744
 
                        _vertices = nvertices;
745
 
                        vertexFormat = VA_FORMAT_POS3F_TEX2F;
746
 
                        
747
 
                        break;
748
 
                }
749
 
                case VA_FORMAT_POS3F_TEX2F:
750
 
                {
751
 
                        break;
752
 
                }
753
 
                case VA_FORMAT_POS3F:
754
 
                {                       
755
 
                        break;
756
 
                }
757
 
                default:
758
 
                        assert(0);
 
756
                switch (vertexFormat)
 
757
                {
 
758
                        case VA_FORMAT_POS3F_NORMAL3F_TEX2F:
 
759
                        {
 
760
                                PositionNormalTex3f3f2f* vertices = _vertices;
 
761
                                PositionTex3f2f* nvertices = calloc(sizeof(*nvertices),numVertices);
 
762
                                for (size_t i = 0; i < numVertices; ++i)
 
763
                                {
 
764
                                        nvertices[i].pos[0] = vertices[i].pos[0];
 
765
                                        nvertices[i].pos[1] = vertices[i].pos[1];
 
766
                                        nvertices[i].pos[2] = vertices[i].pos[2];
 
767
                                        nvertices[i].texcoord[0] = vertices[i].texcoord[0];
 
768
                                        nvertices[i].texcoord[1] = vertices[i].texcoord[1];
 
769
                                }
 
770
                                free(vertices);
 
771
                                _vertices = nvertices;
 
772
                                vertexFormat = VA_FORMAT_POS3F_TEX2F;
 
773
                                
 
774
                                needsVertexBufferUpdate = YES;
 
775
                                break;
 
776
                        }
 
777
                        case VA_FORMAT_POS3F_TEX2F:
 
778
                        {
 
779
                                break;
 
780
                        }
 
781
                        case VA_FORMAT_POS3F:
 
782
                        {                       
 
783
                                break;
 
784
                        }
 
785
                        default:
 
786
                                assert(0);
 
787
                }
759
788
        }
760
 
        if (vertexBufferName)
761
 
                glDeleteBuffers(1, &vertexBufferName);
762
 
        vertexBufferName = 0;
763
 
        if (indexBufferName)
764
 
                glDeleteBuffers(1, &indexBufferName);
765
 
        indexBufferName = 0;
766
789
}
767
790
 
768
791
 

Loggerhead 1.17 is a web-based interface for Bazaar branches