/*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 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
+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.
*/
#include "game.h"
-#include "common_irrlicht.h"
+#include "irrlichttypes_extrabloated.h"
#include <IGUICheckBox.h>
#include <IGUIEditBox.h>
#include <IGUIButton.h>
#include <IGUIStaticText.h>
#include <IGUIFont.h>
+#include <IMaterialRendererServices.h>
#include "client.h"
#include "server.h"
#include "guiPauseMenu.h"
#include "guiPasswordChange.h"
-#include "guiInventoryMenu.h"
+#include "guiVolumeChange.h"
+#include "guiFormSpecMenu.h"
#include "guiTextInputMenu.h"
#include "guiDeathScreen.h"
#include "tool.h"
#include "guiChatConsole.h"
#include "config.h"
#include "clouds.h"
+#include "particles.h"
#include "camera.h"
#include "farmesh.h"
#include "mapblock.h"
#include "main.h" // For g_settings
#include "itemdef.h"
#include "tile.h" // For TextureSource
+#include "shader.h" // For ShaderSource
#include "logoutputbuffer.h"
#include "subgame.h"
-
-/*
- Setting this to 1 enables a special camera mode that forces
- the renderers to think that the camera statically points from
- the starting place to a static direction.
-
- This allows one to move around with the player and see what
- is actually drawn behind solid things and behind the player.
-*/
-#define FIELD_OF_VIEW_TEST 0
-
+#include "quicktune_shortcutter.h"
+#include "clientmap.h"
+#include "sky.h"
+#include "sound.h"
+#if USE_SOUND
+ #include "sound_openal.h"
+#endif
+#include "event_manager.h"
+#include <list>
+#include "util/directiontables.h"
/*
Text input system
{
m_client->typeChatMessage(text);
}
+ void gotText(std::map<std::string, std::string> fields)
+ {
+ m_client->typeChatMessage(narrow_to_wide(fields["text"]));
+ }
Client *m_client;
};
m_p = p;
m_client = client;
}
+ // This is deprecated I guess? -celeron55
void gotText(std::wstring text)
{
std::string ntext = wide_to_narrow(text);
- infostream<<"Changing text of a sign node: "
- <<ntext<<std::endl;
- m_client->sendSignNodeText(m_p, ntext);
+ infostream<<"Submitting 'text' field of node at ("<<m_p.X<<","
+ <<m_p.Y<<","<<m_p.Z<<"): "<<ntext<<std::endl;
+ std::map<std::string, std::string> fields;
+ fields["text"] = ntext;
+ m_client->sendNodemetaFields(m_p, "", fields);
+ }
+ void gotText(std::map<std::string, std::string> fields)
+ {
+ m_client->sendNodemetaFields(m_p, "", fields);
}
v3s16 m_p;
Client *m_client;
};
+struct TextDestPlayerInventory : public TextDest
+{
+ TextDestPlayerInventory(Client *client)
+ {
+ m_client = client;
+ m_formname = "";
+ }
+ TextDestPlayerInventory(Client *client, std::string formname)
+ {
+ m_client = client;
+ m_formname = formname;
+ }
+ void gotText(std::map<std::string, std::string> fields)
+ {
+ m_client->sendInventoryFields(m_formname, fields);
+ }
+
+ Client *m_client;
+ std::string m_formname;
+};
+
/* Respawn menu callback */
class MainRespawnInitiator: public IRespawnInitiator
Client *m_client;
};
+/* Form update callback */
+
+class NodeMetadataFormSource: public IFormSource
+{
+public:
+ NodeMetadataFormSource(ClientMap *map, v3s16 p):
+ m_map(map),
+ m_p(p)
+ {
+ }
+ std::string getForm()
+ {
+ NodeMetadata *meta = m_map->getNodeMetadata(m_p);
+ if(!meta)
+ return "";
+ return meta->getString("formspec");
+ }
+ std::string resolveText(std::string str)
+ {
+ NodeMetadata *meta = m_map->getNodeMetadata(m_p);
+ if(!meta)
+ return str;
+ return meta->resolveString(str);
+ }
+
+ ClientMap *m_map;
+ v3s16 m_p;
+};
+
+class PlayerInventoryFormSource: public IFormSource
+{
+public:
+ PlayerInventoryFormSource(Client *client):
+ m_client(client)
+ {
+ }
+ std::string getForm()
+ {
+ LocalPlayer* player = m_client->getEnv().getLocalPlayer();
+ return player->inventory_formspec;
+ }
+
+ Client *m_client;
+};
+
+class FormspecFormSource: public IFormSource
+{
+public:
+ FormspecFormSource(std::string formspec,FormspecFormSource** game_formspec)
+ {
+ m_formspec = formspec;
+ m_game_formspec = game_formspec;
+ }
+
+ ~FormspecFormSource()
+ {
+ *m_game_formspec = 0;
+ }
+
+ void setForm(std::string formspec) {
+ m_formspec = formspec;
+ }
+
+ std::string getForm()
+ {
+ return m_formspec;
+ }
+
+ std::string m_formspec;
+ FormspecFormSource** m_game_formspec;
+};
/*
Hotbar draw routine
*/
core::line3d<f32> shootline, f32 d,
bool liquids_pointable,
bool look_for_object,
- core::aabbox3d<f32> &hilightbox,
- bool &should_show_hilightbox,
+ std::vector<aabb3f> &hilightboxes,
ClientActiveObject *&selected_object)
{
PointedThing result;
- hilightbox = core::aabbox3d<f32>(0,0,0,0,0,0);
- should_show_hilightbox = false;
+ hilightboxes.clear();
selected_object = NULL;
INodeDefManager *nodedef = client->getNodeDefManager();
+ ClientMap &map = client->getEnv().getClientMap();
// First try to find a pointed at active object
if(look_for_object)
{
selected_object = client->getSelectedActiveObject(d*BS,
camera_position, shootline);
- }
- if(selected_object != NULL)
- {
- core::aabbox3d<f32> *selection_box
- = selected_object->getSelectionBox();
- // Box should exist because object was returned in the
- // first place
- assert(selection_box);
- v3f pos = selected_object->getPosition();
-
- hilightbox = core::aabbox3d<f32>(
- selection_box->MinEdge + pos,
- selection_box->MaxEdge + pos
- );
+ if(selected_object != NULL)
+ {
+ if(selected_object->doShowSelectionBox())
+ {
+ aabb3f *selection_box = selected_object->getSelectionBox();
+ // Box should exist because object was
+ // returned in the first place
+ assert(selection_box);
+
+ v3f pos = selected_object->getPosition();
+ hilightboxes.push_back(aabb3f(
+ selection_box->MinEdge + pos,
+ selection_box->MaxEdge + pos));
+ }
- should_show_hilightbox = selected_object->doShowSelectionBox();
- result.type = POINTEDTHING_OBJECT;
- result.object_id = selected_object->getId();
- return result;
+ result.type = POINTEDTHING_OBJECT;
+ result.object_id = selected_object->getId();
+ return result;
+ }
}
// That didn't work, try to find a pointed at node
s16 zend = pos_i.Z + (camera_direction.Z>0 ? a : 1);
s16 xend = pos_i.X + (camera_direction.X>0 ? a : 1);
+ // Prevent signed number overflow
+ if(yend==32767)
+ yend=32766;
+ if(zend==32767)
+ zend=32766;
+ if(xend==32767)
+ xend=32766;
+
for(s16 y = ystart; y <= yend; y++)
for(s16 z = zstart; z <= zend; z++)
for(s16 x = xstart; x <= xend; x++)
MapNode n;
try
{
- n = client->getNode(v3s16(x,y,z));
+ n = map.getNode(v3s16(x,y,z));
}
catch(InvalidPositionException &e)
{
if(!isPointableNode(n, client, liquids_pointable))
continue;
+ std::vector<aabb3f> boxes = n.getSelectionBoxes(nodedef);
+
v3s16 np(x,y,z);
v3f npf = intToFloat(np, BS);
-
- f32 d = 0.01;
-
- v3s16 dirs[6] = {
- v3s16(0,0,1), // back
- v3s16(0,1,0), // top
- v3s16(1,0,0), // right
- v3s16(0,0,-1), // front
- v3s16(0,-1,0), // bottom
- v3s16(-1,0,0), // left
- };
-
- const ContentFeatures &f = nodedef->get(n);
-
- if(f.selection_box.type == NODEBOX_FIXED)
+
+ for(std::vector<aabb3f>::const_iterator
+ i = boxes.begin();
+ i != boxes.end(); i++)
{
- core::aabbox3d<f32> box = f.selection_box.fixed;
+ aabb3f box = *i;
box.MinEdge += npf;
box.MaxEdge += npf;
- v3s16 facedirs[6] = {
- v3s16(-1,0,0),
- v3s16(1,0,0),
- v3s16(0,-1,0),
- v3s16(0,1,0),
- v3s16(0,0,-1),
- v3s16(0,0,1),
- };
-
- core::aabbox3d<f32> faceboxes[6] = {
- // X-
- core::aabbox3d<f32>(
- box.MinEdge.X, box.MinEdge.Y, box.MinEdge.Z,
- box.MinEdge.X+d, box.MaxEdge.Y, box.MaxEdge.Z
- ),
- // X+
- core::aabbox3d<f32>(
- box.MaxEdge.X-d, box.MinEdge.Y, box.MinEdge.Z,
- box.MaxEdge.X, box.MaxEdge.Y, box.MaxEdge.Z
- ),
- // Y-
- core::aabbox3d<f32>(
- box.MinEdge.X, box.MinEdge.Y, box.MinEdge.Z,
- box.MaxEdge.X, box.MinEdge.Y+d, box.MaxEdge.Z
- ),
- // Y+
- core::aabbox3d<f32>(
- box.MinEdge.X, box.MaxEdge.Y-d, box.MinEdge.Z,
- box.MaxEdge.X, box.MaxEdge.Y, box.MaxEdge.Z
- ),
- // Z-
- core::aabbox3d<f32>(
- box.MinEdge.X, box.MinEdge.Y, box.MinEdge.Z,
- box.MaxEdge.X, box.MaxEdge.Y, box.MinEdge.Z+d
- ),
- // Z+
- core::aabbox3d<f32>(
- box.MinEdge.X, box.MinEdge.Y, box.MaxEdge.Z-d,
- box.MaxEdge.X, box.MaxEdge.Y, box.MaxEdge.Z
- ),
- };
-
- for(u16 i=0; i<6; i++)
+ for(u16 j=0; j<6; j++)
{
- v3f facedir_f(facedirs[i].X, facedirs[i].Y, facedirs[i].Z);
- v3f centerpoint = npf + facedir_f * BS/2;
+ v3s16 facedir = g_6dirs[j];
+ aabb3f facebox = box;
+
+ f32 d = 0.001*BS;
+ if(facedir.X > 0)
+ facebox.MinEdge.X = facebox.MaxEdge.X-d;
+ else if(facedir.X < 0)
+ facebox.MaxEdge.X = facebox.MinEdge.X+d;
+ else if(facedir.Y > 0)
+ facebox.MinEdge.Y = facebox.MaxEdge.Y-d;
+ else if(facedir.Y < 0)
+ facebox.MaxEdge.Y = facebox.MinEdge.Y+d;
+ else if(facedir.Z > 0)
+ facebox.MinEdge.Z = facebox.MaxEdge.Z-d;
+ else if(facedir.Z < 0)
+ facebox.MaxEdge.Z = facebox.MinEdge.Z+d;
+
+ v3f centerpoint = facebox.getCenter();
f32 distance = (centerpoint - camera_position).getLength();
if(distance >= mindistance)
continue;
- if(!faceboxes[i].intersectsWithLine(shootline))
+ if(!facebox.intersectsWithLine(shootline))
continue;
+
+ v3s16 np_above = np + facedir;
+
result.type = POINTEDTHING_NODE;
result.node_undersurface = np;
- result.node_abovesurface = np+facedirs[i];
+ result.node_abovesurface = np_above;
mindistance = distance;
- hilightbox = box;
- should_show_hilightbox = true;
- }
- }
- else if(f.selection_box.type == NODEBOX_WALLMOUNTED)
- {
- v3s16 dir = n.getWallMountedDir(nodedef);
- v3f dir_f = v3f(dir.X, dir.Y, dir.Z);
- dir_f *= BS/2 - BS/6 - BS/20;
- v3f cpf = npf + dir_f;
- f32 distance = (cpf - camera_position).getLength();
- core::aabbox3d<f32> box;
-
- // top
- if(dir == v3s16(0,1,0)){
- box = f.selection_box.wall_top;
- }
- // bottom
- else if(dir == v3s16(0,-1,0)){
- box = f.selection_box.wall_bottom;
- }
- // side
- else{
- v3f vertices[2] =
- {
- f.selection_box.wall_side.MinEdge,
- f.selection_box.wall_side.MaxEdge
- };
-
- for(s32 i=0; i<2; i++)
- {
- if(dir == v3s16(-1,0,0))
- vertices[i].rotateXZBy(0);
- if(dir == v3s16(1,0,0))
- vertices[i].rotateXZBy(180);
- if(dir == v3s16(0,0,-1))
- vertices[i].rotateXZBy(90);
- if(dir == v3s16(0,0,1))
- vertices[i].rotateXZBy(-90);
- }
-
- box = core::aabbox3d<f32>(vertices[0]);
- box.addInternalPoint(vertices[1]);
- }
-
- box.MinEdge += npf;
- box.MaxEdge += npf;
-
- if(distance < mindistance)
- {
- if(box.intersectsWithLine(shootline))
+ hilightboxes.clear();
+ for(std::vector<aabb3f>::const_iterator
+ i2 = boxes.begin();
+ i2 != boxes.end(); i2++)
{
- result.type = POINTEDTHING_NODE;
- result.node_undersurface = np;
- result.node_abovesurface = np;
- mindistance = distance;
- hilightbox = box;
- should_show_hilightbox = true;
+ aabb3f box = *i2;
+ box.MinEdge += npf + v3f(-d,-d,-d);
+ box.MaxEdge += npf + v3f(d,d,d);
+ hilightboxes.push_back(box);
}
}
}
- else // NODEBOX_REGULAR
- {
- for(u16 i=0; i<6; i++)
- {
- v3f dir_f = v3f(dirs[i].X,
- dirs[i].Y, dirs[i].Z);
- v3f centerpoint = npf + dir_f * BS/2;
- f32 distance =
- (centerpoint - camera_position).getLength();
-
- if(distance < mindistance)
- {
- core::CMatrix4<f32> m;
- m.buildRotateFromTo(v3f(0,0,1), dir_f);
-
- // This is the back face
- v3f corners[2] = {
- v3f(BS/2, BS/2, BS/2),
- v3f(-BS/2, -BS/2, BS/2+d)
- };
-
- for(u16 j=0; j<2; j++)
- {
- m.rotateVect(corners[j]);
- corners[j] += npf;
- }
-
- core::aabbox3d<f32> facebox(corners[0]);
- facebox.addInternalPoint(corners[1]);
-
- if(facebox.intersectsWithLine(shootline))
- {
- result.type = POINTEDTHING_NODE;
- result.node_undersurface = np;
- result.node_abovesurface = np + dirs[i];
- mindistance = distance;
-
- //hilightbox = facebox;
-
- const float d = 0.502;
- core::aabbox3d<f32> nodebox
- (-BS*d, -BS*d, -BS*d, BS*d, BS*d, BS*d);
- v3f nodepos_f = intToFloat(np, BS);
- nodebox.MinEdge += nodepos_f;
- nodebox.MaxEdge += nodepos_f;
- hilightbox = nodebox;
- should_show_hilightbox = true;
- }
- } // if distance < mindistance
- } // for dirs
- } // regular block
} // for coords
return result;
}
-void update_skybox(video::IVideoDriver* driver, ITextureSource *tsrc,
- scene::ISceneManager* smgr, scene::ISceneNode* &skybox,
- float brightness)
-{
- if(skybox)
- {
- skybox->remove();
- }
-
- /*// Disable skybox if FarMesh is enabled
- if(g_settings->getBool("enable_farmesh"))
- return;*/
-
- if(brightness >= 0.7)
- {
- skybox = smgr->addSkyBoxSceneNode(
- tsrc->getTextureRaw("skybox2.png"),
- tsrc->getTextureRaw("skybox3.png"),
- tsrc->getTextureRaw("skybox1.png"),
- tsrc->getTextureRaw("skybox1.png"),
- tsrc->getTextureRaw("skybox1.png"),
- tsrc->getTextureRaw("skybox1.png"));
- }
- else if(brightness >= 0.2)
- {
- skybox = smgr->addSkyBoxSceneNode(
- tsrc->getTextureRaw("skybox2_dawn.png"),
- tsrc->getTextureRaw("skybox3_dawn.png"),
- tsrc->getTextureRaw("skybox1_dawn.png"),
- tsrc->getTextureRaw("skybox1_dawn.png"),
- tsrc->getTextureRaw("skybox1_dawn.png"),
- tsrc->getTextureRaw("skybox1_dawn.png"));
- }
- else
- {
- skybox = smgr->addSkyBoxSceneNode(
- tsrc->getTextureRaw("skybox2_night.png"),
- tsrc->getTextureRaw("skybox3_night.png"),
- tsrc->getTextureRaw("skybox1_night.png"),
- tsrc->getTextureRaw("skybox1_night.png"),
- tsrc->getTextureRaw("skybox1_night.png"),
- tsrc->getTextureRaw("skybox1_night.png"));
- }
-}
-
/*
Draws a screen with a single text on it.
Text will be removed when the screen is drawn the next time.
}
}
+class ProfilerGraph
+{
+private:
+ struct Piece{
+ Profiler::GraphValues values;
+ };
+ struct Meta{
+ float min;
+ float max;
+ video::SColor color;
+ Meta(float initial=0, video::SColor color=
+ video::SColor(255,255,255,255)):
+ min(initial),
+ max(initial),
+ color(color)
+ {}
+ };
+ std::list<Piece> m_log;
+public:
+ u32 m_log_max_size;
+
+ ProfilerGraph():
+ m_log_max_size(200)
+ {}
+
+ void put(const Profiler::GraphValues &values)
+ {
+ Piece piece;
+ piece.values = values;
+ m_log.push_back(piece);
+ while(m_log.size() > m_log_max_size)
+ m_log.erase(m_log.begin());
+ }
+
+ void draw(s32 x_left, s32 y_bottom, video::IVideoDriver *driver,
+ gui::IGUIFont* font) const
+ {
+ std::map<std::string, Meta> m_meta;
+ for(std::list<Piece>::const_iterator k = m_log.begin();
+ k != m_log.end(); k++)
+ {
+ const Piece &piece = *k;
+ for(Profiler::GraphValues::const_iterator i = piece.values.begin();
+ i != piece.values.end(); i++){
+ const std::string &id = i->first;
+ const float &value = i->second;
+ std::map<std::string, Meta>::iterator j =
+ m_meta.find(id);
+ if(j == m_meta.end()){
+ m_meta[id] = Meta(value);
+ continue;
+ }
+ if(value < j->second.min)
+ j->second.min = value;
+ if(value > j->second.max)
+ j->second.max = value;
+ }
+ }
+
+ // Assign colors
+ static const video::SColor usable_colors[] = {
+ video::SColor(255,255,100,100),
+ video::SColor(255,90,225,90),
+ video::SColor(255,100,100,255),
+ video::SColor(255,255,150,50),
+ video::SColor(255,220,220,100)
+ };
+ static const u32 usable_colors_count =
+ sizeof(usable_colors) / sizeof(*usable_colors);
+ u32 next_color_i = 0;
+ for(std::map<std::string, Meta>::iterator i = m_meta.begin();
+ i != m_meta.end(); i++){
+ Meta &meta = i->second;
+ video::SColor color(255,200,200,200);
+ if(next_color_i < usable_colors_count)
+ color = usable_colors[next_color_i++];
+ meta.color = color;
+ }
+
+ s32 graphh = 50;
+ s32 textx = x_left + m_log_max_size + 15;
+ s32 textx2 = textx + 200 - 15;
+
+ // Draw background
+ /*{
+ u32 num_graphs = m_meta.size();
+ core::rect<s32> rect(x_left, y_bottom - num_graphs*graphh,
+ textx2, y_bottom);
+ video::SColor bgcolor(120,0,0,0);
+ driver->draw2DRectangle(bgcolor, rect, NULL);
+ }*/
+
+ s32 meta_i = 0;
+ for(std::map<std::string, Meta>::const_iterator i = m_meta.begin();
+ i != m_meta.end(); i++){
+ const std::string &id = i->first;
+ const Meta &meta = i->second;
+ s32 x = x_left;
+ s32 y = y_bottom - meta_i * 50;
+ float show_min = meta.min;
+ float show_max = meta.max;
+ if(show_min >= -0.0001 && show_max >= -0.0001){
+ if(show_min <= show_max * 0.5)
+ show_min = 0;
+ }
+ s32 texth = 15;
+ char buf[10];
+ snprintf(buf, 10, "%.3g", show_max);
+ font->draw(narrow_to_wide(buf).c_str(),
+ core::rect<s32>(textx, y - graphh,
+ textx2, y - graphh + texth),
+ meta.color);
+ snprintf(buf, 10, "%.3g", show_min);
+ font->draw(narrow_to_wide(buf).c_str(),
+ core::rect<s32>(textx, y - texth,
+ textx2, y),
+ meta.color);
+ font->draw(narrow_to_wide(id).c_str(),
+ core::rect<s32>(textx, y - graphh/2 - texth/2,
+ textx2, y - graphh/2 + texth/2),
+ meta.color);
+ s32 graph1y = y;
+ s32 graph1h = graphh;
+ bool relativegraph = (show_min != 0 && show_min != show_max);
+ float lastscaledvalue = 0.0;
+ bool lastscaledvalue_exists = false;
+ for(std::list<Piece>::const_iterator j = m_log.begin();
+ j != m_log.end(); j++)
+ {
+ const Piece &piece = *j;
+ float value = 0;
+ bool value_exists = false;
+ Profiler::GraphValues::const_iterator k =
+ piece.values.find(id);
+ if(k != piece.values.end()){
+ value = k->second;
+ value_exists = true;
+ }
+ if(!value_exists){
+ x++;
+ lastscaledvalue_exists = false;
+ continue;
+ }
+ float scaledvalue = 1.0;
+ if(show_max != show_min)
+ scaledvalue = (value - show_min) / (show_max - show_min);
+ if(scaledvalue == 1.0 && value == 0){
+ x++;
+ lastscaledvalue_exists = false;
+ continue;
+ }
+ if(relativegraph){
+ if(lastscaledvalue_exists){
+ s32 ivalue1 = lastscaledvalue * graph1h;
+ s32 ivalue2 = scaledvalue * graph1h;
+ driver->draw2DLine(v2s32(x-1, graph1y - ivalue1),
+ v2s32(x, graph1y - ivalue2), meta.color);
+ }
+ lastscaledvalue = scaledvalue;
+ lastscaledvalue_exists = true;
+ } else{
+ s32 ivalue = scaledvalue * graph1h;
+ driver->draw2DLine(v2s32(x, graph1y),
+ v2s32(x, graph1y - ivalue), meta.color);
+ }
+ x++;
+ }
+ meta_i++;
+ }
+ }
+};
+
+class NodeDugEvent: public MtEvent
+{
+public:
+ v3s16 p;
+ MapNode n;
+
+ NodeDugEvent(v3s16 p, MapNode n):
+ p(p),
+ n(n)
+ {}
+ const char* getType() const
+ {return "NodeDug";}
+};
+
+class SoundMaker
+{
+ ISoundManager *m_sound;
+ INodeDefManager *m_ndef;
+public:
+ float m_player_step_timer;
+
+ SimpleSoundSpec m_player_step_sound;
+ SimpleSoundSpec m_player_leftpunch_sound;
+ SimpleSoundSpec m_player_rightpunch_sound;
+
+ SoundMaker(ISoundManager *sound, INodeDefManager *ndef):
+ m_sound(sound),
+ m_ndef(ndef),
+ m_player_step_timer(0)
+ {
+ }
+
+ void playPlayerStep()
+ {
+ if(m_player_step_timer <= 0 && m_player_step_sound.exists()){
+ m_player_step_timer = 0.03;
+ m_sound->playSound(m_player_step_sound, false);
+ }
+ }
+
+ static void viewBobbingStep(MtEvent *e, void *data)
+ {
+ SoundMaker *sm = (SoundMaker*)data;
+ sm->playPlayerStep();
+ }
+
+ static void playerRegainGround(MtEvent *e, void *data)
+ {
+ SoundMaker *sm = (SoundMaker*)data;
+ sm->playPlayerStep();
+ }
+
+ static void playerJump(MtEvent *e, void *data)
+ {
+ //SoundMaker *sm = (SoundMaker*)data;
+ }
+
+ static void cameraPunchLeft(MtEvent *e, void *data)
+ {
+ SoundMaker *sm = (SoundMaker*)data;
+ sm->m_sound->playSound(sm->m_player_leftpunch_sound, false);
+ }
+
+ static void cameraPunchRight(MtEvent *e, void *data)
+ {
+ SoundMaker *sm = (SoundMaker*)data;
+ sm->m_sound->playSound(sm->m_player_rightpunch_sound, false);
+ }
+
+ static void nodeDug(MtEvent *e, void *data)
+ {
+ SoundMaker *sm = (SoundMaker*)data;
+ NodeDugEvent *nde = (NodeDugEvent*)e;
+ sm->m_sound->playSound(sm->m_ndef->get(nde->n).sound_dug, false);
+ }
+
+ void registerReceiver(MtEventManager *mgr)
+ {
+ mgr->reg("ViewBobbingStep", SoundMaker::viewBobbingStep, this);
+ mgr->reg("PlayerRegainGround", SoundMaker::playerRegainGround, this);
+ mgr->reg("PlayerJump", SoundMaker::playerJump, this);
+ mgr->reg("CameraPunchLeft", SoundMaker::cameraPunchLeft, this);
+ mgr->reg("CameraPunchRight", SoundMaker::cameraPunchRight, this);
+ mgr->reg("NodeDug", SoundMaker::nodeDug, this);
+ }
+
+ void step(float dtime)
+ {
+ m_player_step_timer -= dtime;
+ }
+};
+
+// Locally stored sounds don't need to be preloaded because of this
+class GameOnDemandSoundFetcher: public OnDemandSoundFetcher
+{
+ std::set<std::string> m_fetched;
+public:
+
+ void fetchSounds(const std::string &name,
+ std::set<std::string> &dst_paths,
+ std::set<std::string> &dst_datas)
+ {
+ if(m_fetched.count(name))
+ return;
+ m_fetched.insert(name);
+ std::string base = porting::path_share + DIR_DELIM + "testsounds";
+ dst_paths.insert(base + DIR_DELIM + name + ".ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".0.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".1.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".2.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".3.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".4.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".5.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".6.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".7.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".8.ogg");
+ dst_paths.insert(base + DIR_DELIM + name + ".9.ogg");
+ }
+};
+
+class GameGlobalShaderConstantSetter : public IShaderConstantSetter
+{
+ Sky *m_sky;
+ bool *m_force_fog_off;
+ f32 *m_fog_range;
+ Client *m_client;
+
+public:
+ GameGlobalShaderConstantSetter(Sky *sky, bool *force_fog_off,
+ f32 *fog_range, Client *client):
+ m_sky(sky),
+ m_force_fog_off(force_fog_off),
+ m_fog_range(fog_range),
+ m_client(client)
+ {}
+ ~GameGlobalShaderConstantSetter() {}
+
+ virtual void onSetConstants(video::IMaterialRendererServices *services,
+ bool is_highlevel)
+ {
+ if(!is_highlevel)
+ return;
+
+ // Background color
+ video::SColor bgcolor = m_sky->getBgColor();
+ video::SColorf bgcolorf(bgcolor);
+ float bgcolorfa[4] = {
+ bgcolorf.r,
+ bgcolorf.g,
+ bgcolorf.b,
+ bgcolorf.a,
+ };
+ services->setPixelShaderConstant("skyBgColor", bgcolorfa, 4);
+
+ // Fog distance
+ float fog_distance = *m_fog_range;
+ if(*m_force_fog_off)
+ fog_distance = 10000*BS;
+ services->setPixelShaderConstant("fogDistance", &fog_distance, 1);
+
+ // Day-night ratio
+ u32 daynight_ratio = m_client->getEnv().getDayNightRatio();
+ float daynight_ratio_f = (float)daynight_ratio / 1000.0;
+ services->setPixelShaderConstant("dayNightRatio", &daynight_ratio_f, 1);
+ }
+};
+
void the_game(
bool &kill,
bool random_input,
std::wstring &error_message,
std::string configpath,
ChatBackend &chat_backend,
- const SubgameSpec &gamespec // Used for local game
+ const SubgameSpec &gamespec, // Used for local game,
+ bool simple_singleplayer_mode
)
{
+ FormspecFormSource* current_formspec = 0;
video::IVideoDriver* driver = device->getVideoDriver();
scene::ISceneManager* smgr = device->getSceneManager();
//const s32 hotbar_imagesize = 64;
s32 hotbar_imagesize = 48;
- // The color of the sky
-
- //video::SColor skycolor = video::SColor(255,140,186,250);
-
- video::SColor bgcolor_bright = video::SColor(255,170,200,230);
-
/*
Draw "Loading" screen
*/
// Create texture source
IWritableTextureSource *tsrc = createTextureSource(device);
+ // Create shader source
+ IWritableShaderSource *shsrc = createShaderSource(device);
+
// These will be filled by data received from the server
// Create item definition manager
IWritableItemDefManager *itemdef = createItemDefManager();
// Create node definition manager
IWritableNodeDefManager *nodedef = createNodeDefManager();
+
+ // Sound fetcher (useful when testing)
+ GameOnDemandSoundFetcher soundfetcher;
+
+ // Sound manager
+ ISoundManager *sound = NULL;
+ bool sound_is_dummy = false;
+#if USE_SOUND
+ if(g_settings->getBool("enable_sound")){
+ infostream<<"Attempting to use OpenAL audio"<<std::endl;
+ sound = createOpenALSoundManager(&soundfetcher);
+ if(!sound)
+ infostream<<"Failed to initialize OpenAL audio"<<std::endl;
+ } else {
+ infostream<<"Sound disabled."<<std::endl;
+ }
+#endif
+ if(!sound){
+ infostream<<"Using dummy audio."<<std::endl;
+ sound = &dummySoundManager;
+ sound_is_dummy = true;
+ }
+ // Event manager
+ EventManager eventmgr;
+
+ // Sound maker
+ SoundMaker soundmaker(sound, nodedef);
+ soundmaker.registerReceiver(&eventmgr);
+
// Add chat log output for errors to be shown in chat
LogOutputBuffer chat_log_error_buf(LMT_ERROR);
+ // Create UI for modifying quicktune values
+ QuicktuneShortcutter quicktune;
+
/*
Create server.
SharedPtr will delete it when it goes out of scope.
if(address == ""){
draw_load_screen(L"Creating server...", driver, font);
infostream<<"Creating server"<<std::endl;
- server = new Server(map_dir, configpath, gamespec);
+ server = new Server(map_dir, configpath, gamespec,
+ simple_singleplayer_mode);
server->start(port);
}
+ try{
do{ // Client scope (breakable do-while(0))
/*
MapDrawControl draw_control;
Client client(device, playername.c_str(), password, draw_control,
- tsrc, itemdef, nodedef);
+ tsrc, shsrc, itemdef, nodedef, sound, &eventmgr);
// Client acts as our GameDef
IGameDef *gamedef = &client;
ss<<L" Item definitions\n";
ss<<(client.nodedefReceived()?L"[X]":L"[ ]");
ss<<L" Node definitions\n";
- //ss<<(client.texturesReceived()?L"[X]":L"[ ]");
- ss<<L"["<<(int)(client.textureReceiveProgress()*100+0.5)<<L"%] ";
- ss<<L" Textures\n";
+ ss<<L"["<<(int)(client.mediaReceiveProgress()*100+0.5)<<L"%] ";
+ ss<<L" Media\n";
draw_load_screen(ss.str(), driver, font);
*/
client.afterContentReceived();
- /*
- Create skybox
- */
- float old_brightness = 1.0;
- scene::ISceneNode* skybox = NULL;
- update_skybox(driver, tsrc, smgr, skybox, 1.0);
-
/*
Create the camera node
*/
- Camera camera(smgr, draw_control);
+ Camera camera(smgr, draw_control, gamedef);
if (!camera.successfullyCreated(error_message))
return;
Clouds
*/
- float cloud_height = BS*100;
Clouds *clouds = NULL;
if(g_settings->getBool("enable_clouds"))
{
- clouds = new Clouds(smgr->getRootSceneNode(), smgr, -1,
- cloud_height, time(0));
+ clouds = new Clouds(smgr->getRootSceneNode(), smgr, -1, time(0));
}
+
+ /*
+ Skybox thingy
+ */
+
+ Sky *sky = NULL;
+ sky = new Sky(smgr->getRootSceneNode(), smgr, -1);
/*
FarMesh
Inventory local_inventory(itemdef);
/*
- Move into game
+ Find out size of crack animation
*/
-
- //gui_loadingtext->remove();
+ int crack_animation_length = 5;
+ {
+ video::ITexture *t = tsrc->getTextureRaw("crack_anylength.png");
+ v2u32 size = t->getOriginalSize();
+ crack_animation_length = size.Y / size.X;
+ }
/*
Add some gui stuff
// First line of debug text
gui::IGUIStaticText *guitext = guienv->addStaticText(
- L"Minetest-c55",
+ L"Minetest",
core::rect<s32>(5, 5, 795, 5+text_height),
false, false);
// Second line of debug text
gui::IGUIStaticText *guitext_info = guienv->addStaticText(
L"",
core::rect<s32>(0,0,400,text_height*5+5) + v2s32(100,200),
- false, false);
+ false, true);
// Status text (displays info when showing and hiding GUI stuff, etc.)
gui::IGUIStaticText *guitext_status = guienv->addStaticText(
L"<Profiler>",
core::rect<s32>(0,0,0,0),
false, false);
- guitext_profiler->setBackgroundColor(video::SColor(80,0,0,0));
+ guitext_profiler->setBackgroundColor(video::SColor(120,0,0,0));
guitext_profiler->setVisible(false);
- /*GUIQuickInventory *quick_inventory = new GUIQuickInventory
- (guienv, NULL, v2s32(10, 70), 5, &local_inventory);*/
- /*GUIQuickInventory *quick_inventory = new GUIQuickInventory
- (guienv, NULL, v2s32(0, 0), quickinv_itemcount, &local_inventory);*/
-
- // Test the text input system
- /*(new GUITextInputMenu(guienv, guiroot, -1, &g_menumgr,
- NULL))->drop();*/
- /*GUIMessageMenu *menu =
- new GUIMessageMenu(guienv, guiroot, -1,
- &g_menumgr,
- L"Asd");
- menu->drop();*/
-
- // Launch pause menu
- /*(new GUIPauseMenu(guienv, guiroot, -1, g_gamecallback,
- &g_menumgr))->drop();*/
-
- //s32 guitext_chat_pad_bottom = 70;
-
/*
Some statistics are collected in these
*/
u32 scenetime = 0;
u32 endscenetime = 0;
- // A test
- //throw con::PeerNotFoundException("lol");
-
- float brightness = 1.0;
-
- core::list<float> frametime_log;
+ float recent_turn_speed = 0.0;
+
+ ProfilerGraph graph;
+ // Initially clear the profiler
+ Profiler::GraphValues dummyvalues;
+ g_profiler->graphGet(dummyvalues);
float nodig_delay_timer = 0.0;
float dig_time = 0.0;
bool digging = false;
bool ldown_for_dig = false;
- float damage_flash_timer = 0;
+ float damage_flash = 0;
s16 farmesh_range = 20*MAP_BLOCKSIZE;
+ float jump_timer = 0;
+ bool reset_jump_timer = false;
+
const float object_hit_delay = 0.2;
float object_hit_delay_timer = 0.0;
float time_from_last_punch = 10;
- float crack_update_timer = 0.0;
-
+ float update_draw_list_timer = 0.0;
+ v3f update_draw_list_last_cam_dir;
+
bool invert_mouse = g_settings->getBool("invert_mouse");
bool respawn_menu_active = false;
bool show_hud = true;
bool show_chat = true;
bool force_fog_off = false;
+ f32 fog_range = 100*BS;
bool disable_camera_update = false;
bool show_debug = g_settings->getBool("show_debug");
- bool show_debug_frametime = false;
+ bool show_profiler_graph = false;
u32 show_profiler = 0;
u32 show_profiler_max = 3; // Number of pages
+ float time_of_day = 0;
+ float time_of_day_smooth = 0;
+
+ float repeat_rightclick_timer = 0;
+
+ /*
+ Shader constants
+ */
+ shsrc->addGlobalConstantSetter(new GameGlobalShaderConstantSetter(
+ sky, &force_fog_off, &fog_range, &client));
+
/*
Main loop
*/
// NOTE: So we have to use getTime() and call run()s between them
u32 lasttime = device->getTimer()->getTime();
- while(device->run() && kill == false)
- {
- //std::cerr<<"frame"<<std::endl;
-
- if(client.accessDenied())
- {
- error_message = L"Access denied. Reason: "
- +client.accessDeniedReason();
- errorstream<<wide_to_narrow(error_message)<<std::endl;
- break;
- }
+ LocalPlayer* player = client.getEnv().getLocalPlayer();
+ player->hurt_tilt_timer = 0;
+ player->hurt_tilt_strength = 0;
- if(g_gamecallback->disconnect_requested)
- {
- g_gamecallback->disconnect_requested = false;
+ for(;;)
+ {
+ if(device->run() == false || kill == true)
break;
- }
-
- if(g_gamecallback->changepassword_requested)
- {
- (new GUIPasswordChange(guienv, guiroot, -1,
- &g_menumgr, &client))->drop();
- g_gamecallback->changepassword_requested = false;
- }
-
- /*
- Process TextureSource's queue
- */
- tsrc->processQueue();
-
- /*
- Random calculations
- */
- last_screensize = screensize;
- screensize = driver->getScreenSize();
- v2s32 displaycenter(screensize.X/2,screensize.Y/2);
- //bool screensize_changed = screensize != last_screensize;
-
- // Resize hotbar
- if(screensize.Y <= 800)
- hotbar_imagesize = 32;
- else if(screensize.Y <= 1280)
- hotbar_imagesize = 48;
- else
- hotbar_imagesize = 64;
-
- // Hilight boxes collected during the loop and displayed
- core::list< core::aabbox3d<f32> > hilightboxes;
-
- // Info text
- std::wstring infotext;
- // When screen size changes, update positions and sizes of stuff
- /*if(screensize_changed)
- {
- v2s32 pos(displaycenter.X-((quickinv_itemcount-1)*quickinv_spacing+quickinv_size)/2, screensize.Y-quickinv_spacing);
- quick_inventory->updatePosition(pos);
- }*/
-
- //TimeTaker //timer1("//timer1");
-
// Time of frame without fps limit
float busytime;
u32 busytime_u32;
busytime_u32 = 0;
busytime = busytime_u32 / 1000.0;
}
+
+ g_profiler->graphAdd("mainloop_other", busytime - (float)drawtime/1000.0f);
- //infostream<<"busytime_u32="<<busytime_u32<<std::endl;
-
// Necessary for device->getTimer()->getTime()
device->run();
{
u32 sleeptime = frametime_min - busytime_u32;
device->sleep(sleeptime);
+ g_profiler->graphAdd("mainloop_sleep", (float)sleeptime/1000.0f);
}
}
dtime = 0;
lasttime = time;
+ g_profiler->graphAdd("mainloop_dtime", dtime);
+
/* Run timers */
if(nodig_delay_timer >= 0)
if(object_hit_delay_timer >= 0)
object_hit_delay_timer -= dtime;
time_from_last_punch += dtime;
- crack_update_timer += dtime;
-
+
g_profiler->add("Elapsed time", dtime);
g_profiler->avg("FPS", 1./dtime);
- /*
- Log frametime for visualization
- */
- frametime_log.push_back(dtime);
- if(frametime_log.size() > 100)
- {
- core::list<float>::Iterator i = frametime_log.begin();
- frametime_log.erase(i);
- }
-
- /*
- Visualize frametime in terminal
- */
- /*for(u32 i=0; i<dtime*400; i++)
- infostream<<"X";
- infostream<<std::endl;*/
-
/*
Time average and jitter calculation
*/
jitter1_max = 0.0;
}
}
-
+
+ /*
+ Busytime average and jitter calculation
+ */
+
+ static f32 busytime_avg1 = 0.0;
+ busytime_avg1 = busytime_avg1 * 0.98 + busytime * 0.02;
+ f32 busytime_jitter1 = busytime - busytime_avg1;
+
+ static f32 busytime_jitter1_max_sample = 0.0;
+ static f32 busytime_jitter1_min_sample = 0.0;
+ {
+ static f32 jitter1_max = 0.0;
+ static f32 jitter1_min = 0.0;
+ static f32 counter = 0.0;
+ if(busytime_jitter1 > jitter1_max)
+ jitter1_max = busytime_jitter1;
+ if(busytime_jitter1 < jitter1_min)
+ jitter1_min = busytime_jitter1;
+ counter += dtime;
+ if(counter > 0.0){
+ counter -= 3.0;
+ busytime_jitter1_max_sample = jitter1_max;
+ busytime_jitter1_min_sample = jitter1_min;
+ jitter1_max = 0.0;
+ jitter1_min = 0.0;
+ }
+ }
+
+ /*
+ Handle miscellaneous stuff
+ */
+
+ if(client.accessDenied())
+ {
+ error_message = L"Access denied. Reason: "
+ +client.accessDeniedReason();
+ errorstream<<wide_to_narrow(error_message)<<std::endl;
+ break;
+ }
+
+ if(g_gamecallback->disconnect_requested)
+ {
+ g_gamecallback->disconnect_requested = false;
+ break;
+ }
+
+ if(g_gamecallback->changepassword_requested)
+ {
+ (new GUIPasswordChange(guienv, guiroot, -1,
+ &g_menumgr, &client))->drop();
+ g_gamecallback->changepassword_requested = false;
+ }
+
+ if(g_gamecallback->changevolume_requested)
+ {
+ (new GUIVolumeChange(guienv, guiroot, -1,
+ &g_menumgr, &client))->drop();
+ g_gamecallback->changevolume_requested = false;
+ }
+
+ /* Process TextureSource's queue */
+ tsrc->processQueue();
+
+ /* Process ItemDefManager's queue */
+ itemdef->processQueue(gamedef);
+
/*
- Busytime average and jitter calculation
+ Process ShaderSource's queue
*/
+ shsrc->processQueue();
- static f32 busytime_avg1 = 0.0;
- busytime_avg1 = busytime_avg1 * 0.98 + busytime * 0.02;
- f32 busytime_jitter1 = busytime - busytime_avg1;
+ /*
+ Random calculations
+ */
+ last_screensize = screensize;
+ screensize = driver->getScreenSize();
+ v2s32 displaycenter(screensize.X/2,screensize.Y/2);
+ //bool screensize_changed = screensize != last_screensize;
+
+ // Resize hotbar
+ if(screensize.Y <= 800)
+ hotbar_imagesize = 32;
+ else if(screensize.Y <= 1280)
+ hotbar_imagesize = 48;
+ else
+ hotbar_imagesize = 64;
- static f32 busytime_jitter1_max_sample = 0.0;
- static f32 busytime_jitter1_min_sample = 0.0;
- {
- static f32 jitter1_max = 0.0;
- static f32 jitter1_min = 0.0;
- static f32 counter = 0.0;
- if(busytime_jitter1 > jitter1_max)
- jitter1_max = busytime_jitter1;
- if(busytime_jitter1 < jitter1_min)
- jitter1_min = busytime_jitter1;
- counter += dtime;
- if(counter > 0.0){
- counter -= 3.0;
- busytime_jitter1_max_sample = jitter1_max;
- busytime_jitter1_min_sample = jitter1_min;
- jitter1_max = 0.0;
- jitter1_min = 0.0;
- }
- }
+ // Hilight boxes collected during the loop and displayed
+ std::vector<aabb3f> hilightboxes;
+ // Info text
+ std::wstring infotext;
+
/*
Debug info for client
*/
// Input handler step() (used by the random input generator)
input->step(dtime);
+ // Increase timer for doubleclick of "jump"
+ if(g_settings->getBool("doubletap_jump") && jump_timer <= 0.2)
+ jump_timer += dtime;
+
/*
Launch menus and trigger stuff according to keys
*/
infostream<<"the_game: "
<<"Launching inventory"<<std::endl;
- GUIInventoryMenu *menu =
- new GUIInventoryMenu(guienv, guiroot, -1,
- &g_menumgr, v2s16(8,7),
+ GUIFormSpecMenu *menu =
+ new GUIFormSpecMenu(device, guiroot, -1,
+ &g_menumgr,
&client, gamedef);
InventoryLocation inventoryloc;
inventoryloc.setCurrentPlayer();
- core::array<GUIInventoryMenu::DrawSpec> draw_spec;
- draw_spec.push_back(GUIInventoryMenu::DrawSpec(
- "list", inventoryloc, "main",
- v2s32(0, 3), v2s32(8, 4)));
- draw_spec.push_back(GUIInventoryMenu::DrawSpec(
- "list", inventoryloc, "craft",
- v2s32(3, 0), v2s32(3, 3)));
- draw_spec.push_back(GUIInventoryMenu::DrawSpec(
- "list", inventoryloc, "craftpreview",
- v2s32(7, 1), v2s32(1, 1)));
-
- menu->setDrawSpec(draw_spec);
-
+ PlayerInventoryFormSource *src = new PlayerInventoryFormSource(&client);
+ assert(src);
+ menu->setFormSpec(src->getForm(), inventoryloc);
+ menu->setFormSource(src);
+ menu->setTextDest(new TextDestPlayerInventory(&client));
menu->drop();
}
else if(input->wasKeyDown(EscapeKey))
<<"Launching pause menu"<<std::endl;
// It will delete itself by itself
(new GUIPauseMenu(guienv, guiroot, -1, g_gamecallback,
- &g_menumgr))->drop();
+ &g_menumgr, simple_singleplayer_mode))->drop();
// Move mouse cursor on top of the disconnect button
- input->setMousePos(displaycenter.X, displaycenter.Y+25);
+ if(simple_singleplayer_mode)
+ input->setMousePos(displaycenter.X, displaycenter.Y+0);
+ else
+ input->setMousePos(displaycenter.X, displaycenter.Y+25);
}
else if(input->wasKeyDown(getKeySetting("keymap_chat")))
{
g_settings->set("free_move","true");
statustext = L"free_move enabled";
statustext_time = 0;
+ if(!client.checkPrivilege("fly"))
+ statustext += L" (note: no 'fly' privilege)";
+ }
+ }
+ else if(input->wasKeyDown(getKeySetting("keymap_jump")))
+ {
+ if(g_settings->getBool("doubletap_jump") && jump_timer < 0.2)
+ {
+ if(g_settings->getBool("free_move"))
+ {
+ g_settings->set("free_move","false");
+ statustext = L"free_move disabled";
+ statustext_time = 0;
+ }
+ else
+ {
+ g_settings->set("free_move","true");
+ statustext = L"free_move enabled";
+ statustext_time = 0;
+ if(!client.checkPrivilege("fly"))
+ statustext += L" (note: no 'fly' privilege)";
+ }
}
+ reset_jump_timer = true;
}
else if(input->wasKeyDown(getKeySetting("keymap_fastmove")))
{
g_settings->set("fast_move","true");
statustext = L"fast_move enabled";
statustext_time = 0;
+ if(!client.checkPrivilege("fast"))
+ statustext += L" (note: no 'fast' privilege)";
+ }
+ }
+ else if(input->wasKeyDown(getKeySetting("keymap_noclip")))
+ {
+ if(g_settings->getBool("noclip"))
+ {
+ g_settings->set("noclip","false");
+ statustext = L"noclip disabled";
+ statustext_time = 0;
+ }
+ else
+ {
+ g_settings->set("noclip","true");
+ statustext = L"noclip enabled";
+ statustext_time = 0;
+ if(!client.checkPrivilege("noclip"))
+ statustext += L" (note: no 'noclip' privilege)";
}
}
else if(input->wasKeyDown(getKeySetting("keymap_screenshot")))
{
// Initial / 3x toggle: Chat only
// 1x toggle: Debug text with chat
- // 2x toggle: Debug text with frametime
+ // 2x toggle: Debug text with profiler graph
if(!show_debug)
{
show_debug = true;
- show_debug_frametime = false;
+ show_profiler_graph = false;
statustext = L"Debug info shown";
statustext_time = 0;
}
- else if(show_debug_frametime)
+ else if(show_profiler_graph)
{
show_debug = false;
- show_debug_frametime = false;
- statustext = L"Debug info and frametime graph hidden";
+ show_profiler_graph = false;
+ statustext = L"Debug info and profiler graph hidden";
statustext_time = 0;
}
else
{
- show_debug_frametime = true;
- statustext = L"Frametime graph shown";
+ show_profiler_graph = true;
+ statustext = L"Profiler graph shown";
statustext_time = 0;
}
}
+ itos(range_new));
statustext_time = 0;
}
+
+ // Reset jump_timer
+ if(!input->isKeyDown(getKeySetting("keymap_jump")) && reset_jump_timer)
+ {
+ reset_jump_timer = false;
+ jump_timer = 0.0;
+ }
+
+ // Handle QuicktuneShortcutter
+ if(input->wasKeyDown(getKeySetting("keymap_quicktune_next")))
+ quicktune.next();
+ if(input->wasKeyDown(getKeySetting("keymap_quicktune_prev")))
+ quicktune.prev();
+ if(input->wasKeyDown(getKeySetting("keymap_quicktune_inc")))
+ quicktune.inc();
+ if(input->wasKeyDown(getKeySetting("keymap_quicktune_dec")))
+ quicktune.dec();
+ {
+ std::string msg = quicktune.getMessage();
+ if(msg != ""){
+ statustext = narrow_to_wide(msg);
+ statustext_time = 0;
+ }
+ }
// Item selection with mouse wheel
u16 new_playeritem = client.getPlayerItem();
NOTE: Do this before client.setPlayerControl() to not cause a camera lag of one frame
*/
+ float turn_amount = 0;
if((device->isWindowActive() && noMenuActive()) || random_input)
{
if(!random_input)
dx -= dtime * keyspeed;
if(input->isKeyDown(irr::KEY_RIGHT))
dx += dtime * keyspeed;*/
-
- camera_yaw -= dx*0.2;
- camera_pitch += dy*0.2;
+
+ float d = 0.2;
+ camera_yaw -= dx*d;
+ camera_pitch += dy*d;
if(camera_pitch < -89.5) camera_pitch = -89.5;
if(camera_pitch > 89.5) camera_pitch = 89.5;
+
+ turn_amount = v2f(dx, dy).getLength() * d;
}
input->setMousePos(displaycenter.X, displaycenter.Y);
}
//infostream<<"window inactive"<<std::endl;
first_loop_after_window_activation = true;
}
+ recent_turn_speed = recent_turn_speed * 0.9 + turn_amount * 0.1;
+ //std::cerr<<"recent_turn_speed = "<<recent_turn_speed<<std::endl;
/*
Player speed control
bool a_jump,
bool a_superspeed,
bool a_sneak,
+ bool a_LMB,
+ bool a_RMB,
float a_pitch,
float a_yaw*/
PlayerControl control(
input->isKeyDown(getKeySetting("keymap_jump")),
input->isKeyDown(getKeySetting("keymap_special1")),
input->isKeyDown(getKeySetting("keymap_sneak")),
+ input->getLeftState(),
+ input->getRightState(),
camera_pitch,
camera_yaw
);
client.setPlayerControl(control);
+ u32 keyPressed=
+ 1*(int)input->isKeyDown(getKeySetting("keymap_forward"))+
+ 2*(int)input->isKeyDown(getKeySetting("keymap_backward"))+
+ 4*(int)input->isKeyDown(getKeySetting("keymap_left"))+
+ 8*(int)input->isKeyDown(getKeySetting("keymap_right"))+
+ 16*(int)input->isKeyDown(getKeySetting("keymap_jump"))+
+ 32*(int)input->isKeyDown(getKeySetting("keymap_special1"))+
+ 64*(int)input->isKeyDown(getKeySetting("keymap_sneak"))+
+ 128*(int)input->getLeftState()+
+ 256*(int)input->getRightState();
+ LocalPlayer* player = client.getEnv().getLocalPlayer();
+ player->keyPressed=keyPressed;
}
/*
{
break;
}
- else if(event.type == CE_PLAYER_DAMAGE)
+ else if(event.type == CE_PLAYER_DAMAGE &&
+ client.getHP() != 0)
{
//u16 damage = event.player_damage.amount;
//infostream<<"Player damage: "<<damage<<std::endl;
- damage_flash_timer = 0.05;
- if(event.player_damage.amount >= 2){
- damage_flash_timer += 0.05 * event.player_damage.amount;
- }
+
+ damage_flash += 100.0;
+ damage_flash += 8.0 * event.player_damage.amount;
+
+ player->hurt_tilt_timer = 1.5;
+ player->hurt_tilt_strength = event.player_damage.amount/2;
+ player->hurt_tilt_strength = rangelim(player->hurt_tilt_strength, 2.0, 10.0);
}
else if(event.type == CE_PLAYER_FORCE_MOVE)
{
/* Handle visualization */
- damage_flash_timer = 0;
+ damage_flash = 0;
+
+ LocalPlayer* player = client.getEnv().getLocalPlayer();
+ player->hurt_tilt_timer = 0;
+ player->hurt_tilt_strength = 0;
/*LocalPlayer* player = client.getLocalPlayer();
player->setPosition(player->getPosition() + v3f(0,-BS,0));
camera.update(player, busytime, screensize);*/
}
+ else if (event.type == CE_SHOW_FORMSPEC)
+ {
+ if (current_formspec == 0)
+ {
+ /* Create menu */
+ current_formspec = new FormspecFormSource(*(event.show_formspec.formspec),¤t_formspec);
+
+ GUIFormSpecMenu *menu =
+ new GUIFormSpecMenu(device, guiroot, -1,
+ &g_menumgr,
+ &client, gamedef);
+ menu->setFormSource(current_formspec);
+ menu->setTextDest(new TextDestPlayerInventory(&client,*(event.show_formspec.formname)));
+ menu->drop();
+ }
+ else
+ {
+ /* update menu */
+ current_formspec->setForm(*(event.show_formspec.formspec));
+ }
+ delete(event.show_formspec.formspec);
+ delete(event.show_formspec.formname);
+ }
else if(event.type == CE_TEXTURES_UPDATED)
{
- update_skybox(driver, tsrc, smgr, skybox, brightness);
-
update_wielded_item_trigger = true;
}
+ else if(event.type == CE_SPAWN_PARTICLE)
+ {
+ LocalPlayer* player = client.getEnv().getLocalPlayer();
+ AtlasPointer ap =
+ gamedef->tsrc()->getTexture(*(event.spawn_particle.texture));
+
+ new Particle(gamedef, smgr, player, client.getEnv(),
+ *event.spawn_particle.pos,
+ *event.spawn_particle.vel,
+ *event.spawn_particle.acc,
+ event.spawn_particle.expirationtime,
+ event.spawn_particle.size,
+ event.spawn_particle.collisiondetection, ap);
+ }
+ else if(event.type == CE_ADD_PARTICLESPAWNER)
+ {
+ LocalPlayer* player = client.getEnv().getLocalPlayer();
+ AtlasPointer ap =
+ gamedef->tsrc()->getTexture(*(event.add_particlespawner.texture));
+
+ new ParticleSpawner(gamedef, smgr, player,
+ event.add_particlespawner.amount,
+ event.add_particlespawner.spawntime,
+ *event.add_particlespawner.minpos,
+ *event.add_particlespawner.maxpos,
+ *event.add_particlespawner.minvel,
+ *event.add_particlespawner.maxvel,
+ *event.add_particlespawner.minacc,
+ *event.add_particlespawner.maxacc,
+ event.add_particlespawner.minexptime,
+ event.add_particlespawner.maxexptime,
+ event.add_particlespawner.minsize,
+ event.add_particlespawner.maxsize,
+ event.add_particlespawner.collisiondetection,
+ ap,
+ event.add_particlespawner.id);
+ }
+ else if(event.type == CE_DELETE_PARTICLESPAWNER)
+ {
+ delete_particlespawner (event.delete_particlespawner.id);
+ }
}
}
Update camera
*/
- LocalPlayer* player = client.getLocalPlayer();
+ LocalPlayer* player = client.getEnv().getLocalPlayer();
float full_punch_interval = playeritem_toolcap.full_punch_interval;
float tool_reload_ratio = time_from_last_punch / full_punch_interval;
tool_reload_ratio = MYMIN(tool_reload_ratio, 1.0);
f32 camera_fov = camera.getFovMax();
if(!disable_camera_update){
- client.updateCamera(camera_position,
+ client.getEnv().getClientMap().updateCamera(camera_position,
camera_direction, camera_fov);
}
+
+ // Update sound listener
+ sound->updateListener(camera.getCameraNode()->getPosition(),
+ v3f(0,0,0), // velocity
+ camera.getDirection(),
+ camera.getCameraNode()->getUpVector());
+ sound->setListenerGain(g_settings->getFloat("sound_volume"));
- //timer2.stop();
- //TimeTaker //timer3("//timer3");
+ /*
+ Update sound maker
+ */
+ {
+ soundmaker.step(dtime);
+
+ ClientMap &map = client.getEnv().getClientMap();
+ MapNode n = map.getNodeNoEx(player->getStandingNodePos());
+ soundmaker.m_player_step_sound = nodedef->get(n).sound_footstep;
+ }
/*
Calculate what block is the crosshair pointing to
core::line3d<f32> shootline(camera_position,
camera_position + camera_direction * BS * (d+1));
- core::aabbox3d<f32> hilightbox;
- bool should_show_hilightbox = false;
ClientActiveObject *selected_object = NULL;
PointedThing pointed = getPointedThing(
camera_position, shootline, d,
playeritem_liquids_pointable, !ldown_for_dig,
// output
- hilightbox, should_show_hilightbox,
+ hilightboxes,
selected_object);
if(pointed != pointed_old)
//dstream<<"Pointing at "<<pointed.dump()<<std::endl;
}
- /*
- Visualize selection
- */
- if(should_show_hilightbox)
- hilightboxes.push_back(hilightbox);
-
/*
Stop digging when
- releasing left mouse button
if(!digging)
{
client.interact(1, pointed_old);
- client.clearTempMod(pointed_old.node_undersurface);
+ client.setCrack(-1, v3s16(0,0,0));
dig_time = 0.0;
}
}
}
bool left_punch = false;
+ soundmaker.m_player_leftpunch_sound.name = "";
+
+ if(input->getRightState())
+ repeat_rightclick_timer += dtime;
+ else
+ repeat_rightclick_timer = 0;
if(playeritem_usable && input->getLeftState())
{
/*
Check information text of node
*/
-
- NodeMetadata *meta = client.getNodeMetadata(nodepos);
- if(meta)
- {
- infotext = narrow_to_wide(meta->infoText());
- }
- else
- {
- MapNode n = client.getNode(nodepos);
- if(nodedef->get(n).tname_tiles[0] == "unknown_block.png"){
+
+ ClientMap &map = client.getEnv().getClientMap();
+ NodeMetadata *meta = map.getNodeMetadata(nodepos);
+ if(meta){
+ infotext = narrow_to_wide(meta->getString("infotext"));
+ } else {
+ MapNode n = map.getNode(nodepos);
+ if(nodedef->get(n).tiledef[0].name == "unknown_block.png"){
infotext = L"Unknown node: ";
infotext += narrow_to_wide(nodedef->get(n).name);
}
Handle digging
*/
-
if(nodig_delay_timer <= 0.0 && input->getLeftState())
{
if(!digging)
digging = true;
ldown_for_dig = true;
}
- MapNode n = client.getNode(nodepos);
-
+ MapNode n = client.getEnv().getClientMap().getNode(nodepos);
+
+ // NOTE: Similar piece of code exists on the server side for
+ // cheat detection.
// Get digging parameters
DigParams params = getDigParams(nodedef->get(n).groups,
&playeritem_toolcap);
if(tp)
params = getDigParams(nodedef->get(n).groups, tp);
}
+
+ SimpleSoundSpec sound_dig = nodedef->get(n).sound_dig;
+ if(sound_dig.exists()){
+ if(sound_dig.name == "__group"){
+ if(params.main_group != ""){
+ soundmaker.m_player_leftpunch_sound.gain = 0.5;
+ soundmaker.m_player_leftpunch_sound.name =
+ std::string("default_dig_") +
+ params.main_group;
+ }
+ } else{
+ soundmaker.m_player_leftpunch_sound = sound_dig;
+ }
+ }
float dig_time_complete = 0.0;
else
{
dig_time_complete = params.time;
+ if (g_settings->getBool("enable_particles"))
+ {
+ const ContentFeatures &features =
+ client.getNodeDefManager()->get(n);
+ addPunchingParticles
+ (gamedef, smgr, player, client.getEnv(),
+ nodepos, features.tiles);
+ }
}
if(dig_time_complete >= 0.001)
{
- dig_index = (u16)((float)CRACK_ANIMATION_LENGTH
+ dig_index = (u16)((float)crack_animation_length
* dig_time/dig_time_complete);
}
// This is for torches
else
{
- dig_index = CRACK_ANIMATION_LENGTH;
+ dig_index = crack_animation_length;
}
-
+
// Don't show cracks if not diggable
if(dig_time_complete >= 100000.0)
{
}
- else if(dig_index < CRACK_ANIMATION_LENGTH)
+ else if(dig_index < crack_animation_length)
{
- // Limit crack update speed
- if(crack_update_timer >= 0.1){
- crack_update_timer = 0.0;
- //infostream<<"dig_index="<<dig_index<<std::endl;
- //TimeTaker timer("client.setTempMod");
- client.setTempMod(nodepos,
- NodeMod(NODEMOD_CRACK, dig_index));
- }
+ //TimeTaker timer("client.setTempMod");
+ //infostream<<"dig_index="<<dig_index<<std::endl;
+ client.setCrack(dig_index, nodepos);
}
else
{
infostream<<"Digging completed"<<std::endl;
client.interact(2, pointed);
- client.clearTempMod(nodepos);
+ client.setCrack(-1, v3s16(0,0,0));
+ MapNode wasnode = map.getNode(nodepos);
client.removeNode(nodepos);
+ if (g_settings->getBool("enable_particles"))
+ {
+ const ContentFeatures &features =
+ client.getNodeDefManager()->get(wasnode);
+ addDiggingParticles
+ (gamedef, smgr, player, client.getEnv(),
+ nodepos, features.tiles);
+ }
+
dig_time = 0;
digging = false;
nodig_delay_timer = dig_time_complete
- / (float)CRACK_ANIMATION_LENGTH;
+ / (float)crack_animation_length;
// We don't want a corresponding delay to
// very time consuming nodes
- if(nodig_delay_timer > 0.5)
- {
- nodig_delay_timer = 0.5;
- }
+ if(nodig_delay_timer > 0.3)
+ nodig_delay_timer = 0.3;
// We want a slight delay to very little
// time consuming nodes
float mindelay = 0.15;
if(nodig_delay_timer < mindelay)
- {
nodig_delay_timer = mindelay;
- }
+
+ // Send event to trigger sound
+ MtEvent *e = new NodeDugEvent(nodepos, wasnode);
+ gamedef->event()->put(e);
}
dig_time += dtime;
camera.setDigging(0); // left click animation
}
- if(input->getRightClicked())
+ if(input->getRightClicked() ||
+ repeat_rightclick_timer >= g_settings->getFloat("repeat_rightclick_time"))
{
+ repeat_rightclick_timer = 0;
infostream<<"Ground right-clicked"<<std::endl;
- // If metadata provides an inventory view, activate it
- if(meta && meta->getInventoryDrawSpecString() != "" && !random_input)
- {
- infostream<<"Launching custom inventory view"<<std::endl;
-
- InventoryLocation inventoryloc;
- inventoryloc.setNodeMeta(nodepos);
-
-
- /*
- Create menu
- */
-
- core::array<GUIInventoryMenu::DrawSpec> draw_spec;
- v2s16 invsize =
- GUIInventoryMenu::makeDrawSpecArrayFromString(
- draw_spec,
- meta->getInventoryDrawSpecString(),
- inventoryloc);
-
- GUIInventoryMenu *menu =
- new GUIInventoryMenu(guienv, guiroot, -1,
- &g_menumgr, invsize,
- &client, gamedef);
- menu->setDrawSpec(draw_spec);
- menu->drop();
- }
- // If metadata provides text input, activate text input
- else if(meta && meta->allowsTextInput() && !random_input)
+ // Sign special case, at least until formspec is properly implemented.
+ // Deprecated?
+ if(meta && meta->getString("formspec") == "hack:sign_text_input"
+ && !random_input
+ && !input->isKeyDown(getKeySetting("keymap_sneak")))
{
infostream<<"Launching metadata text input"<<std::endl;
TextDest *dest = new TextDestNodeMetadata(nodepos, &client);
- std::wstring wtext = narrow_to_wide(meta->getText());
+ std::wstring wtext = narrow_to_wide(meta->getString("text"));
(new GUITextInputMenu(guienv, guiroot, -1,
&g_menumgr, dest,
wtext))->drop();
}
+ // If metadata provides an inventory view, activate it
+ else if(meta && meta->getString("formspec") != "" && !random_input
+ && !input->isKeyDown(getKeySetting("keymap_sneak")))
+ {
+ infostream<<"Launching custom inventory view"<<std::endl;
+
+ InventoryLocation inventoryloc;
+ inventoryloc.setNodeMeta(nodepos);
+
+ /* Create menu */
+
+ GUIFormSpecMenu *menu =
+ new GUIFormSpecMenu(device, guiroot, -1,
+ &g_menumgr,
+ &client, gamedef);
+ menu->setFormSpec(meta->getString("formspec"),
+ inventoryloc);
+ menu->setFormSource(new NodeMetadataFormSource(
+ &client.getEnv().getClientMap(), nodepos));
+ menu->setTextDest(new TextDestNodeMetadata(nodepos, &client));
+ menu->drop();
+ }
// Otherwise report right click to server
else
{
+ // Report to server
client.interact(3, pointed);
camera.setDigging(1); // right click animation
+
+ // If the wielded item has node placement prediction,
+ // make that happen
+ const ItemDefinition &def =
+ playeritem.getDefinition(itemdef);
+ if(def.node_placement_prediction != ""
+ && !nodedef->get(map.getNode(nodepos)).rightclickable)
+ do{ // breakable
+ verbosestream<<"Node placement prediction for "
+ <<playeritem.name<<" is "
+ <<def.node_placement_prediction<<std::endl;
+ v3s16 p = neighbourpos;
+ // Place inside node itself if buildable_to
+ try{
+ MapNode n_under = map.getNode(nodepos);
+ if(nodedef->get(n_under).buildable_to)
+ p = nodepos;
+ }catch(InvalidPositionException &e){}
+ // Find id of predicted node
+ content_t id;
+ bool found =
+ nodedef->getId(def.node_placement_prediction, id);
+ if(!found){
+ errorstream<<"Node placement prediction failed for "
+ <<playeritem.name<<" (places "
+ <<def.node_placement_prediction
+ <<") - Name not known"<<std::endl;
+ break;
+ }
+ MapNode n(id);
+ try{
+ // This triggers the required mesh update too
+ client.addNode(p, n);
+ }catch(InvalidPositionException &e){
+ errorstream<<"Node placement prediction failed for "
+ <<playeritem.name<<" (places "
+ <<def.node_placement_prediction
+ <<") - Position not loaded"<<std::endl;
+ }
+ }while(0);
+
+ // Read the sound
+ soundmaker.m_player_rightpunch_sound = def.sound_place;
}
}
}
/*
Calculate stuff for drawing
*/
-
+
/*
- Calculate general brightness
+ Fog range
*/
- u32 daynight_ratio = client.getDayNightRatio();
- u8 light8 = decode_light((daynight_ratio * LIGHT_SUN) / 1000);
- brightness = (float)light8/255.0;
- // Make night look good
- brightness = brightness * 1.15 - 0.15;
- video::SColor bgcolor;
- if(brightness >= 0.2 && brightness < 0.7)
- bgcolor = video::SColor(
- 255,
- bgcolor_bright.getRed() * brightness,
- bgcolor_bright.getGreen() * brightness*0.7,
- bgcolor_bright.getBlue() * brightness*0.5);
+
+ if(farmesh)
+ {
+ fog_range = BS*farmesh_range;
+ }
else
- bgcolor = video::SColor(
- 255,
- bgcolor_bright.getRed() * brightness,
- bgcolor_bright.getGreen() * brightness,
- bgcolor_bright.getBlue() * brightness);
+ {
+ fog_range = draw_control.wanted_range*BS + 0.0*MAP_BLOCKSIZE*BS;
+ fog_range *= 0.9;
+ if(draw_control.range_all)
+ fog_range = 100000*BS;
+ }
/*
- Update skybox
+ Calculate general brightness
*/
- if(fabs(brightness - old_brightness) > 0.01)
- update_skybox(driver, tsrc, smgr, skybox, brightness);
+ u32 daynight_ratio = client.getEnv().getDayNightRatio();
+ float time_brightness = decode_light_f((float)daynight_ratio/1000.0);
+ float direct_brightness = 0;
+ bool sunlight_seen = false;
+ if(g_settings->getBool("free_move")){
+ direct_brightness = time_brightness;
+ sunlight_seen = true;
+ } else {
+ ScopeProfiler sp(g_profiler, "Detecting background light", SPT_AVG);
+ float old_brightness = sky->getBrightness();
+ direct_brightness = (float)client.getEnv().getClientMap()
+ .getBackgroundBrightness(MYMIN(fog_range*1.2, 60*BS),
+ daynight_ratio, (int)(old_brightness*255.5), &sunlight_seen)
+ / 255.0;
+ }
+
+ time_of_day = client.getEnv().getTimeOfDayF();
+ float maxsm = 0.05;
+ if(fabs(time_of_day - time_of_day_smooth) > maxsm &&
+ fabs(time_of_day - time_of_day_smooth + 1.0) > maxsm &&
+ fabs(time_of_day - time_of_day_smooth - 1.0) > maxsm)
+ time_of_day_smooth = time_of_day;
+ float todsm = 0.05;
+ if(time_of_day_smooth > 0.8 && time_of_day < 0.2)
+ time_of_day_smooth = time_of_day_smooth * (1.0-todsm)
+ + (time_of_day+1.0) * todsm;
+ else
+ time_of_day_smooth = time_of_day_smooth * (1.0-todsm)
+ + time_of_day * todsm;
+
+ sky->update(time_of_day_smooth, time_brightness, direct_brightness,
+ sunlight_seen);
+
+ float brightness = sky->getBrightness();
+ video::SColor bgcolor = sky->getBgColor();
+ video::SColor skycolor = sky->getSkyColor();
/*
Update clouds
*/
- if(clouds)
- {
- clouds->step(dtime);
- clouds->update(v2f(player_position.X, player_position.Z),
- brightness);
+ if(clouds){
+ if(sky->getCloudsVisible()){
+ clouds->setVisible(true);
+ clouds->step(dtime);
+ clouds->update(v2f(player_position.X, player_position.Z),
+ sky->getCloudColor());
+ } else{
+ clouds->setVisible(false);
+ }
}
/*
farmesh->update(v2f(player_position.X, player_position.Z),
brightness, farmesh_range);
}
-
- // Store brightness value
- old_brightness = brightness;
+ /*
+ Update particles
+ */
+
+ allparticles_step(dtime, client.getEnv());
+ allparticlespawners_step(dtime, client.getEnv());
+
/*
Fog
*/
if(g_settings->getBool("enable_fog") == true && !force_fog_off)
{
- f32 range;
- if(farmesh)
- {
- range = BS*farmesh_range;
- }
- else
- {
- range = draw_control.wanted_range*BS + 0.0*MAP_BLOCKSIZE*BS;
- range *= 0.9;
- if(draw_control.range_all)
- range = 100000*BS;
- /*if(range < 50*BS)
- range = range * 0.5 + 25*BS;*/
- }
-
driver->setFog(
bgcolor,
video::EFT_FOG_LINEAR,
- range*0.4,
- range*1.0,
+ fog_range*0.4,
+ fog_range*1.0,
0.01,
false, // pixel fog
false // range fog
//TimeTaker guiupdatetimer("Gui updating");
const char program_name_and_version[] =
- "Minetest-c55 " VERSION_STRING;
+ "Minetest " VERSION_STRING;
if(show_debug)
{
char temptext[300];
snprintf(temptext, 300,
"(% .1f, % .1f, % .1f)"
- " (yaw = %.1f)",
+ " (yaw = %.1f) (seed = %llu)",
player_position.X/BS,
player_position.Y/BS,
player_position.Z/BS,
- wrapDegrees_0_360(camera_yaw));
+ wrapDegrees_0_360(camera_yaw),
+ (unsigned long long)client.getMapSeed());
guitext2->setText(narrow_to_wide(temptext).c_str());
guitext2->setVisible(true);
}
{
- float statustext_time_max = 3.0;
+ float statustext_time_max = 1.5;
if(!statustext.empty())
{
statustext_time += dtime;
initial_color.getInterpolated_quadratic(
initial_color,
final_color,
- statustext_time / (float) statustext_time_max);
+ pow(statustext_time / (float)statustext_time_max, 2.0f));
guitext_status->setOverrideColor(fade_color);
guitext_status->enableOverrideColor(true);
}
ItemStack item;
if(mlist != NULL)
item = mlist->getItem(client.getPlayerItem());
- camera.wield(item, gamedef);
+ camera.wield(item);
}
-
+
+ /*
+ Update block draw list every 200ms or when camera direction has
+ changed much
+ */
+ update_draw_list_timer += dtime;
+ if(update_draw_list_timer >= 0.2 ||
+ update_draw_list_last_cam_dir.getDistanceFrom(camera_direction) > 0.2){
+ update_draw_list_timer = 0;
+ client.getEnv().getClientMap().updateDrawList(driver);
+ update_draw_list_last_cam_dir = camera_direction;
+ }
+
/*
Drawing begins
*/
- TimeTaker drawtimer("Drawing");
+ TimeTaker tt_draw("mainloop: draw");
{
TimeTaker timer("beginScene");
- driver->beginScene(false, true, bgcolor);
//driver->beginScene(false, true, bgcolor);
+ //driver->beginScene(true, true, bgcolor);
+ driver->beginScene(true, true, skycolor);
beginscenetime = timer.stop(true);
}
//timer3.stop();
-
+
//infostream<<"smgr->drawAll()"<<std::endl;
-
{
TimeTaker timer("smgr");
smgr->drawAll();
+
+ if(g_settings->getBool("anaglyph"))
+ {
+ irr::core::vector3df oldPosition = camera.getCameraNode()->getPosition();
+ irr::core::vector3df oldTarget = camera.getCameraNode()->getTarget();
+
+ irr::core::matrix4 startMatrix = camera.getCameraNode()->getAbsoluteTransformation();
+
+ irr::core::vector3df focusPoint = (camera.getCameraNode()->getTarget() -
+ camera.getCameraNode()->getAbsolutePosition()).setLength(1) +
+ camera.getCameraNode()->getAbsolutePosition() ;
+
+ //Left eye...
+ irr::core::vector3df leftEye;
+ irr::core::matrix4 leftMove;
+
+ leftMove.setTranslation( irr::core::vector3df(-g_settings->getFloat("anaglyph_strength"),0.0f,0.0f) );
+ leftEye=(startMatrix*leftMove).getTranslation();
+
+ //clear the depth buffer, and color
+ driver->beginScene( true, true, irr::video::SColor(0,200,200,255) );
+
+ driver->getOverrideMaterial().Material.ColorMask = irr::video::ECP_RED;
+ driver->getOverrideMaterial().EnableFlags = irr::video::EMF_COLOR_MASK;
+ driver->getOverrideMaterial().EnablePasses = irr::scene::ESNRP_SKY_BOX +
+ irr::scene::ESNRP_SOLID +
+ irr::scene::ESNRP_TRANSPARENT +
+ irr::scene::ESNRP_TRANSPARENT_EFFECT +
+ irr::scene::ESNRP_SHADOW;
+
+ camera.getCameraNode()->setPosition( leftEye );
+ camera.getCameraNode()->setTarget( focusPoint );
+
+ smgr->drawAll(); // 'smgr->drawAll();' may go here
+
+
+ //Right eye...
+ irr::core::vector3df rightEye;
+ irr::core::matrix4 rightMove;
+
+ rightMove.setTranslation( irr::core::vector3df(g_settings->getFloat("anaglyph_strength"),0.0f,0.0f) );
+ rightEye=(startMatrix*rightMove).getTranslation();
+
+ //clear the depth buffer
+ driver->clearZBuffer();
+
+ driver->getOverrideMaterial().Material.ColorMask = irr::video::ECP_GREEN + irr::video::ECP_BLUE;
+ driver->getOverrideMaterial().EnableFlags = irr::video::EMF_COLOR_MASK;
+ driver->getOverrideMaterial().EnablePasses = irr::scene::ESNRP_SKY_BOX +
+ irr::scene::ESNRP_SOLID +
+ irr::scene::ESNRP_TRANSPARENT +
+ irr::scene::ESNRP_TRANSPARENT_EFFECT +
+ irr::scene::ESNRP_SHADOW;
+
+ camera.getCameraNode()->setPosition( rightEye );
+ camera.getCameraNode()->setTarget( focusPoint );
+
+ smgr->drawAll(); // 'smgr->drawAll();' may go here
+
+
+ //driver->endScene();
+
+ driver->getOverrideMaterial().Material.ColorMask=irr::video::ECP_ALL;
+ driver->getOverrideMaterial().EnableFlags=0;
+ driver->getOverrideMaterial().EnablePasses=0;
+
+ camera.getCameraNode()->setPosition( oldPosition );
+ camera.getCameraNode()->setTarget( oldTarget );
+ }
+
scenetime = timer.stop(true);
}
if(show_hud)
{
- for(core::list<aabb3f>::Iterator i=hilightboxes.begin();
- i != hilightboxes.end(); i++)
- {
+ v3f selectionbox_color = g_settings->getV3F("selectionbox_color");
+ u32 selectionbox_color_r = rangelim(myround(selectionbox_color.X), 0, 255);
+ u32 selectionbox_color_g = rangelim(myround(selectionbox_color.Y), 0, 255);
+ u32 selectionbox_color_b = rangelim(myround(selectionbox_color.Z), 0, 255);
+
+ for(std::vector<aabb3f>::const_iterator
+ i = hilightboxes.begin();
+ i != hilightboxes.end(); i++)
+ {
/*infostream<<"hilightbox min="
<<"("<<i->MinEdge.X<<","<<i->MinEdge.Y<<","<<i->MinEdge.Z<<")"
<<" max="
<<"("<<i->MaxEdge.X<<","<<i->MaxEdge.Y<<","<<i->MaxEdge.Z<<")"
<<std::endl;*/
- driver->draw3DBox(*i, video::SColor(255,0,0,0));
+ driver->draw3DBox(*i, video::SColor(255,selectionbox_color_r,selectionbox_color_g,selectionbox_color_b));
}
}
Post effects
*/
{
- client.renderPostFx();
+ client.getEnv().getClientMap().renderPostFx();
}
/*
- Frametime log
+ Profiler graph
*/
- if(show_debug_frametime)
- {
- s32 x = 10;
- s32 y = screensize.Y - 10;
- for(core::list<float>::Iterator
- i = frametime_log.begin();
- i != frametime_log.end();
- i++)
- {
- driver->draw2DLine(v2s32(x,y),
- v2s32(x,y-(*i)*1000),
- video::SColor(255,255,255,255));
- x++;
- }
+ if(show_profiler_graph)
+ {
+ graph.draw(10, screensize.Y - 10, driver, font);
}
/*
*/
if(show_hud)
{
+ v3f crosshair_color = g_settings->getV3F("crosshair_color");
+ u32 crosshair_color_r = rangelim(myround(crosshair_color.X), 0, 255);
+ u32 crosshair_color_g = rangelim(myround(crosshair_color.Y), 0, 255);
+ u32 crosshair_color_b = rangelim(myround(crosshair_color.Z), 0, 255);
+ u32 crosshair_alpha = rangelim(g_settings->getS32("crosshair_alpha"), 0, 255);
+
driver->draw2DLine(displaycenter - core::vector2d<s32>(10,0),
displaycenter + core::vector2d<s32>(10,0),
- video::SColor(255,255,255,255));
+ video::SColor(crosshair_alpha,crosshair_color_r,crosshair_color_g,crosshair_color_b));
driver->draw2DLine(displaycenter - core::vector2d<s32>(0,10),
displaycenter + core::vector2d<s32>(0,10),
- video::SColor(255,255,255,255));
+ video::SColor(crosshair_alpha,crosshair_color_r,crosshair_color_g,crosshair_color_b));
}
} // timer
//timer10.stop();
//TimeTaker //timer11("//timer11");
- /*
- Draw gui
- */
- // 0-1ms
- guienv->drawAll();
/*
Draw hotbar
/*
Damage flash
*/
- if(damage_flash_timer > 0.0)
+ if(damage_flash > 0.0)
{
- damage_flash_timer -= dtime;
-
- video::SColor color(128,255,0,0);
+ video::SColor color(std::min(damage_flash, 180.0f),180,0,0);
driver->draw2DRectangle(color,
core::rect<s32>(0,0,screensize.X,screensize.Y),
NULL);
+
+ damage_flash -= 100.0*dtime;
+ }
+
+ /*
+ Damage camera tilt
+ */
+ if(player->hurt_tilt_timer > 0.0)
+ {
+ player->hurt_tilt_timer -= dtime*5;
+ if(player->hurt_tilt_timer < 0)
+ player->hurt_tilt_strength = 0;
}
+ /*
+ Draw gui
+ */
+ // 0-1ms
+ guienv->drawAll();
+
/*
End scene
*/
endscenetime = timer.stop(true);
}
- drawtime = drawtimer.stop(true);
+ drawtime = tt_draw.stop(true);
+ g_profiler->graphAdd("mainloop_draw", (float)drawtime/1000.0f);
/*
End of drawing
device->setWindowCaption(str.c_str());
lastFPS = fps;
}
+
+ /*
+ Log times and stuff for visualization
+ */
+ Profiler::GraphValues values;
+ g_profiler->graphGet(values);
+ graph.put(values);
}
/*
clouds->drop();
if(gui_chat_console)
gui_chat_console->drop();
+ clear_particles ();
/*
Draw a "shutting down" screen, which will be shown while the map
// Client scope (client is destructed before destructing *def and tsrc)
}while(0);
+ } // try-catch
+ catch(SerializationError &e)
+ {
+ error_message = L"A serialization error occurred:\n"
+ + narrow_to_wide(e.what()) + L"\n\nThe server is probably "
+ L" running a different version of Minetest.";
+ errorstream<<wide_to_narrow(error_message)<<std::endl;
+ }
+
+ if(!sound_is_dummy)
+ delete sound;
delete tsrc;
+ delete shsrc;
delete nodedef;
delete itemdef;
}
projects / minetest.git / blobdiff