Shuffling the map stuff around to make more sense structurally. Also shrunk the scope of the demos wayyyy down to facilitate easier debugging in my next planned steps
MitchellHansen
7 years ago
parent
242aaaa485
commit
c35f867c76
@ -0,0 +1,35 @@
|
||||
#pragma once
|
||||
#include<SFML/Graphics.hpp>
|
||||
#include <algorithm>
|
||||
#include "util.hpp"
|
||||
#include <random>
|
||||
#include <functional>
|
||||
|
||||
class ArrayMap {
|
||||
|
||||
|
||||
public:
|
||||
|
||||
ArrayMap(sf::Vector3i dimensions);
|
||||
~ArrayMap();
|
||||
|
||||
char getVoxel(sf::Vector3i position);
|
||||
void setVoxel(sf::Vector3i position, char value);
|
||||
sf::Vector3i getDimensions();
|
||||
|
||||
// =========== DEBUG =========== //
|
||||
char* getDataPtr();
|
||||
|
||||
std::vector<std::tuple<sf::Vector3i, char>> ArrayMap::CastRayCharArray(
|
||||
char* map,
|
||||
sf::Vector3i* map_dim,
|
||||
sf::Vector2f* cam_dir,
|
||||
sf::Vector3f* cam_pos
|
||||
);
|
||||
|
||||
private:
|
||||
|
||||
char *voxel_data;
|
||||
sf::Vector3i dimensions;
|
||||
|
||||
};
|
||||
@ -1,42 +0,0 @@
|
||||
#pragma once
|
||||
#include <SFML/System/Vector3.hpp>
|
||||
#include <SFML/System/Vector2.hpp>
|
||||
#include <SFML/Graphics/Color.hpp>
|
||||
#include <random>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
#include <cmath>
|
||||
|
||||
#define _USE_MATH_DEFINES
|
||||
#include <math.h>
|
||||
|
||||
#include <deque>
|
||||
|
||||
class Old_Map {
|
||||
public:
|
||||
|
||||
Old_Map(sf::Vector3i dim);
|
||||
~Old_Map();
|
||||
|
||||
void generate_terrain();
|
||||
|
||||
sf::Vector3i getDimensions();
|
||||
char* get_voxel_data();
|
||||
|
||||
protected:
|
||||
|
||||
private:
|
||||
|
||||
double* height_map;
|
||||
char *voxel_data;
|
||||
sf::Vector3i dimensions;
|
||||
|
||||
void set_voxel(sf::Vector3i position, int val);
|
||||
double sample(int x, int y);
|
||||
void set_sample(int x, int y, double value);
|
||||
void sample_square(int x, int y, int size, double value);
|
||||
void sample_diamond(int x, int y, int size, double value);
|
||||
void diamond_square(int stepsize, double scale);
|
||||
|
||||
|
||||
};
|
||||
@ -0,0 +1,147 @@
|
||||
#include <map/ArrayMap.h>
|
||||
|
||||
|
||||
|
||||
ArrayMap::ArrayMap(sf::Vector3i dimensions) {
|
||||
|
||||
this->dimensions = dimensions;
|
||||
|
||||
voxel_data = new char[dimensions.x * dimensions.y * dimensions.z];
|
||||
for (int i = 0; i < dimensions.x * dimensions.y * dimensions.z; i++) {
|
||||
voxel_data[i] = 0;
|
||||
}
|
||||
|
||||
for (int x = 0; x < dimensions.x; x++) {
|
||||
for (int y = 0; y < dimensions.y; y++) {
|
||||
setVoxel(sf::Vector3i(x, y, 1), 5);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
ArrayMap::~ArrayMap() {
|
||||
delete[] voxel_data;
|
||||
}
|
||||
|
||||
char ArrayMap::getVoxel(sf::Vector3i position) {
|
||||
return voxel_data[position.x + dimensions.x * (position.y + dimensions.z * position.z)];
|
||||
}
|
||||
|
||||
|
||||
void ArrayMap::setVoxel(sf::Vector3i position, char value) {
|
||||
voxel_data[position.x + dimensions.x * (position.y + dimensions.z * position.z)] = value;
|
||||
}
|
||||
|
||||
sf::Vector3i ArrayMap::getDimensions() {
|
||||
return dimensions;
|
||||
}
|
||||
|
||||
char* ArrayMap::getDataPtr() {
|
||||
return voxel_data;
|
||||
}
|
||||
|
||||
std::vector<std::tuple<sf::Vector3i, char>> ArrayMap::CastRayCharArray(
|
||||
char* map,
|
||||
sf::Vector3i* map_dim,
|
||||
sf::Vector2f* cam_dir,
|
||||
sf::Vector3f* cam_pos
|
||||
) {
|
||||
// Setup the voxel coords from the camera origin
|
||||
sf::Vector3i voxel(*cam_pos);
|
||||
|
||||
std::vector<std::tuple<sf::Vector3i, char>> travel_path;
|
||||
|
||||
sf::Vector3f ray_dir(1, 0, 0);
|
||||
|
||||
// Pitch
|
||||
ray_dir = sf::Vector3f(
|
||||
ray_dir.z * sin((*cam_dir).x) + ray_dir.x * cos((*cam_dir).x),
|
||||
ray_dir.y,
|
||||
ray_dir.z * cos((*cam_dir).x) - ray_dir.x * sin((*cam_dir).x)
|
||||
);
|
||||
|
||||
// Yaw
|
||||
ray_dir = sf::Vector3f(
|
||||
ray_dir.x * cos((*cam_dir).y) - ray_dir.y * sin((*cam_dir).y),
|
||||
ray_dir.x * sin((*cam_dir).y) + ray_dir.y * cos((*cam_dir).y),
|
||||
ray_dir.z
|
||||
);
|
||||
|
||||
// correct for the base ray pointing to (1, 0, 0) as (0, 0). Should equal (1.57, 0)
|
||||
ray_dir = sf::Vector3f(
|
||||
static_cast<float>(ray_dir.z * sin(-1.57) + ray_dir.x * cos(-1.57)),
|
||||
static_cast<float>(ray_dir.y),
|
||||
static_cast<float>(ray_dir.z * cos(-1.57) - ray_dir.x * sin(-1.57))
|
||||
);
|
||||
|
||||
|
||||
// Setup the voxel step based on what direction the ray is pointing
|
||||
sf::Vector3i voxel_step(1, 1, 1);
|
||||
|
||||
voxel_step.x *= (ray_dir.x > 0) - (ray_dir.x < 0);
|
||||
voxel_step.y *= (ray_dir.y > 0) - (ray_dir.y < 0);
|
||||
voxel_step.z *= (ray_dir.z > 0) - (ray_dir.z < 0);
|
||||
|
||||
|
||||
// Delta T is the units a ray must travel along an axis in order to
|
||||
// traverse an integer split
|
||||
sf::Vector3f delta_t(
|
||||
fabs(1.0f / ray_dir.x),
|
||||
fabs(1.0f / ray_dir.y),
|
||||
fabs(1.0f / ray_dir.z)
|
||||
);
|
||||
|
||||
// offset is how far we are into a voxel, enables sub voxel movement
|
||||
// Intersection T is the collection of the next intersection points
|
||||
// for all 3 axis XYZ.
|
||||
sf::Vector3f intersection_t(
|
||||
delta_t.x * (cam_pos->x - floor(cam_pos->x)) * voxel_step.x,
|
||||
delta_t.y * (cam_pos->y - floor(cam_pos->y)) * voxel_step.y,
|
||||
delta_t.z * (cam_pos->z - floor(cam_pos->z)) * voxel_step.z
|
||||
);
|
||||
|
||||
// for negative values, wrap around the delta_t
|
||||
intersection_t.x -= delta_t.x * (std::min(intersection_t.x, 0.0f));
|
||||
intersection_t.y -= delta_t.y * (std::min(intersection_t.y, 0.0f));
|
||||
intersection_t.z -= delta_t.z * (std::min(intersection_t.z, 0.0f));
|
||||
|
||||
|
||||
int dist = 0;
|
||||
sf::Vector3i face_mask(0, 0, 0);
|
||||
int voxel_data = 0;
|
||||
|
||||
// Andrew Woo's raycasting algo
|
||||
do {
|
||||
|
||||
face_mask.x = intersection_t.x <= std::min(intersection_t.y, intersection_t.z);
|
||||
face_mask.y = intersection_t.y <= std::min(intersection_t.z, intersection_t.x);
|
||||
face_mask.z = intersection_t.z <= std::min(intersection_t.x, intersection_t.y);
|
||||
|
||||
intersection_t.x += delta_t.x * fabs(face_mask.x);
|
||||
intersection_t.y += delta_t.y * fabs(face_mask.y);
|
||||
intersection_t.z += delta_t.z * fabs(face_mask.z);
|
||||
|
||||
voxel.x += voxel_step.x * face_mask.x;
|
||||
voxel.y += voxel_step.y * face_mask.y;
|
||||
voxel.z += voxel_step.z * face_mask.z;
|
||||
|
||||
if (voxel.x >= map_dim->x || voxel.y >= map_dim->y || voxel.z >= map_dim->z) {
|
||||
return travel_path;
|
||||
}
|
||||
if (voxel.x < 0 || voxel.y < 0 || voxel.z < 0) {
|
||||
return travel_path;
|
||||
}
|
||||
|
||||
// If we hit a voxel
|
||||
voxel_data = map[voxel.x + (*map_dim).x * (voxel.y + (*map_dim).z * (voxel.z))];
|
||||
|
||||
travel_path.push_back(std::make_tuple(voxel, voxel_data));
|
||||
|
||||
if (voxel_data != 0)
|
||||
return travel_path;
|
||||
|
||||
|
||||
} while (++dist < 700.0f);
|
||||
|
||||
return travel_path;
|
||||
}
|
||||
@ -1,397 +0,0 @@
|
||||
#include <iostream>
|
||||
#include <SFML/System/Vector3.hpp>
|
||||
#include <SFML/System/Vector2.hpp>
|
||||
#include "util.hpp"
|
||||
#include <map/Old_Map.h>
|
||||
#include <algorithm>
|
||||
|
||||
Old_Map::Old_Map(sf::Vector3i dim) {
|
||||
dimensions = dim;
|
||||
}
|
||||
|
||||
|
||||
Old_Map::~Old_Map() {
|
||||
}
|
||||
|
||||
void generate_at(int x, int y, std::vector<std::vector<int>> *grid) {
|
||||
|
||||
size_t x_bound = grid->size();
|
||||
size_t y_bound = grid->at(0).size();
|
||||
|
||||
// N S E W
|
||||
std::vector<int> t = { 1, 2, 3, 4 };
|
||||
std::random_shuffle(t.begin(), t.end());
|
||||
|
||||
while (t.size() > 0) {
|
||||
|
||||
switch (t.back()) {
|
||||
|
||||
// 20 lines to hard code, a headache to do it cleverly
|
||||
case 1: {
|
||||
if (y + 1 < y_bound && grid->at(x).at(y + 1) == 0) {
|
||||
grid->at(x).at(y) = 1;
|
||||
grid->at(x).at(y + 1) = 2;
|
||||
generate_at(x, y + 1, grid);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 2: {
|
||||
if (y - 1 >= 0 && grid->at(x).at(y - 1) == 0) {
|
||||
grid->at(x).at(y) = 2;
|
||||
grid->at(x).at(y - 1) = 1;
|
||||
generate_at(x, y - 1, grid);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 3: {
|
||||
if (x + 1 < x_bound && grid->at(x+1).at(y) == 0) {
|
||||
grid->at(x).at(y) = 3;
|
||||
grid->at(x + 1).at(y) = 4;
|
||||
generate_at(x + 1, y, grid);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 4: {
|
||||
if (x - 1 >= 0 && grid->at(x-1).at(y) == 0) {
|
||||
grid->at(x).at(y) = 4;
|
||||
grid->at(x - 1).at(y) = 3;
|
||||
generate_at(x - 1, y, grid);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
t.pop_back();
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<std::vector<int>> generate_maze(sf::Vector2i dimensions, sf::Vector2i start_point) {
|
||||
|
||||
std::vector<std::vector<int>> grid(dimensions.x, std::vector<int>(dimensions.y, 0));
|
||||
|
||||
generate_at(start_point.x, start_point.y, &grid);
|
||||
|
||||
return grid;
|
||||
}
|
||||
|
||||
|
||||
void Old_Map::generate_terrain() {
|
||||
std::mt19937 gen;
|
||||
std::uniform_real_distribution<double> dis(-1.0, 1.0);
|
||||
auto f_rand = std::bind(dis, std::ref(gen));
|
||||
|
||||
voxel_data = new char[dimensions.x * dimensions.y * dimensions.z];
|
||||
height_map = new double[dimensions.x * dimensions.y];
|
||||
|
||||
for (int i = 0; i < dimensions.x * dimensions.y * dimensions.z; i++) {
|
||||
voxel_data[i] = 0;
|
||||
}
|
||||
|
||||
//set_voxel(sf::Vector3i(63, 63, 63), 1);
|
||||
|
||||
|
||||
for (int i = 0; i < dimensions.x * dimensions.y; i++) {
|
||||
height_map[i] = 0;
|
||||
}
|
||||
|
||||
//size of grid to generate, note this must be a
|
||||
//value 2^n+1
|
||||
int DATA_SIZE = dimensions.x + 1;
|
||||
//an initial seed value for the corners of the data
|
||||
//srand(f_rand());
|
||||
double SEED = rand() % 10 + 55;
|
||||
|
||||
//seed the data
|
||||
set_sample(0, 0, SEED);
|
||||
set_sample(0, dimensions.y, SEED);
|
||||
set_sample(dimensions.x, 0, SEED);
|
||||
set_sample(dimensions.x, dimensions.y, SEED);
|
||||
|
||||
double h = 20.0;//the range (-h -> +h) for the average offset
|
||||
//for the new value in range of h
|
||||
//side length is distance of a single square side
|
||||
//or distance of diagonal in diamond
|
||||
for (int sideLength = DATA_SIZE - 1;
|
||||
//side length must be >= 2 so we always have
|
||||
//a new value (if its 1 we overwrite existing values
|
||||
//on the last iteration)
|
||||
sideLength >= 2;
|
||||
//each iteration we are looking at smaller squares
|
||||
//diamonds, and we decrease the variation of the offset
|
||||
sideLength /= 2, h /= 2.0) {
|
||||
//half the length of the side of a square
|
||||
//or distance from diamond center to one corner
|
||||
//(just to make calcs below a little clearer)
|
||||
int halfSide = sideLength / 2;
|
||||
|
||||
//generate the new square values
|
||||
for (int x = 0; x < DATA_SIZE - 1; x += sideLength) {
|
||||
for (int y = 0; y < DATA_SIZE - 1; y += sideLength) {
|
||||
//x, y is upper left corner of square
|
||||
//calculate average of existing corners
|
||||
double avg = sample(x, y) + //top left
|
||||
sample(x + sideLength, y) +//top right
|
||||
sample(x, y + sideLength) + //lower left
|
||||
sample(x + sideLength, y + sideLength);//lower right
|
||||
avg /= 4.0;
|
||||
|
||||
//center is average plus random offset
|
||||
set_sample(x + halfSide, y + halfSide,
|
||||
//We calculate random value in range of 2h
|
||||
//and then subtract h so the end value is
|
||||
//in the range (-h, +h)
|
||||
avg + (f_rand() * 2 * h) - h);
|
||||
}
|
||||
}
|
||||
|
||||
//generate the diamond values
|
||||
//since the diamonds are staggered we only move x
|
||||
//by half side
|
||||
//NOTE: if the data shouldn't wrap then x < DATA_SIZE
|
||||
//to generate the far edge values
|
||||
for (int x = 0; x < DATA_SIZE - 1; x += halfSide) {
|
||||
//and y is x offset by half a side, but moved by
|
||||
//the full side length
|
||||
//NOTE: if the data shouldn't wrap then y < DATA_SIZE
|
||||
//to generate the far edge values
|
||||
for (int y = (x + halfSide) % sideLength; y < DATA_SIZE - 1; y += sideLength) {
|
||||
//x, y is center of diamond
|
||||
//note we must use mod and add DATA_SIZE for subtraction
|
||||
//so that we can wrap around the array to find the corners
|
||||
double avg =
|
||||
sample((x - halfSide + DATA_SIZE) % DATA_SIZE, y) + //left of center
|
||||
sample((x + halfSide) % DATA_SIZE, y) + //right of center
|
||||
sample(x, (y + halfSide) % DATA_SIZE) + //below center
|
||||
sample(x, (y - halfSide + DATA_SIZE) % DATA_SIZE); //above center
|
||||
avg /= 4.0;
|
||||
|
||||
//new value = average plus random offset
|
||||
//We calculate random value in range of 2h
|
||||
//and then subtract h so the end value is
|
||||
//in the range (-h, +h)
|
||||
avg = avg + (f_rand() * 2 * h) - h;
|
||||
//update value for center of diamond
|
||||
set_sample(x, y, avg);
|
||||
|
||||
//wrap values on the edges, remove
|
||||
//this and adjust loop condition above
|
||||
//for non-wrapping values.
|
||||
if (x == 0) set_sample(DATA_SIZE - 1, y, avg);
|
||||
if (y == 0) set_sample(x, DATA_SIZE - 1, avg);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//for (int x = 100; x < 150; x += 10) {
|
||||
// for (int y = 100; y < 150; y += 10) {
|
||||
// for (int z = 0; z < 10; z += 1) {
|
||||
//
|
||||
// voxel_data[x + dimensions.x * (y + dimensions.z * z)] = 6;
|
||||
|
||||
// }
|
||||
// }
|
||||
//}
|
||||
|
||||
|
||||
|
||||
for (int x = 0; x < dimensions.x; x++) {
|
||||
for (int y = 0; y < dimensions.y; y++) {
|
||||
|
||||
if (height_map[x + y * dimensions.x] > 0) {
|
||||
|
||||
int z = static_cast<int>(height_map[x + y * dimensions.x]);
|
||||
|
||||
while (z > 0 && z < dimensions.z) {
|
||||
voxel_data[x + dimensions.x * (y + dimensions.z * z)] = 5;
|
||||
z--;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
for (int x = dimensions.x / 2; x < dimensions.x / 2 + dimensions.x / 64; x++) {
|
||||
for (int y = dimensions.x / 2; y < dimensions.y / 2 + dimensions.x / 64; y++) {
|
||||
for (int z = 2; z < 7; z++) {
|
||||
|
||||
voxel_data[x + dimensions.x * (y + dimensions.z * z)] = 6;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (int x = dimensions.x / 2 - 3; x < dimensions.x / 2 + dimensions.x / 64 + 3; x++) {
|
||||
for (int y = dimensions.x / 2 - 3; y < dimensions.y / 2 + dimensions.x / 64 + 3; y++) {
|
||||
for (int z = 0; z < 1; z++) {
|
||||
|
||||
voxel_data[x + dimensions.x * (y + dimensions.z * z)] = 5;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
for (int x = 140; x < 145; x++) {
|
||||
for (int y = 155; y < 160; y++) {
|
||||
for (int z = 30; z < 35; z++) {
|
||||
voxel_data[x + dimensions.x * (y + dimensions.z * z)] = 6;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (int x = 0; x < dimensions.x; x++) {
|
||||
for (int y = 0; y < dimensions.y; y++) {
|
||||
// for (int z = 0; z < dimensions.z; z++) {
|
||||
//if (rand() % 1000 < 1)
|
||||
voxel_data[x + dimensions.x * (y + dimensions.z * 1)] = 6;
|
||||
// }
|
||||
}
|
||||
}
|
||||
|
||||
//for (int x = 30; x < 60; x++) {
|
||||
// //for (int y = 0; y < dimensions.y; y++) {
|
||||
// for (int z = 10; z < 25; z++) {
|
||||
// voxel_data[x + dimensions.x * (50 + dimensions.z * z)] = 6;
|
||||
// }
|
||||
// //}
|
||||
//}
|
||||
|
||||
// Hand code in some constructions
|
||||
|
||||
std::vector<std::vector<int>> maze =
|
||||
generate_maze(sf::Vector2i(8, 8), sf::Vector2i(0, 0));
|
||||
|
||||
for (int x = 0; x < maze.size(); x++) {
|
||||
for (int y = 0; y < maze.at(0).size(); y++) {
|
||||
|
||||
switch(maze.at(x).at(y)) {
|
||||
|
||||
case 1: { // North
|
||||
voxel_data[x * 3 + 1 + dimensions.x * (y * 3 + dimensions.z * 1)] = 6;
|
||||
voxel_data[x * 3 + 1 + dimensions.x * (y * 3 + 1 + dimensions.z * 1)] = 6;
|
||||
voxel_data[x * 3 + 1 + dimensions.x * (y * 3 + 2 + dimensions.z * 1)] = 5;
|
||||
//voxel_data[x * 3 + dimensions.x * (y * 3 + 2 + dimensions.z * 1)] = 6;
|
||||
//voxel_data[x * 3 + 2 + dimensions.x * (y * 3 + 2 + dimensions.z * 1)] = 6;
|
||||
break;
|
||||
}
|
||||
case 2: { // South
|
||||
voxel_data[x * 3 + 1 + dimensions.x * (y * 3 + dimensions.z * 1)] = 5;
|
||||
voxel_data[x * 3 + 1 + dimensions.x * (y * 3 + 1 + dimensions.z * 1)] = 6;
|
||||
voxel_data[x * 3 + 1 + dimensions.x * (y * 3 + 2 + dimensions.z * 1)] = 6;
|
||||
//voxel_data[x * 3 + dimensions.x * (y * 3 + dimensions.z * 1)] = 6;
|
||||
//voxel_data[x * 3 + 2 + dimensions.x * (y * 3 + dimensions.z * 1)] = 6;
|
||||
break;
|
||||
}
|
||||
case 3: { // East
|
||||
voxel_data[x * 3 + dimensions.x * (y * 3 + 1 + dimensions.z * 1)] = 6;
|
||||
voxel_data[x * 3 + 1 + dimensions.x * (y * 3 + 1 + dimensions.z * 1)] = 6;
|
||||
voxel_data[x * 3 + 2 + dimensions.x * (y * 3 + 1 + dimensions.z * 1)] = 5;
|
||||
//voxel_data[x * 3 + 2 + dimensions.x * (y * 3 + dimensions.z * 1)] = 6;
|
||||
//voxel_data[x * 3 + 2 + dimensions.x * (y * 3 + 2 + dimensions.z * 1)] = 6;
|
||||
break;
|
||||
}
|
||||
case 4: { // West
|
||||
voxel_data[x * 3 + dimensions.x * (y * 3 + 1 + dimensions.z * 1)] = 5;
|
||||
voxel_data[x * 3 + 1 + dimensions.x * (y * 3 + 1 + dimensions.z * 1)] = 6;
|
||||
voxel_data[x * 3 + 2 + dimensions.x * (y * 3 + 1 + dimensions.z * 1)] = 6;
|
||||
//voxel_data[x * 3 + dimensions.x * (y * 3 + dimensions.z * 1)] = 6;
|
||||
//voxel_data[x * 3 + dimensions.x * (y * 3 + 2 + dimensions.z * 1)] = 6;
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//for (int x = 0; x < dimensions.x; x++) {
|
||||
// for (int y = 0; y < dimensions.y; y++) {
|
||||
// voxel_data[x + dimensions.x * (y + dimensions.z * 1)] = 6;
|
||||
// }
|
||||
//}
|
||||
|
||||
set_voxel(sf::Vector3i(45, 70, 6), 6);
|
||||
set_voxel(sf::Vector3i(47, 70, 6), 6);
|
||||
set_voxel(sf::Vector3i(100, 100, 50), 1);
|
||||
|
||||
}
|
||||
|
||||
|
||||
void Old_Map::set_voxel(sf::Vector3i position, int val) {
|
||||
voxel_data[position.x + dimensions.x * (position.y + dimensions.z * position.z)] = val;
|
||||
}
|
||||
|
||||
sf::Vector3i Old_Map::getDimensions() {
|
||||
return dimensions;
|
||||
}
|
||||
|
||||
char* Old_Map::get_voxel_data() {
|
||||
return voxel_data;
|
||||
}
|
||||
|
||||
double Old_Map::sample(int x, int y) {
|
||||
return height_map[(x & (dimensions.x - 1)) + (y & (dimensions.y - 1)) * dimensions.x];
|
||||
}
|
||||
|
||||
void Old_Map::set_sample(int x, int y, double value) {
|
||||
height_map[(x & (dimensions.x - 1)) + (y & (dimensions.y - 1)) * dimensions.x] = value;
|
||||
}
|
||||
|
||||
void Old_Map::sample_square(int x, int y, int size, double value) {
|
||||
int hs = size / 2;
|
||||
|
||||
// a b
|
||||
//
|
||||
// x
|
||||
//
|
||||
// c d
|
||||
|
||||
double a = sample(x - hs, y - hs);
|
||||
double b = sample(x + hs, y - hs);
|
||||
double c = sample(x - hs, y + hs);
|
||||
double d = sample(x + hs, y + hs);
|
||||
|
||||
set_sample(x, y, ((a + b + c + d) / 4.0) + value);
|
||||
|
||||
}
|
||||
|
||||
void Old_Map::sample_diamond(int x, int y, int size, double value) {
|
||||
int hs = size / 2;
|
||||
|
||||
// c
|
||||
//
|
||||
//a x b
|
||||
//
|
||||
// d
|
||||
|
||||
double a = sample(x - hs, y);
|
||||
double b = sample(x + hs, y);
|
||||
double c = sample(x, y - hs);
|
||||
double d = sample(x, y + hs);
|
||||
|
||||
set_sample(x, y, ((a + b + c + d) / 4.0) + value);
|
||||
}
|
||||
|
||||
void Old_Map::diamond_square(int stepsize, double scale) {
|
||||
|
||||
std::mt19937 generator;
|
||||
std::uniform_real_distribution<double> uniform_distribution(-1.0, 1.0);
|
||||
auto f_rand = std::bind(uniform_distribution, std::ref(generator));
|
||||
|
||||
int halfstep = stepsize / 2;
|
||||
|
||||
for (int y = halfstep; y < dimensions.y + halfstep; y += stepsize) {
|
||||
for (int x = halfstep; x < dimensions.x + halfstep; x += stepsize) {
|
||||
sample_square(x, y, stepsize, f_rand() * scale);
|
||||
}
|
||||
}
|
||||
|
||||
for (int y = 0; y < dimensions.y; y += stepsize) {
|
||||
for (int x = 0; x < dimensions.x; x += stepsize) {
|
||||
sample_diamond(x + halfstep, y, stepsize, f_rand() * scale);
|
||||
sample_diamond(x, y + halfstep, stepsize, f_rand() * scale);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Reference in new issue