]> git.tdb.fi Git - libs/gl.git/blob - source/core/mesh.h
Don't remove individual mipmap levels from Synchronizer
[libs/gl.git] / source / core / mesh.h
1 #ifndef MSP_GL_MESH_H_
2 #define MSP_GL_MESH_H_
3
4 #include <string>
5 #include <vector>
6 #include <msp/datafile/objectloader.h>
7 #include "batch.h"
8 #include "cullface.h"
9 #include "resource.h"
10 #include "vertexarray.h"
11 #include "vertexsetup.h"
12
13 namespace Msp {
14 namespace GL {
15
16 class Buffer;
17 class Renderer;
18
19 /**
20 Stores mesh data using a VertexArray and one or more Batches.
21
22 Meshes can be created at runtime using the MeshBuilder class.
23
24 The Object class provides a higher-level interface which associates a Mesh with
25 a Technique and is usually the appropriate way to of rendering geometry.
26 */
27 class Mesh: public Resource
28 {
29         friend class MeshBuilder;
30         class AsyncLoader;
31
32 public:
33         class Loader: public DataFile::ObjectLoader<Mesh>
34         {
35                 friend class AsyncLoader;
36
37         private:
38                 bool allow_gl_calls = true;
39
40         public:
41                 Loader(Mesh &);
42         private:
43                 void storage(const std::vector<VertexAttribute> &);
44                 void vertices();
45                 void vertices_with_format(const std::vector<VertexAttribute> &);
46                 void batch(PrimitiveType);
47         };
48
49 private:
50         class AsyncLoader: public Resource::AsyncLoader
51         {
52         private:
53                 Mesh &mesh;
54                 IO::Seekable &io;
55                 Bufferable::AsyncUpdater *vertex_updater = 0;
56                 Bufferable::AsyncUpdater *index_updater = 0;
57                 unsigned phase = 0;
58
59         public:
60                 AsyncLoader(Mesh &, IO::Seekable &);
61                 ~AsyncLoader();
62
63                 virtual bool needs_sync() const;
64                 virtual bool process();
65         };
66
67         enum BufferMask
68         {
69                 VERTEX_BUFFER = 1,
70                 INDEX_BUFFER = 2
71         };
72
73         VertexArray vertices;
74         std::vector<Batch> batches;
75         Buffer *vbuf = 0;
76         Buffer *ibuf = 0;
77         VertexSetup vtx_setup;
78         mutable unsigned short dirty = 0;
79         bool disallow_rendering = false;
80         FaceWinding face_winding = NON_MANIFOLD;
81         std::string debug_name;
82
83 public:
84         Mesh() = default;
85         Mesh(const VertexFormat &);
86         Mesh(Mesh &&);
87         ~Mesh();
88
89         /** Sets the vertex format for the mesh.  It cannot be changed once set. */
90         void storage(const VertexFormat &);
91
92         /** Clears all vertices and batches.  Vertex format is retained. */
93         void clear();
94 private:
95         void check_buffers(unsigned);
96
97 public:
98         const VertexArray &get_vertices() const { return vertices; }
99         const VertexSetup &get_vertex_setup() const { return vtx_setup; }
100         const Buffer *get_index_buffer() const { return ibuf; }
101         std::size_t get_n_vertices() const;
102
103         /** Returns a pointer to a vertex.  Offsets of individual attributes can be
104         queried from VertexFormat. */
105         char *modify_vertex(std::size_t);
106
107         /** Adds a batch to the mesh.  It may be combined with the last existing
108         batch if the primitive types are compatible. */
109         void add_batch(Batch &&b);
110
111         const std::vector<Batch> &get_batches() const { return batches; }
112
113         void set_winding(FaceWinding);
114
115         void draw(Renderer &) const;
116         
117         /** Draws multiple instances of the mesh.  The supplied VertexSetup must use
118         the mesh's vertex array. */
119         void draw_instanced(Renderer &, const VertexSetup &, unsigned) const;
120
121 private:
122         void draw(Renderer &, const VertexSetup *, unsigned) const;
123         void resize_buffers() const;
124
125 public:
126         virtual int get_load_priority() const { return 1; }
127         virtual Resource::AsyncLoader *load(IO::Seekable &, const Resources * = 0);
128         virtual std::uint64_t get_data_size() const;
129         virtual void unload();
130
131         void set_debug_name(const std::string &);
132 };
133
134 } // namespace GL
135 } // namespace Msp
136
137 #endif