1/*
2 * Copyright 2015 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#ifndef GrMesh_DEFINED
9#define GrMesh_DEFINED
10
11#include "GrBuffer.h"
12#include "GrGpuResourceRef.h"
13
14class GrNonInstancedMesh {
15public:
16    GrPrimitiveType primitiveType() const { return fPrimitiveType; }
17    int startVertex() const { return fStartVertex; }
18    int startIndex() const { return fStartIndex; }
19    int vertexCount() const { return fVertexCount; }
20    int indexCount() const { return fIndexCount; }
21    bool isIndexed() const { return fIndexCount > 0; }
22
23    const GrBuffer* vertexBuffer() const { return fVertexBuffer.get(); }
24    const GrBuffer* indexBuffer() const { return fIndexBuffer.get(); }
25
26protected:
27    GrPrimitiveType         fPrimitiveType;
28    int                     fStartVertex;
29    int                     fStartIndex;
30    int                     fVertexCount;
31    int                     fIndexCount;
32    GrPendingIOResource<const GrBuffer, kRead_GrIOType> fVertexBuffer;
33    GrPendingIOResource<const GrBuffer, kRead_GrIOType> fIndexBuffer;
34    friend class GrMesh;
35};
36
37/**
38 * Used to communicate index and vertex buffers, counts, and offsets for a draw from GrOp to
39 * GrGpu. It also holds the primitive type for the draw. TODO: Consider moving ownership of this
40 * and draw-issuing responsibility to GrPrimitiveProcessor. The rest of the vertex info lives there
41 * already (stride, attribute mappings).
42 */
43class GrMesh : public GrNonInstancedMesh {
44public:
45    GrMesh() {}
46    GrMesh(const GrMesh& di) { (*this) = di; }
47    GrMesh& operator =(const GrMesh& di);
48
49    void init(GrPrimitiveType primType, const GrBuffer* vertexBuffer, int startVertex,
50                int vertexCount) {
51        SkASSERT(vertexBuffer);
52        SkASSERT(vertexCount);
53        SkASSERT(startVertex >= 0);
54        fPrimitiveType = primType;
55        fVertexBuffer.reset(vertexBuffer);
56        fIndexBuffer.reset(nullptr);
57        fStartVertex = startVertex;
58        fStartIndex = 0;
59        fVertexCount = vertexCount;
60        fIndexCount = 0;
61        fInstanceCount = 0;
62        fVerticesPerInstance = 0;
63        fIndicesPerInstance = 0;
64        fMaxInstancesPerDraw = 0;
65    }
66
67    void initIndexed(GrPrimitiveType primType,
68                        const GrBuffer* vertexBuffer,
69                        const GrBuffer* indexBuffer,
70                        int startVertex,
71                        int startIndex,
72                        int vertexCount,
73                        int indexCount) {
74        SkASSERT(indexBuffer);
75        SkASSERT(vertexBuffer);
76        SkASSERT(indexCount);
77        SkASSERT(vertexCount);
78        SkASSERT(startIndex >= 0);
79        SkASSERT(startVertex >= 0);
80        fPrimitiveType = primType;
81        fVertexBuffer.reset(vertexBuffer);
82        fIndexBuffer.reset(indexBuffer);
83        fStartVertex = startVertex;
84        fStartIndex = startIndex;
85        fVertexCount = vertexCount;
86        fIndexCount = indexCount;
87        fInstanceCount = 0;
88        fVerticesPerInstance = 0;
89        fIndicesPerInstance = 0;
90        fMaxInstancesPerDraw = 0;
91    }
92
93
94    /** Variation of the above that may be used when the total number of instances may exceed
95        the number of instances supported by the index buffer. To be used with
96        nextInstances() to draw in max-sized batches.*/
97    void initInstanced(GrPrimitiveType primType,
98                        const GrBuffer* vertexBuffer,
99                        const GrBuffer* indexBuffer,
100                        int startVertex,
101                        int verticesPerInstance,
102                        int indicesPerInstance,
103                        int instanceCount,
104                        int maxInstancesPerDraw) {
105        SkASSERT(vertexBuffer);
106        SkASSERT(indexBuffer);
107        SkASSERT(instanceCount);
108        SkASSERT(verticesPerInstance);
109        SkASSERT(indicesPerInstance);
110        SkASSERT(startVertex >= 0);
111        fPrimitiveType = primType;
112        fVertexBuffer.reset(vertexBuffer);
113        fIndexBuffer.reset(indexBuffer);
114        fStartVertex = startVertex;
115        fStartIndex = 0;
116        fVerticesPerInstance = verticesPerInstance;
117        fIndicesPerInstance = indicesPerInstance;
118        fInstanceCount = instanceCount;
119        fVertexCount = instanceCount * fVerticesPerInstance;
120        fIndexCount = instanceCount * fIndicesPerInstance;
121        fMaxInstancesPerDraw = maxInstancesPerDraw;
122    }
123
124
125    /** These return 0 if initInstanced was not used to initialize the GrVertices. */
126    int verticesPerInstance() const { return fVerticesPerInstance; }
127    int indicesPerInstance() const { return fIndicesPerInstance; }
128    int instanceCount() const { return fInstanceCount; }
129
130    bool isInstanced() const { return fInstanceCount > 0; }
131
132    class Iterator {
133    public:
134        const GrNonInstancedMesh* init(const GrMesh& mesh) {
135            fMesh = &mesh;
136            if (mesh.fInstanceCount <= mesh.fMaxInstancesPerDraw) {
137                fInstancesRemaining = 0;
138                // Note, this also covers the non-instanced case!
139                return &mesh;
140            }
141            SkASSERT(mesh.isInstanced());
142            fInstanceBatch.fIndexBuffer.reset(mesh.fIndexBuffer.get());
143            fInstanceBatch.fVertexBuffer.reset(mesh.fVertexBuffer.get());
144            fInstanceBatch.fIndexCount = mesh.fMaxInstancesPerDraw *
145                                         mesh.fIndicesPerInstance;
146            fInstanceBatch.fVertexCount = mesh.fMaxInstancesPerDraw *
147                                          mesh.fVerticesPerInstance;
148            fInstanceBatch.fPrimitiveType = mesh.fPrimitiveType;
149            fInstanceBatch.fStartIndex = mesh.fStartIndex;
150            fInstanceBatch.fStartVertex = mesh.fStartVertex;
151            fInstancesRemaining = mesh.fInstanceCount - mesh.fMaxInstancesPerDraw;
152            return &fInstanceBatch;
153        }
154
155        const GrNonInstancedMesh* next() {
156            if (!fInstancesRemaining) {
157                return nullptr;
158            }
159            fInstanceBatch.fStartVertex += fInstanceBatch.fVertexCount;
160            int instances = SkTMin(fInstancesRemaining, fMesh->fMaxInstancesPerDraw);
161            fInstanceBatch.fIndexCount = instances * fMesh->fIndicesPerInstance;
162            fInstanceBatch.fVertexCount = instances * fMesh->fVerticesPerInstance;
163            fInstancesRemaining -= instances;
164            return &fInstanceBatch;
165        }
166    private:
167        GrNonInstancedMesh fInstanceBatch;
168        const GrMesh* fMesh;
169        int fInstancesRemaining;
170    };
171
172private:
173    int                     fInstanceCount;
174    int                     fVerticesPerInstance;
175    int                     fIndicesPerInstance;
176    int                     fMaxInstancesPerDraw;
177};
178
179#endif
180