Ejemplo n.º 1
0
void HDRImage3f::getHDRImage1f (HDRImage1f* out, FuncF3toF* func, uint2 append)
{
	uint2 sizeAvailable = out->getSize ();
	uint2 sizeAppend = out->getAppendSize ();
	if (sizeAvailable != getSize() || sizeAppend != append)
		out->setSize (sizeAvailable, sizeAppend);

	uint2 sizeTotal = out->getTotalSize ();
		
	out->setMult (m_mult);
	for (uint y = 0; y < sizeAvailable.y; y++)
	{
		float* r = getRedBuffer (uint2(0,y));
		float* g = getGreenBuffer (uint2(0,y));
		float* b = getBlueBuffer (uint2(0,y));
		float* a = out->getBuffer (uint2(0,y));
		for (uint x = 0; x < sizeAvailable.x; x++)
		{
			*a = (*func) (float3(*r, *g, *b));
			a++;
			r++;
			g++;
			b++;
		}
	}
}
Ejemplo n.º 2
0
int f_packing(ARG0) {

    unsigned char *p;
    unsigned int pack;
    if (mode >= 0) {
	p = sec[5];
	pack = code_table_5_0(sec);

	if (mode >= 0) {
	    sprintf(inv_out,"packing=");
	    inv_out += strlen(inv_out);

	    if (pack <= sizeof (packing_msg) / sizeof (p)) {
		sprintf(inv_out,"%s", packing_msg[pack]);
	    }
	    else if (pack == 40 || pack == 40000) {
	        sprintf(inv_out,"JPEG2000");
	    }
	    else if (pack == 41 || pack == 40010) {
	        sprintf(inv_out,"PNG");
	    }
	    else if (pack == 50) {
	        sprintf(inv_out,"Simple,Spherical Harmonic");
	    }
	    else if (pack == 51) {
	        sprintf(inv_out,"Complex,Spherical Harmonic");
	    }
	    else if (pack == 255) {
	        sprintf(inv_out,"missing");
	    }
	    else {
	        sprintf(inv_out,"unknown packing");
	    }
	    inv_out += strlen(inv_out);
	}
	if (mode > 0) {
            if (pack == 0) {
                sprintf(inv_out," val=(%lg+i)*2^%d*10^%d, i=0..%d (#bits=%d)", 
                ieee2flt(p+11), int2(p+15), -int2(p+17), (1 << p[19])-1, p[19]);
	    }
	    if (pack == 50) {
                sprintf(inv_out," val=(%lg+i)*2^%d*10^%d, i=0..%d (#bits=%d) global_mean=%lg", 
                ieee2flt(p+11), int2(p+15), -int2(p+17), (1 << p[19])-1, p[19], ieee2flt(p+20));
	    }
	    if (pack == 51) {
                sprintf(inv_out," val=(%lg+i)*2^%d*10^%d, i=0..%d (#bits=%d)", 
                ieee2flt(p+11), int2(p+15), -int2(p+17), (1 << p[19])-1, p[19]);
	        inv_out += strlen(inv_out);
		sprintf(inv_out," P-Laplacian scaling factor*10^-6=%d",int4(p+20));
	        inv_out += strlen(inv_out);
		sprintf(inv_out," Js=%d Ks=%d Ms=%d Ts=%d", uint2(p+24), uint2(p+26), uint2(p+28), 
			int4(p+30));
	        inv_out += strlen(inv_out);
		sprintf(inv_out," code_table_5.7=%d", (int) p[34]);
/*		sprintf(inv_out," mean?=%lg", ieee2flt(sec[7]+5)); */
	    }
        }
    }
    return 0;
}
Ejemplo n.º 3
0
SDL_Surface* HDRImage3f::getSDLSurface (float multCoef, SDL_Surface* surface, uint2 surfaceSize)
{
	uint2 size = uint2::getMin (getSize(), surfaceSize);
	if (surface != NULL)
	{
		if ((surface->w != size.x) || (surface->h != size.y) || (surface->format->BitsPerPixel != 32))
		{	
			SDL_FreeSurface (surface);
			surface = NULL;
		}
	}
	if (! surface)
	{
		surface = SDL_CreateRGBSurface(SDL_SWSURFACE, 
			size.x, size.y, 32,
			0x000000ff, 0x0000ff00, 0x00ff0000, 0x00000000);
	}
	float* inr (m_red);
	float* ing (m_green);
	float* inb (m_blue);

	SDL_LockSurface (surface);
	uint* outpix = (uint*) surface->pixels;
	multCoef *= 256.0;
	//uint2 size = getSize();
	for (uint y = 0; y < size.y; y++)
	{
		inr = getRedBuffer (uint2(0, y));
		ing = getGreenBuffer (uint2(0, y));
		inb = getBlueBuffer (uint2(0, y));
		outpix = (uint*) ((uchar*) surface->pixels + surface->pitch*y);
		for (uint x = 0; x < size.x; x++)
		{
			uchar ucr = toUchar (*inr, multCoef);
			uchar ucg = toUchar (*ing, multCoef);
			uchar ucb = toUchar (*inb, multCoef);
			uchar uca = 0;
			*outpix = ucr << 0 | ucg <<  8 | ucb << 16 | uca << 24;
			inr++;
			ing++;
			inb++;
			outpix++;
		}
		//inr += m_appendSize.x;
		//ing += m_appendSize.x;
		//inb += m_appendSize.x;
	}
	SDL_UnlockSurface (surface);
	return surface;
}
Ejemplo n.º 4
0
bool HDRImage3f::loadFromHDRFile (cchar* pathname, uint2 appendMult, 
				uint2 appendAdd)
{
	HDRLoaderResult res;
	bool bres = HDRLoader::load (pathname, res);
	if (false == bres)
		return false;
	uint2 available = uint2 (res.width, res.height);
	uint2 append = available*appendMult + appendAdd;
	setSize (available, append);

	uint countReals = m_totalSize.getArea();
	m_red = ::fftwf_alloc_real (countReals);
	m_green = ::fftwf_alloc_real (countReals);
	m_blue = ::fftwf_alloc_real (countReals);
	for (uint y = 0; y < getSize().y; y++)
		for (uint x = 0; x < getSize().x; x++)
		{
			uint offsetSrc = x + y*res.width;
			uint offsetDst = getOffset (x, y);
			m_red[offsetDst] = res.cols [offsetSrc*3];
			m_green[offsetDst] = res.cols [offsetSrc*3+1];
			m_blue[offsetDst] = res.cols [offsetSrc*3+2];
		}
	clearAppendArea ();
	return true;
}
Ejemplo n.º 5
0
/*
 * HEADER:400:Sec5:inv:0:Sec 5 values (Data representation section)
 */
int f_Sec5(ARG0) {
    if (mode >= 0) {
        sprintf(inv_out,"Sec5 len=%d #defined data points=%d Data Repr. Template=5.%d",
          uint4(&(sec[5][0])), uint4(&(sec[5][5])), uint2(&(sec[5][9])));
    }
    return 0;
}
Ejemplo n.º 6
0
namespace configuration
{
	uint2 client_dimensions = uint2(1680, 900);
	bool  client_windowed = false;
    int   v_sync = 1;
	uint2 virtual_dimensions = client_dimensions;
	bool  fxaa = true;
}
Ejemplo n.º 7
0
int code_table_4_233(unsigned char **sec) {
    unsigned char *p;
    int i;
    p = code_table_4_233_location(sec);
    if (p == NULL) return -1;
    i = uint2(p);
    return i;
}
Ejemplo n.º 8
0
void HDRImage3f::getSubImage (PtrHDRImage3f& outimg, uint2 size, float2 reloffsetMin, float2 reloffsetMax)
{
	if (! outimg.get())
		outimg = PtrHDRImage3f (new HDRImage3f);
	outimg->setSize (size);
	outimg->setMult (getMult());
	float2 step = (getSize().get<float>() * (float2(1.0f,1.0f) - reloffsetMin- reloffsetMax)/ size.get<float>()) ;
	HDRImage3f midresult (uint2(outimg->getSize().x, getSize().y));
	{
		float3* in = new float3[getSize().x];
		float3* out = new float3[outimg->getSize().x];
		for (uint y = 0; y < getSize().y; y++)
		{
			for (uint x = 0; x < getSize().x; x++)
				in[x] = getPixel (uint2(x,y));
			
			if (step.x < 1.0f)
				remapLanczosFilter (in, getSize().x, out, size.x, float2(reloffsetMin.x, reloffsetMax.x));
			else
				remapAverage (in, getSize().x, out, size.x, float2(reloffsetMin.x, reloffsetMax.x));

			for (uint x = 0; x < size.x; x++)
				midresult.setPixel (uint2(x,y), out[x]);
		}
		delete [] (out);
		delete [] (in);
	}
	{
		float3* in = new float3[getSize().y];
		float3* out = new float3[outimg->getSize().y];
		for (uint x = 0; x < size.x; x++)
		{
			for (uint y = 0; y < getSize().y; y++)
				in[y] = midresult.getPixel (uint2(x,y));
			if (step.y < 1.0f)
				remapLanczosFilter (in, getSize().y, out, size.y, float2(reloffsetMin.y, reloffsetMax.y));
			else
				remapAverage (in, getSize().y, out, size.y, float2(reloffsetMin.y, reloffsetMax.y));

			for (uint y = 0; y < size.y; y++)
				outimg->setPixel (uint2(x,y), out[y]);
		}
		delete [] (out);
		delete [] (in);
	}
}
Ejemplo n.º 9
0
void HDRImage3c::rfftplanUpdate ()
{
	uint2 total = getTotalSize()-uint2(0,2);
	m_rfftplanR = fftwf_plan_dft_c2r_2d (total.y, total.x, 
			m_red, m_hdriRFFT->getRedBuffer(), FFTW_MEASURE);
	m_rfftplanG = fftwf_plan_dft_c2r_2d (total.y, total.x, 
			m_green, m_hdriRFFT->getGreenBuffer(), FFTW_MEASURE);
	m_rfftplanB = fftwf_plan_dft_c2r_2d (total.y, total.x, 
			m_blue, m_hdriRFFT->getBlueBuffer(), FFTW_MEASURE);
}
Ejemplo n.º 10
0
	bool filter(Image_buffer<rendering::Color4c>& destination, const Image_buffer<rendering::Color4c>& source) const
	{
		if (destination.format() != source.format()
		||  destination.dimensions() != source.dimensions())
		{
			return false;
		}

//		const __m128 m4x255f = _mm_set_ps1(255.f);

		for (uint32_t y = 0; y < source.dimensions().y; ++y)
		{
			for (uint32_t x = 0; x < source.dimensions().x; ++x)
			{
				const rendering::Color4c& source_color = source.get(uint2(x, y));
/*
				__m128i mi = _mm_set_epi32(source_color.b, source_color.g, source_color.r, 0);

				__m128 ma = _mm_cvtepi32_ps(mi);
				__m128 mb = _mm_set_ps1(factor_);

				__m128 m_mul = _mm_mul_ps(ma, mb);

				__m128 m_min =_mm_min_ps(m_mul, m4x255f);

				mi = _mm_cvtps_epi32(m_min);

				rendering::Color4c modulated(mi.m128i_i32[3], mi.m128i_i32[2], mi.m128i_i32[1], 255);
				*/

				rendering::Color4c modulated((unsigned char)(std::min(factor_ * float(source_color.r), 255.f)),
											 (unsigned char)(std::min(factor_ * float(source_color.g), 255.f)),
											 (unsigned char)(std::min(factor_ * float(source_color.b), 255.f)),
											 255);

				destination.set(uint2(x, y), modulated);
			}
		}

		return true;
	}
Ejemplo n.º 11
0
boost::shared_ptr<HDRImage3f> HDRImage3c::computeRFFT ()
{
	if (! m_hdriRFFT.get())
		m_hdriRFFT = boost::shared_ptr<HDRImage3f> (new HDRImage3f);
	uint2 size = (getSize()-uint2(0,1))*uint2(1,2);
	uint2 append = (getTotalSize()-uint2(0,1))*uint2(1,2)-size;
	if (size != m_hdriRFFT->getSize() || append != m_hdriRFFT->getAppendSize())
		m_hdriRFFT->setSize (size, append);
	if (m_rfftplanNeedUpdate)
	{
		rfftplanUpdate ();			
		m_rfftplanNeedUpdate = false;
	}

	m_hdriRFFT->setMult (getMult()/m_hdriRFFT->getTotalSize().getArea());

	fftwf_execute (m_rfftplanR);
	fftwf_execute (m_rfftplanG);
	fftwf_execute (m_rfftplanB);
	return m_hdriRFFT;
}
Ejemplo n.º 12
0
	bool filter(Image_buffer<rendering::Color4>& destination, const Image_buffer<rendering::Color4>& source) const
	{
		if (destination.format() != source.format()
		||  destination.dimensions() != source.dimensions())
		{
			return false;
		}

		for (uint32_t y = 0; y < source.dimensions().y; ++y)
		{
			for (uint32_t x = 0; x < source.dimensions().x; ++x)
			{
				const rendering::Color4& source_color = source.get(uint2(x, y));

				rendering::Color4 modulated(factor_ * source_color.r, factor_ * source_color.g, factor_ * source_color.b, 1.f);

				destination.set(uint2(x, y), modulated);
			}
		}

		return true;
	}
Ejemplo n.º 13
0
void copyHDRImage (HDRImage1f* hdriDst, HDRImage1f* hdriSrc,
		uint2 dstOrg, uint2 srcOrg, uint2 size)
{
	uint offminx = -std::min<int>(dstOrg.x, std::min<int>(srcOrg.x,0));
	uint offmaxx = size.x-std::min<uint>(hdriDst->getSize().x-dstOrg.x, std::min<uint> (hdriSrc->getSize().x-srcOrg.x, size.x));
	uint sizex = size.x - offminx - offmaxx;
	uint sx = srcOrg.x + offminx;
	uint dx = dstOrg.x + offminx;
	uint sizeofLine = sizex*sizeof(float);

	for (uint y = 0; y < size.y; y++)
	{
		uint dy = dstOrg.y + y;
		uint sy = srcOrg.y + y;
		if (dy < 0 || dy >= hdriDst->getSize().y)
			continue;
		if (sy < 0 || sy >= hdriSrc->getSize().y)
			continue;
		
		memcpy (hdriDst->getBuffer (uint2(dx, dy)),  hdriSrc->getBuffer (uint2 (sx, sy)),  sizeofLine);
	}
}
Ejemplo n.º 14
0
int code_table_4_230(unsigned char **sec) {
    int val, i;
    val = GB2_ProdDefTemplateNo(sec);
    switch (val) {
        case 40: 
	case 41:
	case 42:
	case 43:
		i = uint2(sec[4]+11); break;
        default: i = -1; break;
    }
    return i;
}
Ejemplo n.º 15
0
	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_);
	}
Ejemplo n.º 16
0
int CALLBACK MyFontFamProc(ENUMLOGFONTA FAR* lpelf,
                           NEWTEXTMETRICA FAR* lpntm,
                           int FontType, LPARAM lParam)
{
	switch (lParam)
	{
	case FQ_NAMES:
		epptr->concatcstring(lpelf->elfLogFont.lfFaceName, EC_RETURN, nfonts++ == 0);
		break;
	case FQ_SIZES:
		if (!(FontType & TRUETYPE_FONTTYPE))
		{ //if not true-type font
			uint2 size = uint2((((lpelf->elfLogFont.lfHeight * 72)
			               / SCREEN_WIDTH_FOR_FONT_USE) * 8 / 7));
			uint2 i;
			for (i = 0; i < nfonts; i++)
				if (sizes[i] == size)
					return True; //return to callback function again
			MCU_realloc((char **)&sizes, nfonts, nfonts + 1, sizeof(uint2));
			sizes[nfonts] = size;
			epptr->concatuint(size, EC_RETURN, nfonts++ == 0);
			break;
		}
		else
		{ //if true-type font, size is always 0.
			epptr->concatuint(0, EC_RETURN, nfonts++ == 0);
			return False; //stop right here. no more callback function
		}
	case FQ_STYLES:
		{
			if (!(FontType & TRUETYPE_FONTTYPE))
			{ //not true-type font
				epptr->setstaticcstring("plain\nbold\nitalic\nbold-italic");
				return False;  //stop right here, do not continue looping through callback
			}
			char *style = (char *)lpelf->elfStyle;
			if (strequal(style, "Regular"))
				epptr->concatcstring("plain", EC_RETURN, nfonts++ == 0);
			else if (strequal(style, "Bold Italic"))
				epptr->concatcstring("bold-italic", EC_RETURN, nfonts++ == 0);
			else
				epptr->concatcstring((char*)lpelf->elfStyle, EC_RETURN, nfonts++ == 0);
			break;
		}
	default:
		break;
	}
	return True;
}
Ejemplo n.º 17
0
void MCStack::setgeom()
{
	if (MCnoui || !opened)
		return;

	// MW-2009-09-25: Ensure things are the right size when doing
	//   remote dialog/menu windows.
	if (window == DNULL)
	{
		state &= ~CS_NEED_RESIZE;
		// MW-2011-08-18: [[ Redraw ]] Update to use redraw.
		MCRedrawLockScreen();
		resize(rect . width, rect . height);
		MCRedrawUnlockScreen();
		mode_setgeom();
		return;
	}

	uint32_t wstyle, exstyle;
	getstyle(wstyle, exstyle);
	RECT newrect = getwrect(rect, wstyle, exstyle);
	RECT wrect;
	GetWindowRect((HWND)window->handle.window, &wrect);
	LONG cx = newrect.right - newrect.left;
	LONG cy = newrect.bottom - newrect.top;
	state &= ~CS_NEED_RESIZE;
	if (wrect.right - wrect.left != cx || wrect.bottom - wrect.top != cy
	        || newrect.left != wrect.left || newrect.top != wrect.top)
	{
		state |= CS_NO_CONFIG;
		MoveWindow((HWND)window->handle.window, newrect.left, newrect.top, cx, cy, True);
		if (wrect.right - wrect.left != cx || wrect.bottom - wrect.top != cy)
			resize(uint2(wrect.right - wrect.left), uint2(wrect.bottom - wrect.top));
		state &= ~CS_NO_CONFIG;
	}
}
Ejemplo n.º 18
0
bool HDRImage3f::loadFromFile (cchar* pathname, uint2 appendMult, uint2 appendAdd)
{
	if ((strlen(pathname)>4) && !(strcmp (".hdr", pathname+strlen(pathname)-4)))
		return loadFromHDRFile (pathname, appendMult, appendAdd);
	
	SDL_Surface* surf = IMG_Load (pathname);
	if (surf == NULL)
		return false;

	assert (surf->format->BitsPerPixel == 24 || surf->format->BitsPerPixel == 32);
	uint2 available = uint2 (surf->w, surf->h);
	uint2 append = available - available*appendMult + appendAdd;
	setSize (available, append);
	uint countReals = m_totalSize.getArea();
	m_red = ::fftwf_alloc_real (countReals);
	m_green = ::fftwf_alloc_real (countReals);
	m_blue = ::fftwf_alloc_real (countReals);

	SDL_LockSurface (surf);
	uint width = surf->w;
	uint* outpix = (uint*) surf->pixels;
	uint2 size = getSize();
	float* r = m_red;
	float* g = m_green;
	float* b = m_blue;
	uchar* inpix = ((uchar*)surf->pixels);
	uint offX = surf->format->BitsPerPixel / 8;
	for (uint y = 0; y < size.y; y++)
	{
		for (uint x = 0; x < size.x; x++)
		{
			uint offsetSrc = offX*x + y*surf->pitch;
			*r = ((float) inpix[offsetSrc+0])/256;
			*g = ((float) inpix[offsetSrc+1])/256;
			*b = ((float) inpix[offsetSrc+2])/256;
			r++;
			g++;
			b++;
		}
		r += m_appendSize.x;
		g += m_appendSize.x;
		b += m_appendSize.x;
	}
	SDL_UnlockSurface (surf);
	SDL_FreeSurface (surf);

	return true;
}
Ejemplo n.º 19
0
void copyHDRImage (HDRImage3c* hdriDst, HDRImage1f* hdriSrc)
{
	assert (hdriDst->getTotalSize () == hdriSrc->getTotalSize()/uint2(1,2));

	uint2 size = hdriDst->getTotalSize ();
	{
		float* dst = (float*) hdriDst->getRedBuffer ();
		float* src = (float*) hdriSrc->getBuffer ();
		for (uint y = 0; y < size.y; y++)
			for (uint x = 0; x < size.x; x++)
				for (uint i = 0; i < 2; i++)
				{
					*dst = *src;
					dst++;
					src++;
				}
	}
	{
		float* dst = (float*) hdriDst->getGreenBuffer ();
		float* src = (float*) hdriSrc->getBuffer ();
		for (uint y = 0; y < size.y; y++)
			for (uint x = 0; x < size.x; x++)
				for (uint i = 0; i < 2; i++)
				{
					*dst = *src;
					dst++;
					src++;
				}
	}
	{
		float* dst = (float*) hdriDst->getBlueBuffer ();
		float* src = (float*) hdriSrc->getBuffer ();
		for (uint y = 0; y < size.y; y++)
			for (uint x = 0; x < size.x; x++)
				for (uint i = 0; i < 2; i++)
				{
					*dst = *src;
					dst++;
					src++;
				}
	}
}
Ejemplo n.º 20
0
int f_hybrid(ARG0) {
    int pdtsize, n, secsize, k;
    if (mode >= 0) {
	pdtsize =  prod_def_temp_size(sec);     // size of PDT with no extra vert coordinates
	secsize = GB2_Sec4_size(sec);		// size of PDT + vert coordinatese + extras
        n = uint2(&(sec[4][5]));                // number of vert coordinate values
	if (n % 2 != 0) fatal_error_i("vertical coordinate parameters should be in pairs, n=%d", n);
	if (n == 0) return 0;
	if (pdtsize + 4*n > secsize) 
	    fatal_error("not enough space allocated for vertical coordinate data","");
	sprintf(inv_out,"Hybrid levels=%d", n/2);
	inv_out += strlen(inv_out);
	for (k = 1; k <= n/2; k++) {
	    sprintf(inv_out," %d=(%9.6f,%9.6f)", k, (double) ieee2flt(sec[4]+pdtsize+k*8-8),
		(double) ieee2flt(sec[4]+pdtsize+k*8-4));
	    inv_out += strlen(inv_out);
	}
    }
    return 0;
}
Ejemplo n.º 21
0
	GpuFftCS5::GpuFftCS5(uint32_t width, uint32_t height, bool forward)
			: width_(width), height_(height), forward_(forward)
	{
		RenderFactory& rf = Context::Instance().RenderFactoryInstance();

		tmp_real_tex_[0] = rf.MakeTexture2D(width, height, 1, 1, EF_ABGR32F, 1, 0, EAH_GPU_Read | EAH_GPU_Unordered, nullptr);
		tmp_imag_tex_[0] = rf.MakeTexture2D(width, height, 1, 1, EF_ABGR32F, 1, 0, EAH_GPU_Read | EAH_GPU_Unordered, nullptr);

		tmp_real_tex_[1] = rf.MakeTexture2D(width, height, 1, 1, EF_ABGR32F, 1, 0, EAH_GPU_Read | EAH_GPU_Unordered, nullptr);
		tmp_imag_tex_[1] = rf.MakeTexture2D(width, height, 1, 1, EF_ABGR32F, 1, 0, EAH_GPU_Read | EAH_GPU_Unordered, nullptr);

		effect_ = SyncLoadRenderEffect("FFT.fxml");
		radix008a_tech_ = effect_->TechniqueByName("FFTRadix008A5");
		radix008a_final_x_tech_ = effect_->TechniqueByName("FFTRadix008AFinalX5");
		radix008a_final_y_tech_ = effect_->TechniqueByName("FFTRadix008AFinalY5");

		*(effect_->ParameterByName("tex_width_height")) = uint2(width - 1, height - 1);

		*(effect_->ParameterByName("forward")) = static_cast<int32_t>(forward_);
		*(effect_->ParameterByName("scale")) = 1.0f / (width_ * height_);
	}
Ejemplo n.º 22
0
#include "Image/Filter/To_BGRA.hpp"
#include "Image_storage/Image_writer.hpp"

#include "Math/Vector.inl"

#include <QFileDialog>
#include <QColorDialog>
#include <QPixmap>
#include <QProgressBar>
#include <QMessageBox>

QImage to_QImage(const Image_buffer<rendering::Color4c>& source);

const std::string Main_window::s_settings_file_name = "settings.txt";

const uint2 Main_window::s_thumbnail_dimensions = uint2(192, 192);

Main_window::Main_window(QWidget *parent) :
	QMainWindow(parent),
	ui(new Ui::Main_window),
	thumbnail_provider_(image_provider_, s_thumbnail_dimensions)
{
    ui->setupUi(this);

	settings_.load(s_settings_file_name);

	ui->material_name_line_edit_->setText("Material_name");

	ui->color_image_controls_->init(3, rendering::Color3(0.75f, 0.75f, 0.75f), true, &thumbnail_provider_);
	ui->opacity_image_controls_->init(1, rendering::Color3(1.f, 1.f, 1.f), true, &thumbnail_provider_);
	ui->emissive_image_controls_->init(1, rendering::Color3(0.f, 0.f, 0.f), true, &thumbnail_provider_);
Ejemplo n.º 23
0
Archivo: JMA.c Proyecto: erget/wgrib2
/*
 * HEADER:400:JMA:inv:0:inventory for JMA locally defined PDT
 */
int f_JMA(ARG0) {
    int pdt, i, nr;

    int center; 
    if (mode < 0) return 0;
    center = GB2_Center(sec);
    if (center != JMA1 && center != JMA2) return 0;
    pdt = GB2_ProdDefTemplateNo(sec);
    if (pdt < 50000) return 0;
    if (pdt == 51022) {
	sprintf(inv_out,"site=%c%c%c%c", sec[4][24], sec[4][25], sec[4][26], sec[4][27]);
	inv_out += strlen(inv_out);
	if (mode >= 1) {
	    sprintf(inv_out,":site_id#=%u", uint2(sec[4]+28));
	    inv_out += strlen(inv_out);

	    sprintf(inv_out,":site_lon=%lf:site_lat=%lf:site_elev=%.1lfm",int4(sec[4]+18)*1e-6,
		int4(sec[4]+14)*1e-6,int2(sec[4]+22)*0.1) ;
	    inv_out += strlen(inv_out);

	    sprintf(inv_out,":mag_dec=%.2fdeg", int2(sec[4]+30)*0.001);
	    inv_out += strlen(inv_out);

	    sprintf(inv_out,":freq=%ukHz", uint4(sec[4]+32));
	    inv_out += strlen(inv_out);
	    sprintf(inv_out,":pol=%d:opn_mode=%d:reflec=%d", (int) sec[4][36], (int) sec[4][37], (int) sec[4][38]);
	    inv_out += strlen(inv_out);
	    sprintf(inv_out,":qc=%d:cluster_filter=%d", (int) sec[4][39], (int) sec[4][40]);
	    inv_out += strlen(inv_out);
	    sprintf(inv_out,":angle_elev_constant=%.2f", int2(sec[4]+41)*0.01);
	    inv_out += strlen(inv_out);
	}

	nr = GB2_Sec4_size(sec);
	nr = (nr % 4) ? -1 : (nr - 60) / 4;

	if (mode >= 1) {
	    sprintf(inv_out,":Ntheta=%d", nr);
	    inv_out += strlen(inv_out);

	    i = uint_n(sec[4]+55, 3);
	    if (i != 0xffffff) {
	        sprintf(inv_out,":bin_size=%dm", i);
	        inv_out += strlen(inv_out);
	    }
	    if ((sec[4][58] != 255) || (sec[4][59] != 255)) {
	        sprintf(inv_out,":d_theta=%.1lfdeg", int2(sec[4]+58)*0.1);
	        inv_out += strlen(inv_out);
	    }
	}


	if (mode < 2) {
	    sprintf(inv_out,":ele(1)=%.2fdeg", int2(sec[4]+60)*0.01);
	    inv_out += strlen(inv_out);
	    sprintf(inv_out,":ele(%d)=%.2fdeg", nr/2,int2(sec[4]+60+((nr-1)/2)*4)*0.01);
	    inv_out += strlen(inv_out);
	}
	if (mode >= 2) {
	    sprintf(inv_out,"\n:elevation angle(1..Ntheta)=");
	    inv_out += strlen(inv_out);
	    for (i = 0; i < nr; i++) {
		sprintf(inv_out,"%.2f ", int2(sec[4]+60+i*4)*0.01);
		inv_out += strlen(inv_out);
	    }
	    sprintf(inv_out,"\n:pulse repetion freq(1..Ntheta)=");
	    inv_out += strlen(inv_out);
	    for (i = 0; i < nr; i++) {
		sprintf(inv_out,"%.2f ", int2(sec[4]+62+i*4)*0.01);
		inv_out += strlen(inv_out);
	    }
        }
    }
    return 0;
}
Ejemplo n.º 24
0
	void GpuFftCS5::Execute(TexturePtr const & out_real, TexturePtr const & out_imag,
			TexturePtr const & in_real, TexturePtr const & in_imag)
	{
		RenderFactory& rf = Context::Instance().RenderFactoryInstance();
		RenderEngine& re = rf.RenderEngineInstance();

		FrameBufferPtr old_fb = re.CurFrameBuffer();
		re.BindFrameBuffer(FrameBufferPtr());

		int index = 0;

		// X direction

		{
			uint32_t istride = width_ / 8;
			float phase_base = -PI2 / width_;

			*(effect_->ParameterByName("ostride2")) = uint2(width_ / 8, 0);
			*(effect_->ParameterByName("iscale2")) = uint2(8, 1);

			*(effect_->ParameterByName("istride2")) = uint4(istride, 0, istride - 1, static_cast<uint32_t>(-1));
			*(effect_->ParameterByName("phase_base2")) = phase_base;
			this->Radix008A(tmp_real_tex_[index], tmp_imag_tex_[index], in_real, in_imag, width_ / 8, height_, 1 == istride, false);
			index = !index;

			uint32_t t = width_;
			while (t > 8)
			{
				istride /= 8;
				phase_base *= 8;
				*(effect_->ParameterByName("istride2")) = uint4(istride, 0, istride - 1, static_cast<uint32_t>(-1));
				*(effect_->ParameterByName("phase_base2")) = phase_base;
				this->Radix008A(tmp_real_tex_[index], tmp_imag_tex_[index], tmp_real_tex_[!index], tmp_imag_tex_[!index], width_ / 8, height_, 1 == istride, false);
				index = !index;

				t /= 8;
			}
		}

		// Y direction
		
		{
			uint32_t istride = height_ / 8;
			float phase_base = -PI2 / height_;

			*(effect_->ParameterByName("ostride2")) = uint2(0, height_ / 8);
			*(effect_->ParameterByName("iscale2")) = uint2(1, 8);

			*(effect_->ParameterByName("istride2")) = uint4(0, istride, static_cast<uint32_t>(-1), istride - 1);
			*(effect_->ParameterByName("phase_base2")) = phase_base;
			if (1 == istride)
			{
				this->Radix008A(out_real, out_imag, tmp_real_tex_[!index], tmp_imag_tex_[!index], width_, height_ / 8, false, 1 == istride);
			}
			else
			{
				this->Radix008A(tmp_real_tex_[index], tmp_imag_tex_[index], tmp_real_tex_[!index], tmp_imag_tex_[!index], width_, height_ / 8, false, 1 == istride);
			}
			index = !index;

			uint32_t t = height_;
			while (t > 8)
			{
				istride /= 8;
				phase_base *= 8;
				*(effect_->ParameterByName("istride2")) = uint4(0, istride, static_cast<uint32_t>(-1), istride - 1);
				*(effect_->ParameterByName("phase_base2")) = phase_base;
				if (1 == istride)
				{
					this->Radix008A(out_real, out_imag, tmp_real_tex_[!index], tmp_imag_tex_[!index], width_, height_ / 8, false, 1 == istride);
				}
				else
				{
					this->Radix008A(tmp_real_tex_[index], tmp_imag_tex_[index], tmp_real_tex_[!index], tmp_imag_tex_[!index], width_, height_ / 8, false, 1 == istride);
				}
				index = !index;

				t /= 8;
			}
		}

		re.BindFrameBuffer(old_fb);
	}
Ejemplo n.º 25
0
	void GpuFftCS4::Execute(TexturePtr const & out_real, TexturePtr const & out_imag,
			TexturePtr const & in_real, TexturePtr const & in_imag)
	{
		RenderFactory& rf = Context::Instance().RenderFactoryInstance();
		RenderEngine& re = rf.RenderEngineInstance();

		tex_fb_->Attach(FrameBuffer::ATT_Color0, rf.Make2DRenderView(*out_real, 0, 1, 0));
		tex_fb_->Attach(FrameBuffer::ATT_Color1, rf.Make2DRenderView(*out_imag, 0, 1, 0));

		FrameBufferPtr old_fb = re.CurFrameBuffer();
		re.BindFrameBuffer(FrameBufferPtr());

		*real_tex_ep_ = in_real;
		*imag_tex_ep_ = in_imag;
		
		uint32_t const thread_count = 3 * (width_ * height_) / 8;
		uint32_t ostride = width_ * height_ / 8;
		uint32_t istride = ostride;
		uint32_t istride3 = height_ / 8;
		uint32_t pstride = width_;
		float phase_base = -PI2 / (width_ * height_);

		*(effect_->ParameterByName("thread_count")) = thread_count;

		// X direction
		
		*(effect_->ParameterByName("ostride")) = ostride;
		*(effect_->ParameterByName("pstride")) = pstride;

		*(effect_->ParameterByName("istride")) = istride;
		*(effect_->ParameterByName("istride3")) = uint2(0, istride3);
		*(effect_->ParameterByName("phase_base")) = phase_base;
		this->Radix008A(tmp_buffer_, src_, thread_count, istride, true);

		GraphicsBufferPtr buf[2] = { dst_, tmp_buffer_ };
		int index = 0;

		uint32_t t = width_;
		while (t > 8)
		{
			istride /= 8;
			istride3 /= 8;
			phase_base *= 8.0f;
			*(effect_->ParameterByName("istride")) = istride;
			*(effect_->ParameterByName("istride3")) = uint2(0, istride3);
			*(effect_->ParameterByName("phase_base")) = phase_base;
			this->Radix008A(buf[index], buf[!index], thread_count, istride, false);
			index = !index;

			t /= 8;
		}

		// Y direction
		
		ostride = height_ / 8;
		pstride = 1;
		*(effect_->ParameterByName("ostride")) = ostride;
		*(effect_->ParameterByName("pstride")) = pstride;
		
		istride /= 8;
		istride3 /= 8;
		phase_base *= 8.0f;
		*(effect_->ParameterByName("istride")) = istride;
		*(effect_->ParameterByName("istride3")) = uint2(istride3, 0);
		*(effect_->ParameterByName("phase_base")) = phase_base;
		this->Radix008A(buf[index], buf[!index], thread_count, istride, false);
		index = !index;

		t = height_;
		while (t > 8)
		{
			istride /= 8;
			istride3 /= 8;
			phase_base *= 8.0f;
			*(effect_->ParameterByName("istride")) = istride;
			*(effect_->ParameterByName("istride3")) = uint2(istride3, 0);
			*(effect_->ParameterByName("phase_base")) = phase_base;
			this->Radix008A(buf[index], buf[!index], thread_count, istride, false);
			index = !index;

			t /= 8;
		}


		re.BindFrameBuffer(tex_fb_);

		re.Render(*buf2tex_tech_, *quad_layout_);

		re.BindFrameBuffer(old_fb);
	}
Ejemplo n.º 26
0
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;
}
Ejemplo n.º 27
0
 T &pixel(float2 uv)
 {
     uint2 coords = uint2(uv * float2(size));
     return pixel<T>(coords);
 }
Ejemplo n.º 28
0
 T &pixel(int2 coords)
 {
     return pixel<T>(uint2(max(int2(0), coords)));
 }
Ejemplo n.º 29
0
 uint2 unnormalized(float2 uv) const
 {
     return uint2(uv * float2(size));
 }
Ejemplo n.º 30
0
	AppInputTest (string testName, int countRenders = 1): UnitTest (testName), m_sof(new SharedObjectsFactory(uint2(1024,768)))
	{
		//m_countRenders = countRenders;
	}