aboutsummaryrefslogtreecommitdiff
path: root/src/mesh.h
blob: 57166235ebf834391bc1cd252a38117d776df812 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
/*
Minetest-c55
Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#ifndef MESH_HEADER
#define MESH_HEADER

#include "common_irrlicht.h"
#include <string>

/*
	Create a new cube mesh.
	Vertices are at (+-scale.X/2, +-scale.Y/2, +-scale.Z/2).

	The resulting mesh has 6 materials (up, down, right, left, back, front)
	which must be defined by the caller.
*/
scene::IAnimatedMesh* createCubeMesh(v3f scale);

/*
	Create a new extruded mesh from a texture.
	Maximum bounding box is (+-scale.X/2, +-scale.Y/2, +-scale.Z).
	Thickness is in Z direction.

	The resulting mesh has 1 material which must be defined by the caller.
*/
scene::IAnimatedMesh* createExtrudedMesh(video::ITexture *texture,
		video::IVideoDriver *driver, v3f scale);

/*
	Multiplies each vertex coordinate by the specified scaling factors
	(componentwise vector multiplication).
*/
void scaleMesh(scene::IMesh *mesh, v3f scale);

/*
	Translate each vertex coordinate by the specified vector.
*/
void translateMesh(scene::IMesh *mesh, v3f vec);

/*
	Set a constant color for all vertices in the mesh
*/
void setMeshColor(scene::IMesh *mesh, const video::SColor &color);

/*
	Set the color of all vertices in the mesh.
	For each vertex, determine the largest absolute entry in
	the normal vector, and choose one of colorX, colorY or
	colorZ accordingly.
*/
void setMeshColorByNormalXYZ(scene::IMesh *mesh,
		const video::SColor &colorX,
		const video::SColor &colorY,
		const video::SColor &colorZ);

/*
	Render a mesh to a texture.
	Returns NULL if render-to-texture failed.
*/
video::ITexture *generateTextureFromMesh(scene::IMesh *mesh,
		IrrlichtDevice *device,
		core::dimension2d<u32> dim,
		std::string texture_name,
		v3f camera_position,
		v3f camera_lookat,
		core::CMatrix4<f32> camera_projection_matrix,
		video::SColorf ambient_light,
		v3f light_position,
		video::SColorf light_color,
		f32 light_radius);

#endif
t">; std::string data; }; class AreaStore { public: AreaStore() : m_res_cache(1000, &cacheMiss, this) {} virtual ~AreaStore() = default; static AreaStore *getOptimalImplementation(); virtual void reserve(size_t count) {}; size_t size() const { return areas_map.size(); } /// Add an area to the store. /// Updates the area's ID if it hasn't already been set. /// @return Whether the area insertion was successful. virtual bool insertArea(Area *a) = 0; /// Removes an area from the store by ID. /// @return Whether the area was in the store and removed. virtual bool removeArea(u32 id) = 0; /// Finds areas that the passed position is contained in. /// Stores output in passed vector. void getAreasForPos(std::vector<Area *> *result, v3s16 pos); /// Finds areas that are completely contained inside the area defined /// by the passed edges. If @p accept_overlap is true this finds any /// areas that intersect with the passed area at any point. virtual void getAreasInArea(std::vector<Area *> *result, v3s16 minedge, v3s16 maxedge, bool accept_overlap) = 0; /// Sets cache parameters. void setCacheParams(bool enabled, u8 block_radius, size_t limit); /// Returns a pointer to the area coresponding to the passed ID, /// or NULL if it doesn't exist. const Area *getArea(u32 id) const; /// Serializes the store's areas to a binary ostream. void serialize(std::ostream &is) const; /// Deserializes the Areas from a binary istream. /// This does not currently clear the AreaStore before adding the /// areas, making it possible to deserialize multiple serialized /// AreaStores. void deserialize(std::istream &is); protected: /// Invalidates the getAreasForPos cache. /// Call after adding or removing an area. void invalidateCache(); /// Implementation of getAreasForPos. /// getAreasForPos calls this if the cache is disabled. virtual void getAreasForPosImpl(std::vector<Area *> *result, v3s16 pos) = 0; /// Returns the next area ID and increments it. u32 getNextId() { return m_next_id++; } // Note: This can't be an unordered_map, since all // references would be invalidated on rehash. typedef std::map<u32, Area> AreaMap; AreaMap areas_map; private: /// Called by the cache when a value isn't found in the cache. static void cacheMiss(void *data, const v3s16 &mpos, std::vector<Area *> *dest); bool m_cache_enabled = true; /// Range, in nodes, of the getAreasForPos cache. /// If you modify this, call invalidateCache() u8 m_cacheblock_radius = 64; LRUCache<v3s16, std::vector<Area *> > m_res_cache; u32 m_next_id = 0; }; class VectorAreaStore : public AreaStore { public: virtual void reserve(size_t count) { m_areas.reserve(count); } virtual bool insertArea(Area *a); virtual bool removeArea(u32 id); virtual void getAreasInArea(std::vector<Area *> *result, v3s16 minedge, v3s16 maxedge, bool accept_overlap); protected: virtual void getAreasForPosImpl(std::vector<Area *> *result, v3s16 pos); private: std::vector<Area *> m_areas; }; #if USE_SPATIAL class SpatialAreaStore : public AreaStore { public: SpatialAreaStore(); virtual ~SpatialAreaStore(); virtual bool insertArea(Area *a); virtual bool removeArea(u32 id); virtual void getAreasInArea(std::vector<Area *> *result, v3s16 minedge, v3s16 maxedge, bool accept_overlap); protected: virtual void getAreasForPosImpl(std::vector<Area *> *result, v3s16 pos); private: SpatialIndex::ISpatialIndex *m_tree = nullptr; SpatialIndex::IStorageManager *m_storagemanager = nullptr; class VectorResultVisitor : public SpatialIndex::IVisitor { public: VectorResultVisitor(std::vector<Area *> *result, SpatialAreaStore *store) : m_store(store), m_result(result) {} ~VectorResultVisitor() {} virtual void visitNode(const SpatialIndex::INode &in) {} virtual void visitData(const SpatialIndex::IData &in) { u32 id = in.getIdentifier(); std::map<u32, Area>::iterator itr = m_store->areas_map.find(id); assert(itr != m_store->areas_map.end()); m_result->push_back(&itr->second); } virtual void visitData(std::vector<const SpatialIndex::IData *> &v)