#include "player.h"
#include "tile.h"
#include <cmath>
+#include <SAnimatedMesh.h>
+#include "settings.h"
+#include "nodedef.h" // For wield visualization
+
+// In Irrlicht 1.8 the signature of ITexture::lock was changed from
+// (bool, u32) to (E_TEXTURE_LOCK_MODE, u32).
+#if IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR <= 7
+#define MY_ETLM_READ_ONLY true
+#else
+#define MY_ETLM_READ_ONLY video::ETLM_READ_ONLY
+#endif
Camera::Camera(scene::ISceneManager* smgr, MapDrawControl& draw_control):
m_smgr(smgr),
{
if (m_view_bobbing_state != 0)
{
- f32 offset = dtime * m_view_bobbing_speed * 0.035;
+ //f32 offset = dtime * m_view_bobbing_speed * 0.035;
+ f32 offset = dtime * m_view_bobbing_speed * 0.030;
if (m_view_bobbing_state == 2)
{
+#if 0
// Animation is getting turned off
if (m_view_bobbing_anim < 0.5)
m_view_bobbing_anim -= offset;
m_view_bobbing_anim = 0;
m_view_bobbing_state = 0;
}
+#endif
+#if 1
+ // Animation is getting turned off
+ if(m_view_bobbing_anim < 0.25){
+ m_view_bobbing_anim -= offset;
+ } else if(m_view_bobbing_anim > 0.75){
+ m_view_bobbing_anim += offset;
+ } if(m_view_bobbing_anim < 0.5){
+ m_view_bobbing_anim += offset;
+ if(m_view_bobbing_anim > 0.5)
+ m_view_bobbing_anim = 0.5;
+ } else {
+ m_view_bobbing_anim -= offset;
+ if(m_view_bobbing_anim < 0.5)
+ m_view_bobbing_anim = 0.5;
+ }
+ if(m_view_bobbing_anim <= 0 || m_view_bobbing_anim >= 1 ||
+ fabs(m_view_bobbing_anim - 0.5) < 0.01)
+ {
+ m_view_bobbing_anim = 0;
+ m_view_bobbing_state = 0;
+ }
+#endif
}
else
{
#if 1
f32 bobknob = 1.2;
f32 bobtmp = sin(pow(bobfrac, bobknob) * PI);
+ //f32 bobtmp2 = cos(pow(bobfrac, bobknob) * PI);
v3f bobvec = v3f(
- bobdir * sin(bobfrac * PI),
- 0.8 * bobtmp * bobtmp,
+ 0.3 * bobdir * sin(bobfrac * PI),
+ -0.28 * bobtmp * bobtmp,
0.);
- rel_cam_pos += 0.03 * bobvec;
- rel_cam_target += 0.045 * bobvec;
- rel_cam_up.rotateXYBy(0.03 * bobdir * bobtmp * PI);
+ //rel_cam_pos += 0.2 * bobvec;
+ //rel_cam_target += 0.03 * bobvec;
+ //rel_cam_up.rotateXYBy(0.02 * bobdir * bobtmp * PI);
+ float f = 1.0;
+ f *= g_settings->getFloat("view_bobbing_amount");
+ rel_cam_pos += bobvec * f;
+ //rel_cam_target += 0.995 * bobvec * f;
+ rel_cam_target += bobvec * f;
+ rel_cam_target.Z -= 0.005 * bobvec.Z * f;
+ //rel_cam_target.X -= 0.005 * bobvec.X * f;
+ //rel_cam_target.Y -= 0.005 * bobvec.Y * f;
+ rel_cam_up.rotateXYBy(-0.03 * bobdir * bobtmp * PI * f);
#else
f32 angle_deg = 1 * bobdir * sin(bobfrac * PI);
f32 angle_rad = angle_deg * PI / 180;
// Position the wielded item
v3f wield_position = v3f(45, -35, 65);
- v3f wield_rotation = v3f(90, -90, -90);
+ v3f wield_rotation = v3f(-100, 120, -100);
if (m_digging_button != -1)
{
f32 digfrac = m_digging_anim;
// Euler angles are PURE EVIL, so why not use quaternions?
core::quaternion quat_begin(wield_rotation * core::DEGTORAD);
- core::quaternion quat_end(v3f(90, 20, -130) * core::DEGTORAD);
+ core::quaternion quat_end(v3f(90, -10, -130) * core::DEGTORAD);
core::quaternion quat_slerp;
quat_slerp.slerp(quat_begin, quat_end, sin(digfrac * PI));
quat_slerp.toEuler(wield_rotation);
wield_rotation *= core::RADTODEG;
}
+ else {
+ f32 bobfrac = my_modf(m_view_bobbing_anim);
+ wield_position.X -= sin(bobfrac*PI*2.0) * 3.0;
+ wield_position.Y += sin(my_modf(bobfrac*2.0)*PI) * 3.0;
+ }
m_wieldnode->setPosition(wield_position);
m_wieldnode->setRotation(wield_rotation);
+ m_wieldnode->updateLight(player->light);
// Render distance feedback loop
updateViewingRange(frametime);
v3f speed = player->getSpeed();
if ((hypot(speed.X, speed.Z) > BS) &&
(player->touching_ground) &&
- (g_settings.getBool("view_bobbing") == true) &&
- (g_settings.getBool("free_move") == false))
+ (g_settings->getBool("view_bobbing") == true) &&
+ (g_settings->getBool("free_move") == false))
{
// Start animation
m_view_bobbing_state = 1;
<<std::endl;*/
m_draw_control.wanted_min_range = m_viewing_range_min;
- m_draw_control.wanted_max_blocks = (1.5*m_draw_control.blocks_would_have_drawn)+1;
+ m_draw_control.wanted_max_blocks = (2.0*m_draw_control.blocks_would_have_drawn)+1;
if (m_draw_control.wanted_max_blocks < 10)
m_draw_control.wanted_max_blocks = 10;
//dstream<<"wanted_frametime_change="<<wanted_frametime_change<<std::endl;
// If needed frametime change is small, just return
- if (fabs(wanted_frametime_change) < m_wanted_frametime*0.4)
+ // This value was 0.4 for many months until 2011-10-18 by c55;
+ // Let's see how this works out.
+ if (fabs(wanted_frametime_change) < m_wanted_frametime*0.33)
{
//dstream<<"ignoring small wanted_frametime_change"<<std::endl;
return;
void Camera::updateSettings()
{
- m_viewing_range_min = g_settings.getS16("viewing_range_nodes_min");
+ m_viewing_range_min = g_settings->getS16("viewing_range_nodes_min");
m_viewing_range_min = MYMAX(5.0, m_viewing_range_min);
- m_viewing_range_max = g_settings.getS16("viewing_range_nodes_max");
+ m_viewing_range_max = g_settings->getS16("viewing_range_nodes_max");
m_viewing_range_max = MYMAX(m_viewing_range_min, m_viewing_range_max);
- f32 fov_degrees = g_settings.getFloat("fov");
+ f32 fov_degrees = g_settings->getFloat("fov");
fov_degrees = MYMAX(fov_degrees, 10.0);
fov_degrees = MYMIN(fov_degrees, 170.0);
m_fov_y = fov_degrees * PI / 180.0;
- f32 wanted_fps = g_settings.getFloat("wanted_fps");
+ f32 wanted_fps = g_settings->getFloat("wanted_fps");
wanted_fps = MYMAX(wanted_fps, 1.0);
m_wanted_frametime = 1.0 / wanted_fps;
}
-void Camera::wield(const InventoryItem* item)
+void Camera::wield(const InventoryItem* item, IGameDef *gamedef)
{
+ //ITextureSource *tsrc = gamedef->tsrc();
+ INodeDefManager *ndef = gamedef->ndef();
+
if (item != NULL)
{
bool isCube = false;
// A block-type material
MaterialItem* mat_item = (MaterialItem*) item;
content_t content = mat_item->getMaterial();
- if (content_features(content).solidness || content_features(content).visual_solidness)
- {
- m_wieldnode->setCube(content_features(content).tiles);
+ switch(ndef->get(content).drawtype){
+ case NDT_NORMAL:
+ case NDT_LIQUID:
+ case NDT_FLOWINGLIQUID:
+ case NDT_GLASSLIKE:
+ case NDT_ALLFACES:
+ case NDT_ALLFACES_OPTIONAL:
+ m_wieldnode->setCube(ndef->get(content).tiles);
m_wieldnode->setScale(v3f(30));
isCube = true;
+ break;
+ default:
+ break;
}
}
else
{
// Bare hands
- m_wieldnode->setVisible(false);
+ m_wieldnode->setSprite(gamedef->tsrc()->getTextureRaw("wieldhand.png"));
+ m_wieldnode->setScale(v3f(40));
+ m_wieldnode->setVisible(true);
}
}
m_thickness = 0.1;
m_cubemesh = NULL;
m_is_cube = false;
+ m_light = LIGHT_MAX;
}
ExtrudedSpriteSceneNode::~ExtrudedSpriteSceneNode()
m_meshnode->getMaterial(0).MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
m_meshnode->setVisible(true);
m_is_cube = false;
+ updateLight(m_light);
}
void ExtrudedSpriteSceneNode::setCube(const TileSpec tiles[6])
}
m_meshnode->setVisible(true);
m_is_cube = true;
+ updateLight(m_light);
+}
+
+void ExtrudedSpriteSceneNode::updateLight(u8 light)
+{
+ m_light = light;
+
+ u8 li = decode_light(light);
+ // Set brightness one lower than incoming light
+ diminish_light(li);
+ video::SColor color(255,li,li,li);
+ setMeshVerticesColor(m_meshnode->getMesh(), color);
}
void ExtrudedSpriteSceneNode::removeSpriteFromCache(video::ITexture* texture)
{
// Texture is in the correct color format, we can pass it
// to extrudeARGB right away.
- void* data = texture->lock(true);
+ void* data = texture->lock(MY_ETLM_READ_ONLY);
if (data == NULL)
return NULL;
mesh = extrudeARGB(size.Width, size.Height, (u8*) data);
{
video::IVideoDriver* driver = SceneManager->getVideoDriver();
- video::IImage* img1 = driver->createImageFromData(format, size, texture->lock(true));
+ video::IImage* img1 = driver->createImageFromData(format, size, texture->lock(MY_ETLM_READ_ONLY));
if (img1 == NULL)
return NULL;
projects / dragonfireclient.git / blobdiff