Mirrorlandia_minetest/minetest
1
0
Fork 1
mirror of https://github.com/minetest/minetest.git synced 2024-12-02 12:33:45 +01:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Refactoring and code style fixes in preparation of adding mesh typed items"

Browse Source 
This reverts commit f14e7bac54af65e3d3d99f89f23f114b17058e49.

Reverted due to missinterpretation of agreement, obvious dislike and me not interested in doing fights for feature I don't actually need
This commit is contained in:
Sapier 2015-12-29 19:55:50 +01:00
parent 25d128da36
commit 1735c20549
2 changed files with 402 additions and 485 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

305
src/itemdef.cpp
View File

@ -28,10 +28,15 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "mapblock_mesh.h" #include "mapblock_mesh.h"
#include "mesh.h" #include "mesh.h"
#include "wieldmesh.h" #include "wieldmesh.h"
#include "client/tile.h"
#endif #endif
#include "log.h" #include "log.h"
#include "settings.h" #include "settings.h"
#include "util/serialize.h" #include "util/serialize.h"
#include "util/container.h"
#include "util/thread.h"
#include <map>
#include <set>
#ifdef __ANDROID__ #ifdef __ANDROID__
#include <GLES/gl.h> #include <GLES/gl.h>
@ -222,29 +227,37 @@ void ItemDefinition::deSerialize(std::istream &is)
// SUGG: Support chains of aliases? // SUGG: Support chains of aliases?
class CItemDefManager: public IWritableItemDefManager
{
#ifndef SERVER #ifndef SERVER
CItemDefManager::ClientCached::ClientCached() : struct ClientCached
{
video::ITexture *inventory_texture;
scene::IMesh *wield_mesh;
ClientCached():
inventory_texture(NULL), inventory_texture(NULL),
wield_mesh(NULL) wield_mesh(NULL)
{} {}
};
#endif #endif
CItemDefManager::CItemDefManager() public:
CItemDefManager()
{ {
#ifndef SERVER #ifndef SERVER
m_main_thread = thr_get_current_thread_id(); m_main_thread = thr_get_current_thread_id();
#endif #endif
clear(); clear();
} }
virtual ~CItemDefManager()
/******************************************************************************/
CItemDefManager::~CItemDefManager()
{ {
#ifndef SERVER #ifndef SERVER
const std::vector<ClientCached*> &values = m_clientcached.getValues(); const std::vector<ClientCached*> &values = m_clientcached.getValues();
for(std::vector<ClientCached*>::const_iterator for(std::vector<ClientCached*>::const_iterator
i = values.begin(); i != values.end(); ++i) { i = values.begin(); i != values.end(); ++i)
{
ClientCached *cc = *i; ClientCached *cc = *i;
if (cc->wield_mesh) if (cc->wield_mesh)
cc->wield_mesh->drop(); cc->wield_mesh->drop();
@ -255,14 +268,11 @@ CItemDefManager::~CItemDefManager()
for (std::map<std::string, ItemDefinition*>::iterator iter = for (std::map<std::string, ItemDefinition*>::iterator iter =
m_item_definitions.begin(); iter != m_item_definitions.end(); m_item_definitions.begin(); iter != m_item_definitions.end();
++iter) { ++iter) {
delete iter->second; delete iter->second;
} }
m_item_definitions.clear(); m_item_definitions.clear();
} }
virtual const ItemDefinition& get(const std::string &name_) const
/******************************************************************************/
const ItemDefinition& CItemDefManager::get(const std::string &name_) const
{ {
// Convert name according to possible alias // Convert name according to possible alias
std::string name = getAlias(name_); std::string name = getAlias(name_);
@ -274,50 +284,39 @@ const ItemDefinition& CItemDefManager::get(const std::string &name_) const
assert(i != m_item_definitions.end()); assert(i != m_item_definitions.end());
return *(i->second); return *(i->second);
} }
virtual std::string getAlias(const std::string &name) const
/******************************************************************************/
std::string CItemDefManager::getAlias(const std::string &name) const
{ {
StringMap::const_iterator it = m_aliases.find(name); StringMap::const_iterator it = m_aliases.find(name);
if (it != m_aliases.end()) if (it != m_aliases.end())
return it->second; return it->second;
return name; return name;
} }
virtual std::set<std::string> getAll() const
/******************************************************************************/
std::set<std::string> CItemDefManager::getAll() const
{ {
std::set<std::string> result; std::set<std::string> result;
for(std::map<std::string, ItemDefinition *>::const_iterator for(std::map<std::string, ItemDefinition *>::const_iterator
it = m_item_definitions.begin(); it = m_item_definitions.begin();
it != m_item_definitions.end(); ++it) { it != m_item_definitions.end(); ++it) {
result.insert(it->first); result.insert(it->first);
} }
for (StringMap::const_iterator for (StringMap::const_iterator
it = m_aliases.begin(); it = m_aliases.begin();
it != m_aliases.end(); ++it) { it != m_aliases.end(); ++it) {
result.insert(it->first); result.insert(it->first);
} }
return result; return result;
} }
virtual bool isKnown(const std::string &name_) const
/******************************************************************************/
bool CItemDefManager::isKnown(const std::string &name_) const
{ {
// Convert name according to possible alias // Convert name according to possible alias
std::string name = getAlias(name_); std::string name = getAlias(name_);
// Get the definition // Get the definition
std::map<std::string, ItemDefinition*>::const_iterator i; std::map<std::string, ItemDefinition*>::const_iterator i;
return m_item_definitions.find(name) != m_item_definitions.end(); return m_item_definitions.find(name) != m_item_definitions.end();
} }
#ifndef SERVER #ifndef SERVER
public:
/******************************************************************************/ ClientCached* createClientCachedDirect(const std::string &name,
CItemDefManager::ClientCached* CItemDefManager::createClientCachedDirect(const std::string &name,
IGameDef *gamedef) const IGameDef *gamedef) const
{ {
infostream<<"Lazily creating item texture and mesh for \"" infostream<<"Lazily creating item texture and mesh for \""
@ -350,7 +349,96 @@ CItemDefManager::ClientCached* CItemDefManager::createClientCachedDirect(const s
// - If inventory_texture isn't set yet, create one using // - If inventory_texture isn't set yet, create one using
// render-to-texture. // render-to-texture.
if (def.type == ITEM_NODE) { if (def.type == ITEM_NODE) {
createNodeItemTexture(name, def, nodedef, cc, gamedef, tsrc); // Get node properties
content_t id = nodedef->getId(name);
const ContentFeatures &f = nodedef->get(id);
bool need_rtt_mesh = cc->inventory_texture == NULL;
// Keep this in sync with WieldMeshSceneNode::setItem()
bool need_wield_mesh =
!(f.mesh_ptr[0] ||
f.drawtype == NDT_NORMAL ||
f.drawtype == NDT_ALLFACES ||
f.drawtype == NDT_AIRLIKE);
scene::IMesh *node_mesh = NULL;
if (need_rtt_mesh || need_wield_mesh) {
u8 param1 = 0;
if (f.param_type == CPT_LIGHT)
param1 = 0xee;
/*
Make a mesh from the node
*/
MeshMakeData mesh_make_data(gamedef, false);
u8 param2 = 0;
if (f.param_type_2 == CPT2_WALLMOUNTED)
param2 = 1;
MapNode mesh_make_node(id, param1, param2);
mesh_make_data.fillSingleNode(&mesh_make_node);
MapBlockMesh mapblock_mesh(&mesh_make_data, v3s16(0, 0, 0));
node_mesh = mapblock_mesh.getMesh();
node_mesh->grab();
video::SColor c(255, 255, 255, 255);
setMeshColor(node_mesh, c);
// scale and translate the mesh so it's a
// unit cube centered on the origin
scaleMesh(node_mesh, v3f(1.0/BS, 1.0/BS, 1.0/BS));
translateMesh(node_mesh, v3f(-1.0, -1.0, -1.0));
}
/*
Draw node mesh into a render target texture
*/
if (need_rtt_mesh) {
TextureFromMeshParams params;
params.mesh = node_mesh;
params.dim.set(64, 64);
params.rtt_texture_name = "INVENTORY_"
+ def.name + "_RTT";
params.delete_texture_on_shutdown = true;
params.camera_position.set(0, 1.0, -1.5);
params.camera_position.rotateXZBy(45);
params.camera_lookat.set(0, 0, 0);
// Set orthogonal projection
params.camera_projection_matrix.buildProjectionMatrixOrthoLH(
1.65, 1.65, 0, 100);
params.ambient_light.set(1.0, 0.2, 0.2, 0.2);
params.light_position.set(10, 100, -50);
params.light_color.set(1.0, 0.5, 0.5, 0.5);
params.light_radius = 1000;
#ifdef __ANDROID__
params.camera_position.set(0, -1.0, -1.5);
params.camera_position.rotateXZBy(45);
params.light_position.set(10, -100, -50);
#endif
cc->inventory_texture =
tsrc->generateTextureFromMesh(params);
// render-to-target didn't work
if (cc->inventory_texture == NULL) {
cc->inventory_texture =
tsrc->getTexture(f.tiledef[0].name);
}
}
/*
Use the node mesh as the wield mesh
*/
if (need_wield_mesh) {
cc->wield_mesh = node_mesh;
cc->wield_mesh->grab();
// no way reference count can be smaller than 2 in this place!
assert(cc->wield_mesh->getReferenceCount() >= 2);
}
if (node_mesh)
node_mesh->drop();
} }
// Put in cache // Put in cache
@ -358,9 +446,7 @@ CItemDefManager::ClientCached* CItemDefManager::createClientCachedDirect(const s
return cc; return cc;
} }
ClientCached* getClientCached(const std::string &name,
/******************************************************************************/
CItemDefManager::ClientCached* CItemDefManager::getClientCached(const std::string &name,
IGameDef *gamedef) const IGameDef *gamedef) const
{ {
ClientCached *cc = NULL; ClientCached *cc = NULL;
@ -368,8 +454,8 @@ CItemDefManager::ClientCached* CItemDefManager::getClientCached(const std::strin
if(cc) if(cc)
return cc; return cc;
if (thr_is_current_thread(m_main_thread)) { if(thr_is_current_thread(m_main_thread))
{
return createClientCachedDirect(name, gamedef); return createClientCachedDirect(name, gamedef);
} }
else else
@ -397,39 +483,31 @@ CItemDefManager::ClientCached* CItemDefManager::getClientCached(const std::strin
} }
} }
} }
/******************************************************************************/
// Get item inventory texture // Get item inventory texture
video::ITexture* CItemDefManager::getInventoryTexture(const std::string &name, virtual video::ITexture* getInventoryTexture(const std::string &name,
IGameDef *gamedef) const IGameDef *gamedef) const
{ {
ClientCached *cc = getClientCached(name, gamedef); ClientCached *cc = getClientCached(name, gamedef);
if(!cc) if(!cc)
return NULL; return NULL;
return cc->inventory_texture; return cc->inventory_texture;
} }
/******************************************************************************/
// Get item wield mesh // Get item wield mesh
scene::IMesh* CItemDefManager::getWieldMesh(const std::string &name, virtual scene::IMesh* getWieldMesh(const std::string &name,
IGameDef *gamedef) const IGameDef *gamedef) const
{ {
ClientCached *cc = getClientCached(name, gamedef); ClientCached *cc = getClientCached(name, gamedef);
if(!cc) if(!cc)
return NULL; return NULL;
return cc->wield_mesh; return cc->wield_mesh;
} }
#endif #endif
void clear()
/******************************************************************************/
void CItemDefManager::clear()
{ {
for(std::map<std::string, ItemDefinition*>::const_iterator for(std::map<std::string, ItemDefinition*>::const_iterator
i = m_item_definitions.begin(); i = m_item_definitions.begin();
i != m_item_definitions.end(); ++i) { i != m_item_definitions.end(); ++i)
{
delete i->second; delete i->second;
} }
m_item_definitions.clear(); m_item_definitions.clear();
@ -463,9 +541,7 @@ void CItemDefManager::clear()
ignore_def->name = "ignore"; ignore_def->name = "ignore";
m_item_definitions.insert(std::make_pair("ignore", ignore_def)); m_item_definitions.insert(std::make_pair("ignore", ignore_def));
} }
virtual void registerItem(const ItemDefinition &def)
/******************************************************************************/
void CItemDefManager::registerItem(const ItemDefinition &def)
{ {
verbosestream<<"ItemDefManager: registering \""<<def.name<<"\""<<std::endl; verbosestream<<"ItemDefManager: registering \""<<def.name<<"\""<<std::endl;
// Ensure that the "" item (the hand) always has ToolCapabilities // Ensure that the "" item (the hand) always has ToolCapabilities
@ -483,21 +559,17 @@ void CItemDefManager::registerItem(const ItemDefinition &def)
infostream<<"ItemDefManager: erased alias "<<def.name infostream<<"ItemDefManager: erased alias "<<def.name
<<" because item was defined"<<std::endl; <<" because item was defined"<<std::endl;
} }
virtual void registerAlias(const std::string &name,
/******************************************************************************/
void CItemDefManager::registerAlias(const std::string &name,
const std::string &convert_to) const std::string &convert_to)
{ {
if (m_item_definitions.find(name) == m_item_definitions.end()) { if(m_item_definitions.find(name) == m_item_definitions.end())
{
verbosestream<<"ItemDefManager: setting alias "<<name verbosestream<<"ItemDefManager: setting alias "<<name
<<" -> "<<convert_to<<std::endl; <<" -> "<<convert_to<<std::endl;
m_aliases[name] = convert_to; m_aliases[name] = convert_to;
} }
} }
void serialize(std::ostream &os, u16 protocol_version)
/******************************************************************************/
void CItemDefManager::serialize(std::ostream &os, u16 protocol_version)
{ {
writeU8(os, 0); // version writeU8(os, 0); // version
u16 count = m_item_definitions.size(); u16 count = m_item_definitions.size();
@ -522,9 +594,7 @@ void CItemDefManager::serialize(std::ostream &os, u16 protocol_version)
os << serializeString(it->second); os << serializeString(it->second);
} }
} }
void deSerialize(std::istream &is)
/******************************************************************************/
void CItemDefManager::deSerialize(std::istream &is)
{ {
// Clear everything // Clear everything
clear(); clear();
@ -533,9 +603,8 @@ void CItemDefManager::deSerialize(std::istream &is)
if(version != 0) if(version != 0)
throw SerializationError("unsupported ItemDefManager version"); throw SerializationError("unsupported ItemDefManager version");
u16 count = readU16(is); u16 count = readU16(is);
for(u16 i=0; i<count; i++)
for (u16 i=0; i<count; i++) { {
// Deserialize a string and grab an ItemDefinition from it // Deserialize a string and grab an ItemDefinition from it
std::istringstream tmp_is(deSerializeString(is), std::ios::binary); std::istringstream tmp_is(deSerializeString(is), std::ios::binary);
ItemDefinition def; ItemDefinition def;
@ -543,23 +612,20 @@ void CItemDefManager::deSerialize(std::istream &is)
// Register // Register
registerItem(def); registerItem(def);
} }
u16 num_aliases = readU16(is); u16 num_aliases = readU16(is);
for (u16 i=0; i<num_aliases; i++) { for(u16 i=0; i<num_aliases; i++)
{
std::string name = deSerializeString(is); std::string name = deSerializeString(is);
std::string convert_to = deSerializeString(is); std::string convert_to = deSerializeString(is);
registerAlias(name, convert_to); registerAlias(name, convert_to);
} }
} }
void processQueue(IGameDef *gamedef)
/******************************************************************************/
void CItemDefManager::processQueue(IGameDef *gamedef)
{ {
#ifndef SERVER #ifndef SERVER
//NOTE this is only thread safe for ONE consumer thread! //NOTE this is only thread safe for ONE consumer thread!
while (!m_get_clientcached_queue.empty()) { while(!m_get_clientcached_queue.empty())
{
GetRequest<std::string, ClientCached*, u8, u8> GetRequest<std::string, ClientCached*, u8, u8>
request = m_get_clientcached_queue.pop(); request = m_get_clientcached_queue.pop();
@ -568,91 +634,22 @@ void CItemDefManager::processQueue(IGameDef *gamedef)
} }
#endif #endif
} }
private:
// Key is name
std::map<std::string, ItemDefinition*> m_item_definitions;
// Aliases
StringMap m_aliases;
#ifndef SERVER #ifndef SERVER
/******************************************************************************/ // The id of the thread that is allowed to use irrlicht directly
void CItemDefManager::createNodeItemTexture(const std::string& name, threadid_t m_main_thread;
const ItemDefinition& def, INodeDefManager* nodedef, // A reference to this can be returned when nothing is found, to avoid NULLs
ClientCached* cc, IGameDef* gamedef, ITextureSource* tsrc) const mutable ClientCached m_dummy_clientcached;
{ // Cached textures and meshes
// Get node properties mutable MutexedMap<std::string, ClientCached*> m_clientcached;
content_t id = nodedef->getId(name); // Queued clientcached fetches (to be processed by the main thread)
const ContentFeatures& f = nodedef->get(id); mutable RequestQueue<std::string, ClientCached*, u8, u8> m_get_clientcached_queue;
bool need_rtt_mesh = cc->inventory_texture == NULL;
// Keep this in sync with WieldMeshSceneNode::setItem()
bool need_wield_mesh = !(f.mesh_ptr[0] || f.drawtype == NDT_NORMAL
|| f.drawtype == NDT_ALLFACES || f.drawtype == NDT_AIRLIKE);
scene::IMesh* node_mesh = NULL;
if (need_rtt_mesh || need_wield_mesh) {
u8 param1 = 0;
if (f.param_type == CPT_LIGHT)
param1 = 0xee;
/*
Make a mesh from the node
*/
MeshMakeData mesh_make_data(gamedef, false);
u8 param2 = 0;
if (f.param_type_2 == CPT2_WALLMOUNTED)
param2 = 1;
MapNode mesh_make_node(id, param1, param2);
mesh_make_data.fillSingleNode(&mesh_make_node);
MapBlockMesh mapblock_mesh(&mesh_make_data, v3s16(0, 0, 0));
node_mesh = mapblock_mesh.getMesh();
node_mesh->grab();
video::SColor c(255, 255, 255, 255);
setMeshColor(node_mesh, c);
// scale and translate the mesh so it's a
// unit cube centered on the origin
scaleMesh(node_mesh, v3f(1.0 / BS, 1.0 / BS, 1.0 / BS));
translateMesh(node_mesh, v3f(-1.0, -1.0, -1.0));
}
/*
Draw node mesh into a render target texture
*/
if (need_rtt_mesh) {
TextureFromMeshParams params;
params.mesh = node_mesh;
params.dim.set(64, 64);
params.rtt_texture_name = "INVENTORY_" + def.name + "_RTT";
params.delete_texture_on_shutdown = true;
params.camera_position.set(0, 1.0, -1.5);
params.camera_position.rotateXZBy(45);
params.camera_lookat.set(0, 0, 0);
// Set orthogonal projection
params.camera_projection_matrix.buildProjectionMatrixOrthoLH(1.65,
1.65, 0, 100);
params.ambient_light.set(1.0, 0.2, 0.2, 0.2);
params.light_position.set(10, 100, -50);
params.light_color.set(1.0, 0.5, 0.5, 0.5);
params.light_radius = 1000;
cc->inventory_texture = tsrc->generateTextureFromMesh(params);
// render-to-target didn't work
if (cc->inventory_texture == NULL) {
cc->inventory_texture = tsrc->getTexture(f.tiledef[0].name);
}
}
/*
Use the node mesh as the wield mesh
*/
if (need_wield_mesh) {
cc->wield_mesh = node_mesh;
cc->wield_mesh->grab();
// no way reference count can be smaller than 2 in this place!
assert(cc->wield_mesh->getReferenceCount() >= 2);
}
if (node_mesh)
node_mesh->drop();
}
#endif #endif
};
/******************************************************************************/
IWritableItemDefManager* createItemDefManager() IWritableItemDefManager* createItemDefManager()
{ {

82
src/itemdef.h
View File

@ -25,18 +25,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include <string> #include <string>
#include <iostream> #include <iostream>
#include <set> #include <set>
#include <map>
#include "itemgroup.h" #include "itemgroup.h"
#include "sound.h" #include "sound.h"
#include "util/container.h"
#include "util/thread.h"
#ifndef SERVER
#include "client/tile.h"
#endif
class IGameDef; class IGameDef;
class INodeDefManager;
struct ToolCapabilities; struct ToolCapabilities;
/* /*
@ -48,7 +39,7 @@ enum ItemType
ITEM_NONE, ITEM_NONE,
ITEM_NODE, ITEM_NODE,
ITEM_CRAFT, ITEM_CRAFT,
ITEM_TOOL ITEM_TOOL,
}; };
struct ItemDefinition struct ItemDefinition
@ -166,77 +157,6 @@ public:
virtual void processQueue(IGameDef *gamedef)=0; virtual void processQueue(IGameDef *gamedef)=0;
}; };
class CItemDefManager: public IWritableItemDefManager
{
public:
CItemDefManager();
virtual ~CItemDefManager();
virtual const ItemDefinition& get(const std::string &name_) const;
virtual std::string getAlias(const std::string &name) const;
virtual std::set<std::string> getAll() const;
virtual bool isKnown(const std::string &name_) const;
#ifndef SERVER
// Get item inventory texture
virtual video::ITexture* getInventoryTexture(const std::string &name,
IGameDef *gamedef) const;
// Get item wield mesh
virtual scene::IMesh* getWieldMesh(const std::string &name,
IGameDef *gamedef) const;
#endif
void clear();
virtual void registerItem(const ItemDefinition &def);
virtual void registerAlias(const std::string &name,
const std::string &convert_to);
void serialize(std::ostream &os, u16 protocol_version);
void deSerialize(std::istream &is);
void processQueue(IGameDef *gamedef);
private:
#ifndef SERVER
struct ClientCached
{
video::ITexture *inventory_texture;
scene::IMesh *wield_mesh;
ClientCached();
};
void createNodeItemTexture(const std::string& name,
const ItemDefinition& def, INodeDefManager* nodedef,
ClientCached* cc, IGameDef* gamedef, ITextureSource* tsrc) const;
ClientCached* createClientCachedDirect(const std::string &name,
IGameDef *gamedef) const;
ClientCached* getClientCached(const std::string &name,
IGameDef *gamedef) const;
// The id of the thread that is allowed to use irrlicht directly
threadid_t m_main_thread;
// A reference to this can be returned when nothing is found, to avoid NULLs
mutable ClientCached m_dummy_clientcached;
// Cached textures and meshes
mutable MutexedMap<std::string, ClientCached*> m_clientcached;
// Queued clientcached fetches (to be processed by the main thread)
mutable RequestQueue<std::string, ClientCached*, u8, u8> m_get_clientcached_queue;
#endif
// Key is name
std::map<std::string, ItemDefinition*> m_item_definitions;
// Aliases
std::map<std::string, std::string> m_aliases;
};
IWritableItemDefManager* createItemDefManager(); IWritableItemDefManager* createItemDefManager();
#endif #endif