X-Git-Url: http://git.localhorst.tv/?a=blobdiff_plain;f=src%2Fworld%2Fblock.cpp;h=61e2ab4e9801fc920b4885353a7bc03858620808;hb=da21395e4900bf283ece7364c67d9bad27dca279;hp=d2453cf534a705fe5435a030500ca3e3960f64db;hpb=3542823a1af7f5063d7cc8da84efa248eb889b8a;p=blank.git diff --git a/src/world/block.cpp b/src/world/block.cpp index d2453cf..61e2ab4 100644 --- a/src/world/block.cpp +++ b/src/world/block.cpp @@ -1,19 +1,20 @@ #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 namespace blank { -const NullShape BlockType::DEFAULT_SHAPE; - - std::ostream &operator <<(std::ostream &out, const Block &block) { return out << "Block(" << block.type << ", " << block.GetFace() << ", " << block.GetTurn() << ')'; } @@ -70,12 +71,15 @@ std::ostream &operator <<(std::ostream &out, const Block::Turn &turn) { BlockType::BlockType() noexcept -: shape(&DEFAULT_SHAPE) -, texture(0) +: shape(nullptr) +, textures() , 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) @@ -95,17 +99,108 @@ BlockType::BlockType() noexcept , min_richness(-1.0f) , mid_richness(0.0f) , max_richness(1.0f) -, commonness(1.0f) -, fill({ false, false, false, false, false, false }) { +, commonness(1.0f) { + +} +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, - EntityMesh::Index idx_offset + const glm::mat4 &transform ) const noexcept { - shape->Vertices(buf, transform, texture, idx_offset); + if (!shape) return; + shape->Fill(buf, transform, textures); buf.hsl_mods.insert(buf.hsl_mods.end(), shape->VertexCount(), hsl_mod); buf.rgb_mods.insert(buf.rgb_mods.end(), shape->VertexCount(), rgb_mod); } @@ -115,14 +210,16 @@ void BlockType::FillBlockMesh( const glm::mat4 &transform, BlockMesh::Index idx_offset ) const noexcept { - shape->Vertices(buf, transform, texture, idx_offset); + if (!shape) return; + shape->Fill(buf, transform, textures, idx_offset); buf.hsl_mods.insert(buf.hsl_mods.end(), shape->VertexCount(), hsl_mod); 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)); } @@ -132,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