X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmapblock_mesh.h;h=f32df39581b8428f7237a6325e65c255fcb3edb1;hb=f151b2322003bbc89c2cd3c603ef1e1ab9d46439;hp=591172bc90e0ea8eac8ed46a78957a9a8629d939;hpb=033ae0dcaecc37fee487e44896a0c0fb4c844e4e;p=dragonfireclient.git diff --git a/src/mapblock_mesh.h b/src/mapblock_mesh.h index 591172bc9..f32df3958 100644 --- a/src/mapblock_mesh.h +++ b/src/mapblock_mesh.h @@ -1,18 +1,18 @@ /* -Minetest-c55 -Copyright (C) 2010-2011 celeron55, Perttu Ahola +Minetest +Copyright (C) 2010-2013 celeron55, Perttu Ahola 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 +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 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. +GNU Lesser General Public License for more details. -You should have received a copy of the GNU General Public License along +You should have received a copy of the GNU Lesser 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. */ @@ -20,124 +20,255 @@ with this program; if not, write to the Free Software Foundation, Inc., #ifndef MAPBLOCK_MESH_HEADER #define MAPBLOCK_MESH_HEADER -#include "common_irrlicht.h" -#include "mapblock_nodemod.h" +#include "irrlichttypes_extrabloated.h" +#include "client/tile.h" #include "voxel.h" +#include "util/cpp11_container.h" +#include + +class Client; +class IShaderSource; /* Mesh making stuff */ -/* - This is used because CMeshBuffer::append() is very slow -*/ -struct PreMeshBuffer + +class MapBlock; +struct MinimapMapblock; + +struct MeshMakeData { - video::SMaterial material; - core::array indices; - core::array vertices; + VoxelManipulator m_vmanip; + v3s16 m_blockpos; + v3s16 m_crack_pos_relative; + bool m_smooth_lighting; + bool m_show_hud; + + Client *m_client; + bool m_use_shaders; + bool m_use_tangent_vertices; + + MeshMakeData(Client *client, bool use_shaders, + bool use_tangent_vertices = false); + + /* + Copy block data manually (to allow optimizations by the caller) + */ + void fillBlockDataBegin(const v3s16 &blockpos); + void fillBlockData(const v3s16 &block_offset, MapNode *data); + + /* + Copy central data directly from block, and other data from + parent of block. + */ + void fill(MapBlock *block); + + /* + Set up with only a single node at (1,1,1) + */ + void fillSingleNode(MapNode *node); + + /* + Set the (node) position of a crack + */ + void setCrack(int crack_level, v3s16 crack_pos); + + /* + Enable or disable smooth lighting + */ + void setSmoothLighting(bool smooth_lighting); }; -class MeshCollector +/* + Holds a mesh for a mapblock. + + Besides the SMesh*, this contains information used for animating + the vertex positions, colors and texture coordinates of the mesh. + For example: + - cracks [implemented] + - day/night transitions [implemented] + - animated flowing liquids [not implemented] + - animating vertex positions for e.g. axles [not implemented] +*/ +class MapBlockMesh { public: - void append( - video::SMaterial material, - const video::S3DVertex* const vertices, - u32 numVertices, - const u16* const indices, - u32 numIndices - ) + // Builds the mesh given + MapBlockMesh(MeshMakeData *data, v3s16 camera_offset); + ~MapBlockMesh(); + + // Main animation function, parameters: + // faraway: whether the block is far away from the camera (~50 nodes) + // time: the global animation time, 0 .. 60 (repeats every minute) + // daynight_ratio: 0 .. 1000 + // crack: -1 .. CRACK_ANIMATION_LENGTH-1 (-1 for off) + // Returns true if anything has been changed. + bool animate(bool faraway, float time, int crack, u32 daynight_ratio); + + scene::IMesh *getMesh() + { + return m_mesh[0]; + } + + scene::IMesh *getMesh(u8 layer) { - PreMeshBuffer *p = NULL; - for(u32 i=0; ivertices.size(); - for(u32 i=0; i 65535) - { - dstream<<"FIXME: Meshbuffer ran out of indices"<indices.push_back(j); - } - for(u32 i=0; ivertices.push_back(vertices[i]); - } + return m_mesh[layer]; } - void fillMesh(scene::SMesh *mesh) + MinimapMapblock *moveMinimapMapblock() { - /*dstream<<"Filling mesh with "< - scene::SMeshBuffer *buf = new scene::SMeshBuffer(); - // Set material - buf->Material = p.material; - //((scene::SMeshBuffer*)buf)->Material = p.material; - // Use VBO - //buf->setHardwareMappingHint(scene::EHM_STATIC); - // Add to mesh - mesh->addMeshBuffer(buf); - // Mesh grabbed it - buf->drop(); - - buf->append(p.vertices.pointer(), p.vertices.size(), - p.indices.pointer(), p.indices.size()); - } + MinimapMapblock *p = m_minimap_mapblock; + m_minimap_mapblock = NULL; + return p; } + bool isAnimationForced() const + { + return m_animation_force_timer == 0; + } + + void decreaseAnimationForceTimer() + { + if(m_animation_force_timer > 0) + m_animation_force_timer--; + } + + void updateCameraOffset(v3s16 camera_offset); + private: - core::array m_prebuffers; + scene::IMesh *m_mesh[MAX_TILE_LAYERS]; + MinimapMapblock *m_minimap_mapblock; + Client *m_client; + video::IVideoDriver *m_driver; + ITextureSource *m_tsrc; + IShaderSource *m_shdrsrc; + + bool m_enable_shaders; + bool m_use_tangent_vertices; + bool m_enable_vbo; + + // Must animate() be called before rendering? + bool m_has_animation; + int m_animation_force_timer; + + // Animation info: cracks + // Last crack value passed to animate() + int m_last_crack; + // Maps mesh and mesh buffer (i.e. material) indices to base texture names + std::map, std::string> m_crack_materials; + + // Animation info: texture animationi + // Maps mesh and mesh buffer indices to TileSpecs + // Keys are pairs of (mesh index, buffer index in the mesh) + std::map, TileLayer> m_animation_tiles; + std::map, int> m_animation_frames; // last animation frame + std::map, int> m_animation_frame_offsets; + + // Animation info: day/night transitions + // Last daynight_ratio value passed to animate() + u32 m_last_daynight_ratio; + // For each mesh and mesh buffer, stores pre-baked colors + // of sunlit vertices + // Keys are pairs of (mesh index, buffer index in the mesh) + std::map, std::map > m_daynight_diffs; + + // Camera offset info -> do we have to translate the mesh? + v3s16 m_camera_offset; }; -class MapBlock; -struct MeshMakeData + +/* + This is used because CMeshBuffer::append() is very slow +*/ +struct PreMeshBuffer { - u32 m_daynight_ratio; - NodeModMap m_temp_mods; - VoxelManipulator m_vmanip; - v3s16 m_blockpos; - - /* - Copy central data directly from block, and other data from - parent of block. - */ - void fill(u32 daynight_ratio, MapBlock *block); + TileLayer layer; + std::vector indices; + std::vector vertices; + std::vector tangent_vertices; }; -scene::SMesh* makeMapBlockMesh(MeshMakeData *data); +struct MeshCollector +{ + std::vector prebuffers[MAX_TILE_LAYERS]; + bool m_use_tangent_vertices; + + MeshCollector(bool use_tangent_vertices): + m_use_tangent_vertices(use_tangent_vertices) + { + } + + void append(const TileSpec &material, + const video::S3DVertex *vertices, u32 numVertices, + const u16 *indices, u32 numIndices); + void append(const TileLayer &material, + const video::S3DVertex *vertices, u32 numVertices, + const u16 *indices, u32 numIndices, u8 layernum); + void append(const TileSpec &material, + const video::S3DVertex *vertices, u32 numVertices, + const u16 *indices, u32 numIndices, v3f pos, + video::SColor c, u8 light_source); + void append(const TileLayer &material, + const video::S3DVertex *vertices, u32 numVertices, + const u16 *indices, u32 numIndices, v3f pos, + video::SColor c, u8 light_source, u8 layernum); + /*! + * Colorizes all vertices in the collector. + */ + void applyTileColors(); +}; + +/*! + * Encodes light of a node. + * The result is not the final color, but a + * half-baked vertex color. + * You have to multiply the resulting color + * with the node's color. + * + * \param light the first 8 bits are day light, + * the last 8 bits are night light + * \param emissive_light amount of light the surface emits, + * from 0 to LIGHT_SUN. + */ +video::SColor encode_light(u16 light, u8 emissive_light); + +// Compute light at node +u16 getInteriorLight(MapNode n, s32 increment, INodeDefManager *ndef); +u16 getFaceLight(MapNode n, MapNode n2, v3s16 face_dir, INodeDefManager *ndef); +u16 getSmoothLight(v3s16 p, v3s16 corner, MeshMakeData *data); + +/*! + * Returns the sunlight's color from the current + * day-night ratio. + */ +void get_sunlight_color(video::SColorf *sunlight, u32 daynight_ratio); + +/*! + * Gives the final SColor shown on screen. + * + * \param result output color + * \param light first 8 bits are day light, second 8 bits are + * night light + */ +void final_color_blend(video::SColor *result, + u16 light, u32 daynight_ratio); + +/*! + * Gives the final SColor shown on screen. + * + * \param result output color + * \param data the half-baked vertex color + * \param dayLight color of the sunlight + */ +void final_color_blend(video::SColor *result, + const video::SColor &data, const video::SColorf &dayLight); + +// Retrieves the TileSpec of a face of a node +// Adds MATERIAL_FLAG_CRACK if the node is cracked +TileSpec getNodeTileN(MapNode mn, v3s16 p, u8 tileindex, MeshMakeData *data); +TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 dir, MeshMakeData *data); #endif