void RenderChain::render_pass(Pass &pass, unsigned pass_index) { set_shaders(pass.fPrg, pass.vPrg); dev->SetTexture(0, pass.tex); dev->SetSamplerState(0, D3DSAMP_MINFILTER, translate_filter(pass.info.pass->filter)); dev->SetSamplerState(0, D3DSAMP_MAGFILTER, translate_filter(pass.info.pass->filter)); dev->SetVertexDeclaration(pass.vertex_decl); for (unsigned i = 0; i < 4; i++) dev->SetStreamSource(i, pass.vertex_buf, 0, sizeof(Vertex)); bind_orig(pass); bind_prev(pass); bind_pass(pass, pass_index); bind_luts(pass); bind_tracker(pass, pass_index); if (SUCCEEDED(dev->BeginScene())) { dev->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2); dev->EndScene(); } // So we don't render with linear filter into render targets, // which apparently looked odd (too blurry). dev->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT); dev->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT); unbind_all(); }
void RenderChain::bind_orig(Pass &pass) { D3DXVECTOR2 video_size, texture_size; video_size.x = passes[0].last_width; video_size.y = passes[0].last_height; texture_size.x = passes[0].info.tex_w; texture_size.y = passes[0].info.tex_h; set_cg_param(pass.vPrg, "ORIG.video_size", video_size); set_cg_param(pass.fPrg, "ORIG.video_size", video_size); set_cg_param(pass.vPrg, "ORIG.texture_size", texture_size); set_cg_param(pass.fPrg, "ORIG.texture_size", texture_size); CGparameter param = cgGetNamedParameter(pass.fPrg, "ORIG.texture"); if (param) { unsigned index = cgGetParameterResourceIndex(param); dev->SetTexture(index, passes[0].tex); dev->SetSamplerState(index, D3DSAMP_MAGFILTER, translate_filter(passes[0].info.pass->filter)); dev->SetSamplerState(index, D3DSAMP_MINFILTER, translate_filter(passes[0].info.pass->filter)); dev->SetSamplerState(index, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER); dev->SetSamplerState(index, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER); bound_tex.push_back(index); } param = cgGetNamedParameter(pass.vPrg, "ORIG.tex_coord"); if (param) { unsigned index = pass.attrib_map[cgGetParameterResourceIndex(param)]; dev->SetStreamSource(index, passes[0].vertex_buf, 0, sizeof(Vertex)); bound_vert.push_back(index); } }
void renderchain_render_pass(void *data, Pass &pass, unsigned pass_index) { renderchain_t *chain = (renderchain_t*)data; LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)chain->dev; renderchain_set_shaders(chain, pass.fPrg, pass.vPrg); d3dr->SetTexture(0, pass.tex); D3DDevice_SetSamplerState_MinFilter(d3dr, 0, translate_filter(pass.info.pass->filter)); D3DDevice_SetSamplerState_MagFilter(d3dr, 0, translate_filter(pass.info.pass->filter)); #ifdef _XBOX1 d3dr->SetVertexShader(D3DFVF_XYZ | D3DFVF_TEX1); #else d3dr->SetVertexDeclaration(pass.vertex_decl); #endif for (unsigned i = 0; i < 4; i++) { D3DDevice_SetStreamSources(d3dr, i, pass.vertex_buf, 0, sizeof(Vertex)); } renderchain_bind_orig(chain, pass); renderchain_bind_prev(chain, pass); renderchain_bind_pass(chain, pass, pass_index); renderchain_bind_luts(chain, pass); renderchain_bind_tracker(chain, pass, pass_index); D3DDevice_DrawPrimitive(d3dr, D3DPT_TRIANGLESTRIP, 0, 2); // So we don't render with linear filter into render targets, // which apparently looked odd (too blurry). D3DDevice_SetSamplerState_MinFilter(d3dr, 0, D3DTEXF_POINT); D3DDevice_SetSamplerState_MagFilter(d3dr, 0, D3DTEXF_POINT); renderchain_unbind_all(chain); }
static bool renderchain_create_first_pass(cg_renderchain_t *chain, const LinkInfo *info, unsigned fmt) { unsigned i; Pass pass; D3DXMATRIX ident; if (!chain) return false; D3DXMatrixIdentity(&ident); d3d_set_transform(chain->dev, D3DTS_WORLD, &ident); d3d_set_transform(chain->dev, D3DTS_VIEW, &ident); pass.info = *info; pass.last_width = 0; pass.last_height = 0; chain->prev.ptr = 0; for (i = 0; i < TEXTURES; i++) { chain->prev.last_width[i] = 0; chain->prev.last_height[i] = 0; chain->prev.vertex_buf[i] = d3d_vertex_buffer_new( chain->dev, 4 * sizeof(Vertex), 0, 0, D3DPOOL_DEFAULT, NULL); if (!chain->prev.vertex_buf[i]) return false; chain->prev.tex[i] = d3d_texture_new(chain->dev, NULL, info->tex_w, info->tex_h, 1, 0, (fmt == RETRO_PIXEL_FORMAT_RGB565) ? D3DFMT_R5G6B5 : D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, 0, 0, 0, NULL, NULL); if (!chain->prev.tex[i]) return false; d3d_set_texture(chain->dev, 0, chain->prev.tex[i]); d3d_set_sampler_minfilter(chain->dev, 0, translate_filter(info->pass->filter)); d3d_set_sampler_magfilter(chain->dev, 0, translate_filter(info->pass->filter)); d3d_set_sampler_address_u(chain->dev, 0, D3DTADDRESS_BORDER); d3d_set_sampler_address_v(chain->dev, 0, D3DTADDRESS_BORDER); d3d_set_texture(chain->dev, 0, NULL); } renderchain_compile_shaders(chain, &pass.fPrg, &pass.vPrg, info->pass->source.path); if (!cg_d3d9_renderchain_init_shader_fvf(chain, &pass)) return false; chain->passes.push_back(pass); return true; }
void RenderChain::bind_pass(Pass &pass, unsigned pass_index) { // We only bother binding passes which are two indices behind. if (pass_index < 3) return; for (unsigned i = 1; i < pass_index - 1; i++) { char pass_base[64]; snprintf(pass_base, sizeof(pass_base), "PASS%u.", i); std::string attr_texture = pass_base; attr_texture += "texture"; std::string attr_video_size = pass_base; attr_video_size += "video_size"; std::string attr_texture_size = pass_base; attr_texture_size += "texture_size"; std::string attr_tex_coord = pass_base; attr_tex_coord += "tex_coord"; D3DXVECTOR2 video_size, texture_size; video_size.x = passes[i].last_width; video_size.y = passes[i].last_height; texture_size.x = passes[i].info.tex_w; texture_size.y = passes[i].info.tex_h; set_cg_param(pass.vPrg, attr_video_size.c_str(), video_size); set_cg_param(pass.fPrg, attr_video_size.c_str(), video_size); set_cg_param(pass.vPrg, attr_texture_size.c_str(), texture_size); set_cg_param(pass.fPrg, attr_texture_size.c_str(), texture_size); CGparameter param = cgGetNamedParameter(pass.fPrg, attr_texture.c_str()); if (param) { unsigned index = cgGetParameterResourceIndex(param); bound_tex.push_back(index); dev->SetTexture(index, passes[i].tex); dev->SetSamplerState(index, D3DSAMP_MAGFILTER, translate_filter(passes[i].info.pass->filter)); dev->SetSamplerState(index, D3DSAMP_MINFILTER, translate_filter(passes[i].info.pass->filter)); dev->SetSamplerState(index, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER); dev->SetSamplerState(index, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER); } param = cgGetNamedParameter(pass.vPrg, attr_tex_coord.c_str()); if (param) { unsigned index = pass.attrib_map[cgGetParameterResourceIndex(param)]; dev->SetStreamSource(index, passes[i].vertex_buf, 0, sizeof(Vertex)); bound_vert.push_back(index); } } }
bool RenderChain::create_first_pass(const LinkInfo &info, PixelFormat fmt) { D3DXMATRIX ident; D3DXMatrixIdentity(&ident); dev->SetTransform(D3DTS_WORLD, &ident); dev->SetTransform(D3DTS_VIEW, &ident); Pass pass; pass.info = info; pass.last_width = 0; pass.last_height = 0; prev.ptr = 0; for (unsigned i = 0; i < Textures; i++) { prev.last_width[i] = 0; prev.last_height[i] = 0; if (FAILED(dev->CreateVertexBuffer( 4 * sizeof(Vertex), dev->GetSoftwareVertexProcessing() ? D3DUSAGE_SOFTWAREPROCESSING : 0, 0, D3DPOOL_DEFAULT, &prev.vertex_buf[i], NULL))) { return false; } if (FAILED(dev->CreateTexture(info.tex_w, info.tex_h, 1, 0, fmt == RGB565 ? D3DFMT_R5G6B5 : D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &prev.tex[i], NULL))) { return false; } dev->SetTexture(0, prev.tex[i]); dev->SetSamplerState(0, D3DSAMP_MINFILTER, translate_filter(info.pass->filter)); dev->SetSamplerState(0, D3DSAMP_MAGFILTER, translate_filter(info.pass->filter)); dev->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER); dev->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER); dev->SetTexture(0, NULL); } compile_shaders(pass.fPrg, pass.vPrg, info.pass->source.cg); if (!init_fvf(pass)) return false; passes.push_back(pass); return true; }
bool renderchain_create_first_pass(void *data, const LinkInfo *info, PixelFormat fmt) { renderchain_t *chain = (renderchain_t*)data; D3DXMATRIX ident; D3DXMatrixIdentity(&ident); LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)chain->dev; d3dr->SetTransform(D3DTS_WORLD, &ident); d3dr->SetTransform(D3DTS_VIEW, &ident); Pass pass; pass.info = *info; pass.last_width = 0; pass.last_height = 0; chain->prev.ptr = 0; for (unsigned i = 0; i < TEXTURES; i++) { chain->prev.last_width[i] = 0; chain->prev.last_height[i] = 0; if (FAILED(d3dr->CreateVertexBuffer( 4 * sizeof(Vertex), d3dr->GetSoftwareVertexProcessing() ? D3DUSAGE_SOFTWAREPROCESSING : 0, 0, D3DPOOL_DEFAULT, &chain->prev.vertex_buf[i], NULL))) { return false; } if (FAILED(d3dr->CreateTexture(info->tex_w, info->tex_h, 1, 0, fmt == RGB565 ? D3DFMT_R5G6B5 : D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &chain->prev.tex[i], NULL))) { return false; } d3dr->SetTexture(0, chain->prev.tex[i]); D3DDevice_SetSamplerState_MinFilter(d3dr, 0, translate_filter(info->pass->filter)); D3DDevice_SetSamplerState_MagFilter(d3dr, 0, translate_filter(info->pass->filter)); D3DDevice_SetSamplerState_AddressU(d3dr, 0, D3DTADDRESS_BORDER); D3DDevice_SetSamplerState_AddressV(d3dr, 0, D3DTADDRESS_BORDER); d3dr->SetTexture(0, NULL); } renderchain_compile_shaders(chain, pass.fPrg, pass.vPrg, info->pass->source.path); if (!renderchain_init_shader_fvf(chain, pass)) return false; chain->passes.push_back(pass); return true; }
static void cg_d3d9_renderchain_add_lut(void *data, unsigned index, unsigned i) { cg_renderchain_t *chain = (cg_renderchain_t*)data; if (!chain) return; d3d_set_texture(chain->dev, index, chain->luts[i].tex); d3d_set_sampler_magfilter(chain->dev, index, translate_filter(chain->luts[i].smooth ? RARCH_FILTER_LINEAR : RARCH_FILTER_NEAREST)); d3d_set_sampler_minfilter(chain->dev, index, translate_filter(chain->luts[i].smooth ? RARCH_FILTER_LINEAR : RARCH_FILTER_NEAREST)); d3d_set_sampler_address_u(chain->dev, index, D3DTADDRESS_BORDER); d3d_set_sampler_address_v(chain->dev, index, D3DTADDRESS_BORDER); chain->bound_tex.push_back(index); }
static void renderchain_bind_orig(cg_renderchain_t *chain, void *pass_data) { unsigned index; CGparameter param; D3DXVECTOR2 video_size, texture_size; Pass *pass = (Pass*)pass_data; video_size.x = chain->passes[0].last_width; video_size.y = chain->passes[0].last_height; texture_size.x = chain->passes[0].info.tex_w; texture_size.y = chain->passes[0].info.tex_h; set_cg_param(pass->vPrg, "ORIG.video_size", video_size); set_cg_param(pass->fPrg, "ORIG.video_size", video_size); set_cg_param(pass->vPrg, "ORIG.texture_size", texture_size); set_cg_param(pass->fPrg, "ORIG.texture_size", texture_size); param = cgGetNamedParameter(pass->fPrg, "ORIG.texture"); if (param) { index = cgGetParameterResourceIndex(param); d3d_set_texture(chain->dev, index, chain->passes[0].tex); d3d_set_sampler_magfilter(chain->dev, index, translate_filter(chain->passes[0].info.pass->filter)); d3d_set_sampler_minfilter(chain->dev, index, translate_filter(chain->passes[0].info.pass->filter)); d3d_set_sampler_address_u(chain->dev, index, D3DTADDRESS_BORDER); d3d_set_sampler_address_v(chain->dev, index, D3DTADDRESS_BORDER); chain->bound_tex.push_back(index); } param = cgGetNamedParameter(pass->vPrg, "ORIG.tex_coord"); if (param) { index = pass->attrib_map[cgGetParameterResourceIndex(param)]; d3d_set_stream_source(chain->dev, index, chain->passes[0].vertex_buf, 0, sizeof(Vertex)); chain->bound_vert.push_back(index); } }
void RenderChain::bind_luts(Pass &pass) { for (unsigned i = 0; i < luts.size(); i++) { CGparameter fparam = cgGetNamedParameter(pass.fPrg, luts[i].id.c_str()); int bound_index = -1; if (fparam) { unsigned index = cgGetParameterResourceIndex(fparam); bound_index = index; dev->SetTexture(index, luts[i].tex); dev->SetSamplerState(index, D3DSAMP_MAGFILTER, translate_filter(luts[i].smooth)); dev->SetSamplerState(index, D3DSAMP_MINFILTER, translate_filter(luts[i].smooth)); dev->SetSamplerState(index, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER); dev->SetSamplerState(index, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER); bound_tex.push_back(index); } CGparameter vparam = cgGetNamedParameter(pass.vPrg, luts[i].id.c_str()); if (vparam) { unsigned index = cgGetParameterResourceIndex(vparam); if (index != (unsigned)bound_index) { dev->SetTexture(index, luts[i].tex); dev->SetSamplerState(index, D3DSAMP_MAGFILTER, translate_filter(luts[i].smooth)); dev->SetSamplerState(index, D3DSAMP_MINFILTER, translate_filter(luts[i].smooth)); dev->SetSamplerState(index, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER); dev->SetSamplerState(index, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER); bound_tex.push_back(index); } } } }
static void renderchain_render_pass( cg_renderchain_t *chain, Pass *pass, unsigned pass_index) { unsigned i; if (!chain) return; renderchain_set_shaders(chain, &pass->fPrg, &pass->vPrg); d3d_set_texture(chain->dev, 0, pass->tex); d3d_set_sampler_minfilter(chain->dev, 0, translate_filter(pass->info.pass->filter)); d3d_set_sampler_magfilter(chain->dev, 0, translate_filter(pass->info.pass->filter)); d3d_set_vertex_declaration(chain->dev, pass->vertex_decl); for (i = 0; i < 4; i++) d3d_set_stream_source(chain->dev, i, pass->vertex_buf, 0, sizeof(Vertex)); renderchain_bind_orig(chain, pass); renderchain_bind_prev(chain, pass); renderchain_bind_pass(chain, pass, pass_index); renderchain_bind_luts(chain, pass); renderchain_bind_tracker(chain, pass, pass_index); d3d_draw_primitive(chain->dev, D3DPT_TRIANGLESTRIP, 0, 2); /* So we don't render with linear filter into render targets, * which apparently looked odd (too blurry). */ d3d_set_sampler_minfilter(chain->dev, 0, D3DTEXF_POINT); d3d_set_sampler_magfilter(chain->dev, 0, D3DTEXF_POINT); renderchain_unbind_all(chain); }
//Compile the specified filter into the previously created (non-null) bsf using specified flags int bsf_compile(bsf_t *bsf_desc, char *filter, int flags) { pcap_t *pcap_desc; struct bpf_program *bpf_prog; int optimize; int translate; char *bpf_filter; //bsf_t *bsf_desc; //modify this if we do translation bpf_filter = filter; //process the pertinant flags //optimize if (flags & BSF_FLAG_NO_OPTIMIZE) { optimize = 0; } else { optimize = 1; } //translate if (flags & BSF_FLAG_NO_TRANSLATE) { translate = 0; } else { translate = 1; } //try to create pcap descriptor pcap_desc = pcap_open_dead(BSF_LINK_TYPE, BSF_SNAP_LEN); if (pcap_desc == NULL) { // free(bsf_desc); return BSF_ERROR_PCAP_OPEN; } //Malloc a bpf_program bpf_prog = calloc(1,sizeof(struct bpf_program)); if (bpf_prog == NULL) { // free(bsf_desc); pcap_close(pcap_desc); return BSF_ERROR_MALLOC; } //create a copy of the input filter so we can translate it. bpf_filter = calloc(1,strlen(filter)+1); if (bpf_filter == NULL) { // free(bsf_desc); pcap_close(pcap_desc); free(bpf_prog); return BSF_ERROR_MALLOC; } strncpy( bpf_filter, filter, strlen(filter)); //run filter translation routines if (translate) { translate_filter(bpf_filter); } if (pcap_compile(pcap_desc, bpf_prog, bpf_filter, optimize, 0) == -1) { // free(bsf_desc); pcap_close(pcap_desc); free(bpf_prog); free(bpf_filter); return BSF_ERROR_FILTER; //we don't do anything with error message, but we could--use pcap_geterr(pcap_desc) to retrieve it. } bsf_desc->bpf_prog = bpf_prog; bsf_desc->flags = flags; //*bsf_desc_ref = bsf_desc; free(bpf_filter); pcap_close(pcap_desc); return BSF_ERROR_NONE; }
void RenderChain::bind_prev(Pass &pass) { static const char *prev_names[] = { "PREV", "PREV1", "PREV2", "PREV3", "PREV4", "PREV5", "PREV6", }; char attr_texture[64], attr_input_size[64], attr_tex_size[64], attr_coord[64]; D3DXVECTOR2 texture_size; texture_size.x = passes[0].info.tex_w; texture_size.y = passes[0].info.tex_h; for (unsigned i = 0; i < Textures - 1; i++) { snprintf(attr_texture, sizeof(attr_texture), "%s.texture", prev_names[i]); snprintf(attr_input_size, sizeof(attr_input_size), "%s.video_size", prev_names[i]); snprintf(attr_tex_size, sizeof(attr_tex_size), "%s.texture_size", prev_names[i]); snprintf(attr_coord, sizeof(attr_coord), "%s.tex_coord", prev_names[i]); D3DXVECTOR2 video_size; video_size.x = prev.last_width[(prev.ptr - (i + 1)) & TexturesMask]; video_size.y = prev.last_height[(prev.ptr - (i + 1)) & TexturesMask]; set_cg_param(pass.vPrg, attr_input_size, video_size); set_cg_param(pass.fPrg, attr_input_size, video_size); set_cg_param(pass.vPrg, attr_tex_size, texture_size); set_cg_param(pass.fPrg, attr_tex_size, texture_size); CGparameter param = cgGetNamedParameter(pass.fPrg, attr_texture); if (param) { unsigned index = cgGetParameterResourceIndex(param); LPDIRECT3DTEXTURE tex = prev.tex[(prev.ptr - (i + 1)) & TexturesMask]; dev->SetTexture(index, tex); bound_tex.push_back(index); dev->SetSamplerState(index, D3DSAMP_MAGFILTER, translate_filter(passes[0].info.pass->filter)); dev->SetSamplerState(index, D3DSAMP_MINFILTER, translate_filter(passes[0].info.pass->filter)); dev->SetSamplerState(index, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER); dev->SetSamplerState(index, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER); } param = cgGetNamedParameter(pass.vPrg, attr_coord); if (param) { unsigned index = pass.attrib_map[cgGetParameterResourceIndex(param)]; LPDIRECT3DVERTEXBUFFER vert_buf = prev.vertex_buf[(prev.ptr - (i + 1)) & TexturesMask]; bound_vert.push_back(index); dev->SetStreamSource(index, vert_buf, 0, sizeof(Vertex)); } } }
static void renderchain_bind_pass(cg_renderchain_t *chain, Pass *pass, unsigned pass_index) { unsigned i, index; /* We only bother binding passes which are two indices behind. */ if (pass_index < 3) return; for (i = 1; i < pass_index - 1; i++) { CGparameter param; D3DXVECTOR2 video_size, texture_size; char pass_base[64] = {0}; char attr_texture[64] = {0}; char attr_input_size[64] = {0}; char attr_tex_size[64] = {0}; char attr_coord[64] = {0}; snprintf(pass_base, sizeof(pass_base), "PASS%u", i); snprintf(attr_texture, sizeof(attr_texture), "%s.texture", pass_base); snprintf(attr_input_size, sizeof(attr_input_size), "%s.video_size", pass_base); snprintf(attr_tex_size, sizeof(attr_tex_size), "%s.texture_size", pass_base); snprintf(attr_coord, sizeof(attr_coord), "%s.tex_coord", pass_base); video_size.x = chain->passes[i].last_width; video_size.y = chain->passes[i].last_height; texture_size.x = chain->passes[i].info.tex_w; texture_size.y = chain->passes[i].info.tex_h; set_cg_param(pass->vPrg, attr_input_size, video_size); set_cg_param(pass->fPrg, attr_input_size, video_size); set_cg_param(pass->vPrg, attr_tex_size, texture_size); set_cg_param(pass->fPrg, attr_tex_size, texture_size); param = cgGetNamedParameter(pass->fPrg, attr_texture); if (param) { index = cgGetParameterResourceIndex(param); chain->bound_tex.push_back(index); d3d_set_texture(chain->dev, index, chain->passes[i].tex); d3d_set_sampler_magfilter(chain->dev, index, translate_filter(chain->passes[i].info.pass->filter)); d3d_set_sampler_minfilter(chain->dev, index, translate_filter(chain->passes[i].info.pass->filter)); d3d_set_sampler_address_u(chain->dev, index, D3DTADDRESS_BORDER); d3d_set_sampler_address_v(chain->dev, index, D3DTADDRESS_BORDER); } param = cgGetNamedParameter(pass->vPrg, attr_coord); if (param) { index = pass->attrib_map[cgGetParameterResourceIndex(param)]; d3d_set_stream_source(chain->dev, index, chain->passes[i].vertex_buf, 0, sizeof(Vertex)); chain->bound_vert.push_back(index); } } }
static void renderchain_bind_prev(cg_renderchain_t *chain, void *pass_data) { unsigned i, index; D3DXVECTOR2 texture_size; char attr_texture[64] = {0}; char attr_input_size[64] = {0}; char attr_tex_size[64] = {0}; char attr_coord[64] = {0}; Pass *pass = (Pass*)pass_data; static const char *prev_names[] = { "PREV", "PREV1", "PREV2", "PREV3", "PREV4", "PREV5", "PREV6", }; texture_size.x = chain->passes[0].info.tex_w; texture_size.y = chain->passes[0].info.tex_h; for (i = 0; i < TEXTURES - 1; i++) { CGparameter param; D3DXVECTOR2 video_size; snprintf(attr_texture, sizeof(attr_texture), "%s.texture", prev_names[i]); snprintf(attr_input_size, sizeof(attr_input_size), "%s.video_size", prev_names[i]); snprintf(attr_tex_size, sizeof(attr_tex_size), "%s.texture_size", prev_names[i]); snprintf(attr_coord, sizeof(attr_coord), "%s.tex_coord", prev_names[i]); video_size.x = chain->prev.last_width[(chain->prev.ptr - (i + 1)) & TEXTURESMASK]; video_size.y = chain->prev.last_height[(chain->prev.ptr - (i + 1)) & TEXTURESMASK]; set_cg_param(pass->vPrg, attr_input_size, video_size); set_cg_param(pass->fPrg, attr_input_size, video_size); set_cg_param(pass->vPrg, attr_tex_size, texture_size); set_cg_param(pass->fPrg, attr_tex_size, texture_size); param = cgGetNamedParameter(pass->fPrg, attr_texture); if (param) { LPDIRECT3DTEXTURE tex; index = cgGetParameterResourceIndex(param); tex = (LPDIRECT3DTEXTURE) chain->prev.tex[(chain->prev.ptr - (i + 1)) & TEXTURESMASK]; d3d_set_texture(chain->dev, index, tex); chain->bound_tex.push_back(index); d3d_set_sampler_magfilter(chain->dev, index, translate_filter(chain->passes[0].info.pass->filter)); d3d_set_sampler_minfilter(chain->dev, index, translate_filter(chain->passes[0].info.pass->filter)); d3d_set_sampler_address_u(chain->dev, index, D3DTADDRESS_BORDER); d3d_set_sampler_address_v(chain->dev, index, D3DTADDRESS_BORDER); } param = cgGetNamedParameter(pass->vPrg, attr_coord); if (param) { LPDIRECT3DVERTEXBUFFER vert_buf = (LPDIRECT3DVERTEXBUFFER) chain->prev.vertex_buf[(chain->prev.ptr - (i + 1)) & TEXTURESMASK]; index = pass->attrib_map[cgGetParameterResourceIndex(param)]; chain->bound_vert.push_back(index); d3d_set_stream_source(chain->dev, index, vert_buf, 0, sizeof(Vertex)); } } }