void osd_xenon_video_hw_init(running_machine &machine) { TR; XenosSurface * fb = Xe_GetFramebufferSurface(g_pVideoDevice); Xe_SetClearColor(g_pVideoDevice, 0); // on mame exit machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(osd_xenon_video_cleanup), &machine)); }
void osd_xenon_video_hw_init(running_machine &machine) { XenosSurface * fb = Xe_GetFramebufferSurface(g_pVideoDevice); Xe_SetRenderTarget(g_pVideoDevice, fb); LoadShaderEffects(); g_pTexture = Xe_CreateTexture(g_pVideoDevice, XE_W, XE_H, 1, XE_FMT_8888 | XE_FMT_ARGB, 0); screen = (unsigned int*) Xe_Surface_LockRect(g_pVideoDevice, g_pTexture, 0, 0, 0, 0, XE_LOCK_WRITE); Xe_Surface_Unlock(g_pVideoDevice, g_pTexture); g_pTexture->use_filtering = 0; pitch = g_pTexture->wpitch; screen_width = fb->width; screen_height = fb->height; vb = Xe_CreateVertexBuffer(g_pVideoDevice, 65536 * sizeof (MameVerticeFormats)); soft_vb = Xe_CreateVertexBuffer(g_pVideoDevice, 65536 * sizeof (MameVerticeFormats)); float w = fb->width; float h = fb->height; Xe_SetClearColor(g_pVideoDevice, 0); osd_xenon_video_resume(); // on mame exit machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(osd_xenon_video_cleanup), &machine)); }
void SYSVideoUpdate() { /* resize uv to viewport */ int vwidth = bitmap.viewport.w + (2 * bitmap.viewport.x); int vheight = bitmap.viewport.h + (2 * bitmap.viewport.y); update_texture_viewport(); int video_filter = getVideoFitler(); // apply video filter switch (video_filter){ case VF_2XSAI: filter_Std2xSaI_ex8(bitmap.data, bitmap.pitch, texture_buffer, vwidth, vheight); g_pTexture->width = vwidth<<1; g_pTexture->height = vheight<<1; break; case VF_BLINEAR: g_pTexture->use_filtering = 0; XeTexSubImage(g_pTexture, bitmap.viewport.x, bitmap.viewport.y, bitmap.viewport.w, bitmap.viewport.h, bitmap.data); g_pTexture->width = vwidth; g_pTexture->height = vheight; break; default: g_pTexture->use_filtering = 1; XeTexSubImage(g_pTexture, bitmap.viewport.x, bitmap.viewport.y, bitmap.viewport.w, bitmap.viewport.h, bitmap.data); g_pTexture->width = vwidth; g_pTexture->height = vheight; break; } // Refresh texture cash Xe_Surface_LockRect(g_pVideoDevice, g_pTexture, 0, 0, 0, 0, XE_LOCK_WRITE); Xe_Surface_Unlock(g_pVideoDevice, g_pTexture); // Select stream and shaders Xe_SetTexture(g_pVideoDevice, 0, g_pTexture); Xe_SetCullMode(g_pVideoDevice, XE_CULL_NONE); Xe_SetStreamSource(g_pVideoDevice, 0, vb, 0, sizeof (DrawVerticeFormats)); Xe_SetShader(g_pVideoDevice, SHADER_TYPE_PIXEL, g_pPixelTexturedShader, 0); Xe_SetShader(g_pVideoDevice, SHADER_TYPE_VERTEX, g_pVertexShader, 0); Xe_SetClearColor(g_pVideoDevice, 0xFF000000); // Draw Xe_DrawPrimitive(g_pVideoDevice, XE_PRIMTYPE_RECTLIST, 0, 1); // Resolve Xe_Resolve(g_pVideoDevice); //while (!Xe_IsVBlank(g_pVideoDevice)); Xe_Sync(g_pVideoDevice); // Reset states Xe_InvalidateState(g_pVideoDevice); }
static bool xenon360_gfx_frame(void *data, const void *frame, unsigned width, unsigned height, uint64_t frame_count, unsigned pitch, const char *msg, video_frame_info_t *video_info) { gl_t *vid = data; ScreenUv[UV_TOP] = ((float) (width) / (float) XE_W)*2; ScreenUv[UV_LEFT] = ((float) (height) / (float) XE_H)*2; DrawVerticeFormats * Rect = Xe_VB_Lock(vid->gl_device, vid->vb, 0, 3 * sizeof(DrawVerticeFormats), XE_LOCK_WRITE); /* bottom left */ Rect[1].v = ScreenUv[UV_LEFT]; Rect[2].u = ScreenUv[UV_TOP]; Xe_VB_Unlock(vid->gl_device, vid->vb); /* Refresh texture cache */ uint16_t *dst = Xe_Surface_LockRect(vid->gl_device, vid->g_pTexture, 0, 0, 0, 0, XE_LOCK_WRITE); const uint16_t *src = frame; unsigned stride_in = pitch >>1; unsigned stride_out = vid->g_pTexture->wpitch >> 1; unsigned copy_size = width << 1; for (unsigned y = 0; y < height; y++, dst += stride_out, src += stride_in) memcpy(dst, src, copy_size); Xe_Surface_Unlock(vid->gl_device, vid->g_pTexture); /* Reset states */ Xe_InvalidateState(vid->gl_device); Xe_SetClearColor(vid->gl_device, 0); /* Select stream */ Xe_SetTexture(vid->gl_device, 0, vid->g_pTexture); Xe_SetCullMode(vid->gl_device, XE_CULL_NONE); Xe_SetStreamSource(vid->gl_device, 0, vid->vb, 0, sizeof(DrawVerticeFormats)); /* Select shaders */ Xe_SetShader(vid->gl_device, SHADER_TYPE_PIXEL, vid->g_pPixelTexturedShader, 0); Xe_SetShader(vid->gl_device, SHADER_TYPE_VERTEX, vid->g_pVertexShader, 0); #ifdef HAVE_MENU menu_driver_frame(video_info); #endif /* Draw */ Xe_DrawPrimitive(vid->gl_device, XE_PRIMTYPE_TRIANGLELIST, 0, 1); /* Resolve */ Xe_Resolve(vid->gl_device); Xe_Sync(vid->gl_device); return true; }
/** Effectue un printf rapide avec effaement de couleur/ et rafraichissement **/ void fastPrintf(int x, int y, int color, char *str) { Xe_InvalidateState(xe); XeDrawSurface2(XeBgInfo, -1, -1, 2, 2, 0); XePrintf(-0.5, 0, str, 0.6, 0xFF0000);//Bleu #if 1 //Blanc .... Xe_SetClearColor(xe, ~0); Xe_Resolve(xe); while (!Xe_IsVBlank(xe)) ; Xe_Sync(xe); #endif }
void osd_xenon_video_init() { g_pVideoDevice = &_xe; Xe_Init(g_pVideoDevice); XenosSurface * fb = Xe_GetFramebufferSurface(g_pVideoDevice); Xe_SetRenderTarget(g_pVideoDevice, fb); static const struct XenosVBFFormat vbf = { 3, { {XE_USAGE_POSITION, 0, XE_TYPE_FLOAT4}, {XE_USAGE_COLOR, 0, XE_TYPE_UBYTE4}, {XE_USAGE_TEXCOORD, 0, XE_TYPE_FLOAT2}, } }; g_pPixelTexturedShader = Xe_LoadShaderFromMemory(g_pVideoDevice, (void*) g_xps_ps_main); Xe_InstantiateShader(g_pVideoDevice, g_pPixelTexturedShader, 0); g_pVertexShader = Xe_LoadShaderFromMemory(g_pVideoDevice, (void*) g_xvs_VSmain); Xe_InstantiateShader(g_pVideoDevice, g_pVertexShader, 0); Xe_ShaderApplyVFetchPatches(g_pVideoDevice, g_pVertexShader, 0, &vbf); g_pTexture = Xe_CreateTexture(g_pVideoDevice, XE_W, XE_H, 1, XE_FMT_8888 | XE_FMT_ARGB, 0); screen = (unsigned int*) Xe_Surface_LockRect(g_pVideoDevice, g_pTexture, 0, 0, 0, 0, XE_LOCK_WRITE); Xe_Surface_Unlock(g_pVideoDevice, g_pTexture); g_pTexture->use_filtering = 0; pitch = g_pTexture->wpitch; screen_width = fb->width; screen_height = fb->height; vb = Xe_CreateVertexBuffer(g_pVideoDevice, 65536 * sizeof (DrawVerticeFormats)); soft_vb = Xe_CreateVertexBuffer(g_pVideoDevice, 65536 * sizeof (DrawVerticeFormats)); float w = fb->width; float h = fb->height; Xe_SetClearColor(g_pVideoDevice, 0); edram_init(g_pVideoDevice); }
void XenonGLDisplay() { Xe_SetBlendOp(xe, XE_BLENDOP_ADD); Xe_SetSrcBlend(xe, XE_BLEND_SRCALPHA); Xe_SetDestBlend(xe, XE_BLEND_INVSRCALPHA); // update vb cache !!! Xe_VB_Lock(xe, pVbGL, 0, XE_MAX_VERTICES, XE_LOCK_WRITE); Xe_VB_Unlock(xe, pVbGL); /* // Refresh texture cash unsigned int * pBitmap = Xe_Surface_LockRect(xe, pVideoSurface, 0, 0, 0, 0, XE_LOCK_WRITE); int i; for(i = 0;i<(vid.width*vid.height);i++) { //Make an ARGB bitmap unsigned int c = (pQ2Palette[vid.buffer[i]]) >> 8 | ( 0xFF << 24 ); pBitmap[i] = c; } Xe_Surface_Unlock(xe, pVideoSurface); // Select stream and shaders Xe_SetTexture(xe, 0, pVideoSurface); Xe_SetCullMode(xe, XE_CULL_NONE); Xe_SetStreamSource(xe, 0, pVBSw, 0, 10); Xe_SetShader(xe, SHADER_TYPE_PIXEL, pPixelShader, 0); Xe_SetShader(xe, SHADER_TYPE_VERTEX, pVertexShader, 0); // Draw Xe_DrawPrimitive(xe, XE_PRIMTYPE_RECTLIST, 0, 1); */ // Resolve Xe_Resolve(xe); while(!Xe_IsVBlank(xe)); Xe_Sync(xe); // Reset states Xe_InvalidateState(xe); Xe_SetClearColor(xe, 0); xe_NumVerts = xe_PrevNumVerts = 0; ShowFPS(); }
void updateIGM(int debut, int fin) { if(debut) Xe_InvalidateState(xe); //Dessine la scene XeDrawSurface2(igmBg, -1, -1, 2, 2, 1); //XeDrawSurface(igmBarr,-1,-1,1,1,1);//Barr en haut XeDrawSurface2(igmBarr, -1, 0.7, 2, .3, 1); //event sur la manette igmInput(); switch(menuselected) { case 0: drawMenuIcon(); break; case ITEM_RETURN_TO_MENU: drawReturnToMenu(); break; case ITEM_DISPLAY_INFO: drawInformation(); break; default: drawMenuIcon(); break; } if(fin) { Xe_SetClearColor(xe, ~0); /* resolve (and clear) */ Xe_Resolve(xe); /* wait for render finish */ while (!Xe_IsVBlank(xe)); Xe_Sync(xe); } nframe=1.0f; }
void XenonGLInit(){ // init video xe=&_xe; Xe_Init(xe); edram_init(xe); Xe_SetRenderTarget(xe, Xe_GetFramebufferSurface(xe)); static const struct XenosVBFFormat vbf = { 4, { {XE_USAGE_POSITION, 0, XE_TYPE_FLOAT4}, {XE_USAGE_TEXCOORD, 0, XE_TYPE_FLOAT2}, {XE_USAGE_TEXCOORD, 1, XE_TYPE_FLOAT2}, {XE_USAGE_COLOR, 0, XE_TYPE_UBYTE4}, } }; pPixelShader = Xe_LoadShaderFromMemory(xe, (void*) g_xps_ps_main); Xe_InstantiateShader(xe, pPixelShader, 0); pVertexShader = Xe_LoadShaderFromMemory(xe, (void*) g_xvs_vs_main); Xe_InstantiateShader(xe, pVertexShader, 0); Xe_ShaderApplyVFetchPatches(xe, pVertexShader, 0, &vbf); // Create vb pVbGL = Xe_CreateVertexBuffer(xe, XE_MAX_VERTICES); xe_Vertices = Xe_VB_Lock(xe, pVbGL, 0, XE_MAX_VERTICES, XE_LOCK_WRITE); Xe_VB_Unlock(xe, pVbGL); // init matrices XeGlInitializeMatrix(&projection_matrix); XeGlInitializeMatrix(&modelview_matrix); // init vertices xe_NumVerts = 0; xe_CurrentColor.u32 = 0xFFFFFFFF; // init textures // not yet ... Xe_InvalidateState(xe); Xe_SetClearColor(xe, 0); }
/** Effectue un printf rapide avec effaement de couleur/ et rafraichissement **/ void errorPrintf(int x, int y, int color, char *str) { Xe_InvalidateState(xe); XePrintf(-0.5, 0, str, 0.6, 0x0000FF);//Red #if 1 //Blanc .... Xe_SetClearColor(xe, ~0); Xe_Resolve(xe); while (!Xe_IsVBlank(xe)) ; Xe_Sync(xe); //Attends qu'une touche soit presser while (1) { struct controller_data_s c; if (get_controller_data(&c, 0)) { return;//Quit } } #endif }
static void *xenon360_gfx_init(const video_info_t *video, const input_driver_t **input, void **input_data) { gl_t * gl = calloc(1, sizeof(gl_t)); if (!gl) return NULL; gl->gl_device = &gl->real_device; Xe_Init(gl->gl_device); Xe_SetRenderTarget(gl->gl_device, Xe_GetFramebufferSurface(gl->gl_device)); static const struct XenosVBFFormat vbf = { 3, { {XE_USAGE_POSITION, 0, XE_TYPE_FLOAT4}, {XE_USAGE_COLOR, 0, XE_TYPE_UBYTE4}, {XE_USAGE_TEXCOORD, 0, XE_TYPE_FLOAT2}, } }; gl->g_pPixelTexturedShader = Xe_LoadShaderFromMemory(gl->gl_device, (void*)g_xps_PS); Xe_InstantiateShader(gl->gl_device, gl->g_pPixelTexturedShader, 0); gl->g_pVertexShader = Xe_LoadShaderFromMemory(gl->gl_device, (void*)g_xvs_VS); Xe_InstantiateShader(gl->gl_device, gl->g_pVertexShader, 0); Xe_ShaderApplyVFetchPatches(gl->gl_device, gl->g_pVertexShader, 0, &vbf); gl->g_pTexture = Xe_CreateTexture(gl->gl_device, XE_W, XE_H, 1, XE_FMT_5551 | XE_FMT_16BE, 0); gl->g_pTexture->use_filtering = 1; edram_init(gl->gl_device); // enable filtering for now float x = -1.0f; float y = 1.0f; float w = 4.0f; float h = 4.0f; gl->vb = Xe_CreateVertexBuffer(gl->gl_device, 3 * sizeof(DrawVerticeFormats)); DrawVerticeFormats *Rect = Xe_VB_Lock(gl->gl_device, gl->vb, 0, 3 * sizeof (DrawVerticeFormats), XE_LOCK_WRITE); ScreenUv[UV_TOP] = ScreenUv[UV_TOP] * 2; ScreenUv[UV_LEFT] = ScreenUv[UV_LEFT] * 2; // top left Rect[0].x = x; Rect[0].y = y; Rect[0].u = ScreenUv[UV_BOTTOM]; Rect[0].v = ScreenUv[UV_RIGHT]; Rect[0].color = 0; // bottom left Rect[1].x = x; Rect[1].y = y - h; Rect[1].u = ScreenUv[UV_BOTTOM]; Rect[1].v = ScreenUv[UV_LEFT]; Rect[1].color = 0; // top right Rect[2].x = x + w; Rect[2].y = y; Rect[2].u = ScreenUv[UV_TOP]; Rect[2].v = ScreenUv[UV_RIGHT]; Rect[2].color = 0; Rect[3].x = x + w; Rect[3].y = y; Rect[3].u = ScreenUv[UV_TOP]; Rect[3].v = ScreenUv[UV_RIGHT]; Rect[3].color = 0; int i = 0; for (i = 0; i < 3; i++) { Rect[i].z = 0.0; Rect[i].w = 1.0; } Xe_VB_Unlock(gl->gl_device, gl->vb); Xe_SetClearColor(gl->gl_device, 0); return gl; }
void CreateDisplay(void) { #ifndef LZX_GUI g_pVideoDevice = &_xe; Xe_Init(g_pVideoDevice); #else g_pVideoDevice = getLzxVideoDevice(); #endif fb = Xe_GetFramebufferSurface(g_pVideoDevice); Xe_SetRenderTarget(g_pVideoDevice, fb); /* mame HLSL struct VS_INPUT { float4 Position : POSITION; float4 Color : COLOR0; float2 TexCoord : TEXCOORD0; }; */ static const struct XenosVBFFormat vbf = { 3, { {XE_USAGE_POSITION, 0, XE_TYPE_FLOAT4}, {XE_USAGE_COLOR, 0, XE_TYPE_UBYTE4}, {XE_USAGE_TEXCOORD, 0, XE_TYPE_FLOAT2}, } }; #ifdef MAME_SHADER g_pPixelTexturedShader = Xe_LoadShaderFromMemory(g_pVideoDevice, (void*) g_xps_ps_main); #else g_pPixelTexturedShader = Xe_LoadShaderFromMemory(g_pVideoDevice, (void*) g_xps_PS); #endif //g_pPixelTexturedShader = Xe_LoadShaderFromMemory(g_pVideoDevice, (void*) draw_t_p_psu); Xe_InstantiateShader(g_pVideoDevice, g_pPixelTexturedShader, 0); #ifdef MAME_SHADER g_pVertexShader = Xe_LoadShaderFromMemory(g_pVideoDevice, (void*) g_xvs_vs_main); #else g_pVertexShader = Xe_LoadShaderFromMemory(g_pVideoDevice, (void*) g_xvs_VS); #endif //g_pVertexShader = Xe_LoadShaderFromMemory(g_pVideoDevice, (void*) draw_v_vsu); Xe_InstantiateShader(g_pVideoDevice, g_pVertexShader, 0); Xe_ShaderApplyVFetchPatches(g_pVideoDevice, g_pVertexShader, 0, &vbf); edram_init(g_pVideoDevice); // Create the psxScreen texture if (g_pTexture) Xe_DestroyTexture(g_pVideoDevice, g_pTexture); g_pTexture = Xe_CreateTexture(g_pVideoDevice, psxRealW, psxRealH, 1, XE_FMT_8888 | XE_FMT_ARGB, 0); psxScreen = (unsigned char*) Xe_Surface_LockRect(g_pVideoDevice, g_pTexture, 0, 0, 0, 0, XE_LOCK_WRITE); g_pPitch = g_pTexture->wpitch; Xe_Surface_Unlock(g_pVideoDevice, g_pTexture); memset(psxScreen, 0, 1024 * 512 * 2); // move it to ini file float x = -1.0f; float y = -1.0f; float w = 2.0f; float h = 2.0f; // top left Rect[0].x = x; Rect[0].y = y + h; Rect[0].u = PsxScreenUv[UvBottom]; Rect[0].v = PsxScreenUv[UvRight]; Rect[0].color = 0; // bottom left Rect[1].x = x; Rect[1].y = y; Rect[1].u = PsxScreenUv[UvBottom]; Rect[1].v = PsxScreenUv[UvLeft]; Rect[1].color = 0; // top right Rect[2].x = x + w; Rect[2].y = y + h; Rect[2].u = PsxScreenUv[UvTop]; Rect[2].v = PsxScreenUv[UvRight]; Rect[2].color = 0; // top right Rect[3].x = x + w; Rect[3].y = y + h; Rect[3].u = PsxScreenUv[UvTop]; ; Rect[3].v = PsxScreenUv[UvRight]; Rect[3].color = 0; // bottom left Rect[4].x = x; Rect[4].y = y; Rect[4].u = PsxScreenUv[UvBottom]; Rect[4].v = PsxScreenUv[UvLeft]; Rect[4].color = 0; // bottom right Rect[5].x = x + w; Rect[5].y = y; Rect[5].u = PsxScreenUv[UvTop]; Rect[5].v = PsxScreenUv[UvLeft]; Rect[5].color = 0; int i = 0; for (i = 0; i < 6; i++) { Rect[i].z = 0.0; Rect[i].w = 1.0; } CreateTexture(psxRealW, psxRealH); Xe_SetClearColor(g_pVideoDevice, 0); }
void XenonGLInit(){ // init video xe=&_xe; Xe_Init(xe); edram_init(xe); Xe_SetRenderTarget(xe, Xe_GetFramebufferSurface(xe)); static const struct XenosVBFFormat vbf = { 4, { {XE_USAGE_POSITION, 0, XE_TYPE_FLOAT4}, {XE_USAGE_TEXCOORD, 0, XE_TYPE_FLOAT2}, {XE_USAGE_TEXCOORD, 1, XE_TYPE_FLOAT2}, {XE_USAGE_COLOR, 0, XE_TYPE_UBYTE4}, } }; struct XenosSurface * fb = Xe_GetFramebufferSurface(xe); pPixelTextureShader = Xe_LoadShaderFromMemory(xe, (void*) g_xps_ps_texture); Xe_InstantiateShader(xe, pPixelTextureShader, 0); pPixelModulateShader = Xe_LoadShaderFromMemory(xe, (void*) g_xps_ps_modulate); Xe_InstantiateShader(xe, pPixelModulateShader, 0); pPixelModulateShader2 = Xe_LoadShaderFromMemory(xe, (void*) g_xps_ps_modulate_2); Xe_InstantiateShader(xe, pPixelModulateShader2, 0); pPixelColorShader = Xe_LoadShaderFromMemory(xe, (void*) g_xps_ps_color); Xe_InstantiateShader(xe, pPixelColorShader, 0); pCurrentPs = g_xps_ps_color; pCurrentTexturedPs = g_xps_ps_texture; pVertexShader = Xe_LoadShaderFromMemory(xe, (void*) g_xvs_vs_main); Xe_InstantiateShader(xe, pVertexShader, 0); Xe_ShaderApplyVFetchPatches(xe, pVertexShader, 0, &vbf); // Create vb pVbGL = Xe_CreateVertexBuffer(xe, XE_MAX_VERTICES * sizeof(glVerticesFormat_t)); xe_Vertices = Xe_VB_Lock(xe, pVbGL, 0, XE_MAX_VERTICES * sizeof(glVerticesFormat_t), XE_LOCK_WRITE); Xe_VB_Unlock(xe, pVbGL); // Create indices pIbGL = Xe_CreateIndexBuffer(xe, XE_MAX_INDICES_PER_DRAW, XE_FMT_INDEX16); xe_indices = Xe_IB_Lock(xe, pIbGL, 0, XE_MAX_INDICES_PER_DRAW, XE_LOCK_WRITE); Xe_IB_Unlock(xe, pIbGL); // init matrices XeGlInitializeMatrix(&projection_matrix); XeGlInitializeMatrix(&modelview_matrix); // frontbuffer = Xe_CreateTexture(xe, fb->width, fb->height, 0, XE_FMT_8888 | XE_FMT_BGRA, 1); // init vertices xe_NumVerts = 0; xe_NumIndices = 0; xe_CurrentColor.u32 = 0x0; // init textures XeGLInitTextures(); // init states XeInitStates(); // not yet ... Xe_InvalidateState(xe); Xe_SetClearColor(xe, 0); GL_InitShaderCache(); }