← Back to branch summary

~ubuntu-branches/ubuntu/wily/opencollada/wily-proposed

« back to all changes in this revision

Viewing changes to COLLADAFramework/src/COLLADAFWMeshPrimitive.cpp

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2015-05-14 17:23:27 UTC
  • Revision ID: package-import@ubuntu.com-20150514172327-f862u8envms01fra
Tags: upstream-0.1.0~20140703.ddf8f47+dfsg1
Import upstream version 0.1.0~20140703.ddf8f47+dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
COLLADAFramework/src/COLLADAFWMeshPrimitive.cpp
 
1
/*
 
2
    Copyright (c) 2008-2009 NetAllied Systems GmbH
 
3
 
 
4
    This file is part of COLLADAFramework.
 
5
 
 
6
    Licensed under the MIT Open Source License,
 
7
    for details please see LICENSE file or the website
 
8
    http://www.opensource.org/licenses/mit-license.php
 
9
*/
 
10
 
 
11
#include "COLLADAFWStableHeaders.h"
 
12
#include "COLLADAFWMeshPrimitive.h"
 
13
#include "COLLADAFWPolygons.h"
 
14
#include "COLLADAFWPolylist.h"
 
15
#include "COLLADAFWMeshPrimitiveWithFaceVertexCount.h"
 
16
#include "COLLADAFWTrifans.h"
 
17
#include "COLLADAFWTristrips.h"
 
18
#include "COLLADAFWLinestrips.h"
 
19
 
 
20
 
 
21
namespace COLLADAFW
 
22
{
 
23
 
 
24
 
 
25
 
 
26
    //-----------------------------
 
27
        MeshPrimitive::MeshPrimitive ( const UniqueId& uniqueId )
 
28
        : ObjectTemplate<COLLADA_TYPE::PRIMITIVE_ELEMENT>(uniqueId)
 
29
        , mPrimitiveType ( UNDEFINED_PRIMITIVE_TYPE )
 
30
            , mFaceCount ( 0 )
 
31
                , mMaterialId(0)
 
32
                , mPositionIndices(UIntValuesArray::OWNER)
 
33
                , mNormalIndices(UIntValuesArray::OWNER)
 
34
                , mColorIndicesArray(UIntValuesArray::OWNER)
 
35
                , mUVCoordIndicesArray(UIntValuesArray::OWNER)
 
36
        {
 
37
        }
 
38
 
 
39
    //-----------------------------
 
40
        MeshPrimitive::MeshPrimitive( const UniqueId& uniqueId, PrimitiveType primitiveType )
 
41
        : ObjectTemplate<COLLADA_TYPE::PRIMITIVE_ELEMENT>(uniqueId)
 
42
                , mPrimitiveType ( primitiveType )
 
43
                , mFaceCount ( 0 )
 
44
                , mMaterialId(0)
 
45
                , mPositionIndices(UIntValuesArray::OWNER)
 
46
                , mNormalIndices(UIntValuesArray::OWNER)
 
47
                , mColorIndicesArray(UIntValuesArray::OWNER)
 
48
                , mUVCoordIndicesArray(UIntValuesArray::OWNER)
 
49
        {
 
50
        }
 
51
 
 
52
    //-----------------------------
 
53
        MeshPrimitive::~MeshPrimitive()
 
54
        {
 
55
                for ( size_t i = 0, count = mUVCoordIndicesArray.getCount(); i< count; ++i)
 
56
                {
 
57
                        FW_DELETE mUVCoordIndicesArray[i];
 
58
                }
 
59
 
 
60
                for ( size_t i = 0, count = mColorIndicesArray.getCount(); i< count; ++i)
 
61
                {
 
62
                        FW_DELETE mColorIndicesArray[i];
 
63
                }
 
64
        }
 
65
 
 
66
    //-----------------------------
 
67
    const int MeshPrimitive::getGroupedVerticesVertexCount( const size_t faceIndex ) const
 
68
    {
 
69
        switch ( mPrimitiveType )
 
70
        {
 
71
        case TRIANGLES:
 
72
            return 3;
 
73
            break;
 
74
        case TRIANGLE_FANS:
 
75
            return ((Trifans*)this)->getGroupedVerticesVertexCount ( faceIndex );
 
76
            break;
 
77
        case TRIANGLE_STRIPS:
 
78
            return ((Tristrips*)this)->getGroupedVerticesVertexCount ( faceIndex );
 
79
            break;
 
80
        case POINTS:
 
81
            return 1;
 
82
            break;
 
83
        case LINES:
 
84
            return 2;
 
85
            break;
 
86
        case LINE_STRIPS:
 
87
            return ((Linestrips*)this)->getGroupedVerticesVertexCount ( faceIndex );
 
88
            break;
 
89
        case POLYGONS:
 
90
                        return ((Polygons*)this)->getGroupedVerticesVertexCount ( faceIndex );
 
91
                        break;
 
92
        case POLYLIST:
 
93
            return ((Polylist*)this)->getGroupedVerticesVertexCount ( faceIndex );
 
94
            break;
 
95
        default:
 
96
            std::cerr << "Unknown primitive type: " << mPrimitiveType << std::endl;
 
97
            return 0;
 
98
        }
 
99
    }
 
100
 
 
101
    //-----------------------------
 
102
    const size_t MeshPrimitive::getGroupedVertexElementsCount () const
 
103
    {
 
104
        // Get the number of grouped vertex elements (faces, holes, tristrips or trifans).
 
105
        size_t groupedVertexElementsCount = 0;
 
106
 
 
107
        MeshPrimitive::PrimitiveType primitiveType = this->getPrimitiveType ();
 
108
        switch ( primitiveType )
 
109
        {
 
110
        case MeshPrimitive::TRIANGLES:
 
111
            {
 
112
                groupedVertexElementsCount = this->getFaceCount ();
 
113
                break;
 
114
            }
 
115
        case MeshPrimitive::TRIANGLE_FANS:
 
116
            {
 
117
                Trifans* trifans = (Trifans*) this;
 
118
                groupedVertexElementsCount = trifans->getTrifanCount ();
 
119
                break;
 
120
            }
 
121
        case MeshPrimitive::TRIANGLE_STRIPS:
 
122
            {
 
123
                Tristrips* tristrips = (Tristrips*) this;
 
124
                groupedVertexElementsCount = tristrips->getTristripCount ();
 
125
                break;
 
126
            }
 
127
        case MeshPrimitive::POLYGONS:
 
128
                        {
 
129
                                Polygons* polygons = (Polygons*) this;
 
130
                                Polygons::VertexCountArray& vertexCountArray =
 
131
                                        polygons->getGroupedVerticesVertexCountArray ();
 
132
                                groupedVertexElementsCount = vertexCountArray.getCount ();
 
133
                        }
 
134
                        break;
 
135
        case MeshPrimitive::POLYLIST:
 
136
            {
 
137
                                Polylist* polylist = (Polylist*) this;
 
138
                                Polylist::VertexCountArray& vertexCountArray =
 
139
                                        polylist->getGroupedVerticesVertexCountArray ();
 
140
                                groupedVertexElementsCount = vertexCountArray.getCount ();
 
141
            }
 
142
            break;
 
143
        case MeshPrimitive::LINES:
 
144
            {
 
145
                groupedVertexElementsCount = this->getFaceCount ();
 
146
                break;
 
147
            }
 
148
            break;
 
149
        case MeshPrimitive::LINE_STRIPS:
 
150
            {
 
151
                Linestrips* linestrips = (Linestrips*)this;
 
152
                groupedVertexElementsCount = linestrips->getLinestripCount ();
 
153
                break;
 
154
            }
 
155
            break;
 
156
        default:
 
157
            std::cerr << "Primitive type not supported: " << primitiveType << std::endl;
 
158
                        COLLADABU_ASSERT ( "Primitive type not supported: " + primitiveType );
 
159
            return 0;
 
160
        }
 
161
 
 
162
        return groupedVertexElementsCount;
 
163
    }
 
164
 
 
165
}