/* voxel loop function for regrid_minc */ void regrid_loop(void *caller_data, long num_voxels, int input_num_buffers, int input_vector_length, double *input_data[], int output_num_buffers, int output_vector_length, double *output_data[], Loop_Info * loop_info) { long ivox; long idx[MAX_VAR_DIMS]; int v, idim; double voxel_coord[WORLD_NDIMS]; double world_coord[WORLD_NDIMS]; double value; int valid; /* get pointer to loop data */ Loop_Data *ld = (Loop_Data *) caller_data; /* shut the compiler up - yes I _know_ I don't use these */ (void)input_num_buffers; (void)output_num_buffers; (void)output_vector_length; (void)output_data; /* for each (vector) voxel */ for(ivox = 0; ivox < num_voxels * (long)input_vector_length; ivox += (long)input_vector_length){ /* figure out where we are in space */ get_info_voxel_index(loop_info, ivox, ld->file_ndims, idx); /* convert voxel index to world co-ordinate */ for(idim = 0; idim < WORLD_NDIMS; idim++){ voxel_coord[idim] = idx[ld->space_to_dim[idim]]; } transform_coord(&world_coord[0], ld->voxel_to_world, &voxel_coord[0]); /* get the data */ valid = 0; for(v = 0; v < input_vector_length; v++){ value = input_data[0][(ivox * (long)input_vector_length) + (long)v]; /* check if this point is valid */ if(value > ld->floor && value < ld->ceil){ valid = 1; } ld->data_buf[v] = value; } /* then regrid the point if valid */ if(valid){ regrid_point(ld->totals, ld->weights, world_coord[0], world_coord[1], world_coord[2], input_vector_length, ld->data_buf); } } return; }
bool BM_get(pbit_mat bm, int r, int c) { _ASSERT_VALID_BM(bm); _ASSERT_VALID_POS(bm, r, c); _LINT cella; _BTYPE mask; transform_coord(bm, r, c, &cella, &mask); return (bm->arr[cella] & mask)!=0; }
void BM_set_block(pbit_mat bm, int r, int c, _BTYPE block) { _ASSERT_VALID_BM(bm); _ASSERT_VALID_POS(bm, r, c); my_assert(c%_LBTYPE==0); _LINT cella; _BTYPE mask; transform_coord(bm, r, c, &cella, &mask); bm->arr[cella]= block; }
_BTYPE BM_get_block(pbit_mat bm, int r, int c) { _ASSERT_VALID_BM(bm); _ASSERT_VALID_POS(bm, r, c); my_assert(c%_LBTYPE==0); _LINT cella; _BTYPE mask; transform_coord(bm, r, c, &cella, &mask); return bm->arr[cella]; }
void BM_set(pbit_mat bm, int r, int c, bool value) { _ASSERT_VALID_BM(bm); _ASSERT_VALID_POS(bm, r, c); _LINT cella; _BTYPE mask; transform_coord(bm, r, c, &cella, &mask); if (value) { bm->arr[cella]= bm->arr[cella] | mask; } else { bm->arr[cella]= bm->arr[cella] & (~mask); } }
/** Transforms local space position in to global space point */ Vector& IDrawInterface::LocalToGlobalTransform(Vector& OutGlobalPoint, const Vector& InLocalPoint) const { transform_coord(OutGlobalPoint, InLocalPoint, m_WorldMatrixTransform); return OutGlobalPoint; }
//---------------------------------------------------------------------------------------------- void IDrawInterface::DoBuildWorldTransform_(const Matrix &WTM) { m_WorldMatrixTransform = GetLTM_() * WTM * GetSTM_(); m_Bounds.SetUnvalid(); // invalidate std::vector<IRenderInterface*> &vecRenderEntities = const_cast<CActor*>(m_pNode->m_pKey)->m_VecRenderEntities; for (std::vector<IRenderInterface*>::const_iterator iter = vecRenderEntities.begin(); iter != vecRenderEntities.end(); ++iter) { (*iter)->SetRWTM(m_WorldMatrixTransform); Bounds3f BBox = (*iter)->GetRBounds_(); if (BBox.IsValid()) { const unsigned int BBOX_POINTS = 8; Vector BoxPoints[BBOX_POINTS] = { /*Vector(BBox.bound_min.x, BBox.bound_min.y, BBox.bound_min.z), Vector(BBox.bound_min.x, BBox.bound_min.y, BBox.bound_max.z), Vector(BBox.bound_max.x, BBox.bound_min.y, BBox.bound_max.z), Vector(BBox.bound_max.x, BBox.bound_min.y, BBox.bound_min.z), Vector(BBox.bound_min.x, BBox.bound_max.y, BBox.bound_min.z), Vector(BBox.bound_min.x, BBox.bound_max.y, BBox.bound_max.z), Vector(BBox.bound_max.x, BBox.bound_max.y, BBox.bound_max.z), Vector(BBox.bound_max.x, BBox.bound_max.y, BBox.bound_min.z),*/ // TODO make homogeneous with exporter tool Vector(BBox.bound_min.z, BBox.bound_min.y, BBox.bound_min.x), Vector(BBox.bound_max.z, BBox.bound_min.y, BBox.bound_min.x), Vector(BBox.bound_max.z, BBox.bound_min.y, BBox.bound_max.x), Vector(BBox.bound_min.z, BBox.bound_min.y, BBox.bound_max.x), Vector(BBox.bound_min.z, BBox.bound_max.y, BBox.bound_min.x), Vector(BBox.bound_max.z, BBox.bound_max.y, BBox.bound_min.x), Vector(BBox.bound_max.z, BBox.bound_max.y, BBox.bound_max.x), Vector(BBox.bound_min.z, BBox.bound_max.y, BBox.bound_max.x), }; Matrix MT = m_WorldMatrixTransform; MT.t = Vector(0.f, 0.f, 0.f); Bounds3f tmpBound; for (int Index = 0; Index < BBOX_POINTS; ++Index) { Vector point = transform_coord(BoxPoints[Index], MT); if (Index == 0) { tmpBound.SetBounds(point, point); continue; } tmpBound.Add(point); } const Vector bound_min = m_WorldMatrixTransform.t + tmpBound.bound_min; const Vector bound_max = m_WorldMatrixTransform.t + tmpBound.bound_max; (*iter)->SetWBounds(Bounds3f(bound_min, bound_max)); if (iter == vecRenderEntities.begin()) { m_Bounds.SetBounds(bound_min, bound_max); continue; } else { m_Bounds.Add(bound_min); m_Bounds.Add(bound_max); } } } // invalidate composite bounds m_CompositeBounds = m_Bounds; }
ExperimentalApp() : GLFWApp(1280, 800, "Geometric Algorithm Development App") { glfwSwapInterval(0); igm.reset(new gui::ImGuiManager(window)); gui::make_dark_theme(); fixedTimer.start(); lights[0] = {{0, 10, -10}, {0, 0, 1}}; lights[1] = {{0, 10, 10}, {0, 1, 0}}; int width, height; glfwGetWindowSize(window, &width, &height); glViewport(0, 0, width, height); grid = RenderableGrid(1, 100, 100); cameraController.set_camera(&camera); camera.look_at({0, 2.5, -2.5}, {0, 2.0, 0}); simpleShader = make_watched_shader(shaderMonitor, "../assets/shaders/simple_vert.glsl", "assets/shaders/simple_frag.glsl"); normalDebugShader = make_watched_shader(shaderMonitor, "../assets/shaders/normal_debug_vert.glsl", "assets/shaders/normal_debug_frag.glsl"); Renderable debugAxis = Renderable(make_axis(), false, GL_LINES); debugAxis.pose = Pose(float4(0, 0, 0, 1), float3(0, 1, 0)); debugModels.push_back(std::move(debugAxis)); // Initial supershape settings supershape = Renderable(make_supershape_3d(16, 5, 7, 4, 12)); supershape.pose.position = {0, 2, -2}; // Initialize PTF stuff { std::array<float3, 4> controlPoints = {float3(0.0f, 0.0f, 0.0f), float3(0.667f, 0.25f, 0.0f), float3(1.33f, 0.25f, 0.0f), float3(2.0f, 0.0f, 0.0f)}; ptf = make_parallel_transport_frame_bezier(controlPoints, 32); for (int i = 0; i < ptf.size(); ++i) { Renderable p = Renderable(make_cube()); ptfBoxes.push_back(std::move(p)); } } // Initialize Parabolic pointer stuff { // Set up the ground plane used as a nav mesh for the parabolic pointer worldSurface = make_plane(48, 48, 96, 96); for (auto & p : worldSurface.vertices) { float4x4 model = make_rotation_matrix({1, 0, 0}, -ANVIL_PI / 2); p = transform_coord(model, p); } worldSurfaceRenderable = Renderable(worldSurface); parabolicPointer = make_parabolic_pointer(worldSurface, params); } // Initialize objects for ballistic trajectory tests { turret.source = Renderable(make_tetrahedron()); turret.source.pose = Pose({-5, 2, 5}); turret.target = Renderable(make_cube()); turret.target.pose = Pose({0, 0, 40}); turret.bullet = Renderable(make_sphere(1.0f)); } float4x4 tMat = mul(make_translation_matrix({3, 4, 5}), make_rotation_matrix({0, 0, 1}, ANVIL_PI / 2)); auto p = make_pose_from_transform_matrix(tMat); std::cout << tMat << std::endl; std::cout << p << std::endl; gl_check_error(__FILE__, __LINE__); }