void MakeDelaunay(const std::vector<float2>& vertexes, std::vector<uint3>& output)
{
output.clear();
if (vertexes.size() < 3) {
return;
}
int N = (int)vertexes.size();
std::vector<std::pair<float2, int>> vertPairs(N);
int index = 0;
for (const float2& vert : vertexes) {
vertPairs[index] = std::pair<float2, int>(vert, index);
index++;
}
std::sort(vertPairs.begin(), vertPairs.end());
std::vector<float2> tmp;
tmp.reserve(vertPairs.size());
for (std::pair<float2, int>& pr : vertPairs) {
tmp.push_back(pr.first);
}
std::vector<int3> cTriangles;
Triangulate(tmp, cTriangles);
for (int3& triangle : cTriangles) {
if (triangle.x < N &&
triangle.y < N &&
triangle.z < N) {
output.push_back(uint3((uint32_t)vertPairs[triangle.x].second, (uint32_t)vertPairs[triangle.y].second, vertPairs[triangle.z].second));
}
}
}
void ClFFT::init( Ptr<cl::Context> context, Ptr<cl::CommandQueue> queue, clFFT_Dimension& dim, clFFT_Dim3& dim3 )
{
m_context = context;
m_queue = queue;
m_size = uint3(dim3.x, dim3.y, dim3.z);
cl_int err = CL_SUCCESS;
*m_fftPlan = clFFT_CreatePlan((*m_context)(), clFFT_Dim3(m_size.x, m_size.y, 1), clFFT_2D, clFFT_SplitComplexFormat, &err);
if(!*m_fftPlan || err)
throw cl::Error(ERR_OPENCL, "clFFT_CreatePlan");
}
GpuFftCS4::GpuFftCS4(uint32_t width, uint32_t height, bool forward)
: width_(width), height_(height), forward_(forward)
{
RenderFactory& rf = Context::Instance().RenderFactoryInstance();
src_ = rf.MakeVertexBuffer(BU_Dynamic, EAH_GPU_Read | EAH_GPU_Unordered | EAH_GPU_Structured, nullptr, EF_GR32F);
src_->Resize(3 * width * height * sizeof(float) * 2);
dst_ = rf.MakeVertexBuffer(BU_Dynamic, EAH_GPU_Read | EAH_GPU_Unordered | EAH_GPU_Structured, nullptr, EF_GR32F);
dst_->Resize(3 * width * height * sizeof(float) * 2);
tmp_buffer_ = rf.MakeVertexBuffer(BU_Dynamic, EAH_GPU_Read | EAH_GPU_Unordered | EAH_GPU_Structured, nullptr, EF_GR32F);
tmp_buffer_->Resize(3 * width * height * sizeof(float) * 2);
quad_layout_ = rf.MakeRenderLayout();
quad_layout_->TopologyType(RenderLayout::TT_TriangleStrip);
float2 xyzs[] =
{
float2(-1, +1),
float2(+1, +1),
float2(-1, -1),
float2(+1, -1)
};
ElementInitData init_data;
init_data.row_pitch = sizeof(xyzs);
init_data.slice_pitch = 0;
init_data.data = xyzs;
GraphicsBufferPtr quad_vb = rf.MakeVertexBuffer(BU_Static, EAH_GPU_Read | EAH_Immutable, &init_data);
quad_layout_->BindVertexStream(quad_vb, std::make_tuple(vertex_element(VEU_Position, 0, EF_GR32F)));
tex_fb_ = rf.MakeFrameBuffer();
effect_ = SyncLoadRenderEffect("FFT.fxml");
buf2tex_tech_ = effect_->TechniqueByName("Buf2Tex");
radix008a_tech_ = effect_->TechniqueByName("FFTRadix008A4");
radix008a_first_tech_ = effect_->TechniqueByName("FFTRadix008AFirst4");
radix008a_final_tech_ = effect_->TechniqueByName("FFTRadix008AFinal4");
real_tex_ep_ = effect_->ParameterByName("real_tex");
imag_tex_ep_ = effect_->ParameterByName("imag_tex");
*(effect_->ParameterByName("input_buf")) = dst_;
*(effect_->ParameterByName("tex_width_height")) = uint2(width, height);
uint32_t n = width * height;
*(effect_->ParameterByName("addr_offset")) = uint3(0 * n, 1 * n, 2 * n);
*(effect_->ParameterByName("forward")) = static_cast<int32_t>(forward_);
*(effect_->ParameterByName("scale")) = 1.0f / (width_ * height_);
}
void drive_operation()
{
// Uint64 tests
CQLValue a1(Uint64(10));
CQLValue a2(Uint64(15));
CQLValue a3(Uint64(25));
CQLValue a4(Uint64(30));
CQLValue a5(Uint64(150));
PEGASUS_TEST_ASSERT(a1 != a2);
PEGASUS_TEST_ASSERT(a5 == a5);
PEGASUS_TEST_ASSERT(a1 < a2);
PEGASUS_TEST_ASSERT(a2 >= a1);
PEGASUS_TEST_ASSERT(a1 <= a2);
PEGASUS_TEST_ASSERT(a2 > a1);
// Sint64 tests
CQLValue b1(Sint64(10));
CQLValue b2(Sint64(15));
CQLValue b3(Sint64(25));
CQLValue b4(Sint64(30));
CQLValue b5(Sint64(150));
PEGASUS_TEST_ASSERT(b1 != b2);
PEGASUS_TEST_ASSERT(b5 == b5);
PEGASUS_TEST_ASSERT(b1 < b2);
PEGASUS_TEST_ASSERT(b2 >= b1);
PEGASUS_TEST_ASSERT(b1 <= b2);
PEGASUS_TEST_ASSERT(b2 > b1);
// Real64 tests
CQLValue c1(Real64(10.00));
CQLValue c2(Real64(15.00));
CQLValue c3(Real64(25.00));
CQLValue c4(Real64(30.00));
CQLValue c5(Real64(150.00));
PEGASUS_TEST_ASSERT(c1 != c2);
PEGASUS_TEST_ASSERT(c5 == c5);
PEGASUS_TEST_ASSERT(c1 < c2);
PEGASUS_TEST_ASSERT(c2 >= c1);
PEGASUS_TEST_ASSERT(c1 <= c2);
PEGASUS_TEST_ASSERT(c2 > c1);
// Misc
PEGASUS_TEST_ASSERT(a1 == b1);
PEGASUS_TEST_ASSERT(a1 == c1);
PEGASUS_TEST_ASSERT(b1 == a1);
PEGASUS_TEST_ASSERT(b1 == c1);
PEGASUS_TEST_ASSERT(c1 == a1);
PEGASUS_TEST_ASSERT(c1 == b1);
PEGASUS_TEST_ASSERT(a2 != b1);
PEGASUS_TEST_ASSERT(a2 != c1);
PEGASUS_TEST_ASSERT(b2 != a1);
PEGASUS_TEST_ASSERT(b2 != c1);
PEGASUS_TEST_ASSERT(c2 != a1);
PEGASUS_TEST_ASSERT(c2 != b1);
PEGASUS_TEST_ASSERT(a2 >= b1);
PEGASUS_TEST_ASSERT(a2 >= c1);
PEGASUS_TEST_ASSERT(b2 >= a1);
PEGASUS_TEST_ASSERT(b2 >= c1);
PEGASUS_TEST_ASSERT(c2 >= a1);
PEGASUS_TEST_ASSERT(c2 >= b1);
PEGASUS_TEST_ASSERT(a2 <= b3);
PEGASUS_TEST_ASSERT(a2 <= c3);
PEGASUS_TEST_ASSERT(b2 <= a3);
PEGASUS_TEST_ASSERT(b2 <= c3);
PEGASUS_TEST_ASSERT(c2 <= a3);
PEGASUS_TEST_ASSERT(c2 <= b3);
PEGASUS_TEST_ASSERT(a2 > b1);
PEGASUS_TEST_ASSERT(a2 > c1);
PEGASUS_TEST_ASSERT(b2 > a1);
PEGASUS_TEST_ASSERT(b2 > c1);
PEGASUS_TEST_ASSERT(c2 > a1);
PEGASUS_TEST_ASSERT(c2 > b1);
PEGASUS_TEST_ASSERT(a2 < b3);
PEGASUS_TEST_ASSERT(a2 < c3);
PEGASUS_TEST_ASSERT(b2 < a3);
PEGASUS_TEST_ASSERT(b2 < c3);
PEGASUS_TEST_ASSERT(c2 < a3);
PEGASUS_TEST_ASSERT(c2 < b3);
//Overflow testing
CQLValue real1(Real64(0.00000001));
CQLValue sint1(Sint64(-1));
CQLValue uint1(Sint64(1));
CQLValue uint2(Uint64(0));
PEGASUS_TEST_ASSERT(uint1 > sint1);
PEGASUS_TEST_ASSERT(real1 > sint1);
PEGASUS_TEST_ASSERT(uint2 > sint1);
PEGASUS_TEST_ASSERT(real1 > uint2);
CQLValue real2(Real64(25.00000000000001));
CQLValue real3(Real64(24.99999999999999));
CQLValue sint2(Sint64(25));
CQLValue uint3(Uint64(25));
PEGASUS_TEST_ASSERT(real2 > real3);
PEGASUS_TEST_ASSERT(real2 > sint2);
PEGASUS_TEST_ASSERT(real2 > uint3);
PEGASUS_TEST_ASSERT(real3 < sint2);
PEGASUS_TEST_ASSERT(real3 < uint3);
// String tests
CQLValue d1(String("HELLO"));
CQLValue d2(String("HEL"));
CQLValue d3(String("LO"));
CQLValue d4(String("AHELLO"));
CQLValue d5(String("ZHELLO"));
PEGASUS_TEST_ASSERT(d1 == d2 + d3);
PEGASUS_TEST_ASSERT(d1 != d2 + d4);
PEGASUS_TEST_ASSERT(d1 <= d5);
PEGASUS_TEST_ASSERT(d1 < d5);
PEGASUS_TEST_ASSERT(d1 >= d4);
PEGASUS_TEST_ASSERT(d1 > d4);
String str1("0x10");
String str2("10");
String str3("10B");
String str4("10.10");
CQLValue e1( str1, CQLValue::Hex);
CQLValue e2( str2, CQLValue::Decimal);
CQLValue e3( str3, CQLValue::Binary);
CQLValue e4( str4, CQLValue::Real);
CQLValue e5(Uint64(16));
CQLValue e6(Uint64(10));
CQLValue e7(Uint64(2));
CQLValue e8(Real64(10.10));
PEGASUS_TEST_ASSERT(e1 == e5);
PEGASUS_TEST_ASSERT(e2 == e6);
PEGASUS_TEST_ASSERT(e3 == e7);
PEGASUS_TEST_ASSERT(e4 == e8);
Array<Uint64> array1;
array1.append(1);
array1.append(2);
array1.append(3);
array1.append(4);
array1.append(5);
array1.append(6);
array1.append(7);
array1.append(8);
array1.append(9);
array1.append(10);
Array<Sint64> array2;
array2.append(1);
array2.append(2);
array2.append(3);
array2.append(4);
array2.append(5);
array2.append(6);
array2.append(7);
array2.append(8);
array2.append(9);
array2.append(10);
array2.append(3);
Array<Real64> array3;
array3.append(1.00);
array3.append(2.00);
array3.append(3.00);
array3.append(9.00);
array3.append(10.00);
array3.append(3.00);
array3.append(4.00);
array3.append(5.00);
array3.append(6.00);
array3.append(7.00);
array3.append(8.00);
Array<Uint64> array4;
array4.append(1);
array4.append(23);
array4.append(3);
array4.append(4);
array4.append(5);
array4.append(6);
array4.append(7);
array4.append(88);
array4.append(9);
array4.append(10);
Array<Sint64> array5;
array5.append(-1);
array5.append(2);
array5.append(3);
array5.append(4);
array5.append(5);
array5.append(-6);
array5.append(7);
array5.append(8);
array5.append(9);
array5.append(10);
array5.append(-3);
Array<Real64> array6;
array6.append(1.23);
array6.append(2.00);
array6.append(3.00);
array6.append(9.00);
array6.append(10.00);
array6.append(3.00);
array6.append(4.14);
array6.append(5.00);
array6.append(6.00);
array6.append(7.00);
array6.append(8.00);
CIMValue cv1(array1);
CIMValue cv2(array2);
CIMValue cv3(array3);
CIMValue cv4(array4);
CIMValue cv5(array5);
CIMValue cv6(array6);
CQLValue vr1(cv1);
CQLValue vr2(cv1);
CQLValue vr3(cv2);
CQLValue vr4(cv3);
CQLValue vr5(cv4);
CQLValue vr6(cv5);
CQLValue vr7(cv6);
PEGASUS_TEST_ASSERT(vr1 == vr2);
PEGASUS_TEST_ASSERT(vr1 == vr3);
PEGASUS_TEST_ASSERT(vr1 == vr4);
PEGASUS_TEST_ASSERT(vr4 == vr3);
PEGASUS_TEST_ASSERT(vr1 != vr5);
PEGASUS_TEST_ASSERT(vr3 != vr6);
PEGASUS_TEST_ASSERT(vr4 != vr7);
const CIMName _cimName(String("CIM_OperatingSystem"));
CIMInstance _i1(_cimName);
CIMProperty _p1(CIMName("Description"),CIMValue(String("Dave Rules")));
CIMProperty _p2(CIMName("EnabledState"),CIMValue(Uint16(2)));
CIMProperty _p3(CIMName("CurrentTimeZone"),CIMValue(Sint16(-600)));
CIMProperty _p4(CIMName("TimeOfLastStateChange"),
CIMValue(CIMDateTime(String("20040811105625.000000-360"))));
_i1.addProperty(_p1);
_i1.addProperty(_p2);
_i1.addProperty(_p3);
_i1.addProperty(_p4);
CIMInstance _i2(_cimName);
CIMProperty _p5(CIMName("Description"),
CIMValue(String("Dave Rules Everything")));
CIMProperty _p6(CIMName("EnabledState"),CIMValue(Uint16(2)));
CIMProperty _p7(CIMName("CurrentTimeZone"),CIMValue(Sint16(-600)));
CIMProperty _p8(CIMName("TimeOfLastStateChange"),
CIMValue(CIMDateTime(String("20040811105625.000000-360"))));
_i2.addProperty(_p5);
_i2.addProperty(_p6);
_i2.addProperty(_p7);
_i2.addProperty(_p8);
CQLValue cql1(_i1);
CQLValue cql2(_i1);
CQLValue cql3(_i2);
CQLValue cql4(_i2);
//PEGASUS_TEST_ASSERT(cql1 == cql1);
return;
}
texture_data make_texture_data(ID3D11Device* p_device, ID3D11DeviceContext* p_ctx,
texture_type type, ID3D11Texture2D* p_tex)
{
assert(p_device);
assert(p_ctx);
assert(type != texture_type::unknown);
assert(p_tex);
// create a staging texture & fill it with p_tex data.
D3D11_TEXTURE2D_DESC desc;
p_tex->GetDesc(&desc);
desc.Usage = D3D11_USAGE_STAGING;
desc.BindFlags = 0;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
desc.MiscFlags = desc.MiscFlags & (~D3D11_RESOURCE_MISC_GENERATE_MIPS);
com_ptr<ID3D11Texture2D> p_tex_staging;
HRESULT hr = p_device->CreateTexture2D(&desc, nullptr, &p_tex_staging.ptr);
assert(hr == S_OK);
p_ctx->CopyResource(p_tex_staging, p_tex);
#ifdef SPARKI_DEBUG
if (type == texture_type::texture_cube) assert(desc.ArraySize == 6);
#endif // SPAKIR_DEBUG
// create a texture_data object
texture_data td(type, uint3(desc.Width, desc.Height, 1),
desc.MipLevels, desc.ArraySize, make_pixel_format(desc.Format));
const size_t fmt_byte_count = byte_count(td.format);
uint8_t* ptr = td.buffer.data();
// for each array slice
// for each mipmap level of the slice
// map p_tex_tmp[array_slice][mipmap_level] and copy its' contents into the texture_data object.
for (UINT a = 0; a < desc.ArraySize; ++a) {
for (UINT m = 0; m < desc.MipLevels; ++m) {
const UINT index = D3D11CalcSubresource(m, a, desc.MipLevels);
D3D11_MAPPED_SUBRESOURCE map;
hr = p_ctx->Map(p_tex_staging, index, D3D11_MAP_READ, 0, &map);
assert(hr == S_OK);
const UINT w = desc.Width >> m;
const UINT h = desc.Height >> m;
const size_t mip_bc = w * h * fmt_byte_count;
assert(mip_bc > 0);
assert(mip_bc <= map.DepthPitch);
if (mip_bc == map.DepthPitch) {
std::memcpy(ptr, map.pData, mip_bc);
ptr += mip_bc;
}
else {
uint8_t* p_src = reinterpret_cast<uint8_t*>(map.pData);
const size_t row_bc = w * fmt_byte_count;
// Note(MSDN): The runtime might assign values to RowPitch and DepthPitch
// that are larger than anticipated because there might be padding between rows and depth.
// https://msdn.microsoft.com/en-us/library/windows/desktop/ff476182(v=vs.85).aspx
for (size_t row = 0; row < h; ++row) {
std::memcpy(ptr, p_src, row_bc);
p_src += map.RowPitch;
ptr += row_bc;
}
}
p_ctx->Unmap(p_tex_staging, index);
}
}
return td;
}
