/*
-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 Lesser General Public License as published by
#include "util/serialize.h"
#include "util/mathconstants.h"
#include "map.h"
+#include "main.h" // g_settings
#include <IMeshManipulator.h>
#include <IAnimatedMeshSceneNode.h>
#include <IBoneSceneNode.h>
#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
-core::map<u16, ClientActiveObject::Factory> ClientActiveObject::m_types;
+std::map<u16, ClientActiveObject::Factory> ClientActiveObject::m_types;
/*
SmoothTranslator
void processMessage(const std::string &data);
+ bool getCollisionBox(aabb3f *toset) { return false; }
private:
scene::IMeshSceneNode *m_node;
v3f m_position;
// Set material
buf->getMaterial().setFlag(video::EMF_LIGHTING, false);
buf->getMaterial().setFlag(video::EMF_BACK_FACE_CULLING, false);
- buf->getMaterial().setTexture(0, tsrc->getTextureRaw("rat.png"));
+ buf->getMaterial().setTexture(0, tsrc->getTexture("rat.png"));
buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false);
buf->getMaterial().setFlag(video::EMF_FOG_ENABLE, true);
buf->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
std::string infoText()
{return m_infotext;}
+ bool getCollisionBox(aabb3f *toset) { return false; }
private:
core::aabbox3d<f32> m_selection_box;
scene::IMeshSceneNode *m_node;
buf->getMaterial().setFlag(video::EMF_LIGHTING, false);
buf->getMaterial().setFlag(video::EMF_BACK_FACE_CULLING, false);
// Initialize with a generated placeholder texture
- buf->getMaterial().setTexture(0, tsrc->getTextureRaw(""));
+ buf->getMaterial().setTexture(0, tsrc->getTexture(""));
buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false);
buf->getMaterial().setFlag(video::EMF_FOG_ENABLE, true);
buf->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
IItemDefManager *idef = m_gamedef->idef();
ItemStack item;
item.deSerialize(is, idef);
- texture = item.getDefinition(idef).inventory_texture;
+ texture = idef->getInventoryTexture(item.getDefinition(idef).name, m_gamedef);
}
catch(SerializationError &e)
{
v2s16 m_tx_basepos;
bool m_initial_tx_basepos_set;
bool m_tx_select_horiz_by_yawpitch;
- v2f m_frames;
- int m_frame_speed;
- int m_frame_blend;
- std::map<std::string, core::vector2d<v3f> > m_bone_posrot;
- ClientActiveObject* m_attachment_parent;
+ v2f m_animation_range;
+ int m_animation_speed;
+ int m_animation_blend;
+ std::map<std::string, core::vector2d<v3f> > m_bone_position; // stores position and rotation for each bone name
std::string m_attachment_bone;
- v3f m_attacmhent_position;
+ v3f m_attachment_position;
v3f m_attachment_rotation;
+ bool m_attached_to_local;
int m_anim_frame;
int m_anim_num_frames;
float m_anim_framelength;
m_tx_basepos(0,0),
m_initial_tx_basepos_set(false),
m_tx_select_horiz_by_yawpitch(false),
- m_frames(v2f(0,0)),
- m_frame_speed(15),
- m_frame_blend(0),
- // Nothing to do for m_bone_posrot
- m_attachment_parent(NULL),
+ m_animation_range(v2f(0,0)),
+ m_animation_speed(15),
+ m_animation_blend(0),
+ m_bone_position(std::map<std::string, core::vector2d<v3f> >()),
m_attachment_bone(""),
- m_attacmhent_position(v3f(0,0,0)),
+ m_attachment_position(v3f(0,0,0)),
m_attachment_rotation(v3f(0,0,0)),
+ m_attached_to_local(false),
m_anim_frame(0),
m_anim_num_frames(1),
m_anim_framelength(0.2),
ClientActiveObject::registerType(getType(), create);
}
+ bool getCollisionBox(aabb3f *toset) {
+ if (m_prop.physical) {
+ aabb3f retval;
+ //update collision box
+ toset->MinEdge = m_prop.collisionbox.MinEdge * BS;
+ toset->MaxEdge = m_prop.collisionbox.MaxEdge * BS;
+
+ toset->MinEdge += m_position;
+ toset->MaxEdge += m_position;
+
+ return true;
+ }
+
+ return false;
+ }
+
+ bool collideWithObjects() {
+ return m_prop.collideWithObjects;
+ }
+
void initialize(const std::string &data)
{
infostream<<"GenericCAO: Got init data"<<std::endl;
std::istringstream is(data, std::ios::binary);
+ int num_messages = 0;
// version
u8 version = readU8(is);
// check version
- if(version != 0){
+ if(version == 1) // In PROTOCOL_VERSION 14
+ {
+ m_name = deSerializeString(is);
+ m_is_player = readU8(is);
+ m_id = readS16(is);
+ m_position = readV3F1000(is);
+ m_yaw = readF1000(is);
+ m_hp = readS16(is);
+ num_messages = readU8(is);
+ }
+ else if(version == 0) // In PROTOCOL_VERSION 13
+ {
+ m_name = deSerializeString(is);
+ m_is_player = readU8(is);
+ m_position = readV3F1000(is);
+ m_yaw = readF1000(is);
+ m_hp = readS16(is);
+ num_messages = readU8(is);
+ }
+ else
+ {
errorstream<<"GenericCAO: Unsupported init data version"
<<std::endl;
return;
}
- m_name = deSerializeString(is);
- m_is_player = readU8(is);
- m_id = readS16(is);
- m_position = readV3F1000(is);
- m_yaw = readF1000(is);
- m_hp = readS16(is);
-
- int num_messages = readU8(is);
+
for(int i=0; i<num_messages; i++){
std::string message = deSerializeLongString(is);
processMessage(message);
if(player && player->isLocal()){
m_is_local_player = true;
}
+ m_env->addPlayerName(m_name.c_str());
}
}
~GenericCAO()
{
+ if(m_is_player){
+ m_env->removePlayerName(m_name.c_str());
+ }
}
static ClientActiveObject* create(IGameDef *gamedef, ClientEnvironment *env)
}
core::aabbox3d<f32>* getSelectionBox()
{
- if(!m_prop.is_visible || !m_is_visible || m_is_local_player)
+ if(!m_prop.is_visible || !m_is_visible || m_is_local_player || getParent() != NULL)
return NULL;
return &m_selection_box;
}
v3f getPosition()
{
+ if(getParent() != NULL){
+ if(m_meshnode)
+ return m_meshnode->getAbsolutePosition();
+ if(m_animated_meshnode)
+ return m_animated_meshnode->getAbsolutePosition();
+ if(m_spritenode)
+ return m_spritenode->getAbsolutePosition();
+ return m_position;
+ }
return pos_translator.vect_show;
}
scene::IMeshSceneNode *getMeshSceneNode()
{
- return m_meshnode;
+ if(m_meshnode)
+ return m_meshnode;
+ return NULL;
}
scene::IAnimatedMeshSceneNode *getAnimatedMeshSceneNode()
{
- return m_animated_meshnode;
+ if(m_animated_meshnode)
+ return m_animated_meshnode;
+ return NULL;
}
scene::IBillboardSceneNode *getSpriteSceneNode()
{
- return m_spritenode;
+ if(m_spritenode)
+ return m_spritenode;
+ return NULL;
}
bool isPlayer()
return m_is_local_player;
}
- void removeFromScene()
+ void setAttachments()
+ {
+ updateAttachments();
+ }
+
+ ClientActiveObject *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
+ obj = m_env->getActiveObject(cii->Y);
+ }
+ }
+ break;
+ }
+ }
+ if(obj)
+ return obj;
+ return NULL;
+ }
+
+ void 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++)
+ {
+ 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
+ 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++)
+ {
+ if(ii->X == getId()) // Is our object
+ {
+ m_env->attachment_list.erase(ii);
+ break;
+ }
+ }
+ }
+
if(m_meshnode){
m_meshnode->remove();
m_meshnode = NULL;
m_spritenode = smgr->addBillboardSceneNode(
NULL, v2f(1, 1), v3f(0,0,0), -1);
m_spritenode->setMaterialTexture(0,
- tsrc->getTextureRaw("unknown_block.png"));
+ tsrc->getTexture("unknown_node.png"));
m_spritenode->setMaterialFlag(video::EMF_LIGHTING, false);
m_spritenode->setMaterialFlag(video::EMF_BILINEAR_FILTER, false);
m_spritenode->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF);
m_prop.visual_size.X));
u8 li = m_last_light;
setMeshColor(m_meshnode->getMesh(), video::SColor(255,li,li,li));
+
+ m_meshnode->setMaterialFlag(video::EMF_LIGHTING, false);
+ m_meshnode->setMaterialFlag(video::EMF_BILINEAR_FILTER, false);
+ m_meshnode->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF);
+ m_meshnode->setMaterialFlag(video::EMF_FOG_ENABLE, true);
}
else if(m_prop.visual == "mesh"){
infostream<<"GenericCAO::addToScene(): mesh"<<std::endl;
if(mesh)
{
m_animated_meshnode = smgr->addAnimatedMeshSceneNode(mesh, NULL);
- m_animated_meshnode->setMD2Animation(scene::EMAT_STAND);
m_animated_meshnode->animateJoints(); // Needed for some animations
m_animated_meshnode->setScale(v3f(m_prop.visual_size.X,
m_prop.visual_size.Y,
m_prop.visual_size.X));
u8 li = m_last_light;
setMeshColor(m_animated_meshnode->getMesh(), video::SColor(255,li,li,li));
+
+ m_animated_meshnode->setMaterialFlag(video::EMF_LIGHTING, false);
+ m_animated_meshnode->setMaterialFlag(video::EMF_BILINEAR_FILTER, false);
+ m_animated_meshnode->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF);
+ m_animated_meshnode->setMaterialFlag(video::EMF_FOG_ENABLE, true);
}
else
errorstream<<"GenericCAO::addToScene(): Could not load mesh "<<m_prop.mesh<<std::endl;
infostream<<"textures[0]: "<<m_prop.textures[0]<<std::endl;
IItemDefManager *idef = m_gamedef->idef();
ItemStack item(m_prop.textures[0], 1, 0, "", idef);
- scene::IMesh *item_mesh = item.getDefinition(idef).wield_mesh;
+ scene::IMesh *item_mesh = idef->getWieldMesh(item.getDefinition(idef).name, m_gamedef);
// Copy mesh to be able to set unique vertex colors
scene::IMeshManipulator *manip =
wname.c_str(), video::SColor(255,255,255,255), node);
m_textnode->setPosition(v3f(0, BS*1.1, 0));
}
-
+
updateNodePos();
+ updateAnimation();
+ updateBonePosition();
+ updateAttachments();
}
void expireVisuals()
void updateLight(u8 light_at_pos)
{
- // Objects attached to the local player should always be hidden
- if(m_attachment_parent != NULL && m_attachment_parent->isLocalPlayer())
- m_is_visible = false;
- else
- m_is_visible = (m_hp != 0);
u8 li = decode_light(light_at_pos);
-
if(li != m_last_light){
m_last_light = li;
video::SColor color(255,li,li,li);
- if(m_meshnode){
+ if(m_meshnode)
setMeshColor(m_meshnode->getMesh(), color);
- m_meshnode->setVisible(m_is_visible);
- }
- if(m_animated_meshnode){
+ if(m_animated_meshnode)
setMeshColor(m_animated_meshnode->getMesh(), color);
- m_animated_meshnode->setVisible(m_is_visible);
- }
- if(m_spritenode){
+ if(m_spritenode)
m_spritenode->setColor(color);
- m_spritenode->setVisible(m_is_visible);
- }
}
}
void updateNodePos()
{
- if(m_attachment_parent != NULL)
+ if(getParent() != NULL)
return;
if(m_meshnode){
void step(float dtime, ClientEnvironment *env)
{
- v3f lastpos = pos_translator.vect_show;
-
if(m_visuals_expired && m_smgr && m_irr){
m_visuals_expired = false;
- removeFromScene();
+
+ // 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
+ if(obj)
+ {
+ 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)
+ m_child_animated_meshnode->setParent(m_smgr->getRootSceneNode());
+ if(m_child_spritenode)
+ m_child_spritenode->setParent(m_smgr->getRootSceneNode());
+ }
+ }
+ }
+
+ removeFromScene(false);
addToScene(m_smgr, m_gamedef->tsrc(), m_irr);
- updateAnimations();
- updateBonePosRot();
- updateAttachments();
+
+ // 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++)
+ {
+ if(ii->Y == getId()) // This is a child of our parent
+ {
+ ClientActiveObject *obj = m_env->getActiveObject(ii->X); // Get the object of the child
+ if(obj)
+ obj->setAttachments();
+ }
+ }
}
- if(m_attachment_parent == NULL) // Attachments should be glued to their parent by Irrlicht
+ // Make sure m_is_visible is always applied
+ if(m_meshnode)
+ m_meshnode->setVisible(m_is_visible);
+ if(m_animated_meshnode)
+ m_animated_meshnode->setVisible(m_is_visible);
+ if(m_spritenode)
+ m_spritenode->setVisible(m_is_visible);
+ if(m_textnode)
+ m_textnode->setVisible(m_is_visible);
+
+ if(getParent() != NULL) // Attachments should be glued to their parent by Irrlicht
{
+ // Set these for later
+ m_position = getPosition();
+ m_velocity = v3f(0,0,0);
+ m_acceleration = v3f(0,0,0);
+ pos_translator.vect_show = m_position;
+
+ if(m_is_local_player) // Update local player attachment position
+ {
+ LocalPlayer *player = m_env->getLocalPlayer();
+ player->overridePosition = getParent()->getPosition();
+ m_env->getLocalPlayer()->parent = getParent();
+ }
+ }
+ else
+ {
+ v3f lastpos = pos_translator.vect_show;
+
if(m_prop.physical){
core::aabbox3d<f32> box = m_prop.collisionbox;
box.MinEdge *= BS;
box.MaxEdge *= BS;
collisionMoveResult moveresult;
f32 pos_max_d = BS*0.125; // Distance per iteration
- f32 stepheight = 0;
v3f p_pos = m_position;
v3f p_velocity = m_velocity;
v3f p_acceleration = m_acceleration;
- IGameDef *gamedef = env->getGameDef();
- moveresult = collisionMoveSimple(&env->getMap(), gamedef,
- pos_max_d, box, stepheight, dtime,
- p_pos, p_velocity, p_acceleration);
+ moveresult = collisionMoveSimple(env,env->getGameDef(),
+ pos_max_d, box, m_prop.stepheight, dtime,
+ p_pos, p_velocity, p_acceleration,
+ this, m_prop.collideWithObjects);
// Apply results
m_position = p_pos;
m_velocity = p_velocity;
updateTextures("");
}
}
- if(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(m_animated_meshnode)
- errorstream<<"Attachment position: "<<m_animated_meshnode->getPosition().X<<","<<m_animated_meshnode->getPosition().Y<<","<<m_animated_meshnode->getPosition().Z<<std::endl;
+ 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;
+ updateNodePos();
+ }
}
void updateTexturePos()
{
ITextureSource *tsrc = m_gamedef->tsrc();
+ bool use_trilinear_filter = g_settings->getBool("trilinear_filter");
+ bool use_bilinear_filter = g_settings->getBool("bilinear_filter");
+ bool use_anisotropic_filter = g_settings->getBool("anisotropic_filter");
+
if(m_spritenode)
{
if(m_prop.visual == "sprite")
{
- std::string texturestring = "unknown_block.png";
+ std::string texturestring = "unknown_node.png";
if(m_prop.textures.size() >= 1)
texturestring = m_prop.textures[0];
texturestring += mod;
m_spritenode->setMaterialTexture(0,
- tsrc->getTextureRaw(texturestring));
+ tsrc->getTexture(texturestring));
- // Does not work yet with the current lighting settings
- m_meshnode->getMaterial(0).AmbientColor = m_prop.colors[0];
- m_meshnode->getMaterial(0).DiffuseColor = m_prop.colors[0];
+ // This allows setting per-material colors. However, until a real lighting
+ // system is added, the code below will have no effect. Once MineTest
+ // has directional lighting, it should work automatically.
+ if(m_prop.colors.size() >= 1)
+ {
+ m_spritenode->getMaterial(0).AmbientColor = m_prop.colors[0];
+ m_spritenode->getMaterial(0).DiffuseColor = m_prop.colors[0];
+ m_spritenode->getMaterial(0).SpecularColor = m_prop.colors[0];
+ }
+
+ m_spritenode->getMaterial(0).setFlag(video::EMF_TRILINEAR_FILTER, use_trilinear_filter);
+ m_spritenode->getMaterial(0).setFlag(video::EMF_BILINEAR_FILTER, use_bilinear_filter);
+ m_spritenode->getMaterial(0).setFlag(video::EMF_ANISOTROPIC_FILTER, use_anisotropic_filter);
}
}
if(m_animated_meshnode)
{
if(m_prop.visual == "mesh")
{
- for (u32 i = 0; i < m_prop.textures.size(); ++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 == "")
continue; // Empty texture string means don't modify that material
texturestring += mod;
- video::ITexture* texture = tsrc->getTextureRaw(texturestring);
+ video::ITexture* texture = tsrc->getTexture(texturestring);
if(!texture)
{
errorstream<<"GenericCAO::updateTextures(): Could not load texture "<<texturestring<<std::endl;
}
// Set material flags and texture
- m_animated_meshnode->setMaterialTexture(i, texture);
video::SMaterial& material = m_animated_meshnode->getMaterial(i);
+ material.TextureLayer[0].Texture = texture;
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);
}
- for (u32 i = 0; i < m_prop.colors.size(); ++i)
+ for (u32 i = 0; i < m_prop.colors.size() && i < m_animated_meshnode->getMaterialCount(); ++i)
{
- // Does not work yet with the current lighting settings
+ // This allows setting per-material colors. However, until a real lighting
+ // system is added, the code below will have no effect. Once MineTest
+ // has directional lighting, it should work automatically.
m_animated_meshnode->getMaterial(i).AmbientColor = m_prop.colors[i];
m_animated_meshnode->getMaterial(i).DiffuseColor = m_prop.colors[i];
+ m_animated_meshnode->getMaterial(i).SpecularColor = m_prop.colors[i];
}
}
}
{
for (u32 i = 0; i < 6; ++i)
{
- std::string texturestring = "unknown_block.png";
+ std::string texturestring = "unknown_node.png";
if(m_prop.textures.size() > i)
texturestring = m_prop.textures[i];
texturestring += mod;
- AtlasPointer ap = tsrc->getTexture(texturestring);
- // Get the tile texture and atlas transformation
- video::ITexture* atlas = ap.atlas;
- v2f pos = ap.pos;
- v2f size = ap.size;
// Set material flags and texture
video::SMaterial& material = m_meshnode->getMaterial(i);
material.setFlag(video::EMF_LIGHTING, false);
material.setFlag(video::EMF_BILINEAR_FILTER, false);
- material.setTexture(0, atlas);
- material.getTextureMatrix(0).setTextureTranslate(pos.X, pos.Y);
- material.getTextureMatrix(0).setTextureScale(size.X, size.Y);
+ material.setTexture(0,
+ tsrc->getTexture(texturestring));
+ material.getTextureMatrix(0).makeIdentity();
+
+ // This allows setting per-material colors. However, until a real lighting
+ // system is added, the code below will have no effect. Once MineTest
+ // has directional lighting, it should work automatically.
+ if(m_prop.colors.size() > i)
+ {
+ m_meshnode->getMaterial(i).AmbientColor = m_prop.colors[i];
+ m_meshnode->getMaterial(i).DiffuseColor = m_prop.colors[i];
+ m_meshnode->getMaterial(i).SpecularColor = m_prop.colors[i];
+ }
- // Does not work yet with the current lighting settings
- m_meshnode->getMaterial(i).AmbientColor = m_prop.colors[i];
- m_meshnode->getMaterial(i).DiffuseColor = m_prop.colors[i];
+ m_meshnode->getMaterial(i).setFlag(video::EMF_TRILINEAR_FILTER, use_trilinear_filter);
+ m_meshnode->getMaterial(i).setFlag(video::EMF_BILINEAR_FILTER, use_bilinear_filter);
+ m_meshnode->getMaterial(i).setFlag(video::EMF_ANISOTROPIC_FILTER, use_anisotropic_filter);
}
}
else if(m_prop.visual == "upright_sprite")
tname += mod;
scene::IMeshBuffer *buf = mesh->getMeshBuffer(0);
buf->getMaterial().setTexture(0,
- tsrc->getTextureRaw(tname));
+ tsrc->getTexture(tname));
- // Does not work yet with the current lighting settings
- m_meshnode->getMaterial(0).AmbientColor = m_prop.colors[0];
- m_meshnode->getMaterial(0).DiffuseColor = m_prop.colors[0];
+ // This allows setting per-material colors. However, until a real lighting
+ // system is added, the code below will have no effect. Once MineTest
+ // has directional lighting, it should work automatically.
+ if(m_prop.colors.size() >= 1)
+ {
+ buf->getMaterial().AmbientColor = m_prop.colors[0];
+ buf->getMaterial().DiffuseColor = m_prop.colors[0];
+ buf->getMaterial().SpecularColor = m_prop.colors[0];
+ }
+
+ buf->getMaterial().setFlag(video::EMF_TRILINEAR_FILTER, use_trilinear_filter);
+ buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, use_bilinear_filter);
+ buf->getMaterial().setFlag(video::EMF_ANISOTROPIC_FILTER, use_anisotropic_filter);
}
{
std::string tname = "unknown_object.png";
tname += mod;
scene::IMeshBuffer *buf = mesh->getMeshBuffer(1);
buf->getMaterial().setTexture(0,
- tsrc->getTextureRaw(tname));
+ tsrc->getTexture(tname));
+
+ // This allows setting per-material colors. However, until a real lighting
+ // system is added, the code below will have no effect. Once MineTest
+ // has directional lighting, it should work automatically.
+ if(m_prop.colors.size() >= 2)
+ {
+ buf->getMaterial().AmbientColor = m_prop.colors[1];
+ buf->getMaterial().DiffuseColor = m_prop.colors[1];
+ buf->getMaterial().SpecularColor = m_prop.colors[1];
+ }
+ else if(m_prop.colors.size() >= 1)
+ {
+ buf->getMaterial().AmbientColor = m_prop.colors[0];
+ buf->getMaterial().DiffuseColor = m_prop.colors[0];
+ buf->getMaterial().SpecularColor = m_prop.colors[0];
+ }
- // Does not work yet with the current lighting settings
- m_meshnode->getMaterial(1).AmbientColor = m_prop.colors[1];
- m_meshnode->getMaterial(1).DiffuseColor = m_prop.colors[1];
+ buf->getMaterial().setFlag(video::EMF_TRILINEAR_FILTER, use_trilinear_filter);
+ buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, use_bilinear_filter);
+ buf->getMaterial().setFlag(video::EMF_ANISOTROPIC_FILTER, use_anisotropic_filter);
}
}
}
}
- void updateAnimations()
+ void updateAnimation()
{
- if(!m_animated_meshnode)
+ if(m_animated_meshnode == NULL)
return;
- m_animated_meshnode->setFrameLoop((int)m_frames.X, (int)m_frames.Y);
- m_animated_meshnode->setAnimationSpeed(m_frame_speed);
- m_animated_meshnode->setTransitionTime(m_frame_blend);
+ m_animated_meshnode->setFrameLoop((int)m_animation_range.X, (int)m_animation_range.Y);
+ m_animated_meshnode->setAnimationSpeed(m_animation_speed);
+ m_animated_meshnode->setTransitionTime(m_animation_blend);
}
- void updateBonePosRot()
+ void updateBonePosition()
{
- if(m_bone_posrot.size() > 0)
- {
- 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_posrot.begin(); ii != m_bone_posrot.end(); ++ii){
- std::string bone_name = (*ii).first;
- v3f bone_pos = (*ii).second.X;
- v3f bone_rot = (*ii).second.Y;
- irr::scene::IBoneSceneNode* bone = m_animated_meshnode->getJointNode(bone_name.c_str());
+ if(!m_bone_position.size() || m_animated_meshnode == NULL)
+ 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){
+ std::string bone_name = (*ii).first;
+ v3f bone_pos = (*ii).second.X;
+ v3f bone_rot = (*ii).second.Y;
+ irr::scene::IBoneSceneNode* bone = m_animated_meshnode->getJointNode(bone_name.c_str());
+ if(bone)
+ {
bone->setPosition(bone_pos);
bone->setRotation(bone_rot);
}
void updateAttachments()
{
- // REMAINING ATTACHMENT ISSUES:
- // We get to this function when the object is an attachment that needs to
- // be attached to its parent. If a bone is set we attach it to that skeletal
- // bone, otherwise just to the object's origin. Attachments should not copy parent
- // position as that's laggy... instead the Irrlicht function(s) to attach should
- // be used. If the parent object is NULL that means this object should be detached.
- // This function is only called whenever a GENERIC_CMD_SET_ATTACHMENT message is received.
-
- // We already attach our entity on the server too (copy position). Reason we attach
- // to the client as well is first of all lag. The server sends the position
- // of the child separately than that of the parent, so even on localhost
- // you'd see the child lagging behind. Models are also client-side, so this is
- // needed to read bone data and attach to joints.
-
- // Functions:
- // - m_attachment_parent is ClientActiveObject* for the parent entity.
- // - m_attachment_bone is std::string of the bone, "" means none.
- // - m_attachment_position is v3f and represents the position offset of the attachment.
- // - m_attachment_rotation is v3f and represents the rotation offset of the attachment.
-
- // Implementation information:
- // From what I know, we need to get the AnimatedMeshSceneNode of m_attachment_parent then
- // use parent_node->addChild(m_animated_meshnode) for position attachment. For skeletal
- // attachment I don't know yet. Same must be used to detach when a NULL parent is received.
-
- //Useful links:
- // http://irrlicht.sourceforge.net/forum/viewtopic.php?t=7514
- // http://www.irrlicht3d.org/wiki/index.php?n=Main.HowToUseTheNewAnimationSystem
- // http://gamedev.stackexchange.com/questions/27363/finding-the-endpoint-of-a-named-bone-in-irrlicht
- // Irrlicht documentation: http://irrlicht.sourceforge.net/docu/
-
- if (m_attachment_parent != NULL && !m_attachment_parent->isLocalPlayer())
- {
- // REMAINING ATTACHMENT ISSUES:
- // The code below should cause the child to get attached, but for some reason it's not working
- // A debug print confirms both position and absolute position are set accordingly, but the object still shows at origin 0,0,0
+ 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
+ if(getParent() == NULL || m_attached_to_local) // Detach or don't attach
+ {
+ if(m_meshnode)
+ {
+ v3f old_position = m_meshnode->getAbsolutePosition();
+ v3f old_rotation = m_meshnode->getRotation();
+ m_meshnode->setParent(m_smgr->getRootSceneNode());
+ m_meshnode->setPosition(old_position);
+ m_meshnode->setRotation(old_rotation);
+ m_meshnode->updateAbsolutePosition();
+ }
+ if(m_animated_meshnode)
+ {
+ v3f old_position = m_animated_meshnode->getAbsolutePosition();
+ v3f old_rotation = m_animated_meshnode->getRotation();
+ m_animated_meshnode->setParent(m_smgr->getRootSceneNode());
+ m_animated_meshnode->setPosition(old_position);
+ m_animated_meshnode->setRotation(old_rotation);
+ m_animated_meshnode->updateAbsolutePosition();
+ }
+ if(m_spritenode)
+ {
+ v3f old_position = m_spritenode->getAbsolutePosition();
+ v3f old_rotation = m_spritenode->getRotation();
+ m_spritenode->setParent(m_smgr->getRootSceneNode());
+ m_spritenode->setPosition(old_position);
+ m_spritenode->setRotation(old_rotation);
+ m_spritenode->updateAbsolutePosition();
+ }
+ if(m_is_local_player)
+ {
+ LocalPlayer *player = m_env->getLocalPlayer();
+ player->isAttached = false;
+ }
+ }
+ else // Attach
+ {
scene::IMeshSceneNode *parent_mesh = NULL;
- if(m_attachment_parent->getMeshSceneNode())
- parent_mesh = m_attachment_parent->getMeshSceneNode();
+ if(getParent()->getMeshSceneNode())
+ parent_mesh = getParent()->getMeshSceneNode();
scene::IAnimatedMeshSceneNode *parent_animated_mesh = NULL;
- if(m_attachment_parent->getAnimatedMeshSceneNode())
- parent_animated_mesh = m_attachment_parent->getAnimatedMeshSceneNode();
+ if(getParent()->getAnimatedMeshSceneNode())
+ parent_animated_mesh = getParent()->getAnimatedMeshSceneNode();
scene::IBillboardSceneNode *parent_sprite = NULL;
- if(m_attachment_parent->getSpriteSceneNode())
- parent_sprite = m_attachment_parent->getSpriteSceneNode();
+ if(getParent()->getSpriteSceneNode())
+ parent_sprite = getParent()->getSpriteSceneNode();
scene::IBoneSceneNode *parent_bone = NULL;
if(parent_animated_mesh && m_attachment_bone != "")
parent_bone = parent_animated_mesh->getJointNode(m_attachment_bone.c_str());
- if(!parent_bone) // Should be false if the bone doesn't exist on the mesh
- parent_bone = NULL;
+ // 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){
- m_meshnode->setPosition(parent_bone->getPosition());
- m_meshnode->setRotation(parent_bone->getRotation());
+ m_meshnode->setParent(parent_bone);
+ m_meshnode->setPosition(m_attachment_position);
+ m_meshnode->setRotation(m_attachment_rotation);
m_meshnode->updateAbsolutePosition();
- //m_meshnode->setParent(parent_bone);
}
else
{
if(parent_mesh){
- m_meshnode->setPosition(parent_mesh->getPosition());
- m_meshnode->setRotation(parent_mesh->getRotation());
+ m_meshnode->setParent(parent_mesh);
+ m_meshnode->setPosition(m_attachment_position);
+ m_meshnode->setRotation(m_attachment_rotation);
m_meshnode->updateAbsolutePosition();
- //m_meshnode->setParent(parent_mesh);
}
else if(parent_animated_mesh){
- m_meshnode->setPosition(parent_animated_mesh->getPosition());
- m_meshnode->setRotation(parent_animated_mesh->getRotation());
+ m_meshnode->setParent(parent_animated_mesh);
+ m_meshnode->setPosition(m_attachment_position);
+ m_meshnode->setRotation(m_attachment_rotation);
m_meshnode->updateAbsolutePosition();
- //m_meshnode->setParent(parent_animated_mesh);
}
else if(parent_sprite){
- m_meshnode->setPosition(parent_sprite->getPosition());
- m_meshnode->setRotation(parent_sprite->getRotation());
+ m_meshnode->setParent(parent_sprite);
+ m_meshnode->setPosition(m_attachment_position);
+ m_meshnode->setRotation(m_attachment_rotation);
m_meshnode->updateAbsolutePosition();
- //m_meshnode->setParent(parent_sprite);
}
}
}
if(m_animated_meshnode){
if(parent_bone){
- m_animated_meshnode->setPosition(parent_bone->getPosition());
- m_animated_meshnode->setRotation(parent_bone->getRotation());
+ m_animated_meshnode->setParent(parent_bone);
+ m_animated_meshnode->setPosition(m_attachment_position);
+ m_animated_meshnode->setRotation(m_attachment_rotation);
m_animated_meshnode->updateAbsolutePosition();
- //m_animated_meshnode->setParent(parent_bone);
}
else
{
if(parent_mesh){
- m_animated_meshnode->setPosition(parent_mesh->getPosition());
- m_animated_meshnode->setRotation(parent_mesh->getRotation());
+ m_animated_meshnode->setParent(parent_mesh);
+ m_animated_meshnode->setPosition(m_attachment_position);
+ m_animated_meshnode->setRotation(m_attachment_rotation);
m_animated_meshnode->updateAbsolutePosition();
- //m_animated_meshnode->setParent(parent_mesh);
}
else if(parent_animated_mesh){
- m_animated_meshnode->setPosition(parent_animated_mesh->getPosition());
- m_animated_meshnode->setRotation(parent_animated_mesh->getRotation());
+ 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();
- //m_animated_meshnode->setParent(parent_animated_mesh);
}
else if(parent_sprite){
- m_animated_meshnode->setPosition(parent_sprite->getPosition());
- m_animated_meshnode->setRotation(parent_sprite->getRotation());
+ m_animated_meshnode->setParent(parent_sprite);
+ m_animated_meshnode->setPosition(m_attachment_position);
+ m_animated_meshnode->setRotation(m_attachment_rotation);
m_animated_meshnode->updateAbsolutePosition();
- //m_animated_meshnode->setParent(parent_sprite);
}
}
}
if(m_spritenode){
if(parent_bone){
- m_spritenode->setPosition(parent_bone->getPosition());
- m_spritenode->setRotation(parent_bone->getRotation());
+ m_spritenode->setParent(parent_bone);
+ m_spritenode->setPosition(m_attachment_position);
+ m_spritenode->setRotation(m_attachment_rotation);
m_spritenode->updateAbsolutePosition();
- //m_spritenode->setParent(parent_bone);
}
else
{
if(parent_mesh){
- m_spritenode->setPosition(parent_mesh->getPosition());
- m_spritenode->setRotation(parent_mesh->getRotation());
+ m_spritenode->setParent(parent_mesh);
+ m_spritenode->setPosition(m_attachment_position);
+ m_spritenode->setRotation(m_attachment_rotation);
m_spritenode->updateAbsolutePosition();
- //m_spritenode->setParent(parent_mesh);
}
else if(parent_animated_mesh){
- m_spritenode->setPosition(parent_animated_mesh->getPosition());
- m_spritenode->setRotation(parent_animated_mesh->getRotation());
+ m_spritenode->setParent(parent_animated_mesh);
+ m_spritenode->setPosition(m_attachment_position);
+ m_spritenode->setRotation(m_attachment_rotation);
m_spritenode->updateAbsolutePosition();
- //m_spritenode->setParent(parent_animated_mesh);
}
else if(parent_sprite){
- m_spritenode->setPosition(parent_sprite->getPosition());
- m_spritenode->setRotation(parent_sprite->getRotation());
+ m_spritenode->setParent(parent_sprite);
+ m_spritenode->setPosition(m_attachment_position);
+ m_spritenode->setRotation(m_attachment_rotation);
m_spritenode->updateAbsolutePosition();
- //m_spritenode->setParent(parent_sprite);
}
}
}
+ if(m_is_local_player)
+ {
+ LocalPlayer *player = m_env->getLocalPlayer();
+ player->isAttached = true;
+ }
}
}
}
else if(cmd == GENERIC_CMD_UPDATE_POSITION)
{
- // Not sent by the server if the object is an attachment
-
+ // Not sent by the server if this object is an attachment.
+ // We might however get here if the server notices the object being detached before the client.
m_position = readV3F1000(is);
m_velocity = readV3F1000(is);
m_acceleration = readV3F1000(is);
// the ground due to sucky collision detection...
if(m_prop.physical)
m_position += v3f(0,0.002,0);
-
+
+ if(getParent() != NULL) // Just in case
+ return;
+
if(do_interpolate){
if(!m_prop.physical)
pos_translator.update(m_position, is_end_position, update_interval);
updateTexturePos();
}
- else if(cmd == GENERIC_CMD_SET_ANIMATIONS)
+ else if(cmd == GENERIC_CMD_SET_PHYSICS_OVERRIDE)
{
- m_frames = readV2F1000(is);
- m_frame_speed = readF1000(is);
- m_frame_blend = readF1000(is);
+ float override_speed = readF1000(is);
+ float override_jump = readF1000(is);
+ float override_gravity = readF1000(is);
+ if(m_is_local_player)
+ {
+ LocalPlayer *player = m_env->getLocalPlayer();
+ player->physics_override_speed = override_speed;
+ player->physics_override_jump = override_jump;
+ player->physics_override_gravity = override_gravity;
+ }
+ }
+ else if(cmd == GENERIC_CMD_SET_ANIMATION)
+ {
+ m_animation_range = readV2F1000(is);
+ m_animation_speed = readF1000(is);
+ m_animation_blend = readF1000(is);
- updateAnimations();
- expireVisuals();
+ updateAnimation();
}
- else if(cmd == GENERIC_CMD_SET_BONE_POSROT)
+ else if(cmd == GENERIC_CMD_SET_BONE_POSITION)
{
std::string bone = deSerializeString(is);
v3f position = readV3F1000(is);
v3f rotation = readV3F1000(is);
- m_bone_posrot[bone] = core::vector2d<v3f>(position, rotation);
+ m_bone_position[bone] = core::vector2d<v3f>(position, rotation);
- updateBonePosRot();
- expireVisuals();
+ updateBonePosition();
}
else if(cmd == GENERIC_CMD_SET_ATTACHMENT)
{
- int parent_id = readS16(is);
- ClientActiveObject *obj = m_env->getActiveObject(parent_id);
- if(!parent_id || !obj)
- obj = NULL;
- m_attachment_parent = obj;
+ // 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++)
+ {
+ if(ii->X == getId()) // This is the ID of our object
+ {
+ m_env->attachment_list.erase(ii);
+ break;
+ }
+ }
+ m_env->attachment_list.push_back(core::vector2d<int>(getId(), readS16(is)));
m_attachment_bone = deSerializeString(is);
- m_attacmhent_position = readV3F1000(is);
+ m_attachment_position = readV3F1000(is);
m_attachment_rotation = readV3F1000(is);
updateAttachments();
{
/*s16 damage =*/ readS16(is);
s16 result_hp = readS16(is);
-
+
+ // Use this instead of the send damage to not interfere with prediction
+ s16 damage = m_hp - result_hp;
+
m_hp = result_hp;
+
+ if (damage > 0) {
+ if (m_hp <= 0) {
+ // TODO: Execute defined fast response
+ // As there is no definition, make a smoke puff
+ ClientSimpleObject *simple = createSmokePuff(
+ m_smgr, m_env, m_position,
+ m_prop.visual_size * BS);
+ m_env->addSimpleObject(simple);
+ } else {
+ // TODO: Execute defined fast response
+ // Flashing shall suffice as there is no definition
+ m_reset_textures_timer = 0.05;
+ if(damage >= 2)
+ m_reset_textures_timer += 0.05 * damage;
+ updateTextures("^[brighten");
+ }
+ }
}
else if(cmd == GENERIC_CMD_UPDATE_ARMOR_GROUPS)
{