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

Add support for interlaced polarized 3d screens

Browse Source 
Add (experimental) support for topbottom as well as sidebyside 3d mode
This commit is contained in:
sapier 2014-04-27 16:09:21 +02:00
parent d9f6f9e7a8
commit 09970b7b6d
17 changed files with 910 additions and 424 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
minetest.conf.example
View File

@ -127,9 +127,15 @@
#view_bobbing_amount = 1.0
# Amount of fall bobbing (0 = no fall bobbing, 1.0 = normal, 2.0 = double)
#fall_bobbing_amount = 0.0
# Anaglyph stereo
#anaglyph = false
#anaglyph_strength = 0.1
# 3d support,
# right now:
# "none" = no 3d output,
# "anaglyph" = cyan/magenta color 3d,
# "interlaced" = odd/even line based polarisation screen support,
# "topbottom" = split screen top boton,
# "sidebyside" = split screen side by side
#3d_mode = none
#3d_paralax_strength = 0.025
# In-game chat console background color (R,G,B)
#console_color = (0,0,0)
# In-game chat console background alpha (opaqueness, between 0 and 255)

1
src/CMakeLists.txt
View File

@ -460,6 +460,7 @@ set(minetest_SRCS
guiEngine.cpp
guiFileSelectMenu.cpp
convert_json.cpp
drawscene.cpp
${minetest_SCRIPT_SRCS}
)

79
src/camera.cpp
View File

@ -82,7 +82,9 @@ Camera::Camera(scene::ISceneManager* smgr, MapDrawControl& draw_control,
m_wield_change_timer(0.125),
m_wield_mesh_next(NULL),
m_previous_playeritem(-1),
m_previous_itemname("")
m_previous_itemname(""),
m_camera_mode(CAMERA_MODE_FIRST)
{
//dstream<<__FUNCTION_NAME<<std::endl;
@ -159,8 +161,10 @@ void Camera::step(f32 dtime)
if(m_wield_change_timer > 0.125)
m_wield_change_timer = 0.125;
if(m_wield_change_timer >= 0 && was_under_zero) {
if(m_wield_mesh_next) {
if(m_wield_change_timer >= 0 && was_under_zero)
{
if(m_wield_mesh_next)
{
m_wieldnode->setMesh(m_wield_mesh_next);
m_wieldnode->setVisible(true);
} else {
@ -189,11 +193,14 @@ void Camera::step(f32 dtime)
#endif
#if 1
// Animation is getting turned off
if(m_view_bobbing_anim < 0.25){
if(m_view_bobbing_anim < 0.25)
{
m_view_bobbing_anim -= offset;
} else if(m_view_bobbing_anim > 0.75){
} else if(m_view_bobbing_anim > 0.75) {
m_view_bobbing_anim += offset;
} if(m_view_bobbing_anim < 0.5){
}
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;
@ -217,7 +224,8 @@ void Camera::step(f32 dtime)
bool step = (was == 0 ||
(was < 0.5f && m_view_bobbing_anim >= 0.5f) ||
(was > 0.5f && m_view_bobbing_anim <= 0.5f));
if(step){
if(step)
{
MtEvent *e = new SimpleTriggerEvent("ViewBobbingStep");
m_gamedef->event()->put(e);
}
@ -237,10 +245,11 @@ void Camera::step(f32 dtime)
float lim = 0.15;
if(m_digging_anim_was < lim && m_digging_anim >= lim)
{
if(m_digging_button == 0){
if(m_digging_button == 0)
{
MtEvent *e = new SimpleTriggerEvent("CameraPunchLeft");
m_gamedef->event()->put(e);
} else if(m_digging_button == 1){
} else if(m_digging_button == 1) {
MtEvent *e = new SimpleTriggerEvent("CameraPunchRight");
m_gamedef->event()->put(e);
}
@ -249,8 +258,7 @@ void Camera::step(f32 dtime)
}
void Camera::update(LocalPlayer* player, f32 frametime, f32 busytime,
f32 tool_reload_ratio,
int current_camera_mode, ClientEnvironment &c_env)
f32 tool_reload_ratio, ClientEnvironment &c_env)
{
// Get player position
// Smooth the movement when walking up stairs
@ -278,7 +286,7 @@ void Camera::update(LocalPlayer* player, f32 frametime, f32 busytime,
// Fall bobbing animation
float fall_bobbing = 0;
if(player->camera_impact >= 1 && current_camera_mode < CAMERA_MODE_THIRD)
if(player->camera_impact >= 1 && m_camera_mode < CAMERA_MODE_THIRD)
{
if(m_view_bobbing_fall == -1) // Effect took place and has finished
player->camera_impact = m_view_bobbing_fall = 0;
@ -297,7 +305,7 @@ void Camera::update(LocalPlayer* player, f32 frametime, f32 busytime,
// Calculate players eye offset for different camera modes
v3f PlayerEyeOffset = player->getEyeOffset();
if (current_camera_mode == CAMERA_MODE_FIRST)
if (m_camera_mode == CAMERA_MODE_FIRST)
PlayerEyeOffset += player->eye_offset_first;
else
PlayerEyeOffset += player->eye_offset_third;
@ -312,7 +320,7 @@ void Camera::update(LocalPlayer* player, f32 frametime, f32 busytime,
v3f rel_cam_target = v3f(0,0,1);
v3f rel_cam_up = v3f(0,1,0);
if (m_view_bobbing_anim != 0 && current_camera_mode < CAMERA_MODE_THIRD)
if (m_view_bobbing_anim != 0 && m_camera_mode < CAMERA_MODE_THIRD)
{
f32 bobfrac = my_modf(m_view_bobbing_anim * 2);
f32 bobdir = (m_view_bobbing_anim < 0.5) ? 1.0 : -1.0;
@ -365,16 +373,17 @@ void Camera::update(LocalPlayer* player, f32 frametime, f32 busytime,
v3f my_cp = m_camera_position;
// Reposition the camera for third person view
if (current_camera_mode > CAMERA_MODE_FIRST) {
if (current_camera_mode == CAMERA_MODE_THIRD_FRONT)
if (m_camera_mode > CAMERA_MODE_FIRST)
{
if (m_camera_mode == CAMERA_MODE_THIRD_FRONT)
m_camera_direction *= -1;
my_cp.Y += 2;
// Calculate new position
bool abort = false;
for (int i = BS; i <= BS*2; i++) {
for (int i = BS; i <= BS*2; i++)
{
my_cp.X = m_camera_position.X + m_camera_direction.X*-i;
my_cp.Z = m_camera_position.Z + m_camera_direction.Z*-i;
if (i > 12)
@ -384,7 +393,8 @@ void Camera::update(LocalPlayer* player, f32 frametime, f32 busytime,
INodeDefManager *nodemgr = m_gamedef->ndef();
MapNode n = c_env.getClientMap().getNodeNoEx(floatToInt(my_cp, BS));
const ContentFeatures& features = nodemgr->get(n);
if(features.walkable) {
if(features.walkable)
{
my_cp.X += m_camera_direction.X*-1*-BS/2;
my_cp.Z += m_camera_direction.Z*-1*-BS/2;
my_cp.Y += m_camera_direction.Y*-1*-BS/2;
@ -413,7 +423,7 @@ void Camera::update(LocalPlayer* player, f32 frametime, f32 busytime,
m_cameranode->setTarget(my_cp-intToFloat(m_camera_offset, BS) + 100 * m_camera_direction);
// update the camera position in front-view mode to render blocks behind player
if (current_camera_mode == CAMERA_MODE_THIRD_FRONT)
if (m_camera_mode == CAMERA_MODE_THIRD_FRONT)
m_camera_position = my_cp;
// Get FOV setting
@ -439,7 +449,8 @@ void Camera::update(LocalPlayer* player, f32 frametime, f32 busytime,
wield_position.Y -= 40 + m_wield_change_timer*320;
else
wield_position.Y -= 40 - m_wield_change_timer*320;
if(m_digging_anim < 0.05 || m_digging_anim > 0.5){
if(m_digging_anim < 0.05 || m_digging_anim > 0.5)
{
f32 frac = 1.0;
if(m_digging_anim > 0.5)
frac = 2.0 * (m_digging_anim - 0.5);
@ -468,8 +479,7 @@ void Camera::update(LocalPlayer* player, f32 frametime, f32 busytime,
quat_slerp.slerp(quat_begin, quat_end, sin(digfrac * M_PI));
quat_slerp.toEuler(wield_rotation);
wield_rotation *= core::RADTODEG;
}
else {
} else {
f32 bobfrac = my_modf(m_view_bobbing_anim);
wield_position.X -= sin(bobfrac*M_PI*2.0) * 3.0;
wield_position.Y += sin(my_modf(bobfrac*2.0)*M_PI) * 3.0;
@ -654,12 +664,14 @@ void Camera::wield(const ItemStack &item, u16 playeritem)
std::string itemname = item.getDefinition(idef).name;
m_wield_mesh_next = idef->getWieldMesh(itemname, m_gamedef);
if(playeritem != m_previous_playeritem &&
!(m_previous_itemname == "" && itemname == "")) {
!(m_previous_itemname == "" && itemname == ""))
{
m_previous_playeritem = playeritem;
m_previous_itemname = itemname;
if(m_wield_change_timer >= 0.125)
m_wield_change_timer = -0.125;
else if(m_wield_change_timer > 0) {
else if(m_wield_change_timer > 0)
{
m_wield_change_timer = -m_wield_change_timer;
}
} else {
@ -670,7 +682,8 @@ void Camera::wield(const ItemStack &item, u16 playeritem)
m_wieldnode->setVisible(false);
}
m_wield_mesh_next = NULL;
if(m_previous_itemname != itemname) {
if(m_previous_itemname != itemname)
{
m_previous_itemname = itemname;
m_wield_change_timer = 0;
}
@ -679,7 +692,7 @@ void Camera::wield(const ItemStack &item, u16 playeritem)
}
}
void Camera::drawWieldedTool()
void Camera::drawWieldedTool(irr::core::matrix4* translation)
{
// Set vertex colors of wield mesh according to light level
u8 li = m_wieldlight;
@ -695,5 +708,17 @@ void Camera::drawWieldedTool()
cam->setFOV(72.0*M_PI/180.0);
cam->setNearValue(0.1);
cam->setFarValue(100);
if (translation != NULL)
{
irr::core::matrix4 startMatrix = cam->getAbsoluteTransformation();
irr::core::vector3df focusPoint = (cam->getTarget()
- cam->getAbsolutePosition()).setLength(1)
+ cam->getAbsolutePosition();
irr::core::vector3df camera_pos =
(startMatrix * *translation).getTranslation();
cam->setPosition(camera_pos);
cam->setTarget(focusPoint);
}
m_wieldmgr->drawAll();
}

25
src/camera.h
View File

@ -33,7 +33,7 @@ class LocalPlayer;
struct MapDrawControl;
class IGameDef;
enum CameraModes {CAMERA_MODE_FIRST, CAMERA_MODE_THIRD, CAMERA_MODE_THIRD_FRONT};
enum CameraMode {CAMERA_MODE_FIRST, CAMERA_MODE_THIRD, CAMERA_MODE_THIRD_FRONT};
/*
Client camera class, manages the player and camera scene nodes, the viewing distance
@ -117,8 +117,7 @@ public:
// Update the camera from the local player's position.
// busytime is used to adjust the viewing range.
void update(LocalPlayer* player, f32 frametime, f32 busytime,
f32 tool_reload_ratio,
int current_camera_mode, ClientEnvironment &c_env);
f32 tool_reload_ratio, ClientEnvironment &c_env);
// Render distance feedback loop
void updateViewingRange(f32 frametime_in, f32 busytime_in);
@ -133,7 +132,23 @@ public:
// Draw the wielded tool.
// This has to happen *after* the main scene is drawn.
// Warning: This clears the Z buffer.
void drawWieldedTool();
void drawWieldedTool(irr::core::matrix4* translation=NULL);
// Toggle the current camera mode
void toggleCameraMode() {
if (m_camera_mode == CAMERA_MODE_FIRST)
m_camera_mode = CAMERA_MODE_THIRD;
else if (m_camera_mode == CAMERA_MODE_THIRD)
m_camera_mode = CAMERA_MODE_THIRD_FRONT;
else
m_camera_mode = CAMERA_MODE_FIRST;
}
//read the current camera mode
inline CameraMode getCameraMode()
{
return m_camera_mode;
}
private:
// Nodes
@ -196,6 +211,8 @@ private:
scene::IMesh *m_wield_mesh_next;
u16 m_previous_playeritem;
std::string m_previous_itemname;
CameraMode m_camera_mode;
};
#endif

11
src/client.cpp
View File

@ -51,6 +51,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "util/directiontables.h"
#include "util/pointedthing.h"
#include "version.h"
#include "drawscene.h"
extern gui::IGUIEnvironment* guienv;
/*
QueuedMeshUpdate
@ -2648,10 +2651,6 @@ float Client::mediaReceiveProgress()
return 1.0; // downloader only exists when not yet done
}
void draw_load_screen(const std::wstring &text,
IrrlichtDevice* device, gui::IGUIFont* font,
float dtime=0 ,int percent=0, bool clouds=true);
void Client::afterContentReceived(IrrlichtDevice *device, gui::IGUIFont* font)
{
infostream<<"Client::afterContentReceived() started"<<std::endl;
@ -2680,7 +2679,7 @@ void Client::afterContentReceived(IrrlichtDevice *device, gui::IGUIFont* font)
{
verbosestream<<"Updating item textures and meshes"<<std::endl;
wchar_t* text = wgettext("Item textures...");
draw_load_screen(text,device,font,0,0);
draw_load_screen(text, device, guienv, font, 0, 0);
std::set<std::string> names = m_itemdef->getAll();
size_t size = names.size();
size_t count = 0;
@ -2693,7 +2692,7 @@ void Client::afterContentReceived(IrrlichtDevice *device, gui::IGUIFont* font)
count++;
percent = count*100/size;
if (count%50 == 0) // only update every 50 item
draw_load_screen(text,device,font,0,percent);
draw_load_screen(text, device, guienv, font, 0, percent);
}
delete[] text;
}

8
src/clientmap.cpp
View File

@ -856,7 +856,7 @@ int ClientMap::getBackgroundBrightness(float max_d, u32 daylight_factor,
return ret;
}
void ClientMap::renderPostFx()
void ClientMap::renderPostFx(CameraMode cam_mode)
{
INodeDefManager *nodemgr = m_gamedef->ndef();
@ -867,8 +867,6 @@ void ClientMap::renderPostFx()
v3f camera_position = m_camera_position;
m_camera_mutex.Unlock();
LocalPlayer *player = m_client->getEnv().getLocalPlayer();
MapNode n = getNodeNoEx(floatToInt(camera_position, BS));
// - If the player is in a solid node, make everything black.
@ -876,7 +874,9 @@ void ClientMap::renderPostFx()
// - Do not if player is in third person mode
const ContentFeatures& features = nodemgr->get(n);
video::SColor post_effect_color = features.post_effect_color;
if(features.solidness == 2 && !(g_settings->getBool("noclip") && m_gamedef->checkLocalPrivilege("noclip")) && player->camera_mode == CAMERA_MODE_FIRST)
if(features.solidness == 2 && !(g_settings->getBool("noclip") &&
m_gamedef->checkLocalPrivilege("noclip")) &&
cam_mode == CAMERA_MODE_FIRST)
{
post_effect_color = video::SColor(255, 0, 0, 0);
}

3
src/clientmap.h
View File

@ -22,6 +22,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "irrlichttypes_extrabloated.h"
#include "map.h"
#include "camera.h"
#include <set>
#include <map>
@ -126,7 +127,7 @@ public:
int getBackgroundBrightness(float max_d, u32 daylight_factor,
int oldvalue, bool *sunlight_seen_result);
void renderPostFx();
void renderPostFx(CameraMode cam_mode);
// For debug printing
virtual void PrintInfo(std::ostream &out);

297
src/content_cao.cpp
View File

@ -84,7 +84,8 @@ void SmoothTranslator::update(v3f vect_new, bool is_end_position, float update_i
aim_is_end = is_end_position;
vect_old = vect_show;
vect_aim = vect_new;
if(update_interval > 0){
if(update_interval > 0)
{
anim_time = update_interval;
} else {
if(anim_time < 0.001 || anim_time > 1.0)
@ -582,8 +583,10 @@ GenericCAO::GenericCAO(IGameDef *gamedef, ClientEnvironment *env):
ClientActiveObject::registerType(getType(), create);
}
bool GenericCAO::getCollisionBox(aabb3f *toset) {
if (m_prop.physical) {
bool GenericCAO::getCollisionBox(aabb3f *toset)
{
if (m_prop.physical)
{
//update collision box
toset->MinEdge = m_prop.collisionbox.MinEdge * BS;
toset->MaxEdge = m_prop.collisionbox.MaxEdge * BS;
@ -597,7 +600,8 @@ bool GenericCAO::getCollisionBox(aabb3f *toset) {
return false;
}
bool GenericCAO::collideWithObjects() {
bool GenericCAO::collideWithObjects()
{
return m_prop.collideWithObjects;
}
@ -635,7 +639,8 @@ void GenericCAO::initialize(const std::string &data)
return;
}
for(int i=0; i<num_messages; i++){
for(int i=0; i<num_messages; i++)
{
std::string message = deSerializeLongString(is);
processMessage(message);
}
@ -643,10 +648,17 @@ void GenericCAO::initialize(const std::string &data)
pos_translator.init(m_position);
updateNodePos();
if(m_is_player){
if(m_is_player)
{
Player *player = m_env->getPlayer(m_name.c_str());
if(player && player->isLocal()){
if(player && player->isLocal())
{
m_is_local_player = true;
m_is_visible = false;
LocalPlayer* localplayer = dynamic_cast<LocalPlayer*>(player);
assert( localplayer != NULL );
localplayer->setCAO(this);
}
m_env->addPlayerName(m_name.c_str());
}
@ -654,7 +666,8 @@ void GenericCAO::initialize(const std::string &data)
GenericCAO::~GenericCAO()
{
if(m_is_player){
if(m_is_player)
{
m_env->removePlayerName(m_name.c_str());
}
}
@ -668,7 +681,8 @@ core::aabbox3d<f32>* GenericCAO::getSelectionBox()
v3f GenericCAO::getPosition()
{
if(getParent() != NULL){
if(getParent() != NULL)
{
if(m_meshnode)
return m_meshnode->getAbsolutePosition();
if(m_animated_meshnode)
@ -711,9 +725,12 @@ ClientActiveObject* GenericCAO::getParent()
ClientActiveObject *obj = NULL;
for(std::vector<core::vector2d<int> >::const_iterator cii = m_env->attachment_list.begin(); cii != m_env->attachment_list.end(); cii++)
{
if(cii->X == getId()){ // This ID is our child
if(cii->Y > 0){ // A parent ID exists for our child
if(cii->X != cii->Y){ // The parent and child ID are not the same
if(cii->X == getId()) // This ID is our child
{
if(cii->Y > 0) // A parent ID exists for our child
{
if(cii->X != cii->Y) // The parent and child ID are not the same
{
obj = m_env->getActiveObject(cii->Y);
}
}
@ -730,18 +747,21 @@ void GenericCAO::removeFromScene(bool permanent)
if(permanent) // Should be true when removing the object permanently and false when refreshing (eg: updating visuals)
{
// Detach this object's children
for(std::vector<core::vector2d<int> >::iterator ii = m_env->attachment_list.begin(); ii != m_env->attachment_list.end(); ii++)
for(std::vector<core::vector2d<int> >::iterator ii = m_env->attachment_list.begin();
ii != m_env->attachment_list.end(); ii++)
{
if(ii->Y == getId()) // Is a child of our object
{
ii->Y = 0;
ClientActiveObject *obj = m_env->getActiveObject(ii->X); // Get the object of the child
// Get the object of the child
ClientActiveObject *obj = m_env->getActiveObject(ii->X);
if(obj)
obj->setAttachments();
}
}
// Delete this object from the attachments list
for(std::vector<core::vector2d<int> >::iterator ii = m_env->attachment_list.begin(); ii != m_env->attachment_list.end(); ii++)
for(std::vector<core::vector2d<int> >::iterator ii = m_env->attachment_list.begin();
ii != m_env->attachment_list.end(); ii++)
{
if(ii->X == getId()) // Is our object
{
@ -751,15 +771,18 @@ void GenericCAO::removeFromScene(bool permanent)
}
}
if(m_meshnode){
if(m_meshnode)
{
m_meshnode->remove();
m_meshnode = NULL;
}
if(m_animated_meshnode){
if(m_animated_meshnode)
{
m_animated_meshnode->remove();
m_animated_meshnode = NULL;
}
if(m_spritenode){
if(m_spritenode)
{
m_spritenode->remove();
m_spritenode = NULL;
}
@ -781,7 +804,8 @@ void GenericCAO::addToScene(scene::ISceneManager *smgr, ITextureSource *tsrc,
//video::IVideoDriver* driver = smgr->getVideoDriver();
if(m_prop.visual == "sprite"){
if(m_prop.visual == "sprite")
{
infostream<<"GenericCAO::addToScene(): single_sprite"<<std::endl;
m_spritenode = smgr->addBillboardSceneNode(
NULL, v2f(1, 1), v3f(0,0,0), -1);
@ -801,8 +825,7 @@ void GenericCAO::addToScene(scene::ISceneManager *smgr, ITextureSource *tsrc,
txs, tys, 0, 0);
}
}
else if(m_prop.visual == "upright_sprite")
{
else if(m_prop.visual == "upright_sprite") {
scene::SMesh *mesh = new scene::SMesh();
double dx = BS*m_prop.visual_size.X/2;
double dy = BS*m_prop.visual_size.Y/2;
@ -856,7 +879,7 @@ void GenericCAO::addToScene(scene::ISceneManager *smgr, ITextureSource *tsrc,
// This is needed for changing the texture in the future
m_meshnode->setReadOnlyMaterials(true);
}
else if(m_prop.visual == "cube"){
else if(m_prop.visual == "cube") {
infostream<<"GenericCAO::addToScene(): cube"<<std::endl;
scene::IMesh *mesh = createCubeMesh(v3f(BS,BS,BS));
m_meshnode = smgr->addMeshSceneNode(mesh, NULL);
@ -873,7 +896,7 @@ void GenericCAO::addToScene(scene::ISceneManager *smgr, ITextureSource *tsrc,
m_meshnode->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF);
m_meshnode->setMaterialFlag(video::EMF_FOG_ENABLE, true);
}
else if(m_prop.visual == "mesh"){
else if(m_prop.visual == "mesh") {
infostream<<"GenericCAO::addToScene(): mesh"<<std::endl;
scene::IAnimatedMesh *mesh = m_gamedef->getMesh(m_prop.mesh);
if(mesh)
@ -895,7 +918,7 @@ void GenericCAO::addToScene(scene::ISceneManager *smgr, ITextureSource *tsrc,
else
errorstream<<"GenericCAO::addToScene(): Could not load mesh "<<m_prop.mesh<<std::endl;
}
else if(m_prop.visual == "wielditem"){
else if(m_prop.visual == "wielditem") {
infostream<<"GenericCAO::addToScene(): node"<<std::endl;
infostream<<"textures: "<<m_prop.textures.size()<<std::endl;
if(m_prop.textures.size() >= 1){
@ -949,7 +972,8 @@ void GenericCAO::addToScene(scene::ISceneManager *smgr, ITextureSource *tsrc,
void GenericCAO::updateLight(u8 light_at_pos)
{
u8 li = decode_light(light_at_pos);
if(li != m_last_light){
if(li != m_last_light)
{
m_last_light = li;
video::SColor color(255,li,li,li);
if(m_meshnode)
@ -972,19 +996,22 @@ void GenericCAO::updateNodePos()
return;
v3s16 camera_offset = m_env->getCameraOffset();
if(m_meshnode){
if(m_meshnode)
{
m_meshnode->setPosition(pos_translator.vect_show-intToFloat(camera_offset, BS));
v3f rot = m_meshnode->getRotation();
rot.Y = -m_yaw;
m_meshnode->setRotation(rot);
}
if(m_animated_meshnode){
if(m_animated_meshnode)
{
m_animated_meshnode->setPosition(pos_translator.vect_show-intToFloat(camera_offset, BS));
v3f rot = m_animated_meshnode->getRotation();
rot.Y = -m_yaw;
m_animated_meshnode->setRotation(rot);
}
if(m_spritenode){
if(m_spritenode)
{
m_spritenode->setPosition(pos_translator.vect_show-intToFloat(camera_offset, BS));
}
}
@ -992,13 +1019,14 @@ void GenericCAO::updateNodePos()
void GenericCAO::step(float dtime, ClientEnvironment *env)
{
// Handel model of local player instantly to prevent lags
if(m_is_local_player) {
if(m_is_local_player)
{
LocalPlayer *player = m_env->getLocalPlayer();
if (player->camera_mode > CAMERA_MODE_FIRST) {
if (m_is_visible)
{
int old_anim = player->last_animation;
float old_anim_speed = player->last_animation_speed;
m_is_visible = true;
m_position = player->getPosition() + v3f(0,BS,0);
m_velocity = v3f(0,0,0);
m_acceleration = v3f(0,0,0);
@ -1026,7 +1054,8 @@ void GenericCAO::step(float dtime, ClientEnvironment *env)
if(controls.sneak && walking)
new_speed /= 2;
if(walking && (controls.LMB || controls.RMB)) {
if(walking && (controls.LMB || controls.RMB))
{
new_anim = player->local_animations[3];
player->last_animation = WD_ANIM;
} else if(walking) {
@ -1039,7 +1068,8 @@ void GenericCAO::step(float dtime, ClientEnvironment *env)
// Apply animations if input detected and not attached
// or set idle animation
if ((new_anim.X + new_anim.Y) > 0 && !player->isAttached) {
if ((new_anim.X + new_anim.Y) > 0 && !player->isAttached)
{
allow_update = true;
m_animation_range = new_anim;
m_animation_speed = new_speed;
@ -1047,36 +1077,42 @@ void GenericCAO::step(float dtime, ClientEnvironment *env)
} else {
player->last_animation = NO_ANIM;
if (old_anim != NO_ANIM) {
if (old_anim != NO_ANIM)
{
m_animation_range = player->local_animations[0];
updateAnimation();
}
}
// Update local player animations
if ((player->last_animation != old_anim || m_animation_speed != old_anim_speed) &&
if ((player->last_animation != old_anim ||
m_animation_speed != old_anim_speed) &&
player->last_animation != NO_ANIM && allow_update)
updateAnimation();
} else {
m_is_visible = false;
}
}
if(m_visuals_expired && m_smgr && m_irr){
m_visuals_expired = false;
// Attachments, part 1: All attached objects must be unparented first, or Irrlicht causes a segmentation fault
for(std::vector<core::vector2d<int> >::iterator ii = m_env->attachment_list.begin(); ii != m_env->attachment_list.end(); ii++)
// Attachments, part 1: All attached objects must be unparented first,
// or Irrlicht causes a segmentation fault
for(std::vector<core::vector2d<int> >::iterator ii = m_env->attachment_list.begin();
ii != m_env->attachment_list.end(); ii++)
{
if(ii->Y == getId()) // This is a child of our parent
{
ClientActiveObject *obj = m_env->getActiveObject(ii->X); // Get the object of the child
// Get the object of the child
ClientActiveObject *obj = m_env->getActiveObject(ii->X);
if(obj)
{
scene::IMeshSceneNode *m_child_meshnode = obj->getMeshSceneNode();
scene::IAnimatedMeshSceneNode *m_child_animated_meshnode = obj->getAnimatedMeshSceneNode();
scene::IBillboardSceneNode *m_child_spritenode = obj->getSpriteSceneNode();
scene::IMeshSceneNode *m_child_meshnode
= obj->getMeshSceneNode();
scene::IAnimatedMeshSceneNode *m_child_animated_meshnode
= obj->getAnimatedMeshSceneNode();
scene::IBillboardSceneNode *m_child_spritenode
= obj->getSpriteSceneNode();
if(m_child_meshnode)
m_child_meshnode->setParent(m_smgr->getRootSceneNode());
if(m_child_animated_meshnode)
@ -1091,11 +1127,13 @@ void GenericCAO::step(float dtime, ClientEnvironment *env)
addToScene(m_smgr, m_gamedef->tsrc(), m_irr);
// Attachments, part 2: Now that the parent has been refreshed, put its attachments back
for(std::vector<core::vector2d<int> >::iterator ii = m_env->attachment_list.begin(); ii != m_env->attachment_list.end(); ii++)
for(std::vector<core::vector2d<int> >::iterator ii = m_env->attachment_list.begin();
ii != m_env->attachment_list.end(); ii++)
{
if(ii->Y == getId()) // This is a child of our parent
{
ClientActiveObject *obj = m_env->getActiveObject(ii->X); // Get the object of the child
// Get the object of the child
ClientActiveObject *obj = m_env->getActiveObject(ii->X);
if(obj)
obj->setAttachments();
}
@ -1126,12 +1164,11 @@ void GenericCAO::step(float dtime, ClientEnvironment *env)
player->overridePosition = getParent()->getPosition();
m_env->getLocalPlayer()->parent = getParent();
}
}
else
{
} else {
v3f lastpos = pos_translator.vect_show;
if(m_prop.physical){
if(m_prop.physical)
{
core::aabbox3d<f32> box = m_prop.collisionbox;
box.MinEdge *= BS;
box.MaxEdge *= BS;
@ -1156,16 +1193,19 @@ void GenericCAO::step(float dtime, ClientEnvironment *env)
} else {
m_position += dtime * m_velocity + 0.5 * dtime * dtime * m_acceleration;
m_velocity += dtime * m_acceleration;
pos_translator.update(m_position, pos_translator.aim_is_end, pos_translator.anim_time);
pos_translator.update(m_position, pos_translator.aim_is_end,
pos_translator.anim_time);
pos_translator.translate(dtime);
updateNodePos();
}
float moved = lastpos.getDistanceFrom(pos_translator.vect_show);
m_step_distance_counter += moved;
if(m_step_distance_counter > 1.5*BS){
if(m_step_distance_counter > 1.5*BS)
{
m_step_distance_counter = 0;
if(!m_is_local_player && m_prop.makes_footstep_sound){
if(!m_is_local_player && m_prop.makes_footstep_sound)
{
INodeDefManager *ndef = m_gamedef->ndef();
v3s16 p = floatToInt(getPosition() + v3f(0,
(m_prop.collisionbox.MinEdge.Y-0.5)*BS, 0), BS);
@ -1177,7 +1217,8 @@ void GenericCAO::step(float dtime, ClientEnvironment *env)
}
m_anim_timer += dtime;
if(m_anim_timer >= m_anim_framelength){
if(m_anim_timer >= m_anim_framelength)
{
m_anim_timer -= m_anim_framelength;
m_anim_frame++;
if(m_anim_frame >= m_anim_num_frames)
@ -1186,28 +1227,33 @@ void GenericCAO::step(float dtime, ClientEnvironment *env)
updateTexturePos();
if(m_reset_textures_timer >= 0){
if(m_reset_textures_timer >= 0)
{
m_reset_textures_timer -= dtime;
if(m_reset_textures_timer <= 0){
m_reset_textures_timer = -1;
updateTextures("");
}
}
if(getParent() == NULL && fabs(m_prop.automatic_rotate) > 0.001){
if(getParent() == NULL && fabs(m_prop.automatic_rotate) > 0.001)
{
m_yaw += dtime * m_prop.automatic_rotate * 180 / M_PI;
updateNodePos();
}
if (getParent() == NULL && m_prop.automatic_face_movement_dir &&
(fabs(m_velocity.Z) > 0.001 || fabs(m_velocity.X) > 0.001)){
m_yaw = atan2(m_velocity.Z,m_velocity.X) * 180 / M_PI + m_prop.automatic_face_movement_dir_offset;
(fabs(m_velocity.Z) > 0.001 || fabs(m_velocity.X) > 0.001))
{
m_yaw = atan2(m_velocity.Z,m_velocity.X) * 180 / M_PI
+ m_prop.automatic_face_movement_dir_offset;
updateNodePos();
}
}
void GenericCAO::updateTexturePos()
{
if(m_spritenode){
if(m_spritenode)
{
scene::ICameraSceneNode* camera =
m_spritenode->getSceneManager()->getActiveCamera();
if(!camera)
@ -1226,7 +1272,8 @@ void GenericCAO::updateTexturePos()
else if(cam_to_entity.Y < -0.75)
col += 4;
else{
float mob_dir = atan2(cam_to_entity.Z, cam_to_entity.X) / M_PI * 180.;
float mob_dir =
atan2(cam_to_entity.Z, cam_to_entity.X) / M_PI * 180.;
float dir = mob_dir - m_yaw;
dir = wrapDegrees_180(dir);
//infostream<<"id="<<m_id<<" dir="<<dir<<std::endl;
@ -1291,7 +1338,8 @@ void GenericCAO::updateTextures(const std::string &mod)
{
if(m_prop.visual == "mesh")
{
for (u32 i = 0; i < m_prop.textures.size() && i < m_animated_meshnode->getMaterialCount(); ++i)
for (u32 i = 0; i < m_prop.textures.size() &&
i < m_animated_meshnode->getMaterialCount(); ++i)
{
std::string texturestring = m_prop.textures[i];
if(texturestring == "")
@ -1310,11 +1358,15 @@ void GenericCAO::updateTextures(const std::string &mod)
material.setFlag(video::EMF_LIGHTING, false);
material.setFlag(video::EMF_BILINEAR_FILTER, false);
m_animated_meshnode->getMaterial(i).setFlag(video::EMF_TRILINEAR_FILTER, use_trilinear_filter);
m_animated_meshnode->getMaterial(i).setFlag(video::EMF_BILINEAR_FILTER, use_bilinear_filter);
m_animated_meshnode->getMaterial(i).setFlag(video::EMF_ANISOTROPIC_FILTER, use_anisotropic_filter);
m_animated_meshnode->getMaterial(i)
.setFlag(video::EMF_TRILINEAR_FILTER, use_trilinear_filter);
m_animated_meshnode->getMaterial(i)
.setFlag(video::EMF_BILINEAR_FILTER, use_bilinear_filter);
m_animated_meshnode->getMaterial(i)
.setFlag(video::EMF_ANISOTROPIC_FILTER, use_anisotropic_filter);
}
for (u32 i = 0; i < m_prop.colors.size() && i < m_animated_meshnode->getMaterialCount(); ++i)
for (u32 i = 0; i < m_prop.colors.size() &&
i < m_animated_meshnode->getMaterialCount(); ++i)
{
// This allows setting per-material colors. However, until a real lighting
// system is added, the code below will have no effect. Once MineTest
@ -1436,7 +1488,10 @@ void GenericCAO::updateBonePosition()
return;
m_animated_meshnode->setJointMode(irr::scene::EJUOR_CONTROL); // To write positions to the mesh on render
for(std::map<std::string, core::vector2d<v3f> >::const_iterator ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii){
for(std::map<std::string,
core::vector2d<v3f> >::const_iterator ii = m_bone_position.begin();
ii != m_bone_position.end(); ++ii)
{
std::string bone_name = (*ii).first;
v3f bone_pos = (*ii).second.X;
v3f bone_rot = (*ii).second.Y;
@ -1451,8 +1506,14 @@ void GenericCAO::updateBonePosition()
void GenericCAO::updateAttachments()
{
m_attached_to_local = getParent() != NULL && getParent()->isLocalPlayer();
m_is_visible = !m_attached_to_local; // Objects attached to the local player should always be hidden
// localplayer itself can't be attached to localplayer
if (!m_is_local_player)
{
m_attached_to_local = getParent() != NULL && getParent()->isLocalPlayer();
// Objects attached to the local player should always be hidden
m_is_visible = !m_attached_to_local;
}
if(getParent() == NULL || m_attached_to_local) // Detach or don't attach
{
@ -1503,12 +1564,17 @@ void GenericCAO::updateAttachments()
scene::IBoneSceneNode *parent_bone = NULL;
if(parent_animated_mesh && m_attachment_bone != "")
parent_bone = parent_animated_mesh->getJointNode(m_attachment_bone.c_str());
// The spaghetti code below makes sure attaching works if either the parent or child is a spritenode, meshnode, or animatedmeshnode
{
parent_bone =
parent_animated_mesh->getJointNode(m_attachment_bone.c_str());
}
// The spaghetti code below makes sure attaching works if either the
// parent or child is a spritenode, meshnode, or animatedmeshnode
// TODO: Perhaps use polymorphism here to save code duplication
if(m_meshnode){
if(parent_bone){
if(m_meshnode)
{
if(parent_bone)
{
m_meshnode->setParent(parent_bone);
m_meshnode->setPosition(m_attachment_position);
m_meshnode->setRotation(m_attachment_rotation);
@ -1516,19 +1582,20 @@ void GenericCAO::updateAttachments()
}
else
{
if(parent_mesh){
if(parent_mesh)
{
m_meshnode->setParent(parent_mesh);
m_meshnode->setPosition(m_attachment_position);
m_meshnode->setRotation(m_attachment_rotation);
m_meshnode->updateAbsolutePosition();
}
else if(parent_animated_mesh){
else if(parent_animated_mesh) {
m_meshnode->setParent(parent_animated_mesh);
m_meshnode->setPosition(m_attachment_position);
m_meshnode->setRotation(m_attachment_rotation);
m_meshnode->updateAbsolutePosition();
}
else if(parent_sprite){
else if(parent_sprite) {
m_meshnode->setParent(parent_sprite);
m_meshnode->setPosition(m_attachment_position);
m_meshnode->setRotation(m_attachment_rotation);
@ -1536,8 +1603,10 @@ void GenericCAO::updateAttachments()
}
}
}
if(m_animated_meshnode){
if(parent_bone){
if(m_animated_meshnode)
{
if(parent_bone)
{
m_animated_meshnode->setParent(parent_bone);
m_animated_meshnode->setPosition(m_attachment_position);
m_animated_meshnode->setRotation(m_attachment_rotation);
@ -1545,19 +1614,18 @@ void GenericCAO::updateAttachments()
}
else
{
if(parent_mesh){
if(parent_mesh)
{
m_animated_meshnode->setParent(parent_mesh);
m_animated_meshnode->setPosition(m_attachment_position);
m_animated_meshnode->setRotation(m_attachment_rotation);
m_animated_meshnode->updateAbsolutePosition();
}
else if(parent_animated_mesh){
} else if(parent_animated_mesh) {
m_animated_meshnode->setParent(parent_animated_mesh);
m_animated_meshnode->setPosition(m_attachment_position);
m_animated_meshnode->setRotation(m_attachment_rotation);
m_animated_meshnode->updateAbsolutePosition();
}
else if(parent_sprite){
} else if(parent_sprite) {
m_animated_meshnode->setParent(parent_sprite);
m_animated_meshnode->setPosition(m_attachment_position);
m_animated_meshnode->setRotation(m_attachment_rotation);
@ -1565,28 +1633,29 @@ void GenericCAO::updateAttachments()
}
}
}
if(m_spritenode){
if(parent_bone){
if(m_spritenode)
{
if(parent_bone)
{
m_spritenode->setParent(parent_bone);
m_spritenode->setPosition(m_attachment_position);
m_spritenode->setRotation(m_attachment_rotation);
m_spritenode->updateAbsolutePosition();
}
else
{
if(parent_mesh){
} else {
if(parent_mesh)
{
m_spritenode->setParent(parent_mesh);
m_spritenode->setPosition(m_attachment_position);
m_spritenode->setRotation(m_attachment_rotation);
m_spritenode->updateAbsolutePosition();
}
else if(parent_animated_mesh){
else if(parent_animated_mesh) {
m_spritenode->setParent(parent_animated_mesh);
m_spritenode->setPosition(m_attachment_position);
m_spritenode->setRotation(m_attachment_rotation);
m_spritenode->updateAbsolutePosition();
}
else if(parent_sprite){
else if(parent_sprite) {
m_spritenode->setParent(parent_sprite);
m_spritenode->setPosition(m_attachment_position);
m_spritenode->setRotation(m_attachment_rotation);
@ -1649,7 +1718,8 @@ void GenericCAO::processMessage(const std::string &data)
if(getParent() != NULL) // Just in case
return;
if(do_interpolate){
if(do_interpolate)
{
if(!m_prop.physical)
pos_translator.update(m_position, is_end_position, update_interval);
} else {
@ -1657,13 +1727,11 @@ void GenericCAO::processMessage(const std::string &data)
}
updateNodePos();
}
else if(cmd == GENERIC_CMD_SET_TEXTURE_MOD)
{
else if(cmd == GENERIC_CMD_SET_TEXTURE_MOD) {
std::string mod = deSerializeString(is);
updateTextures(mod);
}
else if(cmd == GENERIC_CMD_SET_SPRITE)
{
else if(cmd == GENERIC_CMD_SET_SPRITE) {
v2s16 p = readV2S16(is);
int num_frames = readU16(is);
float framelength = readF1000(is);
@ -1676,8 +1744,7 @@ void GenericCAO::processMessage(const std::string &data)
updateTexturePos();
}
else if(cmd == GENERIC_CMD_SET_PHYSICS_OVERRIDE)
{
else if(cmd == GENERIC_CMD_SET_PHYSICS_OVERRIDE) {
float override_speed = readF1000(is);
float override_jump = readF1000(is);
float override_gravity = readF1000(is);
@ -1696,8 +1763,7 @@ void GenericCAO::processMessage(const std::string &data)
player->physics_override_sneak_glitch = sneak_glitch;
}
}
else if(cmd == GENERIC_CMD_SET_ANIMATION)
{
else if(cmd == GENERIC_CMD_SET_ANIMATION) {
// TODO: change frames send as v2s32 value
v2f range = readV2F1000(is);
if (!m_is_local_player) {
@ -1707,7 +1773,8 @@ void GenericCAO::processMessage(const std::string &data)
updateAnimation();
} else {
LocalPlayer *player = m_env->getLocalPlayer();
if(player->last_animation == NO_ANIM) {
if(player->last_animation == NO_ANIM)
{
m_animation_range = v2s32((s32)range.X, (s32)range.Y);
m_animation_speed = readF1000(is);
m_animation_blend = readF1000(is);
@ -1715,7 +1782,8 @@ void GenericCAO::processMessage(const std::string &data)
// update animation only if local animations present
// and received animation is unknown (except idle animation)
bool is_known = false;
for (int i = 1;i<4;i++) {
for (int i = 1;i<4;i++)
{
if(m_animation_range.Y == player->local_animations[i].Y)
is_known = true;
}
@ -1726,8 +1794,7 @@ void GenericCAO::processMessage(const std::string &data)
}
}
}
else if(cmd == GENERIC_CMD_SET_BONE_POSITION)
{
else if(cmd == GENERIC_CMD_SET_BONE_POSITION) {
std::string bone = deSerializeString(is);
v3f position = readV3F1000(is);
v3f rotation = readV3F1000(is);
@ -1735,8 +1802,7 @@ void GenericCAO::processMessage(const std::string &data)
updateBonePosition();
}
else if(cmd == GENERIC_CMD_SET_ATTACHMENT)
{
else if(cmd == GENERIC_CMD_SET_ATTACHMENT) {
// If an entry already exists for this object, delete it first to avoid duplicates
for(std::vector<core::vector2d<int> >::iterator ii = m_env->attachment_list.begin(); ii != m_env->attachment_list.end(); ii++)
{
@ -1753,8 +1819,7 @@ void GenericCAO::processMessage(const std::string &data)
updateAttachments();
}
else if(cmd == GENERIC_CMD_PUNCHED)
{
else if(cmd == GENERIC_CMD_PUNCHED) {
/*s16 damage =*/ readS16(is);
s16 result_hp = readS16(is);
@ -1763,8 +1828,10 @@ void GenericCAO::processMessage(const std::string &data)
m_hp = result_hp;
if (damage > 0) {
if (m_hp <= 0) {
if (damage > 0)
{
if (m_hp <= 0)
{
// TODO: Execute defined fast response
// As there is no definition, make a smoke puff
ClientSimpleObject *simple = createSmokePuff(
@ -1781,11 +1848,11 @@ void GenericCAO::processMessage(const std::string &data)
}
}
}
else if(cmd == GENERIC_CMD_UPDATE_ARMOR_GROUPS)
{
else if(cmd == GENERIC_CMD_UPDATE_ARMOR_GROUPS) {
m_armor_groups.clear();
int armor_groups_size = readU16(is);
for(int i=0; i<armor_groups_size; i++){
for(int i=0; i<armor_groups_size; i++)
{
std::string name = deSerializeString(is);
int rating = readS16(is);
m_armor_groups[name] = rating;
@ -1807,7 +1874,8 @@ bool GenericCAO::directReportPunch(v3f dir, const ItemStack *punchitem,
if(result.did_punch && result.damage != 0)
{
if(result.damage < m_hp){
if(result.damage < m_hp)
{
m_hp -= result.damage;
} else {
m_hp = 0;
@ -1835,7 +1903,8 @@ std::string GenericCAO::debugInfoText()
os<<"GenericCAO hp="<<m_hp<<"\n";
os<<"armor={";
for(ItemGroupList::const_iterator i = m_armor_groups.begin();
i != m_armor_groups.end(); i++){
i != m_armor_groups.end(); i++)
{
os<<i->first<<"="<<i->second<<", ";
}
os<<"}";

4
src/defaultsettings.cpp
View File

@ -56,8 +56,8 @@ void set_default_settings(Settings *settings)
settings->setDefault("keymap_camera_mode", "KEY_F7");
settings->setDefault("keymap_increase_viewing_range_min", "+");
settings->setDefault("keymap_decrease_viewing_range_min", "-");
settings->setDefault("anaglyph", "false");
settings->setDefault("anaglyph_strength", "0.1");
settings->setDefault("3d_mode", "none");
settings->setDefault("3d_paralax_strength", "0.025");
settings->setDefault("aux1_descends", "false");
settings->setDefault("doubletap_jump", "false");
settings->setDefault("always_fly_fast", "true");

529
src/drawscene.cpp Normal file
View File

@ -0,0 +1,529 @@
/*
Minetest
Copyright (C) 2010-2014 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 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 Lesser General Public License for more details.
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 "drawscene.h"
#include "main.h" // for g_settings
#include "settings.h"
#include "clouds.h"
#include "util/timetaker.h"
typedef enum {
LEFT = -1,
RIGHT = 1,
EYECOUNT = 2
} paralax_sign;
void draw_selectionbox(video::IVideoDriver* driver, Hud& hud,
std::vector<aabb3f>& hilightboxes, bool show_hud)
{
if (!show_hud)
return;
video::SMaterial oldmaterial = driver->getMaterial2D();
video::SMaterial m;
m.Thickness = 3;
m.Lighting = false;
driver->setMaterial(m);
hud.drawSelectionBoxes(hilightboxes);
driver->setMaterial(oldmaterial);
}
void draw_anaglyph_3d_mode(Camera& camera, bool show_hud, Hud& hud,
std::vector<aabb3f> hilightboxes, video::IVideoDriver* driver,
scene::ISceneManager* smgr, bool draw_wield_tool, Client& client,
gui::IGUIEnvironment* guienv )
{
/* preserve old setup*/
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("3d_paralax_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();
driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
if (show_hud)
{
draw_selectionbox(driver, hud, hilightboxes, show_hud);
if (draw_wield_tool)
camera.drawWieldedTool(&leftMove);
}
guienv->drawAll();
//Right eye...
irr::core::vector3df rightEye;
irr::core::matrix4 rightMove;
rightMove.setTranslation(
irr::core::vector3df(g_settings->getFloat("3d_paralax_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();
driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
if (show_hud)
{
draw_selectionbox(driver, hud, hilightboxes, show_hud);
if (draw_wield_tool)
camera.drawWieldedTool(&rightMove);
}
guienv->drawAll();
driver->getOverrideMaterial().Material.ColorMask = irr::video::ECP_ALL;
driver->getOverrideMaterial().EnableFlags = 0;
driver->getOverrideMaterial().EnablePasses = 0;
camera.getCameraNode()->setPosition(oldPosition);
camera.getCameraNode()->setTarget(oldTarget);
}
void init_texture(video::IVideoDriver* driver, const v2u32& screensize,
video::ITexture** texture)
{
static v2u32 last_screensize = v2u32(0,0);
if (( *texture == NULL ) || (screensize != last_screensize))
{
if (*texture != NULL)
{
driver->removeTexture(*texture);
}
*texture = driver->addRenderTargetTexture(
core::dimension2d<u32>(screensize.X, screensize.Y));
last_screensize = screensize;
}
}
video::ITexture* draw_image(const v2u32& screensize,
paralax_sign psign, const irr::core::matrix4& startMatrix,
const irr::core::vector3df& focusPoint, bool show_hud,
video::IVideoDriver* driver, Camera& camera, scene::ISceneManager* smgr,
Hud& hud, std::vector<aabb3f>& hilightboxes,
bool draw_wield_tool, Client& client, gui::IGUIEnvironment* guienv,
video::SColor skycolor )
{
static video::ITexture* images[2] = { NULL, NULL };
video::ITexture* image = NULL;
if (psign == RIGHT)
{
init_texture(driver, screensize, &images[1]);
image = images[1];
} else {
init_texture(driver, screensize, &images[0]);
image = images[0];
}
driver->setRenderTarget(image, true, true,
irr::video::SColor(255,
skycolor.getRed(), skycolor.getGreen(), skycolor.getBlue()));
irr::core::vector3df eye_pos;
irr::core::matrix4 movement;
movement.setTranslation(
irr::core::vector3df((int) psign *
g_settings->getFloat("3d_paralax_strength"), 0.0f, 0.0f));
eye_pos = (startMatrix * movement).getTranslation();
//clear the depth buffer
driver->clearZBuffer();
camera.getCameraNode()->setPosition(eye_pos);
camera.getCameraNode()->setTarget(focusPoint);
smgr->drawAll();
driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
if (show_hud)
{
draw_selectionbox(driver, hud, hilightboxes, show_hud);
if (draw_wield_tool)
camera.drawWieldedTool(&movement);
}
guienv->drawAll();
/* switch back to real renderer */
driver->setRenderTarget(0, true, true,
irr::video::SColor(0,
skycolor.getRed(), skycolor.getGreen(), skycolor.getBlue()));
return image;
}
video::ITexture* draw_hud(video::IVideoDriver* driver, const v2u32& screensize,
bool show_hud, Hud& hud, Client& client, bool draw_crosshair,
video::SColor skycolor, gui::IGUIEnvironment* guienv, Camera& camera )
{
static video::ITexture* image = NULL;
init_texture(driver, screensize, &image);
driver->setRenderTarget(image, true, true,
irr::video::SColor(255,0,0,0));
if (show_hud)
{
if (draw_crosshair)
hud.drawCrosshair();
hud.drawHotbar(client.getPlayerItem());
hud.drawLuaElements(camera.getOffset());
guienv->drawAll();
}
driver->setRenderTarget(0, true, true,
irr::video::SColor(0,
skycolor.getRed(), skycolor.getGreen(), skycolor.getBlue()));
return image;
}
void draw_interlaced_3d_mode(Camera& camera, bool show_hud,
Hud& hud, std::vector<aabb3f> hilightboxes, video::IVideoDriver* driver,
scene::ISceneManager* smgr, const v2u32& screensize,
bool draw_wield_tool, Client& client, gui::IGUIEnvironment* guienv,
video::SColor skycolor )
{
/* save current info */
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();
/* create left view */
video::ITexture* left_image = draw_image(screensize, LEFT, startMatrix,
focusPoint, show_hud, driver, camera, smgr, hud, hilightboxes,
draw_wield_tool, client, guienv, skycolor);
//Right eye...
irr::core::vector3df rightEye;
irr::core::matrix4 rightMove;
rightMove.setTranslation(
irr::core::vector3df(g_settings->getFloat("3d_paralax_strength"),
0.0f, 0.0f));
rightEye = (startMatrix * rightMove).getTranslation();
//clear the depth buffer
driver->clearZBuffer();
camera.getCameraNode()->setPosition(rightEye);
camera.getCameraNode()->setTarget(focusPoint);
smgr->drawAll();
driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
if (show_hud)
{
draw_selectionbox(driver, hud, hilightboxes, show_hud);
if(draw_wield_tool)
camera.drawWieldedTool(&rightMove);
}
guienv->drawAll();
for (unsigned int i = 0; i < screensize.Y; i+=2 ) {
driver->draw2DImage(left_image, irr::core::position2d<s32>(0, screensize.Y-i),
irr::core::rect<s32>(0, i,screensize.X, i+1), 0,
irr::video::SColor(255, 255, 255, 255),
false);
}
/* cleanup */
camera.getCameraNode()->setPosition(oldPosition);
camera.getCameraNode()->setTarget(oldTarget);
}
void draw_sidebyside_3d_mode(Camera& camera, bool show_hud,
Hud& hud, std::vector<aabb3f> hilightboxes, video::IVideoDriver* driver,
scene::ISceneManager* smgr, const v2u32& screensize,
bool draw_wield_tool, Client& client, gui::IGUIEnvironment* guienv,
video::SColor skycolor )
{
/* save current info */
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();
/* create left view */
video::ITexture* left_image = draw_image(screensize, LEFT, startMatrix,
focusPoint, show_hud, driver, camera, smgr, hud, hilightboxes,
draw_wield_tool, client, guienv, skycolor);
/* create right view */
video::ITexture* right_image = draw_image(screensize, RIGHT, startMatrix,
focusPoint, show_hud, driver, camera, smgr, hud, hilightboxes,
draw_wield_tool, client, guienv, skycolor);
/* create hud overlay */
video::ITexture* hudtexture = draw_hud(driver, screensize, show_hud, hud, client,
false, skycolor, guienv, camera );
driver->makeColorKeyTexture(hudtexture, irr::video::SColor(255, 0, 0, 0));
//makeColorKeyTexture mirrors texture so we do it twice to get it right again
driver->makeColorKeyTexture(hudtexture, irr::video::SColor(255, 0, 0, 0));
driver->draw2DImage(left_image,
irr::core::rect<s32>(0, 0, screensize.X/2, screensize.Y),
irr::core::rect<s32>(0, 0, screensize.X, screensize.Y), 0, 0, false);
driver->draw2DImage(hudtexture,
irr::core::rect<s32>(0, 0, screensize.X/2, screensize.Y),
irr::core::rect<s32>(0, 0, screensize.X, screensize.Y), 0, 0, true);
driver->draw2DImage(right_image,
irr::core::rect<s32>(screensize.X/2, 0, screensize.X, screensize.Y),
irr::core::rect<s32>(0, 0, screensize.X, screensize.Y), 0, 0, false);
driver->draw2DImage(hudtexture,
irr::core::rect<s32>(screensize.X/2, 0, screensize.X, screensize.Y),
irr::core::rect<s32>(0, 0, screensize.X, screensize.Y), 0, 0, true);
left_image = NULL;
right_image = NULL;
/* cleanup */
camera.getCameraNode()->setPosition(oldPosition);
camera.getCameraNode()->setTarget(oldTarget);
}
void draw_top_bottom_3d_mode(Camera& camera, bool show_hud,
Hud& hud, std::vector<aabb3f> hilightboxes, video::IVideoDriver* driver,
scene::ISceneManager* smgr, const v2u32& screensize,
bool draw_wield_tool, Client& client, gui::IGUIEnvironment* guienv,
video::SColor skycolor )
{
/* save current info */
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();
/* create left view */
video::ITexture* left_image = draw_image(screensize, LEFT, startMatrix,
focusPoint, show_hud, driver, camera, smgr, hud, hilightboxes,
draw_wield_tool, client, guienv, skycolor);
/* create right view */
video::ITexture* right_image = draw_image(screensize, RIGHT, startMatrix,
focusPoint, show_hud, driver, camera, smgr, hud, hilightboxes,
draw_wield_tool, client, guienv, skycolor);
/* create hud overlay */
video::ITexture* hudtexture = draw_hud(driver, screensize, show_hud, hud, client,
false, skycolor, guienv, camera );
driver->makeColorKeyTexture(hudtexture, irr::video::SColor(255, 0, 0, 0));
//makeColorKeyTexture mirrors texture so we do it twice to get it right again
driver->makeColorKeyTexture(hudtexture, irr::video::SColor(255, 0, 0, 0));
driver->draw2DImage(left_image,
irr::core::rect<s32>(0, 0, screensize.X, screensize.Y/2),
irr::core::rect<s32>(0, 0, screensize.X, screensize.Y), 0, 0, false);
driver->draw2DImage(hudtexture,
irr::core::rect<s32>(0, 0, screensize.X, screensize.Y/2),
irr::core::rect<s32>(0, 0, screensize.X, screensize.Y), 0, 0, true);
driver->draw2DImage(right_image,
irr::core::rect<s32>(0, screensize.Y/2, screensize.X, screensize.Y),
irr::core::rect<s32>(0, 0, screensize.X, screensize.Y), 0, 0, false);
driver->draw2DImage(hudtexture,
irr::core::rect<s32>(0, screensize.Y/2, screensize.X, screensize.Y),
irr::core::rect<s32>(0, 0, screensize.X, screensize.Y), 0, 0, true);
left_image = NULL;
right_image = NULL;
/* cleanup */
camera.getCameraNode()->setPosition(oldPosition);
camera.getCameraNode()->setTarget(oldTarget);
}
void draw_plain(Camera& camera, bool show_hud, Hud& hud,
std::vector<aabb3f> hilightboxes, video::IVideoDriver* driver,
bool draw_wield_tool, Client& client, gui::IGUIEnvironment* guienv)
{
draw_selectionbox(driver, hud, hilightboxes, show_hud);
if(draw_wield_tool)
camera.drawWieldedTool();
}
void draw_scene(video::IVideoDriver* driver, scene::ISceneManager* smgr,
Camera& camera, Client& client, LocalPlayer* player, Hud& hud,
gui::IGUIEnvironment* guienv, std::vector<aabb3f> hilightboxes,
const v2u32& screensize, video::SColor skycolor, bool show_hud)
{
//TODO check if usefull
u32 scenetime = 0;
{
TimeTaker timer("smgr");
bool draw_wield_tool = (show_hud &&
(player->hud_flags & HUD_FLAG_WIELDITEM_VISIBLE) &&
camera.getCameraMode() < CAMERA_MODE_THIRD );
bool draw_crosshair = ((player->hud_flags & HUD_FLAG_CROSSHAIR_VISIBLE) &&
(camera.getCameraMode() != CAMERA_MODE_THIRD_FRONT));
std::string draw_mode = g_settings->get("3d_mode");
smgr->drawAll();
if (draw_mode == "anaglyph")
{
draw_anaglyph_3d_mode(camera, show_hud, hud, hilightboxes, driver,
smgr, draw_wield_tool, client, guienv);
draw_crosshair = false;
}
else if (draw_mode == "interlaced")
{
draw_interlaced_3d_mode(camera, show_hud, hud, hilightboxes, driver,
smgr, screensize, draw_wield_tool, client, guienv, skycolor);
draw_crosshair = false;
}
else if (draw_mode == "sidebyside")
{
draw_sidebyside_3d_mode(camera, show_hud, hud, hilightboxes, driver,
smgr, screensize, draw_wield_tool, client, guienv, skycolor);
show_hud = false;
}
else if (draw_mode == "topbottom")
{
draw_top_bottom_3d_mode(camera, show_hud, hud, hilightboxes, driver,
smgr, screensize, draw_wield_tool, client, guienv, skycolor);
show_hud = false;
}
else {
draw_plain(camera, show_hud, hud, hilightboxes, driver,
draw_wield_tool, client, guienv);
}
//TODO how to make those 3d too
if (show_hud)
{
if (draw_crosshair)
hud.drawCrosshair();
hud.drawHotbar(client.getPlayerItem());
hud.drawLuaElements(camera.getOffset());
guienv->drawAll();
}
scenetime = timer.stop(true);
}
}
/*
Draws a screen with a single text on it.
Text will be removed when the screen is drawn the next time.
Additionally, a progressbar can be drawn when percent is set between 0 and 100.
*/
/*gui::IGUIStaticText **/
void draw_load_screen(const std::wstring &text, IrrlichtDevice* device,
gui::IGUIEnvironment* guienv, gui::IGUIFont* font, float dtime,
int percent, bool clouds )
{
video::IVideoDriver* driver = device->getVideoDriver();
v2u32 screensize = driver->getScreenSize();
const wchar_t *loadingtext = text.c_str();
core::vector2d<u32> textsize_u = font->getDimension(loadingtext);
core::vector2d<s32> textsize(textsize_u.X,textsize_u.Y);
core::vector2d<s32> center(screensize.X/2, screensize.Y/2);
core::rect<s32> textrect(center - textsize/2, center + textsize/2);
gui::IGUIStaticText *guitext = guienv->addStaticText(
loadingtext, textrect, false, false);
guitext->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
bool cloud_menu_background = clouds && g_settings->getBool("menu_clouds");
if (cloud_menu_background)
{
g_menuclouds->step(dtime*3);
g_menuclouds->render();
driver->beginScene(true, true, video::SColor(255,140,186,250));
g_menucloudsmgr->drawAll();
}
else
driver->beginScene(true, true, video::SColor(255,0,0,0));
if (percent >= 0 && percent <= 100) // draw progress bar
{
core::vector2d<s32> barsize(256,32);
core::rect<s32> barrect(center-barsize/2, center+barsize/2);
driver->draw2DRectangle(video::SColor(255,255,255,255),barrect, NULL); // border
driver->draw2DRectangle(video::SColor(255,64,64,64), core::rect<s32> (
barrect.UpperLeftCorner+1,
barrect.LowerRightCorner-1), NULL); // black inside the bar
driver->draw2DRectangle(video::SColor(255,128,128,128), core::rect<s32> (
barrect.UpperLeftCorner+1,
core::vector2d<s32>(
barrect.LowerRightCorner.X-(barsize.X-1)+percent*(barsize.X-2)/100,
barrect.LowerRightCorner.Y-1)), NULL); // the actual progress
}
guienv->drawAll();
driver->endScene();
guitext->remove();
//return guitext;
}

37
src/drawscene.h Normal file
View File

@ -0,0 +1,37 @@
/*
Minetest
Copyright (C) 2010-2014 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 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 Lesser General Public License for more details.
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.
*/
#ifndef DRAWSCENE_H_
#define DRAWSCENE_H_
#include "camera.h"
#include "hud.h"
#include "irrlichttypes_extrabloated.h"
void draw_load_screen(const std::wstring &text, IrrlichtDevice* device,
gui::IGUIEnvironment* guienv, gui::IGUIFont* font, float dtime=0,
int percent=0, bool clouds=true);
void draw_scene(video::IVideoDriver* driver, scene::ISceneManager* smgr,
Camera& camera, Client& client, LocalPlayer* player, Hud& hud,
gui::IGUIEnvironment* guienv, std::vector<aabb3f> hilightboxes,
const v2u32& screensize, video::SColor skycolor, bool show_hud);
#endif /* DRAWSCENE_H_ */

266
src/game.cpp
View File

@ -68,6 +68,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include <list>
#include "util/directiontables.h"
#include "util/pointedthing.h"
#include "drawscene.h"
#include "content_cao.h"
/*
Text input system
@ -418,59 +420,6 @@ PointedThing getPointedThing(Client *client, v3f player_position,
return result;
}
/*
Draws a screen with a single text on it.
Text will be removed when the screen is drawn the next time.
Additionally, a progressbar can be drawn when percent is set between 0 and 100.
*/
/*gui::IGUIStaticText **/
void draw_load_screen(const std::wstring &text, IrrlichtDevice* device,
gui::IGUIFont* font, float dtime=0 ,int percent=0, bool clouds=true)
{
video::IVideoDriver* driver = device->getVideoDriver();
v2u32 screensize = driver->getScreenSize();
const wchar_t *loadingtext = text.c_str();
core::vector2d<u32> textsize_u = font->getDimension(loadingtext);
core::vector2d<s32> textsize(textsize_u.X,textsize_u.Y);
core::vector2d<s32> center(screensize.X/2, screensize.Y/2);
core::rect<s32> textrect(center - textsize/2, center + textsize/2);
gui::IGUIStaticText *guitext = guienv->addStaticText(
loadingtext, textrect, false, false);
guitext->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
bool cloud_menu_background = clouds && g_settings->getBool("menu_clouds");
if (cloud_menu_background)
{
g_menuclouds->step(dtime*3);
g_menuclouds->render();
driver->beginScene(true, true, video::SColor(255,140,186,250));
g_menucloudsmgr->drawAll();
}
else
driver->beginScene(true, true, video::SColor(255,0,0,0));
if (percent >= 0 && percent <= 100) // draw progress bar
{
core::vector2d<s32> barsize(256,32);
core::rect<s32> barrect(center-barsize/2, center+barsize/2);
driver->draw2DRectangle(video::SColor(255,255,255,255),barrect, NULL); // border
driver->draw2DRectangle(video::SColor(255,64,64,64), core::rect<s32> (
barrect.UpperLeftCorner+1,
barrect.LowerRightCorner-1), NULL); // black inside the bar
driver->draw2DRectangle(video::SColor(255,128,128,128), core::rect<s32> (
barrect.UpperLeftCorner+1,
core::vector2d<s32>(
barrect.LowerRightCorner.X-(barsize.X-1)+percent*(barsize.X-2)/100,
barrect.LowerRightCorner.Y-1)), NULL); // the actual progress
}
guienv->drawAll();
driver->endScene();
guitext->remove();
//return guitext;
}
/* Profiler display */
void update_profiler_gui(gui::IGUIStaticText *guitext_profiler,
@ -1113,7 +1062,7 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
{
wchar_t* text = wgettext("Loading...");
draw_load_screen(text, device, font,0,0);
draw_load_screen(text, device, guienv, font, 0, 0);
delete[] text;
}
@ -1173,7 +1122,7 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
if(address == ""){
wchar_t* text = wgettext("Creating server....");
draw_load_screen(text, device, font,0,25);
draw_load_screen(text, device, guienv, font, 0, 25);
delete[] text;
infostream<<"Creating server"<<std::endl;
@ -1216,7 +1165,7 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
{
wchar_t* text = wgettext("Creating client...");
draw_load_screen(text, device, font,0,50);
draw_load_screen(text, device, guienv, font, 0, 50);
delete[] text;
}
infostream<<"Creating client"<<std::endl;
@ -1225,7 +1174,7 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
{
wchar_t* text = wgettext("Resolving address...");
draw_load_screen(text, device, font,0,75);
draw_load_screen(text, device, guienv, font, 0, 75);
delete[] text;
}
Address connect_address(0,0,0,0, port);
@ -1324,7 +1273,7 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
// Display status
{
wchar_t* text = wgettext("Connecting to server...");
draw_load_screen(text, device, font, dtime, 100);
draw_load_screen(text, device, guienv, font, dtime, 100);
delete[] text;
}
@ -1428,14 +1377,14 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
{
wchar_t* text = wgettext("Item definitions...");
progress = 0;
draw_load_screen(text, device, font, dtime, progress);
draw_load_screen(text, device, guienv, font, dtime, progress);
delete[] text;
}
else if (!client.nodedefReceived())
{
wchar_t* text = wgettext("Node definitions...");
progress = 25;
draw_load_screen(text, device, font, dtime, progress);
draw_load_screen(text, device, guienv, font, dtime, progress);
delete[] text;
}
else
@ -1457,7 +1406,8 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
message << " ( " << cur << cur_unit << " )";
}
progress = 50+client.mediaReceiveProgress()*50+0.5;
draw_load_screen(narrow_to_wide(message.str().c_str()), device, font, dtime, progress);
draw_load_screen(narrow_to_wide(message.str().c_str()), device,
guienv, font, dtime, progress);
}
// On some computers framerate doesn't seem to be
@ -1513,8 +1463,6 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
f32 camera_yaw = 0; // "right/left"
f32 camera_pitch = 0; // "up/down"
int current_camera_mode = CAMERA_MODE_FIRST; // start in first-person view
/*
Clouds
*/
@ -1530,7 +1478,7 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
*/
Sky *sky = NULL;
sky = new Sky(smgr->getRootSceneNode(), smgr, -1, client.getEnv().getLocalPlayer());
sky = new Sky(smgr->getRootSceneNode(), smgr, -1);
scene::ISceneNode* skybox = NULL;
@ -1605,7 +1553,6 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
*/
u32 drawtime = 0;
u32 beginscenetime = 0;
u32 scenetime = 0;
u32 endscenetime = 0;
float recent_turn_speed = 0.0;
@ -2281,7 +2228,7 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
else{
s32 dx = input->getMousePos().X - (driver->getScreenSize().Width/2);
s32 dy = input->getMousePos().Y - (driver->getScreenSize().Height/2);
if(invert_mouse || player->camera_mode == CAMERA_MODE_THIRD_FRONT) {
if(invert_mouse || camera.getCameraMode() == CAMERA_MODE_THIRD_FRONT) {
dy = -dy;
}
//infostream<<"window active, pos difference "<<dx<<","<<dy<<std::endl;
@ -2668,19 +2615,20 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
float tool_reload_ratio = time_from_last_punch / full_punch_interval;
if(input->wasKeyDown(getKeySetting("keymap_camera_mode"))) {
camera.toggleCameraMode();
GenericCAO* playercao = player->getCAO();
if (current_camera_mode == CAMERA_MODE_FIRST)
current_camera_mode = CAMERA_MODE_THIRD;
else if (current_camera_mode == CAMERA_MODE_THIRD)
current_camera_mode = CAMERA_MODE_THIRD_FRONT;
else
current_camera_mode = CAMERA_MODE_FIRST;
assert( playercao != NULL );
if (camera.getCameraMode() > CAMERA_MODE_FIRST) {
playercao->setVisible(true);
}
else {
playercao->setVisible(false);
}
}
player->camera_mode = current_camera_mode;
tool_reload_ratio = MYMIN(tool_reload_ratio, 1.0);
camera.update(player, dtime, busytime, tool_reload_ratio,
current_camera_mode, client.getEnv());
client.getEnv());
camera.step(dtime);
v3f player_position = player->getPosition();
@ -2736,7 +2684,7 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
camera_position + camera_direction * BS * (d+1));
// prevent player pointing anything in front-view
if (current_camera_mode == CAMERA_MODE_THIRD_FRONT)
if (camera.getCameraMode() == CAMERA_MODE_THIRD_FRONT)
shootline = core::line3d<f32>(0,0,0,0,0,0);
ClientActiveObject *selected_object = NULL;
@ -3148,7 +3096,8 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
+ time_of_day * todsm;
sky->update(time_of_day_smooth, time_brightness, direct_brightness,
sunlight_seen);
sunlight_seen,camera.getCameraMode(), player->getYaw(),
player->getPitch());
video::SColor bgcolor = sky->getBgColor();
video::SColor skycolor = sky->getSkyColor();
@ -3417,141 +3366,22 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
/*
Drawing begins
*/
TimeTaker tt_draw("mainloop: draw");
{
TimeTaker timer("beginScene");
//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
driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
if (show_hud)
hud.drawSelectionBoxes(hilightboxes);
//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->setTransform(video::ETS_WORLD, core::IdentityMatrix);
if (show_hud)
hud.drawSelectionBoxes(hilightboxes);
//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);
}
{
//TimeTaker timer9("auxiliary drawings");
// 0ms
//timer9.stop();
//TimeTaker //timer10("//timer10");
video::SMaterial m;
//m.Thickness = 10;
m.Thickness = 3;
m.Lighting = false;
driver->setMaterial(m);
driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
if((!g_settings->getBool("anaglyph")) && (show_hud))
{
hud.drawSelectionBoxes(hilightboxes);
}
/*
Wielded tool
*/
if(show_hud &&
(player->hud_flags & HUD_FLAG_WIELDITEM_VISIBLE) &&
current_camera_mode < CAMERA_MODE_THIRD)
{
// Warning: This clears the Z buffer.
camera.drawWieldedTool();
}
draw_scene(driver, smgr, camera, client, player, hud, guienv,
hilightboxes, screensize, skycolor, show_hud);
/*
Post effects
*/
{
client.getEnv().getClientMap().renderPostFx();
client.getEnv().getClientMap().renderPostFx(camera.getCameraMode());
}
/*
@ -3562,26 +3392,6 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
graph.draw(10, screensize.Y - 10, driver, font);
}
/*
Draw crosshair
*/
if (show_hud)
hud.drawCrosshair();
} // timer
//timer10.stop();
//TimeTaker //timer11("//timer11");
/*
Draw hotbar
*/
if (show_hud)
{
hud.drawHotbar(client.getPlayerItem());
}
/*
Damage flash
*/
@ -3605,18 +3415,6 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
player->hurt_tilt_strength = 0;
}
/*
Draw lua hud items
*/
if (show_hud)
hud.drawLuaElements(camera.getOffset());
/*
Draw gui
*/
// 0-1ms
guienv->drawAll();
/*
End scene
*/
@ -3659,7 +3457,7 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
{
/*gui::IGUIStaticText *gui_shuttingdowntext = */
wchar_t* text = wgettext("Shutting down stuff...");
draw_load_screen(text, device, font, 0, -1, false);
draw_load_screen(text, device, guienv, font, 0, -1, false);
delete[] text;
/*driver->beginScene(true, true, video::SColor(255,0,0,0));
guienv->drawAll();
@ -3728,5 +3526,3 @@ void the_game(bool &kill, bool random_input, InputHandler *input,
<< driver-> getMaterialRendererCount ()
<< " (note: irrlicht doesn't support removing renderers)"<< std::endl;
}

4
src/hud.cpp
View File

@ -435,10 +435,6 @@ void Hud::drawHotbar(u16 playeritem) {
void Hud::drawCrosshair() {
if (!(player->hud_flags & HUD_FLAG_CROSSHAIR_VISIBLE) ||
(player->camera_mode == CAMERA_MODE_THIRD_FRONT)) {
return;
}
if (use_crosshair_image) {
video::ITexture *crosshair = tsrc->getTexture("crosshair.png");

6
src/localplayer.cpp
View File

@ -43,7 +43,6 @@ LocalPlayer::LocalPlayer(IGameDef *gamedef):
last_pitch(0),
last_yaw(0),
last_keyPressed(0),
camera_mode(0),
eye_offset_first(v3f(0,0,0)),
eye_offset_third(v3f(0,0,0)),
last_animation(NO_ANIM),
@ -54,7 +53,8 @@ LocalPlayer::LocalPlayer(IGameDef *gamedef):
m_old_node_below(32767,32767,32767),
m_old_node_below_type("air"),
m_need_to_get_new_sneak_node(true),
m_can_jump(false)
m_can_jump(false),
m_cao(NULL)
{
// Initialize hp to 0, so that no hearts will be shown if server
// doesn't support health points
@ -505,7 +505,7 @@ void LocalPlayer::applyControl(float dtime)
if(control.jump)
{
if(free_move)
{
{
if(g_settings->getBool("aux1_descends") || g_settings->getBool("always_fly_fast"))
{
if(fast_move)

14
src/localplayer.h
View File

@ -24,7 +24,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include <list>
class Environment;
class GenericCAO;
class ClientActiveObject;
enum LocalPlayerAnimations {NO_ANIM, WALK_ANIM, DIG_ANIM, WD_ANIM}; // no local animation, walking, digging, both
@ -62,7 +62,6 @@ public:
unsigned int last_keyPressed;
float camera_impact;
int camera_mode;
v3f eye_offset_first;
v3f eye_offset_third;
@ -72,6 +71,15 @@ public:
std::string hotbar_image;
std::string hotbar_selected_image;
GenericCAO* getCAO() const {
return m_cao;
}
void setCAO(GenericCAO* toset) {
assert( m_cao == NULL );
m_cao = toset;
}
private:
// This is used for determining the sneaking range
v3s16 m_sneak_node;
@ -84,6 +92,8 @@ private:
// Whether recalculation of the sneak node is needed
bool m_need_to_get_new_sneak_node;
bool m_can_jump;
GenericCAO* m_cao;
};
#endif

30
src/sky.cpp
View File

@ -13,7 +13,7 @@
#include "camera.h" // CameraModes
//! constructor
Sky::Sky(scene::ISceneNode* parent, scene::ISceneManager* mgr, s32 id, LocalPlayer* player):
Sky::Sky(scene::ISceneNode* parent, scene::ISceneManager* mgr, s32 id):
scene::ISceneNode(parent, mgr, id),
m_visible(true),
m_fallback_bg_color(255,255,255,255),
@ -22,8 +22,7 @@ Sky::Sky(scene::ISceneNode* parent, scene::ISceneManager* mgr, s32 id, LocalPlay
m_cloud_brightness(0.5),
m_bgcolor_bright_f(1,1,1,1),
m_skycolor_bright_f(1,1,1,1),
m_cloudcolor_bright_f(1,1,1,1),
m_player(player)
m_cloudcolor_bright_f(1,1,1,1)
{
setAutomaticCulling(scene::EAC_OFF);
Box.MaxEdge.set(0,0,0);
@ -66,14 +65,14 @@ Sky::Sky(scene::ISceneNode* parent, scene::ISceneManager* mgr, s32 id, LocalPlay
m_materials[3].setTexture(0, m_sun_texture);
m_materials[3].MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
if (m_sun_tonemap)
m_materials[3].Lighting = true;
m_materials[3].Lighting = true;
}
if (m_moon_texture){
m_materials[4] = mat;
m_materials[4].setTexture(0, m_moon_texture);
m_materials[4].MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
if (m_moon_tonemap)
m_materials[4].Lighting = true;
m_materials[4].Lighting = true;
}
for(u32 i=0; i<SKY_STAR_COUNT; i++){
@ -161,20 +160,20 @@ void Sky::render()
video::SColor mooncolor2 = mooncolor2_f.toSColor();
// Calculate offset normalized to the X dimension of a 512x1 px tonemap
float offset=(1.0-fabs(sin((m_time_of_day - 0.5)*irr::core::PI)))*511;
float offset=(1.0-fabs(sin((m_time_of_day - 0.5)*irr::core::PI)))*511;
if (m_sun_tonemap){
u8 * texels = (u8 *)m_sun_tonemap->lock();
video::SColor* texel = (video::SColor *)(texels + (u32)offset * 4);
video::SColor texel_color (255,texel->getRed(),texel->getGreen(), texel->getBlue());
m_sun_tonemap->unlock();
m_sun_tonemap->unlock();
m_materials[3].EmissiveColor = texel_color;
}
if (m_moon_tonemap){
u8 * texels = (u8 *)m_moon_tonemap->lock();
video::SColor* texel = (video::SColor *)(texels + (u32)offset * 4);
video::SColor texel_color (255,texel->getRed(),texel->getGreen(), texel->getBlue());
m_moon_tonemap->unlock();
m_moon_tonemap->unlock();
m_materials[4].EmissiveColor = texel_color;
}
@ -263,7 +262,7 @@ void Sky::render()
}
// Draw sun
if(wicked_time_of_day > 0.15 && wicked_time_of_day < 0.85){
if(wicked_time_of_day > 0.15 && wicked_time_of_day < 0.85){
if (!m_sun_texture){
driver->setMaterial(m_materials[1]);
float d = sunsize * 1.7;
@ -411,7 +410,7 @@ void Sky::render()
vertices[i].Pos.rotateXZBy(-90);
vertices[i].Pos.rotateXYBy(wicked_time_of_day * 360 - 90);
}
driver->drawIndexedTriangleFan(&vertices[0], 4, indices, 2);
driver->drawIndexedTriangleFan(&vertices[0], 4, indices, 2);
}
}
@ -485,7 +484,8 @@ void Sky::render()
}
void Sky::update(float time_of_day, float time_brightness,
float direct_brightness, bool sunlight_seen)
float direct_brightness, bool sunlight_seen,
CameraMode cam_mode, float yaw, float pitch)
{
// Stabilize initial brightness and color values by flooding updates
if(m_first_update){
@ -496,7 +496,7 @@ void Sky::update(float time_of_day, float time_brightness,
m_first_update = false;
for(u32 i=0; i<100; i++){
update(time_of_day, time_brightness, direct_brightness,
sunlight_seen);
sunlight_seen, cam_mode, yaw, pitch);
}
return;
}
@ -580,16 +580,16 @@ void Sky::update(float time_of_day, float time_brightness,
{
// calculate hemisphere value from yaw, (inverted in third person front view)
s8 dir_factor = 1;
if (m_player->camera_mode > CAMERA_MODE_THIRD)
if (cam_mode > CAMERA_MODE_THIRD)
dir_factor = -1;
f32 pointcolor_blend = wrapDegrees_0_360(m_player->getYaw()*dir_factor + 90);
f32 pointcolor_blend = wrapDegrees_0_360( yaw*dir_factor + 90);
if (pointcolor_blend > 180)
pointcolor_blend = 360 - pointcolor_blend;
pointcolor_blend /= 180;
// bound view angle to determine where transition starts and ends
pointcolor_blend = rangelim(1 - pointcolor_blend * 1.375, 0, 1 / 1.375) * 1.375;
// combine the colors when looking up or down, otherwise turning looks weird
pointcolor_blend += (0.5 - pointcolor_blend) * (1 - MYMIN((90 - std::abs(m_player->getPitch())) / 90 * 1.5, 1));
pointcolor_blend += (0.5 - pointcolor_blend) * (1 - MYMIN((90 - std::abs(pitch)) / 90 * 1.5, 1));
// invert direction to match where the sun and moon are rising
if (m_time_of_day > 0.5)
pointcolor_blend = 1 - pointcolor_blend;

8
src/sky.h
View File

@ -19,7 +19,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "irrlichttypes_extrabloated.h"
#include <ISceneNode.h>
#include "localplayer.h"
#include "camera.h"
#ifndef SKY_HEADER
#define SKY_HEADER
@ -32,7 +32,7 @@ class Sky : public scene::ISceneNode
{
public:
//! constructor
Sky(scene::ISceneNode* parent, scene::ISceneManager* mgr, s32 id, LocalPlayer* player);
Sky(scene::ISceneNode* parent, scene::ISceneManager* mgr, s32 id);
virtual void OnRegisterSceneNode();
@ -50,7 +50,8 @@ public:
{ return SKY_MATERIAL_COUNT; }
void update(float m_time_of_day, float time_brightness,
float direct_brightness, bool sunlight_seen);
float direct_brightness, bool sunlight_seen, CameraMode cam_mode,
float yaw, float pitch);
float getBrightness(){ return m_brightness; }
@ -126,7 +127,6 @@ private:
video::SColorf m_cloudcolor_f;
v3f m_stars[SKY_STAR_COUNT];
video::S3DVertex m_star_vertices[SKY_STAR_COUNT*4];
LocalPlayer* m_player;
video::ITexture* m_sun_texture;
video::ITexture* m_moon_texture;
video::ITexture* m_sun_tonemap;