示例#1
0
文件: FFT.cpp 项目: BobLChen/KlayGE
	GpuFftPS::GpuFftPS(uint32_t width, uint32_t height, bool forward)
		: width_(width), height_(height), forward_(forward)
	{
		BOOST_ASSERT(0 == (width_ & (width_ - 1)));
		BOOST_ASSERT(0 == (height_ & (height_ - 1)));

		log_x_ = static_cast<uint32_t>(log(static_cast<float>(width_)) / log(2.0f));
		log_y_ = static_cast<uint32_t>(log(static_cast<float>(height_)) / log(2.0f));

		lookup_i_wr_wi_x_tex_.resize(log_x_);
		lookup_i_wr_wi_y_tex_.resize(log_y_);

		std::vector<half> lookup_i_wr_wi_x(log_x_ * width_ * 4);
		std::vector<half> lookup_i_wr_wi_y(log_y_ * height_ * 4);

		this->CreateButterflyLookups(lookup_i_wr_wi_x, log_x_, width_);
		this->CreateButterflyLookups(lookup_i_wr_wi_y, log_y_, height_);

		RenderFactory& rf = Context::Instance().RenderFactoryInstance();

		half* ptr = &lookup_i_wr_wi_x[0];
		for (uint32_t i = 0; i < log_x_; ++ i)
		{
			ElementInitData init_data;
			
			init_data.data = ptr;
			init_data.row_pitch = width_ * sizeof(half) * 4;
			init_data.slice_pitch = init_data.row_pitch;
			lookup_i_wr_wi_x_tex_[i] = rf.MakeTexture2D(width_, 1, 1, 1, EF_ABGR16F, 1, 0, EAH_GPU_Read | EAH_Immutable, &init_data);
			ptr += width_ * 4;
		}

		ptr = &lookup_i_wr_wi_y[0];
		for (uint32_t i = 0; i < log_y_; ++ i)
		{
			ElementInitData init_data;
			
			init_data.data = ptr;
			init_data.row_pitch = sizeof(half) * 4;
			init_data.slice_pitch = init_data.row_pitch * height_;
			lookup_i_wr_wi_y_tex_[i] = rf.MakeTexture2D(1, height_, 1, 1, EF_ABGR16F, 1, 0, EAH_GPU_Read | EAH_Immutable, &init_data);
			ptr += height_ * 4;
		}

		tmp_real_tex_[0] = rf.MakeTexture2D(width_, height_, 1, 1, EF_ABGR32F, 1, 0, EAH_GPU_Read | EAH_GPU_Write, nullptr);
		tmp_real_tex_[1] = rf.MakeTexture2D(width_, height_, 1, 1, EF_ABGR32F, 1, 0, EAH_GPU_Read | EAH_GPU_Write, nullptr);
		tmp_imag_tex_[0] = rf.MakeTexture2D(width_, height_, 1, 1, EF_ABGR32F, 1, 0, EAH_GPU_Read | EAH_GPU_Write, nullptr);
		tmp_imag_tex_[1] = rf.MakeTexture2D(width_, height_, 1, 1, EF_ABGR32F, 1, 0, EAH_GPU_Read | EAH_GPU_Write, nullptr);

		fft_x_pp_ = SyncLoadPostProcess("FFT.ppml", "fft_x");
		fft_y_pp_ = SyncLoadPostProcess("FFT.ppml", "fft_y");
	}
示例#2
0
	void MultiResSILLayer::RSM(TexturePtr const & rt0_tex, TexturePtr const & rt1_tex, TexturePtr const & depth_tex)
	{
		std::string RSM2VPLsSpotName = "RSM2VPLsSpot";

		rsm_texs_[0] = rt0_tex;
		rsm_texs_[1] = rt1_tex;
		rsm_depth_tex_ = depth_tex;

		rsm_to_vpls_pps_[LightSource::LT_Spot] = SyncLoadPostProcess("RSM2VPLs.ppml", RSM2VPLsSpotName);
		rsm_to_vpls_pps_[LightSource::LT_Spot]->InputPin(0, rsm_texs_[0]);
		rsm_to_vpls_pps_[LightSource::LT_Spot]->InputPin(1, rsm_texs_[1]);
		rsm_to_vpls_pps_[LightSource::LT_Spot]->InputPin(2, rsm_depth_tex_);
		rsm_to_vpls_pps_[LightSource::LT_Spot]->InputPin(3, rsm_depth_derivative_tex_);
		rsm_to_vpls_pps_[LightSource::LT_Spot]->OutputPin(0, vpl_tex_);

		RenderFactory& rf = Context::Instance().RenderFactoryInstance();
		RenderDeviceCaps const & caps = rf.RenderEngineInstance().DeviceCaps();

		ElementFormat fmt;
		if (caps.rendertarget_format_support(EF_GR32F, 1, 0))
		{
			fmt = EF_GR32F;
		}
		else if (caps.rendertarget_format_support(EF_ABGR32F, 1, 0))
		{
			fmt = EF_ABGR32F;
		}
		else if (caps.rendertarget_format_support(EF_GR16F, 1, 0))
		{
			fmt = EF_GR16F;
		}
		else
		{
			BOOST_ASSERT(caps.rendertarget_format_support(EF_ABGR16F, 1, 0));

			fmt = EF_ABGR16F;
		}

		rsm_depth_derivative_tex_ = rf.MakeTexture2D(MIN_RSM_MIPMAP_SIZE, MIN_RSM_MIPMAP_SIZE, 1, 1, fmt, 1, 0, EAH_GPU_Read | EAH_GPU_Write, nullptr);

		rsm_to_depth_derivate_pp_ = SyncLoadPostProcess("MultiRes.ppml", "GBuffer2DepthDerivate");
		rsm_to_depth_derivate_pp_->InputPin(1, rsm_depth_tex_);
		rsm_to_depth_derivate_pp_->OutputPin(0, rsm_depth_derivative_tex_);
		float delta_x = 1.0f / rsm_depth_derivative_tex_->Width(0);
		float delta_y = 1.0f / rsm_depth_derivative_tex_->Height(0);
		float4 rsm_delta_offset(delta_x, delta_y, delta_x / 2, delta_y / 2);
		rsm_to_depth_derivate_pp_->SetParam(0, rsm_delta_offset);
	}
示例#3
0
void RenderEngine::Stereo(StereoMethod method)
{
    stereo_method_ = method;
    if (stereo_method_ != STM_None)
    {
        std::string pp_name;
        switch (stereo_method_)
        {
        case STM_ColorAnaglyph_RedCyan:
            pp_name = "stereoscopic_red_cyan";
            break;

        case STM_ColorAnaglyph_YellowBlue:
            pp_name = "stereoscopic_yellow_blue";
            break;

        case STM_ColorAnaglyph_GreenRed:
            pp_name = "stereoscopic_green_red";
            break;

        case STM_HorizontalInterlacing:
            pp_name = "stereoscopic_hor_interlacing";
            break;

        case STM_VerticalInterlacing:
            pp_name = "stereoscopic_ver_interlacing";
            break;

        case STM_Horizontal:
            pp_name = "stereoscopic_horizontal";
            break;

        case STM_Vertical:
            pp_name = "stereoscopic_vertical";
            break;

        case STM_LCDShutter:
            pp_name = "stereoscopic_lcd_shutter";
            break;

        case STM_OculusVR:
            pp_name = "stereoscopic_oculus_vr";
            break;

        default:
            BOOST_ASSERT(false);
            break;
        }

        stereoscopic_pp_ = SyncLoadPostProcess("Stereoscopic.ppml", pp_name);
    }

    pp_chain_dirty_ = true;
}
示例#4
0
	MultiResLayer::MultiResLayer()
	{
		RenderFactory& rf = Context::Instance().RenderFactoryInstance();

		{
			rl_quad_ = rf.MakeRenderLayout();
			rl_quad_->TopologyType(RenderLayout::TT_TriangleStrip);

			float3 pos[] = 
			{
				float3(+1, +1, 1),
				float3(-1, +1, 1),
				float3(+1, -1, 1),
				float3(-1, -1, 1)
			};

			ElementInitData init_data;
			init_data.row_pitch = static_cast<uint32_t>(sizeof(pos));
			init_data.slice_pitch = 0;
			init_data.data = &pos[0];
			rl_quad_->BindVertexStream(rf.MakeVertexBuffer(BU_Static, EAH_GPU_Read | EAH_Immutable, &init_data),
				make_tuple(vertex_element(VEU_Position, 0, EF_BGR32F)));
		}

		gbuffer_to_depth_derivate_pp_ = SyncLoadPostProcess("MultiRes.ppml", "GBuffer2DepthDerivate");
		depth_derivate_mipmap_pp_ =  SyncLoadPostProcess("MultiRes.ppml", "DepthDerivateMipMap");
		gbuffer_to_normal_cone_pp_ =  SyncLoadPostProcess("MultiRes.ppml", "GBuffer2NormalCone");
		normal_cone_mipmap_pp_ =  SyncLoadPostProcess("MultiRes.ppml", "NormalConeMipMap");

		RenderEffectPtr subsplat_stencil_effect = SyncLoadRenderEffect("MultiRes.fxml");
		subsplat_stencil_tech_ = subsplat_stencil_effect->TechniqueByName("SetSubsplatStencil");

		subsplat_cur_lower_level_param_ = subsplat_stencil_effect->ParameterByName("cur_lower_level");
		subsplat_is_not_first_last_level_param_ = subsplat_stencil_effect->ParameterByName("is_not_first_last_level");
		subsplat_depth_deriv_tex_param_ = subsplat_stencil_effect->ParameterByName("depth_deriv_tex");
		subsplat_normal_cone_tex_param_ = subsplat_stencil_effect->ParameterByName("normal_cone_tex");
		subsplat_depth_normal_threshold_param_ = subsplat_stencil_effect->ParameterByName("depth_normal_threshold");
		subsplat_far_plane_param_ = subsplat_stencil_effect->ParameterByName("far_plane");

		upsampling_pp_ = SyncLoadPostProcess("MultiRes.ppml", "Upsampling");
	}
示例#5
0
	SDSMCascadedShadowLayer::SDSMCascadedShadowLayer()
		: frame_index_(0)
	{
		RenderFactory& rf = Context::Instance().RenderFactoryInstance();
		RenderDeviceCaps const & caps = rf.RenderEngineInstance().DeviceCaps();
		cs_support_ = caps.cs_support && (caps.max_shader_model >= ShaderModel(5, 0));

		if (cs_support_)
		{
			interval_buff_ = rf.MakeVertexBuffer(BU_Dynamic, EAH_GPU_Read | EAH_GPU_Write | EAH_GPU_Unordered | EAH_GPU_Structured, nullptr, EF_GR32F);
			scale_buff_ = rf.MakeVertexBuffer(BU_Dynamic, EAH_GPU_Write | EAH_GPU_Unordered | EAH_GPU_Structured, nullptr, EF_BGR32F);
			bias_buff_ = rf.MakeVertexBuffer(BU_Dynamic, EAH_GPU_Write | EAH_GPU_Unordered | EAH_GPU_Structured, nullptr, EF_BGR32F);
			cascade_min_buff_ = rf.MakeVertexBuffer(BU_Dynamic, EAH_GPU_Read | EAH_GPU_Write | EAH_GPU_Unordered | EAH_GPU_Structured, nullptr, EF_BGR32F);
			cascade_max_buff_ = rf.MakeVertexBuffer(BU_Dynamic, EAH_GPU_Read | EAH_GPU_Write | EAH_GPU_Unordered | EAH_GPU_Structured, nullptr, EF_BGR32F);

			interval_buff_->Resize(MAX_NUM_CASCADES * sizeof(float2));
			scale_buff_->Resize(MAX_NUM_CASCADES * sizeof(float3));
			bias_buff_->Resize(MAX_NUM_CASCADES * sizeof(float3));
			cascade_min_buff_->Resize(MAX_NUM_CASCADES * sizeof(float3));
			cascade_max_buff_->Resize(MAX_NUM_CASCADES * sizeof(float3));

			for (uint32_t i = 0; i < 2; ++ i)
			{
				interval_cpu_buffs_[i] = rf.MakeVertexBuffer(BU_Dynamic, EAH_CPU_Read, nullptr);
				scale_cpu_buffs_[i] = rf.MakeVertexBuffer(BU_Dynamic, EAH_CPU_Read, nullptr);
				bias_cpu_buffs_[i] = rf.MakeVertexBuffer(BU_Dynamic, EAH_CPU_Read, nullptr);

				interval_cpu_buffs_[i]->Resize(interval_buff_->Size());
				scale_cpu_buffs_[i]->Resize(scale_buff_->Size());
				bias_cpu_buffs_[i]->Resize(bias_buff_->Size());
			}

			RenderEffectPtr effect = SyncLoadRenderEffect("CascadedShadow.fxml");

			clear_z_bounds_tech_ = effect->TechniqueByName("ClearZBounds");
			reduce_z_bounds_from_depth_tech_ = effect->TechniqueByName("ReduceZBoundsFromDepth");
			compute_log_cascades_from_z_bounds_tech_ = effect->TechniqueByName("ComputeLogCascadesFromZBounds");
			clear_cascade_bounds_tech_ = effect->TechniqueByName("ClearCascadeBounds");
			reduce_bounds_from_depth_tech_ = effect->TechniqueByName("ReduceBoundsFromDepth");
			compute_custom_cascades_tech_ = effect->TechniqueByName("ComputeCustomCascades");

			interval_buff_param_ = effect->ParameterByName("interval_buff");
			interval_buff_uint_param_ = effect->ParameterByName("interval_buff_uint");
			interval_buff_read_param_ = effect->ParameterByName("interval_buff_read");
			scale_buff_param_ = effect->ParameterByName("scale_buff");
			bias_buff_param_ = effect->ParameterByName("bias_buff");
			cascade_min_buff_uint_param_ = effect->ParameterByName("cascade_min_buff_uint");
			cascade_max_buff_uint_param_ = effect->ParameterByName("cascade_max_buff_uint");
			cascade_min_buff_read_param_ = effect->ParameterByName("cascade_min_buff_read");
			cascade_max_buff_read_param_ = effect->ParameterByName("cascade_max_buff_read");
			depth_tex_param_ = effect->ParameterByName("depth_tex");
			num_cascades_param_ = effect->ParameterByName("num_cascades");
			inv_depth_width_height_param_ = effect->ParameterByName("inv_depth_width_height");
			near_far_param_ = effect->ParameterByName("near_far");
			upper_left_param_ = effect->ParameterByName("upper_left");
			xy_dir_param_ = effect->ParameterByName("xy_dir");
			view_to_light_view_proj_param_ = effect->ParameterByName("view_to_light_view_proj");
			light_space_border_param_ = effect->ParameterByName("light_space_border");
			max_cascade_scale_param_ = effect->ParameterByName("max_cascade_scale");
		}
		else
		{
			reduce_z_bounds_from_depth_pp_ = SyncLoadPostProcess("CascadedShadow.ppml", "reduce_z_bounds_from_depth");
			reduce_z_bounds_from_depth_mip_map_pp_ = SyncLoadPostProcess("CascadedShadow.ppml", "reduce_z_bounds_from_depth_mip_map");
			compute_log_cascades_from_z_bounds_pp_ = SyncLoadPostProcess("CascadedShadow.ppml", "compute_log_cascades_from_z_bounds");

			interval_tex_ = rf.MakeTexture2D(MAX_NUM_CASCADES, 1, 1, 1, EF_GR16F, 1, 0, EAH_GPU_Read | EAH_GPU_Write, nullptr);
			for (uint32_t i = 0; i < 2; ++ i)
			{
				interval_cpu_texs_[i] = rf.MakeTexture2D(MAX_NUM_CASCADES, 1, 1, 1, EF_GR16F, 1, 0, EAH_CPU_Read, nullptr);
			}
		}
	}
示例#6
0
// 建立渲染窗口
/////////////////////////////////////////////////////////////////////////////////
void RenderEngine::CreateRenderWindow(std::string const & name, RenderSettings& settings)
{
    if (settings.stereo_method != STM_OculusVR)
    {
        stereo_separation_ = settings.stereo_separation;
    }
    this->DoCreateRenderWindow(name, settings);
    this->CheckConfig(settings);
    RenderDeviceCaps const & caps = this->DeviceCaps();

    screen_frame_buffer_ = cur_frame_buffer_;

    uint32_t const screen_width = screen_frame_buffer_->Width();
    uint32_t const screen_height = screen_frame_buffer_->Height();
    float const screen_aspect = static_cast<float>(screen_width) / screen_height;
    if (!MathLib::equal(screen_aspect, static_cast<float>(settings.width) / settings.height))
    {
        settings.width = static_cast<uint32_t>(settings.height * screen_aspect + 0.5f);
    }

    RenderFactory& rf = Context::Instance().RenderFactoryInstance();

    pp_rl_ = rf.MakeRenderLayout();
    pp_rl_->TopologyType(RenderLayout::TT_TriangleStrip);

    float2 pos[] =
    {
        float2(-1, +1),
        float2(+1, +1),
        float2(-1, -1),
        float2(+1, -1)
    };
    GraphicsBufferPtr pp_pos_vb = rf.MakeVertexBuffer(BU_Static, EAH_GPU_Read | EAH_Immutable, sizeof(pos), &pos[0]);
    pp_rl_->BindVertexStream(pp_pos_vb, std::make_tuple(vertex_element(VEU_Position, 0, EF_GR32F)));

    uint32_t const render_width = static_cast<uint32_t>(settings.width * default_render_width_scale_ + 0.5f);
    uint32_t const render_height = static_cast<uint32_t>(settings.height * default_render_height_scale_ + 0.5f);

    hdr_enabled_ = settings.hdr;
    if (settings.hdr)
    {
        hdr_pp_ = MakeSharedPtr<HDRPostProcess>(settings.fft_lens_effects);
        skip_hdr_pp_ = SyncLoadPostProcess("Copy.ppml", "copy");
    }

    ppaa_enabled_ = settings.ppaa ? 1 : 0;
    gamma_enabled_ = settings.gamma;
    color_grading_enabled_ = settings.color_grading;
    if (settings.ppaa || settings.color_grading || settings.gamma)
    {
        for (size_t i = 0; i < 12; ++ i)
        {
            ldr_pps_[i] = SyncLoadPostProcess("PostToneMapping.ppml",
                                              "PostToneMapping" + boost::lexical_cast<std::string>(i));
        }

        ldr_pp_ = ldr_pps_[ppaa_enabled_ * 4 + gamma_enabled_ * 2 + color_grading_enabled_];
    }

    bool need_resize = false;
    if (!settings.hide_win)
    {
        need_resize = ((render_width != screen_width) || (render_height != screen_height));

        resize_pps_[0] = SyncLoadPostProcess("Resizer.ppml", "bilinear");
        resize_pps_[1] = MakeSharedPtr<BicubicFilteringPostProcess>();

        float const scale_x = static_cast<float>(screen_width) / render_width;
        float const scale_y = static_cast<float>(screen_height) / render_height;

        float2 pos_scale;
        if (scale_x < scale_y)
        {
            pos_scale.x() = 1;
            pos_scale.y() = (scale_x * render_height) / screen_height;
        }
        else
        {
            pos_scale.x() = (scale_y * render_width) / screen_width;
            pos_scale.y() = 1;
        }

        for (size_t i = 0; i < 2; ++ i)
        {
            resize_pps_[i]->SetParam(0, pos_scale);
        }
    }

    for (int i = 0; i < 4; ++ i)
    {
        default_frame_buffers_[i] = screen_frame_buffer_;
    }

    RenderViewPtr ds_view;
    if (hdr_pp_ || ldr_pp_ || (settings.stereo_method != STM_None))
    {
        ds_tex_ = this->ScreenDepthStencilTexture();
        if (ds_tex_ && (screen_width == render_width) && (screen_height == render_height))
        {
            ds_view = rf.Make2DDepthStencilRenderView(*ds_tex_, 0, 1, 0);
        }
        else
        {
            if (caps.texture_format_support(EF_D32F) || caps.texture_format_support(EF_D24S8)
                    || caps.texture_format_support(EF_D16))
            {
                ElementFormat fmt;
                if ((settings.depth_stencil_fmt != EF_Unknown)
                        && caps.texture_format_support(settings.depth_stencil_fmt))
                {
                    fmt = settings.depth_stencil_fmt;
                }
                else
                {
                    BOOST_ASSERT(caps.texture_format_support(EF_D16));

                    fmt = EF_D16;
                }
                ds_tex_ = rf.MakeTexture2D(render_width, render_height, 1, 1, fmt, 1, 0, EAH_GPU_Read | EAH_GPU_Write, nullptr);
                ds_view = rf.Make2DDepthStencilRenderView(*ds_tex_, 0, 1, 0);
            }
            else
            {
                ElementFormat fmt;
                if ((settings.depth_stencil_fmt != EF_Unknown)
                        && caps.rendertarget_format_support(settings.depth_stencil_fmt, 1, 0))
                {
                    fmt = settings.depth_stencil_fmt;
                }
                else
                {
                    BOOST_ASSERT(caps.rendertarget_format_support(EF_D16, 1, 0));

                    fmt = EF_D16;
                }
                ds_view = rf.Make2DDepthStencilRenderView(render_width, render_height, fmt, 1, 0);
            }
        }
    }

    if (settings.stereo_method != STM_None)
    {
        mono_frame_buffer_ = rf.MakeFrameBuffer();
        mono_frame_buffer_->GetViewport()->camera = cur_frame_buffer_->GetViewport()->camera;

        ElementFormat fmt;
        if (caps.texture_format_support(settings.color_fmt) && caps.rendertarget_format_support(settings.color_fmt, 1, 0))
        {
            fmt = settings.color_fmt;
        }
        else
        {
            if (caps.texture_format_support(EF_ABGR8) && caps.rendertarget_format_support(EF_ABGR8, 1, 0))
            {
                fmt = EF_ABGR8;
            }
            else
            {
                BOOST_ASSERT(caps.texture_format_support(EF_ARGB8) && caps.rendertarget_format_support(EF_ARGB8, 1, 0));

                fmt = EF_ARGB8;
            }
        }

        mono_tex_ = rf.MakeTexture2D(screen_width, screen_height, 1, 1,
                                     fmt, 1, 0, EAH_GPU_Read | EAH_GPU_Write, nullptr);
        mono_frame_buffer_->Attach(FrameBuffer::ATT_Color0, rf.Make2DRenderView(*mono_tex_, 0, 1, 0));

        default_frame_buffers_[0] = default_frame_buffers_[1]
                                    = default_frame_buffers_[2] = mono_frame_buffer_;

        overlay_frame_buffer_ = rf.MakeFrameBuffer();
        overlay_frame_buffer_->GetViewport()->camera = cur_frame_buffer_->GetViewport()->camera;

        overlay_tex_ = rf.MakeTexture2D(screen_width, screen_height, 1, 1,
                                        fmt, 1, 0, EAH_GPU_Read | EAH_GPU_Write, nullptr);
        overlay_frame_buffer_->Attach(FrameBuffer::ATT_Color0, rf.Make2DRenderView(*overlay_tex_, 0, 1, 0));

        RenderViewPtr screen_size_ds_view;
        if (need_resize)
        {
            screen_size_ds_view = rf.Make2DDepthStencilRenderView(screen_width, screen_height, ds_view->Format(), 1, 0);
        }
        else
        {
            screen_size_ds_view = ds_view;
        }
        overlay_frame_buffer_->Attach(FrameBuffer::ATT_DepthStencil, screen_size_ds_view);
    }
    else
    {
        if (need_resize)
        {
            resize_frame_buffer_ = rf.MakeFrameBuffer();
            resize_frame_buffer_->GetViewport()->camera = cur_frame_buffer_->GetViewport()->camera;

            ElementFormat fmt;
            if (caps.texture_format_support(EF_ABGR8) && caps.rendertarget_format_support(EF_ABGR8, 1, 0))
            {
                fmt = EF_ABGR8;
            }
            else
            {
                BOOST_ASSERT(caps.texture_format_support(EF_ARGB8) && caps.rendertarget_format_support(EF_ARGB8, 1, 0));

                fmt = EF_ARGB8;
            }

            resize_tex_ = rf.MakeTexture2D(render_width, render_height, 1, 1,
                                           fmt, 1, 0, EAH_GPU_Read | EAH_GPU_Write, nullptr);
            resize_frame_buffer_->Attach(FrameBuffer::ATT_Color0, rf.Make2DRenderView(*resize_tex_, 0, 1, 0));

            ElementFormat ds_fmt;
            if ((settings.depth_stencil_fmt != EF_Unknown) && caps.rendertarget_format_support(settings.depth_stencil_fmt, 1, 0))
            {
                ds_fmt = settings.depth_stencil_fmt;
            }
            else
            {
                BOOST_ASSERT(caps.rendertarget_format_support(EF_D16, 1, 0));

                ds_fmt = EF_D16;
            }
            resize_frame_buffer_->Attach(FrameBuffer::ATT_DepthStencil,
                                         rf.Make2DDepthStencilRenderView(render_width, render_height, ds_fmt, 1, 0));

            default_frame_buffers_[0] = default_frame_buffers_[1]
                                        = default_frame_buffers_[2] = resize_frame_buffer_;
        }
    }

    if (ldr_pp_)
    {
        ldr_frame_buffer_ = rf.MakeFrameBuffer();
        ldr_frame_buffer_->GetViewport()->camera = cur_frame_buffer_->GetViewport()->camera;

        ElementFormat fmt;
        if (caps.texture_format_support(EF_ABGR8) && caps.rendertarget_format_support(EF_ABGR8, 1, 0))
        {
            fmt = EF_ABGR8;
        }
        else
        {
            BOOST_ASSERT(caps.texture_format_support(EF_ARGB8) && caps.rendertarget_format_support(EF_ARGB8, 1, 0));

            fmt = EF_ARGB8;
        }
        ElementFormat fmt_srgb = MakeSRGB(fmt);
        if (caps.texture_format_support(fmt_srgb) && caps.rendertarget_format_support(fmt_srgb, 1, 0))
        {
            fmt = fmt_srgb;
        }

        ldr_tex_ = rf.MakeTexture2D(render_width, render_height, 1, 1, fmt, 1, 0, EAH_GPU_Read | EAH_GPU_Write, nullptr);
        ldr_frame_buffer_->Attach(FrameBuffer::ATT_Color0, rf.Make2DRenderView(*ldr_tex_, 0, 1, 0));
        ldr_frame_buffer_->Attach(FrameBuffer::ATT_DepthStencil, ds_view);

        default_frame_buffers_[0] = default_frame_buffers_[1] = ldr_frame_buffer_;
    }

    if (hdr_pp_)
    {
        hdr_frame_buffer_ = rf.MakeFrameBuffer();
        hdr_frame_buffer_->GetViewport()->camera = cur_frame_buffer_->GetViewport()->camera;

        ElementFormat fmt;
        if (caps.fp_color_support)
        {
            if (caps.texture_format_support(EF_B10G11R11F) && caps.rendertarget_format_support(EF_B10G11R11F, 1, 0))
            {
                fmt = EF_B10G11R11F;
            }
            else
            {
                BOOST_ASSERT(caps.texture_format_support(EF_ABGR16F) && caps.rendertarget_format_support(EF_ABGR16F, 1, 0));
                fmt = EF_ABGR16F;
            }
        }
        else
        {
            if (caps.texture_format_support(EF_ABGR8) && caps.rendertarget_format_support(EF_ABGR8, 1, 0))
            {
                fmt = EF_ABGR8;
            }
            else
            {
                BOOST_ASSERT(caps.texture_format_support(EF_ARGB8) && caps.rendertarget_format_support(EF_ARGB8, 1, 0));
                fmt = EF_ARGB8;
            }

            ElementFormat fmt_srgb = MakeSRGB(fmt);
            if (caps.rendertarget_format_support(fmt_srgb, 1, 0))
            {
                fmt = fmt_srgb;
            }
        }
        hdr_tex_ = rf.MakeTexture2D(render_width, render_height, 4, 1, fmt, 1, 0, EAH_GPU_Read | EAH_GPU_Write | EAH_Generate_Mips, nullptr);
        hdr_frame_buffer_->Attach(FrameBuffer::ATT_Color0, rf.Make2DRenderView(*hdr_tex_, 0, 1, 0));
        hdr_frame_buffer_->Attach(FrameBuffer::ATT_DepthStencil, ds_view);

        default_frame_buffers_[0] = hdr_frame_buffer_;
    }

    this->BindFrameBuffer(default_frame_buffers_[0]);
    this->Stereo(settings.stereo_method);

#ifndef KLAYGE_SHIP
    PerfProfiler& profiler = PerfProfiler::Instance();
    hdr_pp_perf_ = profiler.CreatePerfRange(0, "HDR PP");
    ldr_pp_perf_ = profiler.CreatePerfRange(0, "LDR PP");
    resize_pp_perf_ = profiler.CreatePerfRange(0, "Resize PP");
    stereoscopic_pp_perf_ = profiler.CreatePerfRange(0, "Stereoscopic PP");
#endif
}
示例#7
0
	ProceduralTerrain::ProceduralTerrain()
		: HQTerrainRenderable(SyncLoadRenderEffect("ProceduralTerrain.fxml"))
	{
		RenderFactory& rf = Context::Instance().RenderFactoryInstance();
		RenderEngine& re = rf.RenderEngineInstance();
		RenderDeviceCaps const & caps = re.DeviceCaps();

		ElementFormat height_fmt;
		if (caps.pack_to_rgba_required)
		{
			if (caps.rendertarget_format_support(EF_ABGR8, 1, 0))
			{
				height_fmt = EF_ABGR8;
			}
			else
			{
				BOOST_ASSERT(caps.rendertarget_format_support(EF_ARGB8, 1, 0));
				height_fmt = EF_ARGB8;
			}
		}
		else
		{
			if (caps.rendertarget_format_support(EF_R16F, 1, 0))
			{
				height_fmt = EF_R16F;
			}
			else
			{
				BOOST_ASSERT(caps.rendertarget_format_support(EF_R32F, 1, 0));
				height_fmt = EF_R32F;
			}
		}
		height_map_tex_ = rf.MakeTexture2D(COARSE_HEIGHT_MAP_SIZE, COARSE_HEIGHT_MAP_SIZE, 1, 1, height_fmt,
			1, 0, EAH_GPU_Read | EAH_GPU_Write, nullptr);
		height_map_cpu_tex_ = rf.MakeTexture2D(height_map_tex_->Width(0), height_map_tex_->Height(0),
			1, 1, height_map_tex_->Format(), 1, 0, EAH_CPU_Read, nullptr);

		ElementFormat gradient_fmt;
		if (EF_R16F == height_fmt)
		{
			gradient_fmt = EF_GR16F;
		}
		else if (EF_R32F == height_fmt)
		{
			gradient_fmt = EF_GR32F;
		}
		else
		{
			gradient_fmt = height_fmt;
		}
		gradient_map_tex_ = rf.MakeTexture2D(COARSE_HEIGHT_MAP_SIZE, COARSE_HEIGHT_MAP_SIZE, 1, 1, gradient_fmt,
			1, 0, EAH_GPU_Read | EAH_GPU_Write, nullptr);
		gradient_map_cpu_tex_ = rf.MakeTexture2D(gradient_map_tex_->Width(0), gradient_map_tex_->Height(0),
			1, 1, gradient_map_tex_->Format(), 1, 0, EAH_CPU_Read, nullptr);

		ElementFormat mask_fmt;
		if (caps.texture_format_support(EF_ABGR8))
		{
			mask_fmt = EF_ABGR8;
		}
		else
		{
			BOOST_ASSERT(caps.texture_format_support(EF_ARGB8));
			mask_fmt = EF_ARGB8;
		}
		mask_map_tex_ = rf.MakeTexture2D(COARSE_HEIGHT_MAP_SIZE, COARSE_HEIGHT_MAP_SIZE, 1, 1, mask_fmt,
			1, 0, EAH_GPU_Read | EAH_GPU_Write, nullptr);
		mask_map_cpu_tex_ = rf.MakeTexture2D(mask_map_tex_->Width(0), mask_map_tex_->Height(0),
			1, 1, mask_map_tex_->Format(), 1, 0, EAH_CPU_Read, nullptr);

		height_pp_ = SyncLoadPostProcess("ProceduralTerrain.ppml", "height");
		gradient_pp_ = SyncLoadPostProcess("ProceduralTerrain.ppml", "gradient");
		mask_pp_ = SyncLoadPostProcess("ProceduralTerrain.ppml", "mask");

		height_pp_->OutputPin(0, height_map_tex_);

		gradient_pp_->InputPin(0, height_map_tex_);
		gradient_pp_->OutputPin(0, gradient_map_tex_);

		mask_pp_->InputPin(0, height_map_tex_);
		mask_pp_->InputPin(1, gradient_map_tex_);
		mask_pp_->OutputPin(0, mask_map_tex_);
	}
示例#8
0
	MultiResSILLayer::MultiResSILLayer()
	{
		RenderFactory& rf = Context::Instance().RenderFactoryInstance();
		RenderEngine& re = rf.RenderEngineInstance();
		RenderDeviceCaps const & caps = re.DeviceCaps();

		{
			rl_quad_ = rf.MakeRenderLayout();
			rl_quad_->TopologyType(RenderLayout::TT_TriangleStrip);

			std::vector<float3> pos;
			std::vector<uint16_t> index;

			pos.push_back(float3(+1, +1, 1));
			pos.push_back(float3(-1, +1, 1));
			pos.push_back(float3(+1, -1, 1));
			pos.push_back(float3(-1, -1, 1));

			ElementInitData init_data;
			init_data.row_pitch = static_cast<uint32_t>(pos.size() * sizeof(pos[0]));
			init_data.slice_pitch = 0;
			init_data.data = &pos[0];
			rl_quad_->BindVertexStream(rf.MakeVertexBuffer(BU_Static, EAH_GPU_Read | EAH_Immutable, &init_data),
				make_tuple(vertex_element(VEU_Position, 0, EF_BGR32F)));
		}

		vpl_tex_ = rf.MakeTexture2D(VPL_COUNT, 4, 1, 1, EF_ABGR16F, 1, 0, EAH_GPU_Read | EAH_GPU_Write, nullptr);	

		gbuffer_to_depth_derivate_pp_ = SyncLoadPostProcess("MultiRes.ppml", "GBuffer2DepthDerivate");
		depth_derivate_mipmap_pp_ =  SyncLoadPostProcess("MultiRes.ppml", "DepthDerivateMipMap");
		gbuffer_to_normal_cone_pp_ =  SyncLoadPostProcess("MultiRes.ppml", "GBuffer2NormalCone");
		normal_cone_mipmap_pp_ =  SyncLoadPostProcess("MultiRes.ppml", "NormalConeMipMap");

		RenderEffectPtr subsplat_stencil_effect = SyncLoadRenderEffect("MultiRes.fxml");
		subsplat_stencil_tech_ = subsplat_stencil_effect->TechniqueByName("SetSubsplatStencil");

		subsplat_cur_lower_level_param_ = subsplat_stencil_effect->ParameterByName("cur_lower_level");
		subsplat_is_not_first_last_level_param_ = subsplat_stencil_effect->ParameterByName("is_not_first_last_level");
		subsplat_depth_deriv_tex_param_ = subsplat_stencil_effect->ParameterByName("depth_deriv_tex");
		subsplat_normal_cone_tex_param_ = subsplat_stencil_effect->ParameterByName("normal_cone_tex");
		subsplat_depth_normal_threshold_param_ = subsplat_stencil_effect->ParameterByName("depth_normal_threshold");

		RenderEffectPtr vpls_lighting_effect = SyncLoadRenderEffect("VPLsLighting.fxml");
		vpls_lighting_instance_id_tech_ = vpls_lighting_effect->TechniqueByName("VPLsLightingInstanceID");
		vpls_lighting_no_instance_id_tech_ = vpls_lighting_effect->TechniqueByName("VPLsLightingNoInstanceID");

		vpl_view_param_ = vpls_lighting_effect->ParameterByName("view");
		vpl_proj_param_ = vpls_lighting_effect->ParameterByName("proj");
		vpl_depth_near_far_invfar_param_ = vpls_lighting_effect->ParameterByName("depth_near_far_invfar");
		vpl_light_pos_es_param_ = vpls_lighting_effect->ParameterByName("light_pos_es");
		vpl_light_color_param_ = vpls_lighting_effect->ParameterByName("light_color");
		vpl_light_falloff_param_ = vpls_lighting_effect->ParameterByName("light_falloff");
		vpl_x_coord_param_ = vpls_lighting_effect->ParameterByName("x_coord");
		vpl_gbuffer_tex_param_ = vpls_lighting_effect->ParameterByName("gbuffer_tex");
		vpl_depth_tex_param_ = vpls_lighting_effect->ParameterByName("depth_tex");
		*(vpls_lighting_effect->ParameterByName("vpls_tex")) = vpl_tex_;
		*(vpls_lighting_effect->ParameterByName("vpl_params")) = float2(1.0f / VPL_COUNT, 0.5f / VPL_COUNT);

		upsampling_pp_ = SyncLoadPostProcess("MultiRes.ppml", "Upsampling");

		rl_vpl_ = SyncLoadModel("indirect_light_proxy.meshml", EAH_GPU_Read | EAH_Immutable, CreateModelFactory<RenderModel>(), CreateMeshFactory<StaticMesh>())->Mesh(0)->GetRenderLayout();
		if (caps.instance_id_support)
		{
			rl_vpl_->NumInstances(VPL_COUNT);
		}
	}