void Piece::RotateXCCW() {
isMoved = true;
unsigned int n = size;
unsigned int colLimit = floor((float) n / 2.0);
unsigned int rowLimit = ceil((float) n / 2.0);
for (unsigned int c = 0; c < n; c++) {
for (unsigned int d = 0; d < colLimit; d++) {
for (unsigned int r = 0; r < rowLimit; r++) {
Voxel* temp = container[c][r][d];
if (temp != 0) {
temp = temp->Copy();
}
//SwapVoxels(c, r, d, container[n - 1 - r][c][d]);
SwapVoxels(c, r, d, container[c][d][n - 1 - r]);
//SwapVoxels(n - 1 - r, c, d, container[n - 1 - c][n - 1 - r][d]);
SwapVoxels(c, d, n - 1 - r, container[c][n - 1 - r][n - 1 - d]);
//SwapVoxels(n - 1 - c, n - 1 - r, d, container[r][n - 1 - c][d]);
SwapVoxels(c, n - 1 - r, n - 1 - d, container[c][n - 1 - d][r]);
//SwapVoxels(r, n - 1 - c, d, temp);
SwapVoxels(c, n - 1 - d, r, temp);
}
}
}
}
virtual void init(Voxel& voxel)
{
if(!voxel.grad_dev.empty() || voxel.qsdr)
voxel.calculate_q_vec_t(q_vectors_time);
else
voxel.calculate_sinc_ql(sinc_ql);
}
/**
* Performs element-wise addition of `offset` and the position of each voxel.
*
* @param offset
* offset vector
*/
void Chunk::shiftVoxels(Position offset)
{
unsigned long long x;
unsigned long long y;
unsigned long long z;
unsigned long long dx = std::get<0>(offset);
unsigned long long dy = std::get<1>(offset);
unsigned long long dz = std::get<2>(offset);
for(unsigned int i=0;i<this->size;i++)
{
for(unsigned int j=0;j<this->size;j++)
{
for(unsigned int k=0;k<this->size;k++)
{
Voxel currVoxel = this->voxels[i][j][k];
x = std::get<0>(currVoxel.getPosition());
y = std::get<1>(currVoxel.getPosition());
z = std::get<2>(currVoxel.getPosition());
this->voxels[i][j][k].setPosition(std::make_tuple(x+dx, y+dy, z+dz));
}
}
}
}
bool voxelAppartientCylindre(Point origine, Vector vecteur,double rayon, Voxel v){
Point limite(origine.getX()+vecteur.getX(), origine.getY()+vecteur.getY(),origine.getZ()+vecteur.getZ());
int distancePointProjete;
int distanceOrigineProjete;
for( int i = 0; i<8; i++ ){
Point projete(v.getSommet(i).projectOnLine(origine,limite));
distancePointProjete = sqrt( pow(v.getSommet(i).getX()-projete.getX(),2)
+ pow(v.getSommet(i).getY()-projete.getY(),2)
+ pow(v.getSommet(i).getZ()-projete.getZ(),2)
);
distanceOrigineProjete = sqrt( pow(origine.getX()-projete.getX(),2)
+ pow(origine.getY()-projete.getY(),2)
+ pow(origine.getZ()-projete.getZ(),2)
);
if( distancePointProjete > rayon || projete.getY() < origine.getY() || projete.getY() > limite.getY() ){
return false;
}
}
return true;
}
std::pair<std::pair<ParticleID, Voxel>, bool>
SpatiocyteWorld::new_voxel(const Voxel& v)
{
const private_coordinate_type private_coord(coord2private(v.coordinate()));
return new_voxel_private(
Voxel(v.species(), private_coord, v.radius(), v.D(), v.loc()));
}
bool GridAccel::IntersectP(const Ray &ray) const {
if (!gridForRefined) { // NOBOOK
rayTests.Add(0, 1); // NOBOOK
rayHits.Add(0, 1); // NOBOOK
} // NOBOOK
int rayId = ++curMailboxId;
// Check ray against overall grid bounds
float rayT;
if (bounds.Inside(ray(ray.mint)))
rayT = ray.mint;
else if (!bounds.IntersectP(ray, &rayT))
return false;
Point gridIntersect = ray(rayT);
// Set up 3D DDA for ray
float NextCrossingT[3], DeltaT[3];
int Step[3], Out[3], Pos[3];
for (int axis = 0; axis < 3; ++axis) {
// Compute current voxel for axis
Pos[axis] = PosToVoxel(gridIntersect, axis);
if (ray.d[axis] >= 0) {
// Handle ray with positive direction for voxel stepping
NextCrossingT[axis] = rayT +
(VoxelToPos(Pos[axis]+1, axis) - gridIntersect[axis]) /
ray.d[axis];
DeltaT[axis] = Width[axis] / ray.d[axis];
Step[axis] = 1;
Out[axis] = NVoxels[axis];
}
else {
// Handle ray with negative direction for voxel stepping
NextCrossingT[axis] = rayT +
(VoxelToPos(Pos[axis], axis) - gridIntersect[axis]) /
ray.d[axis];
DeltaT[axis] = -Width[axis] / ray.d[axis];
Step[axis] = -1;
Out[axis] = -1;
}
}
// Walk grid for shadow ray
for (;;) {
int offset = Offset(Pos[0], Pos[1], Pos[2]);
Voxel *voxel = voxels[offset];
if (voxel && voxel->IntersectP(ray, rayId))
return true;
// Advance to next voxel
// Find _stepAxis_ for stepping to next voxel
int bits = ((NextCrossingT[0] < NextCrossingT[1]) << 2) +
((NextCrossingT[0] < NextCrossingT[2]) << 1) +
((NextCrossingT[1] < NextCrossingT[2]));
const int cmpToAxis[8] = { 2, 1, 2, 1, 2, 2, 0, 0 };
int stepAxis = cmpToAxis[bits];
if (ray.maxt < NextCrossingT[stepAxis])
break;
Pos[stepAxis] += Step[stepAxis];
if (Pos[stepAxis] == Out[stepAxis])
break;
NextCrossingT[stepAxis] += DeltaT[stepAxis];
}
return false;
}
void Piece::RotateZCCW() {
isMoved = true;
unsigned int n = size;
unsigned int colLimit = floor((float) n / 2.0);
unsigned int rowLimit = ceil((float) n / 2.0);
// unsigned int topRow = GetTopRow();
// unsigned int leftCol = GetLeftCol();
// unsigned int topDep = GetTopDep();
for (unsigned int d = 0; d < size; d++) {
for (unsigned int c = 0; c < colLimit; c++) {
for (unsigned int r = 0; r < rowLimit; r++) {
Voxel* temp = container[c][r][d];
if (temp != 0) {
temp = temp->Copy();
}
SwapVoxels(c, r, d, container[n - 1 - r][c][d]); // container[c][r][d] = container[n - 1 - r][c][d];
SwapVoxels(n - 1 - r, c, d, container[n - 1 - c][n - 1 - r][d]); //container[n - 1 - r][c][d] = container[n - 1 - c][n - 1 - r][d];
SwapVoxels(n - 1 - c, n - 1 - r, d, container[r][n - 1 - c][d]); // container[n - 1 - c][n - 1 - r][d] = container[r][n - 1 - c][d];
SwapVoxels(r, n - 1 - c, d, temp); //container[r][n - 1 - c][d] = temp;
}
}
}
}
void AbstractPiece::Set(unsigned int col, unsigned int row, unsigned int dep, bool flag) {
if (!Validate(col, row, dep))
return;
Voxel* v = 0;
if (flag) {
v = new Voxel();
VoxelColour colour;
colour.alpha = 1.0;
colour.red = 0.0;
colour.green = 0.0;
colour.blue = 1.0;
v->SetColour(colour);
VoxelLocation location;
location.col = col;
location.row = row;
location.dep = dep;
v->SetLocation(location);
VoxelDrawPosition position;
position.x = 0.0;
position.y = 0.0;
position.z = 0.0;
v->SetPosition(position);
}
Set(col, row, dep, v);
}
/**
* Add edges of the neighbouring path tiles.
* @param xpos X coordinate of the central voxel with a path tile.
* @param ypos Y coordinate of the central voxel with a path tile.
* @param zpos Z coordinate of the central voxel with a path tile.
* @param slope Imploded path slope of the central voxel.
* @param dirs Edge directions to change (bitset of #TileEdge), usually #EDGE_ALL.
* @param use_additions Use #_additions rather than #_world.
* @param add_edges If set, add edges (else, remove them).
* @return Updated (imploded) slope at the central voxel.
*/
uint8 AddRemovePathEdges(uint16 xpos, uint16 ypos, uint8 zpos, uint8 slope, uint8 dirs, bool use_additions, bool add_edges)
{
for (TileEdge edge = EDGE_BEGIN; edge < EDGE_COUNT; edge++) {
if ((dirs & (1 << edge)) == 0) continue; // Skip directions that should not be updated.
int delta_z = 0;
if (slope >= PATH_FLAT_COUNT) {
if (_path_down_from_edge[edge] == slope) {
delta_z = 1;
} else if (_path_up_from_edge[edge] != slope) {
continue;
}
}
Point16 dxy = _tile_dxy[edge];
if ((dxy.x < 0 && xpos == 0) || (dxy.x > 0 && xpos == _world.GetXSize() - 1)) continue;
if ((dxy.y < 0 && ypos == 0) || (dxy.y > 0 && ypos == _world.GetYSize() - 1)) continue;
TileEdge edge2 = (TileEdge)((edge + 2) % 4);
bool modified = false;
if (delta_z <= 0 || zpos < WORLD_Z_SIZE - 1) {
Voxel *v;
if (use_additions) {
v = _additions.GetCreateVoxel(xpos + dxy.x, ypos + dxy.y, zpos + delta_z, false);
} else {
v = _world.GetCreateVoxel(xpos + dxy.x, ypos + dxy.y, zpos + delta_z, false);
}
if (v != nullptr) {
uint16 number = v->GetInstance();
if (number == SRI_PATH) { // Valid path.
v->SetInstanceData(SetPathEdge(v->GetInstanceData(), edge2, add_edges));
MarkVoxelDirty(xpos + dxy.x, ypos + dxy.y, zpos + delta_z);
modified = true;
} else if (number >= SRI_FULL_RIDES) { // A ride instance. Does it have an entrance here?
if ((v->GetInstanceData() & (1 << edge2)) != 0) modified = true;
}
}
}
delta_z--;
if (delta_z >= 0 || zpos > 0) {
Voxel *v;
if (use_additions) {
v = _additions.GetCreateVoxel(xpos + dxy.x, ypos + dxy.y, zpos + delta_z, false);
} else {
v = _world.GetCreateVoxel(xpos + dxy.x, ypos + dxy.y, zpos + delta_z, false);
}
if (v != nullptr) {
uint16 number = v->GetInstance();
if (number == SRI_PATH) { // Valid path.
v->SetInstanceData(SetPathEdge(v->GetInstanceData(), edge2, add_edges));
MarkVoxelDirty(xpos + dxy.x, ypos + dxy.y, zpos + delta_z);
modified = true;
} else if (number >= SRI_FULL_RIDES) { // A ride instance. Does it have an entrance here?
if ((v->GetInstanceData() & (1 << edge2)) != 0) modified = true;
}
}
}
if (modified && slope < PATH_FLAT_COUNT) slope = SetPathEdge(slope, edge, add_edges);
}
return slope;
}
std::pair<std::pair<ParticleID, Voxel>, bool>
SpatiocyteWorld::new_voxel_structure(const Voxel& v)
{
const bool is_succeeded((*space_).update_voxel_private(ParticleID(), v));
const coordinate_type coord(private2coord(v.coordinate()));
return std::make_pair(std::make_pair(ParticleID(),
Voxel(v.species(), coord, v.radius(), v.D(), v.loc())),
is_succeeded);
}
void BrickDensityRegion::set(int i, int j, int k, float val) {
if(i < 0 || i > m_brickData.size_x() ||
j < 0 || j > m_brickData.size_y() ||
k < 0 || k > m_brickData.size_z()) {
printf("Error: setting index out of value [%d, %d, %d]\n", i, j, k);
exit(1);
}
Voxel *tmp = m_brickData(i,j,k);
tmp->set(0, val);
}
bool reconstruct(unsigned int thread_count)
{
begin_prog("reconstruction");
voxel.image_model = this;
voxel.CreateProcesses<ProcessType>();
voxel.init(thread_count);
boost::thread_group threads;
for (unsigned int index = 1;index < thread_count;++index)
threads.add_thread(new boost::thread(&Voxel::thread_run,&voxel,
index,thread_count,mask));
voxel.thread_run(0,thread_count,mask);
threads.join_all();
return !prog_aborted();
}
/**
* Move a voxel stack to this world. May destroy the original stack in the process.
* @param vs Source stack.
*/
void VoxelStack::MoveStack(VoxelStack *vs)
{
/* Clean up the stack a bit before copying it, and get lowest and highest non-empty voxel. */
int vs_first = 0;
int vs_last = 0;
for (int i = 0; i < (int)vs->height; i++) {
Voxel *v = &vs->voxels[i];
assert(!v->HasVoxelObjects()); // There should be no voxel objects in the stack being moved.
if (!v->IsEmpty()) {
vs_last = i;
} else {
if (vs_first == i) vs_first++;
}
}
/* There should be at least one surface voxel. */
assert(vs_first <= vs_last);
/* Examine current stack with respect to persons. */
int old_first = 0;
int old_last = 0;
for (int i = 0; i < (int)this->height; i++) {
const Voxel *v = &this->voxels[i];
if (v->HasVoxelObjects()) {
old_last = i;
} else {
if (old_first == i) old_first++;
}
}
int new_base = std::min(vs->base + vs_first, this->base + old_first);
int new_height = std::max(vs->base + vs_last, this->base + old_last) - new_base + 1;
assert(new_base >= 0);
/* Make a new stack. Copy new surface, then copy the persons. */
Voxel *new_voxels = MakeNewVoxels(new_height);
CopyStackData(new_voxels + (vs->base + vs_first) - new_base, vs->voxels + vs_first, vs_last - vs_first + 1, false);
int i = (this->base + old_first) - new_base;
while (old_first <= old_last) {
CopyVoxelObjectList(&new_voxels[i], &this->voxels[old_first]);
i++;
old_first++;
}
this->base = new_base;
this->height = new_height;
delete[] this->voxels;
this->voxels = new_voxels;
}
/**
* Change the path type of a currently existing path.
* @param voxel_pos Coordinate of the voxel.
* @param path_type The type of path to change to.
* @param path_spr Imploded sprite number.
*/
static void ChangePathAtTile(const XYZPoint16 &voxel_pos, PathType path_type, uint8 path_spr)
{
VoxelStack *avs = _additions.GetModifyStack(voxel_pos.x, voxel_pos.y);
Voxel *av = avs->GetCreate(voxel_pos.z, false);
AddRemovePathEdges(voxel_pos, path_spr, EDGE_ALL, true, PAS_UNUSED);
/* Reset flat path to one without edges or corners. */
if (path_spr < PATH_FLAT_COUNT)
path_spr = PATH_EMPTY;
uint8 slope = AddRemovePathEdges(voxel_pos, path_spr, EDGE_ALL, true, _sprite_manager.GetPathStatus(path_type));
av->SetInstanceData(MakePathInstanceData(slope, path_type));
MarkVoxelDirty(voxel_pos);
}
//---------------------------------------------------------------------------
void OGLGeo::voxel(Voxel &v_in)
{
//Voxel
int i,j,k,index_temp;
for(k=0;k<v_in.mesh_z;k++)
{
for(j=0;j<v_in.mesh_y;j++)
{
for(i=0;i<v_in.mesh_x;i++)
{
index_temp=v_in.index(i,j,k);
if(v_in.flag[index_temp]!=0)
{
double x0=v_in.x0+i*v_in.dx;
double x1=v_in.x0+(i+1)*v_in.dx;
double y0=v_in.y0+j*v_in.dy;
double y1=v_in.y0+(j+1)*v_in.dy;
double z0=v_in.z0+k*v_in.dz;
double z1=v_in.z0+(k+1)*v_in.dz;
GL_Box(x0,x1,y0,y1,z0,z1);
}
}
}
}
}
/**
* Examine, and perhaps modify a neighbouring path edge or ride connection, to make it connect (or not if not \a add_edges)
* to the centre examined tile.
* @param voxel_pos Coordinate of the neighbouring voxel.
* @param edge Edge to examine, and/or connected to.
* @param add_edges If set, add edges (else, remove them).
* @param at_bottom Whether a path connection is expected at the bottom (if \c false, it should be at the top).
* @param dest_voxel [out] %Voxel containing the neighbouring path, or \c nullptr.
* @param dest_inst_data [out] New instance of the voxel. Only valid if \a dest_voxel is not \c nullptr.
* @param dest_status [out] Status of the neighbouring path.
* @return Neighbouring voxel was (logically) connected to the centre tile.
*/
static bool ExamineNeighbourPathEdge(const XYZPoint16 &voxel_pos, TileEdge edge, bool add_edges, bool at_bottom,
Voxel **dest_voxel, uint16 *dest_inst_data, PathStatus *dest_status)
{
Voxel *v;
*dest_voxel = nullptr;
*dest_status = PAS_UNUSED;
*dest_inst_data = PATH_INVALID;
v = _world.GetCreateVoxel(voxel_pos, false);
if (v == nullptr) return false;
uint16 fences = v->GetFences();
FenceType fence_type = GetFenceType(fences, edge);
if (fence_type != FENCE_TYPE_INVALID) return false;
uint16 number = v->GetInstance();
if (number == SRI_PATH) {
uint16 instance_data = v->GetInstanceData();
if (!HasValidPath(instance_data)) return false;
uint8 slope = GetImplodedPathSlope(instance_data);
if (at_bottom) {
if (slope >= PATH_FLAT_COUNT && slope != _path_up_from_edge[edge]) return false;
} else {
if (slope != _path_down_from_edge[edge]) return false;
}
PathStatus status = _sprite_manager.GetPathStatus(GetPathType(instance_data));
if (add_edges && status == PAS_QUEUE_PATH) { // Only try to connect to queue paths if they are not yet connected to 2 (or more) neighbours.
if (GetQuePathEdgeConnectCount(slope) > 1) return false;
}
slope = SetPathEdge(slope, edge, add_edges);
*dest_status = status;
*dest_voxel = v;
*dest_inst_data = SetImplodedPathSlope(instance_data, slope);
return true;
} else if (number >= SRI_FULL_RIDES) { // A ride instance. Does it have an entrance here?
if ((v->GetInstanceData() & (1 << edge)) != 0) {
*dest_status = PAS_QUEUE_PATH;
return true;
}
}
return false;
}
void Snake::AddBody(int x, int y, int z)
{
// if cube is already max size, remove the tail
if(size >= MaxLength)
{
Voxel *temp = Body[size%MaxLength];
int tx = temp->Get_X();
int ty = temp->Get_Y();
int tz = temp->Get_Z();
Cube->SetVoxel(tx,ty,tz,0);
free(temp); // frees up the tail in memory
}
Body[size%MaxLength] = new Voxel(Cur_x,Cur_y,Cur_z);
Cube->SetVoxel(Cur_x,Cur_y,Cur_z,1);
size ++;
}
inline bool is_face_visible(const VoxelLibrary &lib, const Voxel &vt, int other_voxel_id) {
if (other_voxel_id == 0) // air
return true;
if (lib.has_voxel(other_voxel_id)) {
const Voxel &other_vt = lib.get_voxel_const(other_voxel_id);
return other_vt.is_transparent() && vt.get_id() != other_voxel_id;
}
return true;
}
void Fibertracking::trackFiber_forward()
{
using namespace std;
Voxel *current = &voxels[cur_voxel_index];
Vector *curVec;
start_o = *new Vector( (current->getX()+0.5)*voxelext_x, (current->getY()+0.5)*voxelext_y, (current->getZ()+0.5)*voxelext_z );
curVectorList = *new VectorList();
while (current->getAnisotropy() > min_anisotropy && !current->isVisited() && (fabs(intersec_angle) < max_intersec_angle) )
{
// current->print();
currentFiber.add_at_end(*current);
curVectorList.add_at_end(start_o); // schreibt den Schnittpunkt an die verkettete Liste
curVec = new Vector((double)(voxels[cur_voxel_index].getDir_Index()), (double)cur_voxel_index, 0.);
curVectorList.add_at_end(*curVec);
nextVoxel_forward();
if ( current == &voxels[cur_voxel_index]) // || voxels[cur_voxel_index].isVisited()
{
break;
}
else
{
current->setVisited(true);
current = &voxels[cur_voxel_index];
}
}
if (current->isVisited())
{
n_visited++;
}
else
{
if (current->getAnisotropy() < min_anisotropy)
{
n_aniso++;
}
else
{
if (fabs(intersec_angle) > max_intersec_angle)
{
n_angle++;
}
}
}
}
bool voxelHorsSphere(Voxel voxel, Point centreSphere, double rayonSphere){
for( int i = 0; i<8; i++ ){
if( distance(centreSphere, voxel.getSommet(i)) < rayonSphere ){
return false;
}
}
return true;
}
/**
* Creates a world of flat tiles.
* @param z Height of the tiles.
*/
void VoxelWorld::MakeFlatWorld(int16 z)
{
for (uint16 xpos = 0; xpos < this->x_size; xpos++) {
for (uint16 ypos = 0; ypos < this->y_size; ypos++) {
Voxel *v = this->GetCreateVoxel(XYZPoint16(xpos, ypos, z), true);
v->SetFoundationType(FDT_INVALID);
v->SetGroundType(GTP_GRASS0);
v->SetGroundSlope(ImplodeTileSlope(SL_FLAT));
v->ClearInstances();
}
}
for (uint16 xpos = 0; xpos < this->x_size; xpos++) {
AddFoundations(this, xpos, 0, z, 0xC0);
AddFoundations(this, xpos, this->y_size - 1, z, 0x0C);
}
for (uint16 ypos = 0; ypos < this->y_size; ypos++) {
AddFoundations(this, 0, ypos, z, 0x03);
AddFoundations(this, this->x_size - 1, ypos, z, 0x30);
}
}
bool voxelHorsCylindre(Point origine, Vector vecteur,double rayon, Voxel v){
Point limite(origine.getX()+vecteur.getX(), origine.getY()+vecteur.getY(),origine.getZ()+vecteur.getZ());
int distancePointProjete;
for( int i = 0; i<8; i++ ){
Point projete(v.getSommet(i).projectOnLine(origine,limite));
distancePointProjete = sqrt( pow(v.getSommet(i).getX()-projete.getX(),2)
+ pow(v.getSommet(i).getY()-projete.getY(),2)
+ pow(v.getSommet(i).getZ()-projete.getZ(),2)
);
if( distancePointProjete <= rayon && projete.getY() >= origine.getY() && projete.getY() <= limite.getY() ){
return false;
}
}
return true;
}
__global__
void kernelInsertMetaPointCloud(Voxel* voxelmap, const MetaPointCloudStruct* meta_point_cloud,
VoxelType* voxel_types, const Vector3ui *map_dim,
const float voxel_side_length)
{
const Vector3ui dimensions = (*map_dim);
for (uint32_t i = blockIdx.x * blockDim.x + threadIdx.x; i < meta_point_cloud->accumulated_cloud_size;
i += blockDim.x * gridDim.x)
{
uint32_t voxel_type_index = i / meta_point_cloud->cloud_sizes[0];
const Vector3ui integer_coordinates = mapToVoxels(voxel_side_length,
meta_point_cloud->clouds_base_addresses[0][i]);
// printf("Point @(%f,%f,%f)\n",
// meta_point_cloud->clouds_base_addresses[0][i].x,
// meta_point_cloud->clouds_base_addresses[0][i].y,
// meta_point_cloud->clouds_base_addresses[0][i].z);
//check if point is in the range of the voxel map
if ((integer_coordinates.x < dimensions.x) && (integer_coordinates.y < dimensions.y)
&& (integer_coordinates.z < dimensions.z))
{
Voxel* voxel = &voxelmap[getVoxelIndex(map_dim, integer_coordinates.x, integer_coordinates.y,
integer_coordinates.z)];
voxel->insert(voxel_types[voxel_type_index]);
// printf("Inserted Point @(%u,%u,%u) with type %u into the voxel map \n",
// integer_coordinates.x,
// integer_coordinates.y,
// integer_coordinates.z,
// voxel_types[voxel_type_index]);
}
else
{
printf("Point (%f,%f,%f) is not in the range of the voxel map \n",
meta_point_cloud->clouds_base_addresses[0][i].x, meta_point_cloud->clouds_base_addresses[0][i].y,
meta_point_cloud->clouds_base_addresses[0][i].z);
}
}
}
/**
* Set the ground fences of a voxel stack.
* @param fences Ground fences to set.
* @param stack The voxel stack to assign to.
* @param base_z Height of the base voxel.
*/
void AddGroundFencesToMap(uint16 fences, VoxelStack *stack, int base_z)
{
Voxel *v = stack->GetCreate(base_z, false); // It should have ground at least.
assert(v->GetGroundType() != GTP_INVALID);
uint8 slope = v->GetGroundSlope();
v->SetFences(MergeGroundFencesAtBase(v->GetFences(), fences, slope));
v = stack->GetCreate(base_z + 1, HasTopVoxelFences(slope));
if (v != nullptr) v->SetFences(MergeGroundFencesAtTop(v->GetFences(), fences, slope));
}
void save_fib(const std::string& ext)
{
std::string output_name = file_name;
output_name += ext;
begin_prog("saving data");
gz_mat_write mat_writer(output_name.c_str());
save_to_file(mat_writer);
voxel.end(mat_writer);
std::string final_report = voxel.report.c_str();
final_report += voxel.recon_report.str();
mat_writer.write("report",final_report.c_str(),1,final_report.length());
}
//---------------------------------------------------------------------------
void OGLGeo::voxel_all(Voxel &voxel_in)
{
//全ボクセル描画
//点を出力
GLfloat materialBlue[]={0.2f,0.4f,1.0f,0.5f};
glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,materialBlue);
for(int k=0;k<voxel_in.mesh_z;k++)
{
for(int j=0;j<voxel_in.mesh_y;j++)
{
for(int i=0;i<voxel_in.mesh_x;i++)
{
glBegin(GL_POINTS);
glVertex3d(voxel_in.itox(i),voxel_in.jtoy(j),voxel_in.ktoz(k));
glEnd();
}
}
}
}
void AbstractPiece::SwapVoxels(unsigned int dest_c, unsigned int dest_r, unsigned int dest_d, Voxel* src) {
Voxel* dest = container[dest_c][dest_r][dest_d];
if (src == 0) {
if (dest != 0) {
delete container[dest_c][dest_r][dest_d];
}
container[dest_c][dest_r][dest_d] = 0;
return;
}
if (dest == 0) {
Voxel* v = new Voxel();
v->GetLocation().col = dest_c;
v->GetLocation().row = dest_r;
v->GetLocation().dep = dest_d;
container[dest_c][dest_r][dest_d] = v;
dest = container[dest_c][dest_r][dest_d];
}
dest->GetColour().red = src->GetColour().red;
dest->GetColour().blue = src->GetColour().blue;
dest->GetColour().green = src->GetColour().green;
dest->GetColour().alpha = src->GetColour().alpha;
}
__global__
void kernelInsertGlobalPointCloud(Voxel* voxelmap, const Vector3ui *map_dim, const float voxel_side_length,
Vector3f* points, const std::size_t sizePoints, const uint32_t voxel_type)
{
const Vector3ui dimensions = (*map_dim);
for (uint32_t i = blockIdx.x * blockDim.x + threadIdx.x; i < sizePoints; i += blockDim.x * gridDim.x)
{
const Vector3ui integer_coordinates = mapToVoxels(voxel_side_length, points[i]);
//check if point is in the range of the voxel map
if ((integer_coordinates.x < dimensions.x) && (integer_coordinates.y < dimensions.y)
&& (integer_coordinates.z < dimensions.z))
{
Voxel* voxel = &voxelmap[getVoxelIndex(map_dim, integer_coordinates.x, integer_coordinates.y,
integer_coordinates.z)];
voxel->insert(voxel_type);
}
else
{
printf("Point (%u,%u,%u) is not in the range of the voxel map \n", points[i].x, points[i].y,
points[i].z);
}
}
}
void RideBuildWindow::SelectorMouseButtonEvent(uint8 state)
{
if (!IsLeftClick(state)) return;
if (this->selector.area.width != 1 || this->selector.area.height != 1) return;
ShopInstance *si = static_cast<ShopInstance *>(this->instance);
SmallRideInstance inst_number = static_cast<SmallRideInstance>(this->instance->GetIndex());
uint8 entrances = si->GetEntranceDirections(si->vox_pos);
Voxel *v = _world.GetCreateVoxel(si->vox_pos, true);
assert(v != nullptr && v->GetInstance() == SRI_FREE);
v->SetInstance(inst_number);
v->SetInstanceData(entrances);
_rides_manager.NewInstanceAdded(inst_number);
AddRemovePathEdges(si->vox_pos, PATH_EMPTY, entrances, false, PAS_QUEUE_PATH);
this->instance = nullptr; // Delete this window, and
si = nullptr; // (Also clean the copy of the pointer.)
delete this;
ShowShopManagementGui(inst_number); // Open gui for the new shop.
}
//---------------------------------------------------------------------------
void OGLGeo::voxel2(Voxel &voxel_in)
{
//ボクセルモデリング関数2
//点を出力
//GLfloat materialBlue[]={0.2f,0.4f,1.0f,0.5f};
//glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,materialBlue);
for(int k=0;k<voxel_in.mesh_z;k++)
{
for(int j=0;j<voxel_in.mesh_y;j++)
{
for(int i=0;i<voxel_in.mesh_x;i++)
{
if(voxel_in.flag[voxel_in.index(i,j,k)])
{
glBegin(GL_POINTS);
glVertex3d(voxel_in.itox(i),voxel_in.jtoy(j),voxel_in.ktoz(k));
glEnd();
}
}
}
}
}
