X-Git-Url: http://git.localhorst.tv/?a=blobdiff_plain;f=src%2Fworld%2Fblock.cpp;h=61e2ab4e9801fc920b4885353a7bc03858620808;hb=da21395e4900bf283ece7364c67d9bad27dca279;hp=78aa9d8a30bdfe765983332247fc6bfddae92f7e;hpb=955fbb45dedb570520fc45d2ce69f420bed2ad08;p=blank.git diff --git a/src/world/block.cpp b/src/world/block.cpp index 78aa9d8..61e2ab4 100644 --- a/src/world/block.cpp +++ b/src/world/block.cpp @@ -1,23 +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; - - -bool operator ==(const Block &a, const Block &b) { - return a.type == b.type && a.orient == b.orient; -} - std::ostream &operator <<(std::ostream &out, const Block &block) { return out << "Block(" << block.type << ", " << block.GetFace() << ", " << block.GetTurn() << ')'; } @@ -73,60 +70,262 @@ std::ostream &operator <<(std::ostream &out, const Block::Turn &turn) { } -BlockType::BlockType(bool v, const glm::vec3 &col, const Shape *s) noexcept -: shape(s) -, color(col) +BlockType::BlockType() noexcept +: 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(v) -, block_light(false) -, collision(false) -, collide_block(false) -, fill({ false, false, false, false, false, false }) { +, visible(true) +, block_light(true) +, collision(true) +, collide_block(true) +, generate(false) +, min_solidity(0.5f) +, mid_solidity(0.75f) +, max_solidity(1.0f) +, min_humidity(-1.0f) +, mid_humidity(0.0f) +, max_humidity(1.0f) +, min_temperature(-1.0f) +, mid_temperature(0.0f) +, max_temperature(1.0f) +, min_richness(-1.0f) +, mid_richness(0.0f) +, max_richness(1.0f) +, commonness(1.0f) { } -void BlockType::FillModel( - Model::Buffer &buf, - const glm::mat4 &transform, - Model::Index idx_offset +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 ) const noexcept { - shape->Vertices(buf.vertices, buf.normals, buf.indices, transform, idx_offset); - buf.colors.insert(buf.colors.end(), shape->VertexCount(), color); + 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); } -void BlockType::FillBlockModel( - BlockModel::Buffer &buf, +void BlockType::FillBlockMesh( + BlockMesh::Buffer &buf, const glm::mat4 &transform, - BlockModel::Index idx_offset + BlockMesh::Index idx_offset ) const noexcept { - shape->Vertices(buf.vertices, buf.indices, transform, idx_offset); - buf.colors.insert(buf.colors.end(), shape->VertexCount(), color); + 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::FillOutlineModel( - OutlineModel &model, - const glm::vec3 &pos_offset, - OutlineModel::Index idx_offset -) const noexcept { - shape->Outline(model.vertices, model.indices, pos_offset, idx_offset); - model.colors.insert(model.colors.end(), shape->OutlineCount(), outline_color); +void BlockType::OutlinePrimitiveMesh(PrimitiveMesh::Buffer &buf) const noexcept { + if (!shape) return; + shape->Outline(buf); + buf.colors.insert(buf.colors.end(), shape->OutlineCount(), glm::vec4(outline_color, 1.0f)); } BlockTypeRegistry::BlockTypeRegistry() { - Add(BlockType()); + BlockType air; + air.visible = false; + air.block_light = false; + air.collision = false; + air.collide_block = false; + 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 @@ -154,7 +353,7 @@ const glm::mat4 Block::orient2transform[ORIENT_COUNT] = { { 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, }, // face: back, turn: right }; -const glm::tvec3 Block::face2normal[FACE_COUNT] = { +const glm::ivec3 Block::face2normal[FACE_COUNT] = { { 0, 1, 0 }, { 0, -1, 0 }, { 1, 0, 0 },