void DiagSplit::split_quad(Patch *patch) { QuadDice::SubPatch sub_split; QuadDice::EdgeFactors ef_split; sub_split.patch = patch; sub_split.P00 = make_float2(0.0f, 0.0f); sub_split.P10 = make_float2(1.0f, 0.0f); sub_split.P01 = make_float2(0.0f, 1.0f); sub_split.P11 = make_float2(1.0f, 1.0f); ef_split.tu0 = T(patch, sub_split.P00, sub_split.P10); ef_split.tu1 = T(patch, sub_split.P01, sub_split.P11); ef_split.tv0 = T(patch, sub_split.P00, sub_split.P01); ef_split.tv1 = T(patch, sub_split.P10, sub_split.P11); split(sub_split, ef_split); QuadDice dice(params); for(size_t i = 0; i < subpatches_quad.size(); i++) { QuadDice::SubPatch& sub = subpatches_quad[i]; QuadDice::EdgeFactors& ef = edgefactors_quad[i]; ef.tu0 = max(ef.tu0, 1); ef.tu1 = max(ef.tu1, 1); ef.tv0 = max(ef.tv0, 1); ef.tv1 = max(ef.tv1, 1); dice.dice(sub, ef); } subpatches_quad.clear(); edgefactors_quad.clear(); }
std::vector<float3> oabf_line( int ix, int iy, const cpu_image& lfm_, float sigma_d_, float sigma_r_, bool tangential_, float precision_ ) { std::deque<float3> L; float4 l = lfm_.at<float4>(ix, iy); float2 t; float sigma_d = sigma_d_; if (tangential_) { t = make_float2(l.x, l.y); sigma_d *= l.z; } else { t = make_float2(l.y, -l.x); sigma_d *= l.w; } float twoSigmaD2 = 2 * sigma_d * sigma_d; float twoSigmaR2 = 2 * sigma_r_ * sigma_r_; int halfWidth = int(ceilf( precision_ * sigma_d )); float2 tabs = fabs(t); float ds = 1.0f / ((tabs.x > tabs.y)? tabs.x : tabs.y); float norm = 1; for (float d = ds; d <= halfWidth; d += ds) { float2 dt = d * t; L.push_back(make_float3(0.5f + ix + dt.x, 0.5f + iy + dt.y, d)); L.push_front(make_float3(0.5f + ix - dt.x, 0.5f + iy - dt.y, -d)); } return std::vector<float3>(L.begin(), L.end());; }
void vm::scanner::device::ComputeIcpHelper::setLevelIntr(int level_index, float fx, float fy, float cx, float cy) { int div = 1 << level_index; f = make_float2(fx/div, fy/div); c = make_float2(cx/div, cy/div); finv = make_float2(1.f/f.x, 1.f/f.y); }
int oabf_sample_dir( int ix, int iy, const cpu_image& lfm_, bool tangential_ ) { float4 l = lfm_.at<float4>(ix, iy); float2 t; if (tangential_) { t = make_float2(l.x, l.y); } else { t = make_float2(l.y, -l.x); } float2 tabs = fabs(t); return (tabs.x > tabs.y)? 0 : 1; }
// The kernel function of gravitation __host__ __device__ inline float2 kernelFunction( const float2 position_target, const float2 position_source, const float weight_source ) { const float epsilon = 1e-1; float2 distance = make_float2(position_source.x - position_target.x, position_source.y - position_target.y); float r = sqrt(distance.x * distance.x + distance.y * distance.y); float tmp = weight_source / (r*r*r + epsilon); return make_float2(distance.x * tmp, distance.y * tmp); }
InteractiveCamera::InteractiveCamera() { centerPosition = Vector3Df(0, 0, 0); yaw = 0; pitch = 0.3; radius = 4; apertureRadius = 0.04; // 0.04 focalDistance = 4.0f; resolution = make_float2(512, 512); // width, height fov = make_float2(40, 40); }
void SPHSystem::add_particle(float2 pos, float2 vel) { Particle *p=&(hMem[hParam->num_particle]); p->pos=pos; p->vel=vel; p->acc=make_float2(0.0f, 0.0f); p->ev=make_float2(0.0f, 0.0f); p->dens=hParam->rest_density; p->pres=0.0f; hParam->num_particle++; }
std::vector<float3> stgauss3_path_( int ix, int iy, const cpu_image& st, float sigma, bool st_linear, bool adaptive, bool ustep, int order, float step_size ) { cpu_sampler<float3> st_sampler(st, st_linear? cudaFilterModeLinear : cudaFilterModePoint); float2 p0 = make_float2(ix + 0.5f, iy + 0.5f); filter_path f(2 * sigma); if (!ustep) { if (order == 1) { if (adaptive) st3_int<cpu_sampler<float3>,filter_path,1,true>(p0, st_sampler, f, st.w(), st.h(), step_size); else st3_int<cpu_sampler<float3>,filter_path,1,false>(p0, st_sampler, f, st.w(), st.h(), step_size); } else { if (adaptive) st3_int<cpu_sampler<float3>,filter_path,2,true>(p0, st_sampler, f, st.w(), st.h(), step_size); else st3_int<cpu_sampler<float3>,filter_path,2,false>(p0, st_sampler, f, st.w(), st.h(), step_size); } } else { if (order == 1) { st3_int_ustep<cpu_sampler<float3>,filter_path,1>(p0, st_sampler, f, st.w(), st.h(), step_size); } else { st3_int_ustep<cpu_sampler<float3>,filter_path,2>(p0, st_sampler, f, st.w(), st.h(), step_size); } } return f.path(); }
void ToolViewMouseHandler::Mouse(pangolin::View & v, pangolin::MouseButton button, int x, int y, bool pressed, int button_state) { pangolin::Handler::Mouse(v,button,x,y,pressed,button_state); switch(button) { case pangolin::MouseButtonLeft: if (!pressed) { const float2 toolboxPoint = make_float2(x - v.GetBounds().l,v.GetBounds().t() - y); ToolboxSection section = toolbox_->getSection(toolboxPoint); switch(section) { case ButtonSection: hasButtonSelection_ = true; selectedButton_ = toolbox_->getButton(toolboxPoint); break; case LabelSection: hasClassSelection_ = true; selectedClass_ = toolbox_->getClass(toolboxPoint); break; case OverviewSection: toolbox_->processOverviewCentering(toolboxPoint,v.GetBounds().w); break; } } break; case pangolin::MouseWheelUp: toolbox_->processZoom(1.f/zoomSpeed_); break; case pangolin::MouseWheelDown: toolbox_->processZoom(zoomSpeed_); break; } }
static void blender_camera_init(BlenderCamera *bcam, BL::RenderSettings& b_render) { memset(bcam, 0, sizeof(BlenderCamera)); bcam->type = CAMERA_PERSPECTIVE; bcam->zoom = 1.0f; bcam->pixelaspect = make_float2(1.0f, 1.0f); bcam->sensor_width = 32.0f; bcam->sensor_height = 18.0f; bcam->sensor_fit = BlenderCamera::AUTO; bcam->shuttertime = 1.0f; bcam->motion_position = Camera::MOTION_POSITION_CENTER; bcam->rolling_shutter_type = Camera::ROLLING_SHUTTER_NONE; bcam->rolling_shutter_duration = 0.1f; bcam->border.right = 1.0f; bcam->border.top = 1.0f; bcam->pano_viewplane.right = 1.0f; bcam->pano_viewplane.top = 1.0f; bcam->viewport_camera_border.right = 1.0f; bcam->viewport_camera_border.top = 1.0f; /* render resolution */ bcam->full_width = render_resolution_x(b_render); bcam->full_height = render_resolution_y(b_render); /* pixel aspect */ bcam->pixelaspect.x = b_render.pixel_aspect_x(); bcam->pixelaspect.y = b_render.pixel_aspect_y(); }
SPHSystem::SPHSystem() { hParam=new SysParam(); hParam->max_particle=10000; hParam->num_particle=0; hParam->kernel=0.04f; hParam->mass=0.02f; hParam->world_size=make_float2(2.56f, 2.56f); hParam->cell_size=hParam->kernel; hParam->grid_size.x=(uint)ceil(hParam->world_size.x/hParam->cell_size); hParam->grid_size.y=(uint)ceil(hParam->world_size.y/hParam->cell_size); hParam->tot_cell=hParam->grid_size.x*hParam->grid_size.y; hParam->gravity.x=0.0f; hParam->gravity.y=-0.9f; hParam->wall_damping=-0.5f; hParam->rest_density=1000.0f; hParam->gas_constant=3.0f; hParam->viscosity=3.5f; hParam->time_step=0.003f; hParam->surf_normal=6.0f; hParam->surf_coe=0.2f; hParam->poly6_value=315.0f/(64.0f * PI * pow(hParam->kernel, 9));; hParam->spiky_value=-45.0f/(PI * pow(hParam->kernel, 6)); hParam->visco_value=45.0f/(PI * pow(hParam->kernel, 6)); hParam->grad_poly6=-945/(32 * PI * pow(hParam->kernel, 9)); hParam->lplc_poly6=-945/(8 * PI * pow(hParam->kernel, 9)); hParam->kernel_2=hParam->kernel*hParam->kernel; hParam->self_dens=hParam->mass*hParam->poly6_value*pow(hParam->kernel, 6); hParam->self_lplc_color=hParam->lplc_poly6*hParam->mass*(hParam->kernel_2)*(0-3/4*(hParam->kernel_2)); sys_running=0; hMem=(Particle *)malloc(sizeof(Particle)*hParam->max_particle); alloc_array((void**)&(dMem), sizeof(Particle)*hParam->max_particle); hPoints=(float2 *)malloc(sizeof(float2)*hParam->max_particle); alloc_array((void**)&(dPoints), sizeof(float2)*hParam->max_particle); alloc_array((void**)&dHash, sizeof(uint)*hParam->max_particle); alloc_array((void**)&dIndex, sizeof(uint)*hParam->max_particle); alloc_array((void**)&dStart, sizeof(uint)*hParam->tot_cell); alloc_array((void**)&dEnd, sizeof(uint)*hParam->tot_cell); printf("Initialize SPH:\n"); printf("World Width : %f\n", hParam->world_size.x); printf("World Height: %f\n", hParam->world_size.y); printf("Cell Size : %f\n", hParam->cell_size); printf("Grid Width : %u\n", hParam->grid_size.x); printf("Grid Height: %u\n", hParam->grid_size.y); printf("Poly6 Kernel: %f\n", hParam->poly6_value); printf("Spiky Kernel: %f\n", hParam->spiky_value); printf("Visco Kernel: %f\n", hParam->visco_value); printf("Self Density: %f\n", hParam->self_dens); }
void InteractiveCamera::buildRenderCamera(Camera* renderCamera){ float xDirection = sin(yaw) * cos(pitch); float yDirection = sin(pitch); float zDirection = cos(yaw) * cos(pitch); glm::vec3 directionToCamera = glm::vec3(xDirection, yDirection, zDirection); glm::vec3 viewDirection = -directionToCamera; glm::vec3 eyePosition = centerPosition + directionToCamera * radius; renderCamera->position = make_float3(eyePosition[0], eyePosition[1], eyePosition[2]); renderCamera->view = make_float3(viewDirection[0], viewDirection[1], viewDirection[2]); renderCamera->up = make_float3(0, 1, 0); renderCamera->resolution = make_float2(resolution.x, resolution.y); renderCamera->fov = make_float2(fov.x, fov.y); renderCamera->apertureRadius = apertureRadius; renderCamera->focalDistance = radius; }
static void bssrdf_lookup_table_create(const BSSRDFParams *ss, vector<float>& sample_table, vector<float>& pdf_table) { const int size = BSSRDF_RADIUS_TABLE_SIZE; vector<float> cdf(size); vector<float> pdf(size); float step = 1.0f/(float)(size - 1); float max_radius = bssrdf_lookup_table_max_radius(ss); float pdf_sum = 0.0f; /* compute the probability density function */ for(int i = 0; i < pdf.size(); i++) { float x = (i*step)*max_radius; pdf[i] = bssrdf_cubic(ss->ld, x); pdf_sum += pdf[i]; } /* adjust for area covered by each distance */ for(int i = 0; i < pdf.size(); i++) { float x = (i*step)*max_radius; pdf[i] *= M_2PI_F*x; } /* normalize pdf, we multiply in reflectance later */ if(pdf_sum > 0.0f) for(int i = 0; i < pdf.size(); i++) pdf[i] /= pdf_sum; /* sum to account for sampling which uses overlapping sphere */ for(int i = pdf.size() - 2; i >= 0; i--) pdf[i] = pdf[i] + pdf[i+1]; /* compute the cumulative density function */ cdf[0] = 0.0f; for(int i = 1; i < size; i++) cdf[i] = cdf[i-1] + 0.5f*(pdf[i-1] + pdf[i])*step*max_radius; /* invert cumulative density function for importance sampling */ float2 cdf_range = make_float2(0.0f, cdf[size - 1]); float2 table_range = make_float2(0.0f, max_radius); cdf_invert(sample_table, table_range, cdf, cdf_range); /* copy pdf table */ for(int i = 0; i < pdf.size(); i++) pdf_table[i] = pdf[i]; }
LDEVICE float2 BeckmannDistribution::DPDF( float3 N, float3 H ) const { const float cos_theta = optix::dot( N, H ); const float dee = D( N, H ); CHECK_FINITE( dee ); CHECK_FINITE( cos_theta ); return make_float2( dee, dee/cos_theta); }
void InteractiveCamera::buildRenderCamera(Camera* renderCamera){ float xDirection = sin(yaw) * cos(pitch); float yDirection = sin(pitch); float zDirection = cos(yaw) * cos(pitch); Vector3Df directionToCamera = Vector3Df(xDirection, yDirection, zDirection); viewDirection = directionToCamera * (-1.0); Vector3Df eyePosition = centerPosition +directionToCamera * radius; //Vector3Df eyePosition = centerPosition; // rotate camera from stationary viewpoint renderCamera->position = eyePosition; renderCamera->view = viewDirection; renderCamera->up = Vector3Df(0, 1, 0); renderCamera->resolution = make_float2(resolution.x, resolution.y); renderCamera->fov = make_float2(fov.x, fov.y); renderCamera->apertureRadius = apertureRadius; renderCamera->focalDistance = focalDistance; }
void ToolViewMouseHandler::MouseMotion(pangolin::View & v, int x, int y, int button_state) { const float2 toolboxPoint = make_float2(x - v.GetBounds().l,v.GetBounds().t() - y); ToolboxSection section = toolbox_->getSection(toolboxPoint); switch(section) { case OverviewSection: toolbox_->processOverviewCentering(toolboxPoint, v.GetBounds().w); break; } }
void Projector::findProjectedCorners( float4 afCorners[4], const float4 &rfRange, const float16 &rfInvViewPrj) { float2 fMin = make_float2(rfRange.x, rfRange.y); float2 fMax = make_float2(rfRange.z, rfRange.w); afCorners[0] = make_float4(fMin.x, fMin.y, 0.0f, 1.0f); afCorners[1] = make_float4(fMax.x, fMin.y, 0.0f, 1.0f); afCorners[2] = make_float4(fMax.x, fMax.y, 0.0f, 1.0f); afCorners[3] = make_float4(fMin.x, fMax.y, 0.0f, 1.0f); // printf("Projected Grid: Find Projected Corners...\n"); for (uint i = 0; i < 4; i++) { float4 fA = afCorners[i]; float4 fB = afCorners[i]; fA.z = -1.0f; fB.z = +1.0f; fA = rfInvViewPrj * fA; fB = rfInvViewPrj * fB; fB -= fA; float fT = -fA.y / fB.y; afCorners[i] = fA + fB * fT; /* printf("[%2d] %8.5f %8.5f %8.5f %8.5f\n", i, afCorners[i].x / afCorners[i].w, afCorners[i].y / afCorners[i].w, afCorners[i].z / afCorners[i].w, afCorners[i].w / afCorners[i].w); */ } }
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Sync rendered View from blender scene to Octane camera data ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// void BlenderSync::sync_view(BL::SpaceView3D b_v3d, BL::RegionView3D b_rv3d, int width, int height) { Camera* cam = scene->camera; Camera prevcam = *cam; cam->pixelaspect = make_float2(1.0f, 1.0f); float2 offset = {0}; load_camera_from_view(cam, b_scene, b_v3d, b_rv3d, width, height, offset); cam->is_hidden = false; if(cam->modified(prevcam)) cam->tag_update(); } //sync_view()
void DiagSplit::split_triangle(Patch *patch) { TriangleDice::SubPatch sub_split; TriangleDice::EdgeFactors ef_split; sub_split.patch = patch; sub_split.Pu = make_float2(1.0f, 0.0f); sub_split.Pv = make_float2(0.0f, 1.0f); sub_split.Pw = make_float2(0.0f, 0.0f); ef_split.tu = T(patch, sub_split.Pv, sub_split.Pw); ef_split.tv = T(patch, sub_split.Pw, sub_split.Pu); ef_split.tw = T(patch, sub_split.Pu, sub_split.Pv); split(sub_split, ef_split); TriangleDice dice(params); for(size_t i = 0; i < subpatches_triangle.size(); i++) { TriangleDice::SubPatch& sub = subpatches_triangle[i]; TriangleDice::EdgeFactors& ef = edgefactors_triangle[i]; ef.tu = 4; ef.tv = 4; ef.tw = 4; ef.tu = max(ef.tu, 1); ef.tv = max(ef.tv, 1); ef.tw = max(ef.tw, 1); dice.dice(sub, ef); } subpatches_triangle.clear(); edgefactors_triangle.clear(); }
void oz::gpu_image::clear_white() { switch (format()) { case FMT_FLOAT: fill(1, 0, 0, w(), h()); break; case FMT_FLOAT2: fill(make_float2(1), 0, 0, w(), h()); break; case FMT_FLOAT3: fill(make_float3(1), 0, 0, w(), h()); break; case FMT_FLOAT4: fill(make_float4(1), 0, 0, w(), h()); break; default: OZ_INVALID_FORMAT(); } }
std::vector<float3> gpu_stgauss2_path( int ix, int iy, const cpu_image<float4>& st, float sigma, float max_angle, bool adaptive, bool st_linear, int order, float step_size ) { cpu_sampler<float4> st_sampler(st, st_linear? cudaFilterModeLinear : cudaFilterModePoint); float2 p0 = make_float2(ix + 0.5f, iy + 0.5f); if (adaptive) { float A = st2A(st(p0.x, p0.y)); sigma *= 0.25f * (1 + A)*(1 + A); } std::deque<float3> C; float cos_max = cosf(radians(max_angle)); stgauss2_path f(C, sigma); if (order == 1) st_integrate_euler(p0, st_sampler, f, cos_max, st.w(), st.h(), step_size); if (order == 2) st_integrate_rk2(p0, st_sampler, f, cos_max, st.w(), st.h(), step_size); if (order == 4) st_integrate_rk4(p0, st_sampler, f, cos_max, st.w(), st.h(), step_size); return std::vector<float3>(C.begin(), C.end()); }
void SPHSystem::init_system() { srand((unsigned int)time(NULL)); float2 pos; float2 vel=make_float2(0.0f, 0.0f); for(pos.x=hParam->world_size.x*0.0f; pos.x<hParam->world_size.x*0.4f; pos.x+=(hParam->kernel*0.6f)) { for(pos.y=hParam->world_size.y*0.0f; pos.y<hParam->world_size.y*0.9f; pos.y+=(hParam->kernel*0.6f)) { add_particle(pos, vel); } } copy_array(dMem, hMem, sizeof(Particle)*hParam->num_particle, CUDA_HOST_TO_DEV); printf("Init Particle: %u\n", hParam->num_particle); }
static void blender_camera_init(BlenderCamera *bcam, BL::RenderSettings b_render, BL::Scene b_scene) { memset(bcam, 0, sizeof(BlenderCamera)); bcam->type = CAMERA_PERSPECTIVE; bcam->zoom = 1.0f; bcam->pixelaspect = make_float2(1.0f, 1.0f); bcam->sensor_width = 32.0f; bcam->sensor_height = 18.0f; bcam->sensor_fit = BlenderCamera::AUTO; bcam->shuttertime = 1.0f; bcam->border.right = 1.0f; bcam->border.top = 1.0f; bcam->pano_viewplane.right = 1.0f; bcam->pano_viewplane.top = 1.0f; /* render resolution */ bcam->full_width = render_resolution_x(b_render); bcam->full_height = render_resolution_y(b_render); }
void plotPoints(Vec3f* dirs, unsigned int N) { std::ostringstream str1, str2; str1 << "x = ["; str2 << "y = ["; for (size_t i = 0; i < N; i++) { dirs[i] = normalize(dirs[i]); float2 d = make_float2(dirs[i].x, dirs[i].y); str1 << d.x; str2 << d.y; if (i != N - 1) { str1 << ", "; str2 << ", "; } } str1 << "];"; str2 << "];"; str1 << "\n" << str2.str() << "\n" << "scatter(x,y,5)\ngrid on\naxis equal "; std::string plt = str1.str(); toClipboard(plt); }
void vm::scanner::cuda::computeDists(const Depth& depth, Dists& dists, const Intr& intr) { dists.create(depth.rows(), depth.cols()); device::compute_dists(depth, dists, make_float2(intr.fx, intr.fy), make_float2(intr.cx, intr.cy)); }
__device__ float2 convert2f2(const short2 s2O1_){ //can be called from host and device return make_float2(s2O1_.x, s2O1_.y); }
//---------------------------------------------------------------------------------------------------------------------- // This method should be overridden in user defined nodes. // Recompute the given output based on the nodes inputs. // The plug represents the data value that needs to be recomputed, and the data block holds the storage // for all of the node'_scale attributes. //---------------------------------------------------------------------------------------------------------------------- MStatus OceanNode::compute( const MPlug &_plug , MDataBlock &_data ){ MStatus status; // see if we get the output plug if( _plug == m_output){ MDataHandle dataHandle; dataHandle = _data.inputValue(m_resolution, &status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to get data handle for resolution plug"); if (m_res != dataHandle.asInt()){ switch(dataHandle.asInt()){ case 0: m_ocean->setResolution(128); MGlobal::displayInfo("Resolution: 128"); break; case 1: m_ocean->setResolution(256); MGlobal::displayInfo("Resolution: 256"); break; case 2: m_ocean->setResolution(512); MGlobal::displayInfo("Resolution: 512"); break; case 3: m_ocean->setResolution(1024); MGlobal::displayInfo("Resolution: 1024"); break; default: break; } m_res = dataHandle.asInt(); } dataHandle = _data.inputValue( m_amplitude , &status ); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL( status , "Unable to get data handle for amplitude plug" ); // now get the value for the data handle as a double double amp = dataHandle.asDouble(); m_ocean->setAmplitude(amp); dataHandle = _data.inputValue(m_frequency, &status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to get handle for \"frequency\" plug"); double freq = dataHandle.asDouble(); m_ocean->setFrequency(freq); dataHandle = _data.inputValue(m_windDirectionX, &status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to get data handle for windDirectionX plug"); // now get value for data handle double wdx = dataHandle.asDouble(); dataHandle = _data.inputValue(m_windDirectionZ, &status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to get data handle for windDirectionY plug"); // now get value for data handle double wdz = dataHandle.asDouble(); m_ocean->setWindVector(make_float2(wdx, wdz)); dataHandle = _data.inputValue(m_windSpeed, &status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to get data handle for windSpeed plug"); // now get value for data handle double ws = dataHandle.asDouble(); m_ocean->setWindSpeed(ws); // Only create a new frequency domain if either amplitude or the wind vecotr has changed if (m_amp != amp || m_wdx != wdx || m_wdz != wdz || m_ws != ws ){ MGlobal::displayInfo("here"); m_ocean->createH0(); m_amp = amp; m_wdx = wdx; m_wdz = wdz; m_ws = ws; } dataHandle = _data.inputValue(m_choppiness, &status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to get data handle for the choppiness plug"); double choppiness = dataHandle.asDouble(); dataHandle = _data.inputValue(m_time, &status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to get data handle for time plug"); MTime time = dataHandle.asTime(); MDataHandle outputData = _data.outputValue(m_output, &status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL( status , "Unable to get data handle for output plug" ); MFnMeshData mesh; MObject outputObject = mesh.create(&status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to create output mesh"); // Find the current frame number we're on and create the grid based on this MAnimControl anim; anim.setMinTime(time); createGrid((int)pow(2.0, m_res+7), anim.currentTime().value()/24, choppiness, outputObject, status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to to create grid"); outputData.set(outputObject); // clean the output plug, ie unset it from dirty so that maya does not re-evaluate it _data.setClean( _plug ); return MStatus::kSuccess; } return MStatus::kUnknownParameter; }
int extractManifold(const float4* p, int nPoints, float4& nearNormal, float4& centerOut, int contactIdx[4]) { if( nPoints == 0 ) return 0; nPoints = min2( nPoints, 64 ); float4 center = make_float4(0.f); { float4 v[64]; memcpy( v, p, nPoints*sizeof(float4) ); PARALLEL_SUM( v, nPoints ); center = v[0]/(float)nPoints; } centerOut = center; { // sample 4 directions if( nPoints < 4 ) { for(int i=0; i<nPoints; i++) contactIdx[i] = i; return nPoints; } float4 aVector = p[0] - center; float4 u = cross3( nearNormal, aVector ); float4 v = cross3( nearNormal, u ); u = normalize3( u ); v = normalize3( v ); int idx[4]; float2 max00 = make_float2(0,FLT_MAX); { float4 dir0 = u; float4 dir1 = -u; float4 dir2 = v; float4 dir3 = -v; // idx, distance { { int4 a[64]; for(int ie = 0; ie<nPoints; ie++ ) { float4 f; float4 r = p[ie]-center; f.x = dot3F4( dir0, r ); f.y = dot3F4( dir1, r ); f.z = dot3F4( dir2, r ); f.w = dot3F4( dir3, r ); a[ie].x = ((*(u32*)&f.x) & 0xffffff00); a[ie].x |= (0xff & ie); a[ie].y = ((*(u32*)&f.y) & 0xffffff00); a[ie].y |= (0xff & ie); a[ie].z = ((*(u32*)&f.z) & 0xffffff00); a[ie].z |= (0xff & ie); a[ie].w = ((*(u32*)&f.w) & 0xffffff00); a[ie].w |= (0xff & ie); } for(int ie=0; ie<nPoints; ie++) { a[0].x = (a[0].x > a[ie].x )? a[0].x: a[ie].x; a[0].y = (a[0].y > a[ie].y )? a[0].y: a[ie].y; a[0].z = (a[0].z > a[ie].z )? a[0].z: a[ie].z; a[0].w = (a[0].w > a[ie].w )? a[0].w: a[ie].w; } idx[0] = (int)a[0].x & 0xff; idx[1] = (int)a[0].y & 0xff; idx[2] = (int)a[0].z & 0xff; idx[3] = (int)a[0].w & 0xff; } } { float2 h[64]; PARALLEL_DO( h[ie] = make_float2((float)ie, p[ie].w), nPoints ); REDUCE_MIN( h, nPoints ); max00 = h[0]; } } contactIdx[0] = idx[0]; contactIdx[1] = idx[1]; contactIdx[2] = idx[2]; contactIdx[3] = idx[3]; // if( max00.y < 0.0f ) // contactIdx[0] = (int)max00.x; std::sort( contactIdx, contactIdx+4 ); return 4; } }
void kf::cuda::computeDists(const Depth& depth, Dists& dists, const Intr& intr) { dists.create(depth.rows(), depth.cols()); impl::compute_dists(depth, dists, make_float2(intr.fx, intr.fy), make_float2(intr.cx, intr.cy)); }
static bool ObtainCacheParticleUV(Mesh *mesh, BL::Mesh *b_mesh, BL::Object *b_ob, ParticleCurveData *CData, bool background, int uv_num) { if (!(mesh && b_mesh && b_ob && CData)) return false; CData->curve_uv.clear(); BL::Object::modifiers_iterator b_mod; for (b_ob->modifiers.begin(b_mod); b_mod != b_ob->modifiers.end(); ++b_mod) { if ((b_mod->type() == b_mod->type_PARTICLE_SYSTEM) && (background ? b_mod->show_render() : b_mod->show_viewport())) { BL::ParticleSystemModifier psmd((const PointerRNA)b_mod->ptr); BL::ParticleSystem b_psys((const PointerRNA)psmd.particle_system().ptr); BL::ParticleSettings b_part((const PointerRNA)b_psys.settings().ptr); if ((b_part.render_type() == BL::ParticleSettings::render_type_PATH) && (b_part.type() == BL::ParticleSettings::type_HAIR)) { int totparts = b_psys.particles.length(); int totchild = background ? b_psys.child_particles.length() : (int)((float)b_psys.child_particles.length() * (float)b_part.display_percentage() / 100.0f); int totcurves = totchild; if (b_part.child_type() == 0 || totchild == 0) totcurves += totparts; if (totcurves == 0) continue; int pa_no = 0; if (!(b_part.child_type() == 0) && totchild != 0) pa_no = totparts; int num_add = (totparts + totchild - pa_no); CData->curve_uv.reserve(CData->curve_uv.size() + num_add); BL::ParticleSystem::particles_iterator b_pa; b_psys.particles.begin(b_pa); for (; pa_no < totparts + totchild; pa_no++) { /* Add UVs */ BL::Mesh::uv_layers_iterator l; b_mesh->uv_layers.begin(l); float2 uv = make_float2(0.0f, 0.0f); if (b_mesh->uv_layers.length()) b_psys.uv_on_emitter(psmd, *b_pa, pa_no, uv_num, &uv.x); CData->curve_uv.push_back_slow(uv); if (pa_no < totparts && b_pa != b_psys.particles.end()) ++b_pa; } } } } return true; }