X-Git-Url: http://git.localhorst.tv/?a=blobdiff_plain;f=src%2Fworld%2Fblock.cpp;h=61e2ab4e9801fc920b4885353a7bc03858620808;hb=e4a1425dccd0ba9b106e415dd02809f4308a85ee;hp=954a112579089d71b2e8478ad60f7393f4b47c31;hpb=ba55bf4293f3abc742eef710545a4b207ba2c820;p=blank.git diff --git a/src/world/block.cpp b/src/world/block.cpp index 954a112..61e2ab4 100644 --- a/src/world/block.cpp +++ b/src/world/block.cpp @@ -1,11 +1,15 @@ #include "Block.hpp" +#include "BlockGravity.hpp" #include "BlockType.hpp" #include "BlockTypeRegistry.hpp" -#include "../model/geometry.hpp" +#include "../io/TokenStreamReader.hpp" +#include "../model/ShapeRegistry.hpp" +#include "../shared/ResourceIndex.hpp" -#include +#include #include +#include #include @@ -72,7 +76,10 @@ BlockType::BlockType() noexcept , hsl_mod(0.0f, 1.0f, 1.0f) , rgb_mod(1.0f, 1.0f, 1.0f) , outline_color(-1, -1, -1) +, gravity() , label("some block") +, place_sound(-1) +, remove_sound(-1) , id(0) , luminosity(0) , visible(true) @@ -96,6 +103,98 @@ BlockType::BlockType() noexcept } +void BlockType::Read( + TokenStreamReader &in, + ResourceIndex &snd_index, + ResourceIndex &tex_index, + const ShapeRegistry &shapes +) { + std::string name; + in.Skip(Token::ANGLE_BRACKET_OPEN); + while (in.Peek().type != Token::ANGLE_BRACKET_CLOSE) { + in.ReadIdentifier(name); + in.Skip(Token::EQUALS); + if (name == "visible") { + visible = in.GetBool(); + } else if (name == "texture") { + in.ReadString(name); + textures.push_back(tex_index.GetID(name)); + } else if (name == "textures") { + in.Skip(Token::BRACKET_OPEN); + while (in.Peek().type != Token::BRACKET_CLOSE) { + in.ReadString(name); + textures.push_back(tex_index.GetID(name)); + if (in.Peek().type == Token::COMMA) { + in.Skip(Token::COMMA); + } + } + in.Skip(Token::BRACKET_CLOSE); + } else if (name == "rgb_mod") { + in.ReadVec(rgb_mod); + } else if (name == "hsl_mod") { + in.ReadVec(hsl_mod); + } else if (name == "outline") { + in.ReadVec(outline_color); + } else if (name == "gravity") { + gravity = BlockGravity::Read(in); + } else if (name == "label") { + in.ReadString(label); + } else if (name == "place_sound") { + in.ReadString(name); + place_sound = snd_index.GetID(name); + } else if (name == "remove_sound") { + in.ReadString(name); + remove_sound = snd_index.GetID(name); + } else if (name == "luminosity") { + luminosity = in.GetInt(); + } else if (name == "block_light") { + block_light = in.GetBool(); + } else if (name == "collision") { + collision = in.GetBool(); + } else if (name == "collide_block") { + collide_block = in.GetBool(); + } else if (name == "generate") { + generate = in.GetBool(); + } else if (name == "min_solidity") { + min_solidity = in.GetFloat(); + } else if (name == "mid_solidity") { + mid_solidity = in.GetFloat(); + } else if (name == "max_solidity") { + max_solidity = in.GetFloat(); + } else if (name == "min_humidity") { + min_humidity = in.GetFloat(); + } else if (name == "mid_humidity") { + mid_humidity = in.GetFloat(); + } else if (name == "max_humidity") { + max_humidity = in.GetFloat(); + } else if (name == "min_temperature") { + min_temperature = in.GetFloat(); + } else if (name == "mid_temperature") { + mid_temperature = in.GetFloat(); + } else if (name == "max_temperature") { + max_temperature = in.GetFloat(); + } else if (name == "min_richness") { + min_richness = in.GetFloat(); + } else if (name == "mid_richness") { + mid_richness = in.GetFloat(); + } else if (name == "max_richness") { + max_richness = in.GetFloat(); + } else if (name == "commonness") { + commonness = in.GetFloat(); + } else if (name == "shape") { + in.ReadIdentifier(name); + shape = &shapes.Get(name); + } else { + std::cerr << "warning: unknown block type property " << name << std::endl; + while (in.Peek().type != Token::SEMICOLON) { + in.Next(); + } + } + in.Skip(Token::SEMICOLON); + } + in.Skip(Token::ANGLE_BRACKET_CLOSE); +} + void BlockType::FillEntityMesh( EntityMesh::Buffer &buf, const glm::mat4 &transform @@ -117,10 +216,10 @@ void BlockType::FillBlockMesh( buf.rgb_mods.insert(buf.rgb_mods.end(), shape->VertexCount(), rgb_mod); } -void BlockType::FillOutlineMesh(OutlineMesh::Buffer &buf) const noexcept { +void BlockType::OutlinePrimitiveMesh(PrimitiveMesh::Buffer &buf) const noexcept { if (!shape) return; shape->Outline(buf); - buf.colors.insert(buf.colors.end(), shape->OutlineCount(), outline_color); + buf.colors.insert(buf.colors.end(), shape->OutlineCount(), glm::vec4(outline_color, 1.0f)); } @@ -130,17 +229,103 @@ BlockTypeRegistry::BlockTypeRegistry() { air.block_light = false; air.collision = false; air.collide_block = false; - Add(air); + Add(std::move(air)); } -Block::Type BlockTypeRegistry::Add(const BlockType &t) { +Block::Type BlockTypeRegistry::Add(BlockType &&t) { int id = types.size(); - types.push_back(t); + types.push_back(std::move(t)); types.back().id = id; return id; } +namespace { + +/// the "usual" type of gravity +/// direction is towards the block's center, strength is inverse +/// proportional to distance squared +/// note that the effect can get clipped at distances > 16 units +struct RadialGravity +: public BlockGravity { + + explicit RadialGravity(float strength) + : strength(strength) { } + + glm::vec3 GetGravity(const glm::vec3 &diff, const glm::mat4 &) const noexcept override { + float dist2 = length2(diff); + glm::vec3 dir = -normalize(diff); + return dir * (strength / dist2); + } + + float strength; + +}; + +/// a "force field" variant of artificial gravity +/// strength and direction is constant throughout the cuboid +/// extent shouldn't exceed 16 units as gravity is only calculated for +/// chunks surrounding and entity (and sometimes not even those if they're +/// unavailable, but they will be for players) +struct CuboidFieldGravity +: public BlockGravity { + + explicit CuboidFieldGravity(const glm::vec3 &strength, const AABB &extent) + : strength(strength), extent(extent) { } + + glm::vec3 GetGravity(const glm::vec3 &diff, const glm::mat4 &M) const noexcept override { + /// rotate AABB endpoints accordingly, ignore translation + glm::vec3 min(M * glm::vec4(extent.min, 0.0f)); + glm::vec3 max(M * glm::vec4(extent.max, 0.0f)); + if (diff.x < min.x || diff.y < min.y || diff.z < min.z || + diff.x > max.x || diff.y > max.y || diff.z > max.z) { + /// if point is outside, force is zero + return glm::vec3(0.0f); + } else { + /// otherwise it's out constant strength in block orientation + return glm::vec3(M * glm::vec4(strength, 0.0f)); + } + } + + glm::vec3 strength; + AABB extent; + +}; + + +} + +BlockGravity::~BlockGravity() { + +} + +std::unique_ptr BlockGravity::Read(TokenStreamReader &in) { + std::string type; + in.ReadIdentifier(type); + if (type == "Radial") { + float strength; + in.Skip(Token::PARENTHESIS_OPEN); + in.ReadNumber(strength); + in.Skip(Token::PARENTHESIS_CLOSE); + return std::unique_ptr(new RadialGravity(strength)); + } else if (type == "CuboidField") { + glm::vec3 strength; + AABB extent; + in.Skip(Token::PARENTHESIS_OPEN); + in.ReadVec(strength); + in.Skip(Token::COMMA); + in.ReadVec(extent.min); + in.Skip(Token::COMMA); + in.ReadVec(extent.max); + in.Skip(Token::PARENTHESIS_CLOSE); + extent.Adjust(); + return std::unique_ptr(new CuboidFieldGravity(strength, extent)); + } else { + throw std::runtime_error("unknown gravity type: " + type); + } +} + + const glm::mat4 Block::orient2transform[ORIENT_COUNT] = { { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, }, // face: up, turn: none { 0, 0, -1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, }, // face: up, turn: left