djledda/somaesque-native
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
dLedda
2022-11-13 22:08:20 +01:00
commit 0b7b6059c1
5 changed files with 499 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
/build

15
CMakeLists.txt Normal file
View File

@@ -0,0 +1,15 @@
cmake_minimum_required(VERSION 3.18)
project(somaesque)
#find_package(glfw3 3.3 REQUIRED)
#find_package(glm REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_FLAGS -I/usr/include/SDL2)
add_executable(somaesque
main.cpp
VoxelSpace.cpp
VoxelSpace.h
)
#target_link_libraries(somaesque glfw GL X11 pthread Xrandr dl SDL2 glm::glm)
#target_include_directories(somaesque PRIVATE src/KHR src/glad)

262
VoxelSpace.cpp Normal file
View File

@@ -0,0 +1,262 @@
#include "VoxelSpace.h"
#include <vector>
#include <algorithm>
#include <iostream>
#include <cstdint>
namespace Voxel {
inline auto index(int dims[3], int x, int y, int z) -> int {
return (dims[1] * dims[2] * x + dims[2] * y + z);
}
// [1, 0, 0] [x] [ x]
// [0, 0, -1] * [y] = [-z]
// [0, 1, 0] [z] [ y]
inline auto newIndexRotX(int dims[3], int x, int y, int z) -> int {
return dims[2] * dims[1] * x + dims[1] * (dims[2] - 1 - z) + y;
}
// [ 0, 0, 1] [x] [ z]
// [ 0, 1, 0] * [y] = [ y]
// [-1, 0, 0] [z] [-x]
inline auto newIndexRotY(int dims[3], int x, int y, int z) -> int {
return dims[1] * dims[0] * z + dims[0] * y + (dims[0] - 1 - x);
}
// [0, -1, 0] [x] [-y]
// [1, 0, 0] * [y] = [ x]
// [0, 0, 1] [z] [ z]
inline auto newIndexRotZ(int dims[3], int x, int y, int z) -> int {
return dims[0] * dims[2] * (dims[1] - 1 - y) + dims[2] * x + z;
}
inline auto toggle(uint64_t space, int index) -> uint64_t {
space ^= 1ull << index;
return space;
}
inline auto set(uint64_t *space, int index, bool val) -> void {
if (val) {
*space |= 1ull << index;
} else {
*space &= ~(1ull << index);
}
}
inline auto collides(uint64_t a, uint64_t b) -> bool {
return (a | b) != (a ^ b);
}
inline auto filledAt(uint64_t space, int dims[3], int x, int y, int z) -> bool {
auto mask = 1ull << (dims[1] * dims[2] * x + dims[2] * y + z);
return (space & mask) != 0ull;
}
auto getExtrema(uint64_t space, int dims[3]) -> Extrema {
auto extrema = Extrema{
.xMax=0,
.xMin=dims[0],
.yMax=0,
.yMin=dims[1],
.zMax=0,
.zMin=dims[2],
};
for (int x = 0; x < dims[0]; x++) {
for (int y = 0; y < dims[1]; y++) {
for (int z = 0; z < dims[2]; z++) {
if (filledAt(space, dims, x, y, z)) {
if (x > extrema.xMax) extrema.xMax = x;
if (x < extrema.xMin) extrema.xMin = x;
if (y > extrema.yMax) extrema.yMax = y;
if (y < extrema.yMin) extrema.yMin = y;
if (z > extrema.zMax) extrema.zMax = z;
if (z < extrema.zMin) extrema.zMin = z;
}
}
}
}
return extrema;
}
auto cullEmptySpace(Space *space) -> void {
auto extrema = getExtrema(space->space, space->dims);
auto space_index = 0;
auto newSpace = 0ull;
for (int x = extrema.xMin; x <= extrema.xMax; x++) {
for (int y = extrema.yMin; y <= extrema.yMax; y++) {
for (int z = extrema.zMin; z <= extrema.zMax; z++) {
if (filledAt(space->space, space->dims, x, y, z)) {
newSpace |= 1ull << space_index;
}
space_index++;
}
}
}
space->dims[0] = extrema.xMax - extrema.xMin + 1;
space->dims[1] = extrema.yMax - extrema.yMin + 1;
space->dims[2] = extrema.zMax - extrema.zMin + 1;
space->space = newSpace;
}
auto rotate90X(Space *space) -> void {
for (int x = 0; x < space->dims[0]; x++) {
for (int y = 0; y < space->dims[1]; y++) {
for (int z = 0; z < space->dims[2]; z++) {
if (filledAt(space->space, space->dims, x, y, z)) {
space->space |= 1 << newIndexRotX(space->dims, x, y, z);
}
}
}
}
auto temp = space->dims[1];
space->dims[1] = space->dims[2];
space->dims[2] = temp;
}
auto rotate90Y(Space *space) -> void {
for (int x = 0; x < space->dims[0]; x++) {
for (int y = 0; y < space->dims[1]; y++) {
for (int z = 0; z < space->dims[2]; z++) {
if (filledAt(space->space, space->dims, x, y, z)) {
space->space |= 1 << newIndexRotY(space->dims, x, y, z);
}
}
}
}
auto temp = space->dims[0];
space->dims[0] = space->dims[2];
space->dims[2] = temp;
}
auto rotate90Z(Space *space) -> void {
for (int x = 0; x < space->dims[0]; x++) {
for (int y = 0; y < space->dims[1]; y++) {
for (int z = 0; z < space->dims[2]; z++) {
if (filledAt(space->space, space->dims, x, y, z)) {
space->space |= 1 << newIndexRotZ(space->dims, x, y, z);
}
}
}
}
auto temp = space->dims[0];
space->dims[0] = space->dims[1];
space->dims[1] = temp;
}
inline auto isMatch(Space *a, Space *b) -> bool {
return a->space == b->space
&& a->dims[0] == b->dims[0]
&& a->dims[1] == b->dims[1]
&& a->dims[2] == b->dims[2];
}
auto pushNewUniqueSpins(std::vector<Space> *existingSpaces, Space* spaceToSpin) -> void {
Space spins[4] = {};
spins[0] = *spaceToSpin;
for (int i = 0; i < 3; i++) {
spins[i + 1] = spins[i];
rotate90X(&spins[i + 1]);
}
for (int i = 0; i < 4; i++) {
auto matchFound = false;
for (auto &existingSpace : *existingSpaces) {
if (isMatch(&existingSpace, &spins[i])) {
matchFound = true;
break;
}
}
if (!matchFound) {
existingSpaces->push_back(spins[i]);
}
}
}
auto getUniqueRotations(Space *space) -> std::vector<Space> {
auto rotations = std::vector<Space>();
rotations.reserve(6*24);
auto dims = space->dims;
auto refSpace = *space;
pushNewUniqueSpins(&rotations, &refSpace);
rotate90Y(&refSpace);
pushNewUniqueSpins(&rotations, &refSpace);
rotate90Y(&refSpace);
pushNewUniqueSpins(&rotations, &refSpace);
rotate90Z(&refSpace);
pushNewUniqueSpins(&rotations, &refSpace);
rotate90Z(&refSpace);
rotate90Z(&refSpace);
pushNewUniqueSpins(&rotations, &refSpace);
return rotations;
}
/*
getAllRotations(): Space[] {
let rotations: Space[] = new Array<Space>();
const refSpace = this.clone();
rotations = rotations.concat(refSpace.getXAxisSpins());
refSpace.rot90Y();
rotations = rotations.concat(refSpace.getXAxisSpins());
refSpace.rot90Y();
rotations = rotations.concat(refSpace.getXAxisSpins());
refSpace.rot90Y();
rotations = rotations.concat(refSpace.getXAxisSpins());
refSpace.rot90Z();
rotations = rotations.concat(refSpace.getXAxisSpins());
refSpace.rot90Z();
refSpace.rot90Z();
rotations = rotations.concat(refSpace.getXAxisSpins());
return rotations;
}
*/
auto getAllPositionsInPrism(uint64_t space, int space_dims[3], int prism_dims[3]) -> std::vector<uint64_t> {
auto cubePositions = std::vector<uint64_t>();
if (space_dims[0] > prism_dims[0] || space_dims[1] > prism_dims[1] || space_dims[2] > prism_dims[2]) {
return cubePositions;
}
auto xPositionCount = prism_dims[0] - space_dims[0] + 1;
auto yPositionCount = prism_dims[1] - space_dims[1] + 1;
auto zPositionCount = prism_dims[2] - space_dims[2] + 1;
cubePositions.reserve(xPositionCount + yPositionCount + zPositionCount);
for (int x = 0; x < xPositionCount; x++) {
for (int y = 0; y < yPositionCount; y++) {
for (int z = 0; z < zPositionCount; z++) {
auto new_space = space;
for (int posX = 0; posX < space_dims[0]; posX++) {
for (int posY = 0; posY < space_dims[1]; posY++) {
for (int posZ = 0; posZ < space_dims[2]; posZ++) {
auto set_val = filledAt(space, space_dims, x, y, z);
auto index_to_set = index(space_dims, x + posX, y + posY, z + posZ);
set(&new_space, index_to_set, set_val);
}
}
}
cubePositions.push_back(new_space);
}
}
}
return cubePositions;
}
auto getAllPermutationsInPrism(Space *space, int prism_dims[3]) -> std::vector<uint64_t> {
auto rotations = getUniqueRotations(space);
auto result = std::vector<uint64_t>();
for (auto &rotation : rotations) {
auto positions = getAllPositionsInPrism(rotation.space, rotation.dims, prism_dims);
result.insert(result.end(), positions.begin(), positions.end());
}
return result;
}
auto size(uint64_t space) -> int {
auto size = 0;
for (int i = 0; i < 64; i++) {
if ((space & (1ull << i)) != 0) {
size++;
}
}
return size;
}
}

63
VoxelSpace.h Normal file
View File

@@ -0,0 +1,63 @@
#ifndef VOXELSPACE_H
#define VOXELSPACE_H
#include <vector>
#include <cstdint>
namespace Voxel {
struct Extrema {
int xMax;
int xMin;
int yMax;
int yMin;
int zMax;
int zMin;
};
struct Space {
uint64_t space;
int dims[3];
};
inline auto index(int dims[3], int x, int y, int z) -> int;
inline auto newIndexRotX(int dims[3], int x, int y, int z) -> int;
inline auto newIndexRotY(int dims[3], int x, int y, int z) -> int;
inline auto newIndexRotZ(int dims[3], int x, int y, int z) -> int;
inline auto toggle(uint64_t space, int index) -> uint64_t;
inline auto set(uint64_t space, int index, bool val) -> uint64_t;
inline auto collides(Space *a, Space *b) -> bool;
inline auto add(Space *a, Space *b) -> Space;
inline auto filledAt(Space *space, int index) -> bool;
auto getExtrema(uint64_t space, int dims[3]) -> Extrema;
auto cullEmptySpace(Space *space) -> void;
auto isMatch(Space *a, Space *b) -> bool;
auto rotate90X(Space *space) -> void;
auto rotate90Y(Space *space) -> void;
auto rotate90Z(Space *space) -> void;
auto pushNewUniqueSpins(std::vector<Space> *existingSpaces, Space* spaceToSpin) -> void;
auto getUniqueRotations(Space *space) -> std::vector<Space>;
auto getAllPositionsInPrism(uint64_t space, int space_dims[3], int prism_dims[3]) -> std::vector<uint64_t>;
auto getAllPermutationsInPrism(Space *space, int prism_dims[3]) -> std::vector<uint64_t>;
auto size(uint64_t space) -> int;
}
#endif

158
main.cpp Normal file
View File

@@ -0,0 +1,158 @@
#include <iostream>
#include <string>
#include <vector>
#include "VoxelSpace.h"
auto backtrack_solve(std::vector<uint64_t> *polycube_input, std::vector<int> *offsets)-> void {
auto num_inputs = offsets->size() - 1;
auto solns = std::vector<int>();
auto iter_stack = std::vector<int>();
auto curr_soln_stack = std::vector<int>();
auto soln_spaces_stack = std::vector<uint64_t>();
soln_spaces_stack.push_back(0ull);
auto depth = 0;
while (depth >= 0) {
if (depth >= iter_stack.size()) {
iter_stack.push_back(offsets->at(depth));
}
auto end = offsets->at(depth + 1);
auto broke = false;
for (; iter_stack[depth] < end; iter_stack[depth]++) {
auto next_space = polycube_input->at(iter_stack[depth]);
auto soln_space = soln_spaces_stack[depth];
std::cout << next_space << " " << soln_space << std::endl;
auto successful_fuse = (soln_space | next_space) == (soln_space ^ next_space);
if (successful_fuse) {
soln_spaces_stack.push_back(soln_space |= next_space);
curr_soln_stack.push_back(iter_stack[depth]);
depth++;
if (curr_soln_stack.size() == num_inputs) {
solns.push_back(1);
curr_soln_stack.pop_back();
soln_spaces_stack.pop_back();
depth--;
} else {
depth++;
auto broke = true;
break;
}
}
}
if (!broke) {
curr_soln_stack.pop_back();
soln_spaces_stack.pop_back();
depth--;
}
}
std::cout << "Done. Found " << solns.size() << " solutions." << std::endl;
}
auto get_dims_input(int dims[3]) -> void {
std::cout << "Enter dimensions separated by newlines. (x*y*z must not exceed 64)\n";
auto success = false;
while (!success) {
std::cout << "x: ";
std::cin >> dims[0];
std::cout << "y: ";
std::cin >> dims[1];
std::cout << "z: ";
std::cin >> dims[2];
auto size = dims[0]*dims[1]*dims[2];
if (size <= 64) {
success = true;
} else {
std::cout << "That resulted in " << size << " units. Try again.\n";
}
std::cin.ignore();
}
}
auto get_reprs_input(int units_required) -> std::vector<uint64_t> {
std::cout << "Enter bit-representations (big endian, max 64 bits, total 1s must add up to " << units_required << "). press ENTER twice to finish input.\n";
auto reprs = std::vector<uint64_t>();
auto total_units = 0;
while (true) {
auto input = std::string();
std::getline(std::cin, input);
if (input.size() == 0) {
if (total_units == units_required) {
break;
} else {
std::cout << "Bad number of units. You entered: " << total_units << ", but exactly " << units_required << " were required.\n";
total_units = 0;
continue;
}
}
auto bit_repr = 0ull;
auto i = 0;
auto good_repr = true;
for (auto it = input.rbegin(); it < input.rend(); it++, i++) {
if (*it == '1') {
bit_repr |= 1ull << i;
total_units++;
} else if (*it != '0' || i >= 64) {
std::cout << "Input invalid. Enter a binary string only with max 64 bits." << '\n';
good_repr = false;
break;
}
}
if (good_repr) {
reprs.push_back(bit_repr);
}
}
return reprs;
}
auto main() -> int {
int dims[3] = {};
get_dims_input(dims);
std::cout << '\n';
//auto reprs = get_reprs_input(dims[0]*dims[1]*dims[2]);
auto reprs = std::vector<uint64_t>{
23ull,
30ull,
15ull,
43ull,
172ull,
92ull,
11ull,
};
std::cout << "Great. Calculating solutions...\n";
auto offsets = std::vector<int>();
auto polycubes = std::vector<Voxel::Space>();
polycubes.reserve(reprs.size() * 10);
auto model_space = Voxel::Space{
.space={},
.dims={dims[0], dims[1], dims[2]},
};
offsets.push_back(polycubes.size());
auto space = model_space;
space.space = reprs[0];
Voxel::cullEmptySpace(&space);
std::cout << space.dims[0] << space.dims[1] << space.dims[2] << std::endl;
auto positions = Voxel::getUniqueRotations(&space);
polycubes.insert(polycubes.end(), positions.begin(), positions.end());
for (int i = 1; i < reprs.size(); i++) {
offsets.push_back(polycubes.size());
auto space = model_space;
space.space = reprs[i];
Voxel::cullEmptySpace(&space);
std::cout << space.dims[0] << space.dims[1] << space.dims[2] << std::endl;
auto perms = Voxel::getUniqueRotations(&space);
polycubes.insert(polycubes.end(), perms.begin(), perms.end());
}
offsets.push_back(polycubes.size());
//backtrack_solve(&polycubes, &offsets);
return 0;
}