static int Direct3DRenderRegion(vout_display_t *vd,
d3d_region_t *region)
{
vout_display_sys_t *sys = vd->sys;
LPDIRECT3DDEVICE9 d3ddev = vd->sys->d3ddev;
LPDIRECT3DVERTEXBUFFER9 d3dvtc = sys->d3dvtc;
LPDIRECT3DTEXTURE9 d3dtex = region->texture;
HRESULT hr;
/* Import vertices */
void *vertex;
hr = IDirect3DVertexBuffer9_Lock(d3dvtc, 0, 0, &vertex, D3DLOCK_DISCARD);
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
return -1;
}
memcpy(vertex, region->vertex, sizeof(region->vertex));
hr = IDirect3DVertexBuffer9_Unlock(d3dvtc);
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
return -1;
}
// Setup our texture. Using textures introduces the texture stage states,
// which govern how textures get blended together (in the case of multiple
// textures) and lighting information. In this case, we are modulating
// (blending) our texture with the diffuse color of the vertices.
hr = IDirect3DDevice9_SetTexture(d3ddev, 0, (LPDIRECT3DBASETEXTURE9)d3dtex);
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
return -1;
}
// Render the vertex buffer contents
hr = IDirect3DDevice9_SetStreamSource(d3ddev, 0, d3dvtc, 0, sizeof(CUSTOMVERTEX));
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
return -1;
}
// we use FVF instead of vertex shader
hr = IDirect3DDevice9_SetFVF(d3ddev, D3DFVF_CUSTOMVERTEX);
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
return -1;
}
// draw rectangle
hr = IDirect3DDevice9_DrawPrimitive(d3ddev, D3DPT_TRIANGLEFAN, 0, 2);
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
return -1;
}
return 0;
}
static int
D3D_RenderDrawLines(SDL_Renderer * renderer, const SDL_Point * points,
int count)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
DWORD color;
Vertex *vertices;
int i;
HRESULT result;
if (data->beginScene) {
IDirect3DDevice9_BeginScene(data->device);
data->beginScene = SDL_FALSE;
}
D3D_SetBlendMode(data, renderer->blendMode);
result =
IDirect3DDevice9_SetTexture(data->device, 0,
(IDirect3DBaseTexture9 *) 0);
if (FAILED(result)) {
D3D_SetError("SetTexture()", result);
return -1;
}
color = D3DCOLOR_ARGB(renderer->a, renderer->r, renderer->g, renderer->b);
vertices = SDL_stack_alloc(Vertex, count);
for (i = 0; i < count; ++i) {
vertices[i].x = (float) points[i].x;
vertices[i].y = (float) points[i].y;
vertices[i].z = 0.0f;
vertices[i].rhw = 1.0f;
vertices[i].color = color;
vertices[i].u = 0.0f;
vertices[i].v = 0.0f;
}
result =
IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_LINESTRIP, count-1,
vertices, sizeof(*vertices));
/* DirectX 9 has the same line rasterization semantics as GDI,
so we need to close the endpoint of the line */
if (points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
vertices[0].x = (float) points[count-1].x;
vertices[0].y = (float) points[count-1].y;
result = IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_POINTLIST, 1, vertices, sizeof(*vertices));
}
SDL_stack_free(vertices);
if (FAILED(result)) {
D3D_SetError("DrawPrimitiveUP()", result);
return -1;
}
return 0;
}
static void test_gettexture(IDirect3DDevice9 *device) {
HRESULT hr;
IDirect3DBaseTexture9 *texture = (IDirect3DBaseTexture9 *) 0xdeadbeef;
hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr = 0x%08x\n", hr);
hr = IDirect3DDevice9_GetTexture(device, 0, &texture);
ok(hr == D3D_OK, "IDirect3DDevice9_GetTexture failed, hr = 0x%08x\n", hr);
ok(texture == NULL, "Texture returned is %p, expected NULL\n", texture);
}
static int
D3D_RenderLine(SDL_Renderer * renderer, int x1, int y1, int x2, int y2)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
DWORD color;
Vertex vertices[2];
HRESULT result;
if (data->beginScene) {
IDirect3DDevice9_BeginScene(data->device);
data->beginScene = SDL_FALSE;
}
color = D3DCOLOR_ARGB(renderer->a, renderer->r, renderer->g, renderer->b);
vertices[0].x = (float) x1 - 0.5f;
vertices[0].y = (float) y1 - 0.5f;
vertices[0].z = 0.0f;
vertices[0].rhw = 1.0f;
vertices[0].color = color;
vertices[0].u = 0.0f;
vertices[0].v = 0.0f;
vertices[1].x = (float) x2 - 0.5f;
vertices[1].y = (float) y2 - 0.5f;
vertices[1].z = 0.0f;
vertices[1].rhw = 1.0f;
vertices[1].color = color;
vertices[1].u = 0.0f;
vertices[1].v = 0.0f;
D3D_SetBlendMode(data, renderer->blendMode);
result =
IDirect3DDevice9_SetTexture(data->device, 0,
(IDirect3DBaseTexture9 *) 0);
if (FAILED(result)) {
D3D_SetError("SetTexture()", result);
return -1;
}
result =
IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_LINELIST, 1,
vertices, sizeof(*vertices));
if (FAILED(result)) {
D3D_SetError("DrawPrimitiveUP()", result);
return -1;
}
return 0;
}
static int
D3D_RenderDrawPoints(SDL_Renderer * renderer, const SDL_Point * points,
int count)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
DWORD color;
Vertex *vertices;
int i;
HRESULT result;
if (data->beginScene) {
IDirect3DDevice9_BeginScene(data->device);
data->beginScene = SDL_FALSE;
}
D3D_SetBlendMode(data, renderer->blendMode);
result =
IDirect3DDevice9_SetTexture(data->device, 0,
(IDirect3DBaseTexture9 *) 0);
if (FAILED(result)) {
D3D_SetError("SetTexture()", result);
return -1;
}
color = D3DCOLOR_ARGB(renderer->a, renderer->r, renderer->g, renderer->b);
vertices = SDL_stack_alloc(Vertex, count);
for (i = 0; i < count; ++i) {
vertices[i].x = (float) points[i].x;
vertices[i].y = (float) points[i].y;
vertices[i].z = 0.0f;
vertices[i].rhw = 1.0f;
vertices[i].color = color;
vertices[i].u = 0.0f;
vertices[i].v = 0.0f;
}
result =
IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_POINTLIST, count,
vertices, sizeof(*vertices));
SDL_stack_free(vertices);
if (FAILED(result)) {
D3D_SetError("DrawPrimitiveUP()", result);
return -1;
}
return 0;
}
void d3d_set_texture(LPDIRECT3DDEVICE dev, unsigned sampler,
void *tex_data)
{
LPDIRECT3DTEXTURE tex = (LPDIRECT3DTEXTURE)tex_data;
#if defined(_XBOX1)
D3DDevice_SetTexture(sampler, tex);
#elif defined(_XBOX360)
unsigned fetchConstant =
GPU_CONVERT_D3D_TO_HARDWARE_TEXTUREFETCHCONSTANT(sampler);
uint64_t pendingMask3 =
D3DTAG_MASKENCODE(D3DTAG_START(D3DTAG_FETCHCONSTANTS)
+ fetchConstant, D3DTAG_START(D3DTAG_FETCHCONSTANTS)
+ fetchConstant);
D3DDevice_SetTexture(dev, sampler, tex, pendingMask3);
#elif defined(HAVE_D3D9) && !defined(__cplusplus)
IDirect3DDevice9_SetTexture(dev, sampler, tex);
#else
dev->SetTexture(sampler, tex);
#endif
}
static int
D3D_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * srcrect, const SDL_Rect * dstrect)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
D3D_TextureData *texturedata = (D3D_TextureData *) texture->driverdata;
LPDIRECT3DPIXELSHADER9 shader = NULL;
float minx, miny, maxx, maxy;
float minu, maxu, minv, maxv;
DWORD color;
Vertex vertices[4];
HRESULT result;
if (data->beginScene) {
IDirect3DDevice9_BeginScene(data->device);
data->beginScene = SDL_FALSE;
}
minx = (float) dstrect->x - 0.5f;
miny = (float) dstrect->y - 0.5f;
maxx = (float) dstrect->x + dstrect->w - 0.5f;
maxy = (float) dstrect->y + dstrect->h - 0.5f;
minu = (float) srcrect->x / texture->w;
maxu = (float) (srcrect->x + srcrect->w) / texture->w;
minv = (float) srcrect->y / texture->h;
maxv = (float) (srcrect->y + srcrect->h) / texture->h;
color = D3DCOLOR_ARGB(texture->a, texture->r, texture->g, texture->b);
vertices[0].x = minx;
vertices[0].y = miny;
vertices[0].z = 0.0f;
vertices[0].rhw = 1.0f;
vertices[0].color = color;
vertices[0].u = minu;
vertices[0].v = minv;
vertices[1].x = maxx;
vertices[1].y = miny;
vertices[1].z = 0.0f;
vertices[1].rhw = 1.0f;
vertices[1].color = color;
vertices[1].u = maxu;
vertices[1].v = minv;
vertices[2].x = maxx;
vertices[2].y = maxy;
vertices[2].z = 0.0f;
vertices[2].rhw = 1.0f;
vertices[2].color = color;
vertices[2].u = maxu;
vertices[2].v = maxv;
vertices[3].x = minx;
vertices[3].y = maxy;
vertices[3].z = 0.0f;
vertices[3].rhw = 1.0f;
vertices[3].color = color;
vertices[3].u = minu;
vertices[3].v = maxv;
D3D_SetBlendMode(data, texture->blendMode);
if (texture->blendMode == SDL_BLENDMODE_MASK) {
shader = data->ps_mask;
}
switch (texture->scaleMode) {
case SDL_TEXTURESCALEMODE_NONE:
case SDL_TEXTURESCALEMODE_FAST:
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MINFILTER,
D3DTEXF_POINT);
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MAGFILTER,
D3DTEXF_POINT);
break;
case SDL_TEXTURESCALEMODE_SLOW:
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MINFILTER,
D3DTEXF_LINEAR);
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MAGFILTER,
D3DTEXF_LINEAR);
break;
case SDL_TEXTURESCALEMODE_BEST:
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MINFILTER,
D3DTEXF_GAUSSIANQUAD);
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MAGFILTER,
D3DTEXF_GAUSSIANQUAD);
break;
}
result =
IDirect3DDevice9_SetTexture(data->device, 0, (IDirect3DBaseTexture9 *)
texturedata->texture);
if (FAILED(result)) {
D3D_SetError("SetTexture()", result);
return -1;
}
if (shader) {
result = IDirect3DDevice9_SetPixelShader(data->device, shader);
if (FAILED(result)) {
D3D_SetError("SetShader()", result);
return -1;
}
}
result =
IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN, 2,
vertices, sizeof(*vertices));
if (FAILED(result)) {
D3D_SetError("DrawPrimitiveUP()", result);
return -1;
}
if (shader) {
result = IDirect3DDevice9_SetPixelShader(data->device, NULL);
if (FAILED(result)) {
D3D_SetError("SetShader()", result);
return -1;
}
}
return 0;
}
static int
D3D_RenderDrawRects(SDL_Renderer * renderer, const SDL_Rect ** rects,
int count)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
DWORD color;
int i;
Vertex vertices[5];
HRESULT result;
if (data->beginScene) {
IDirect3DDevice9_BeginScene(data->device);
data->beginScene = SDL_FALSE;
}
D3D_SetBlendMode(data, renderer->blendMode);
result =
IDirect3DDevice9_SetTexture(data->device, 0,
(IDirect3DBaseTexture9 *) 0);
if (FAILED(result)) {
D3D_SetError("SetTexture()", result);
return -1;
}
color = D3DCOLOR_ARGB(renderer->a, renderer->r, renderer->g, renderer->b);
for (i = 0; i < SDL_arraysize(vertices); ++i) {
vertices[i].z = 0.0f;
vertices[i].rhw = 1.0f;
vertices[i].color = color;
vertices[i].u = 0.0f;
vertices[i].v = 0.0f;
}
for (i = 0; i < count; ++i) {
const SDL_Rect *rect = rects[i];
vertices[0].x = (float) rect->x;
vertices[0].y = (float) rect->y;
vertices[1].x = (float) rect->x+rect->w-1;
vertices[1].y = (float) rect->y;
vertices[2].x = (float) rect->x+rect->w-1;
vertices[2].y = (float) rect->y+rect->h-1;
vertices[3].x = (float) rect->x;
vertices[3].y = (float) rect->y+rect->h-1;
vertices[4].x = (float) rect->x;
vertices[4].y = (float) rect->y;
result =
IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_LINESTRIP, 4,
vertices, sizeof(*vertices));
if (FAILED(result)) {
D3D_SetError("DrawPrimitiveUP()", result);
return -1;
}
}
return 0;
}
static int
D3D_RenderFillRects(SDL_Renderer * renderer, const SDL_Rect * rects,
int count)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
DWORD color;
int i;
float minx, miny, maxx, maxy;
Vertex vertices[4];
HRESULT result;
if (D3D_ActivateRenderer(renderer) < 0) {
return -1;
}
D3D_SetBlendMode(data, renderer->blendMode);
result =
IDirect3DDevice9_SetTexture(data->device, 0,
(IDirect3DBaseTexture9 *) 0);
if (FAILED(result)) {
D3D_SetError("SetTexture()", result);
return -1;
}
color = D3DCOLOR_ARGB(renderer->a, renderer->r, renderer->g, renderer->b);
for (i = 0; i < count; ++i) {
const SDL_Rect *rect = &rects[i];
minx = (float) rect->x;
miny = (float) rect->y;
maxx = (float) rect->x + rect->w;
maxy = (float) rect->y + rect->h;
vertices[0].x = minx;
vertices[0].y = miny;
vertices[0].z = 0.0f;
vertices[0].color = color;
vertices[0].u = 0.0f;
vertices[0].v = 0.0f;
vertices[1].x = maxx;
vertices[1].y = miny;
vertices[1].z = 0.0f;
vertices[1].color = color;
vertices[1].u = 0.0f;
vertices[1].v = 0.0f;
vertices[2].x = maxx;
vertices[2].y = maxy;
vertices[2].z = 0.0f;
vertices[2].color = color;
vertices[2].u = 0.0f;
vertices[2].v = 0.0f;
vertices[3].x = minx;
vertices[3].y = maxy;
vertices[3].z = 0.0f;
vertices[3].color = color;
vertices[3].u = 0.0f;
vertices[3].v = 0.0f;
result =
IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN,
2, vertices, sizeof(*vertices));
if (FAILED(result)) {
D3D_SetError("DrawPrimitiveUP()", result);
return -1;
}
}
return 0;
}
/**
* It copies picture surface into a texture and renders into a scene.
*
* This function is intented for higher end 3D cards, with pixel shader support
* and at least 64 MiB of video RAM.
*/
static void Direct3DRenderScene(vout_display_t *vd, LPDIRECT3DSURFACE9 surface)
{
vout_display_sys_t *sys = vd->sys;
LPDIRECT3DDEVICE9 d3ddev = sys->d3ddev;
HRESULT hr;
// check if device is still available
hr = IDirect3DDevice9_TestCooperativeLevel(d3ddev);
if (FAILED(hr)) {
if (hr == D3DERR_DEVICENOTRESET && !sys->reset_device) {
vout_display_SendEventPicturesInvalid(vd);
sys->reset_device = true;
}
return;
}
/* */
LPDIRECT3DTEXTURE9 d3dtex = sys->d3dtex;
LPDIRECT3DVERTEXBUFFER9 d3dvtc = sys->d3dvtc;
/* Clear the backbuffer and the zbuffer */
hr = IDirect3DDevice9_Clear(d3ddev, 0, NULL, D3DCLEAR_TARGET,
D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
return;
}
/* retrieve picture surface */
LPDIRECT3DSURFACE9 d3dsrc = surface;
if (!d3dsrc) {
msg_Dbg(vd, "no surface to render ?");
return;
}
/* retrieve texture top-level surface */
LPDIRECT3DSURFACE9 d3ddest;
hr = IDirect3DTexture9_GetSurfaceLevel(d3dtex, 0, &d3ddest);
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
return;
}
/* Copy picture surface into texture surface
* color space conversion and scaling happen here */
RECT src = vd->sys->rect_src_clipped;
RECT dst = vd->sys->rect_dest_clipped;
hr = IDirect3DDevice9_StretchRect(d3ddev, d3dsrc, &src, d3ddest, &dst, D3DTEXF_LINEAR);
IDirect3DSurface9_Release(d3ddest);
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
return;
}
/* Update the vertex buffer */
CUSTOMVERTEX *vertices;
hr = IDirect3DVertexBuffer9_Lock(d3dvtc, 0, 0, (void **)&vertices, D3DLOCK_DISCARD);
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
return;
}
/* Setup vertices */
const float f_width = vd->sys->d3dpp.BackBufferWidth;
const float f_height = vd->sys->d3dpp.BackBufferHeight;
/* -0.5f is a "feature" of DirectX and it seems to apply to Direct3d also */
/* http://www.sjbrown.co.uk/2003/05/01/fix-directx-rasterisation/ */
vertices[0].x = -0.5f; // left
vertices[0].y = -0.5f; // top
vertices[0].z = 0.0f;
vertices[0].diffuse = D3DCOLOR_ARGB(255, 255, 255, 255);
vertices[0].rhw = 1.0f;
vertices[0].tu = 0.0f;
vertices[0].tv = 0.0f;
vertices[1].x = f_width - 0.5f; // right
vertices[1].y = -0.5f; // top
vertices[1].z = 0.0f;
vertices[1].diffuse = D3DCOLOR_ARGB(255, 255, 255, 255);
vertices[1].rhw = 1.0f;
vertices[1].tu = 1.0f;
vertices[1].tv = 0.0f;
vertices[2].x = f_width - 0.5f; // right
vertices[2].y = f_height - 0.5f; // bottom
vertices[2].z = 0.0f;
vertices[2].diffuse = D3DCOLOR_ARGB(255, 255, 255, 255);
vertices[2].rhw = 1.0f;
vertices[2].tu = 1.0f;
vertices[2].tv = 1.0f;
vertices[3].x = -0.5f; // left
vertices[3].y = f_height - 0.5f; // bottom
vertices[3].z = 0.0f;
vertices[3].diffuse = D3DCOLOR_ARGB(255, 255, 255, 255);
vertices[3].rhw = 1.0f;
vertices[3].tu = 0.0f;
vertices[3].tv = 1.0f;
hr= IDirect3DVertexBuffer9_Unlock(d3dvtc);
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
return;
}
// Begin the scene
hr = IDirect3DDevice9_BeginScene(d3ddev);
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
return;
}
// Setup our texture. Using textures introduces the texture stage states,
// which govern how textures get blended together (in the case of multiple
// textures) and lighting information. In this case, we are modulating
// (blending) our texture with the diffuse color of the vertices.
hr = IDirect3DDevice9_SetTexture(d3ddev, 0, (LPDIRECT3DBASETEXTURE9)d3dtex);
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
IDirect3DDevice9_EndScene(d3ddev);
return;
}
// Render the vertex buffer contents
hr = IDirect3DDevice9_SetStreamSource(d3ddev, 0, d3dvtc, 0, sizeof(CUSTOMVERTEX));
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
IDirect3DDevice9_EndScene(d3ddev);
return;
}
// we use FVF instead of vertex shader
hr = IDirect3DDevice9_SetFVF(d3ddev, D3DFVF_CUSTOMVERTEX);
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
IDirect3DDevice9_EndScene(d3ddev);
return;
}
// draw rectangle
hr = IDirect3DDevice9_DrawPrimitive(d3ddev, D3DPT_TRIANGLEFAN, 0, 2);
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
IDirect3DDevice9_EndScene(d3ddev);
return;
}
// End the scene
hr = IDirect3DDevice9_EndScene(d3ddev);
if (FAILED(hr)) {
msg_Dbg(vd, "%s:%d (hr=0x%0lX)", __FUNCTION__, __LINE__, hr);
return;
}
}
static int _al_draw_prim_raw(ALLEGRO_BITMAP* texture, const void* vtx, const ALLEGRO_VERTEX_DECL* decl,
const int* indices, int num_vtx, int type)
{
int stride = decl ? decl->stride : (int)sizeof(ALLEGRO_VERTEX);
int num_primitives = 0;
ALLEGRO_DISPLAY *display;
LPDIRECT3DDEVICE9 device;
LPDIRECT3DBASETEXTURE9 d3d_texture;
DWORD old_wrap_state[2];
DWORD old_ttf_state;
int min_idx = 0, max_idx = num_vtx - 1;
if(indices)
{
int ii;
for(ii = 0; ii < num_vtx; ii++)
{
int idx = indices[ii];
if(ii == 0) {
min_idx = idx;
max_idx = idx;
} else if (idx < min_idx) {
min_idx = idx;
} else if (idx > max_idx) {
max_idx = idx;
}
}
}
display = al_get_current_display();
device = al_d3d_get_device(display);
if(decl) {
if(decl->d3d_decl) {
IDirect3DDevice9_SetVertexDeclaration(device, (IDirect3DVertexDeclaration9*)decl->d3d_decl);
} else {
return _al_draw_prim_soft(texture, vtx, decl, 0, num_vtx, type);
}
} else {
IDirect3DDevice9_SetFVF(device, A5V_FVF);
}
set_blender(display);
if (texture) {
int tex_x, tex_y;
D3DSURFACE_DESC desc;
float mat[4][4] = {
{1, 0, 0, 0},
{0, 1, 0, 0},
{0, 0, 1, 0},
{0, 0, 0, 1}
};
IDirect3DTexture9_GetLevelDesc(al_d3d_get_video_texture(texture), 0, &desc);
al_get_d3d_texture_position(texture, &tex_x, &tex_y);
if(decl) {
if(decl->elements[ALLEGRO_PRIM_TEX_COORD_PIXEL].attribute) {
mat[0][0] = 1.0f / desc.Width;
mat[1][1] = 1.0f / desc.Height;
} else {
mat[0][0] = (float)al_get_bitmap_width(texture) / desc.Width;
mat[1][1] = (float)al_get_bitmap_height(texture) / desc.Height;
}
} else {
mat[0][0] = 1.0f / desc.Width;
mat[1][1] = 1.0f / desc.Height;
}
mat[2][0] = (float)tex_x / desc.Width;
mat[2][1] = (float)tex_y / desc.Height;
IDirect3DDevice9_GetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, &old_ttf_state);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *)&mat);
d3d_texture = (LPDIRECT3DBASETEXTURE9)al_d3d_get_video_texture(texture);
IDirect3DDevice9_SetTexture(device, 0, d3d_texture);
} else {
IDirect3DDevice9_SetTexture(device, 0, NULL);
}
IDirect3DDevice9_GetSamplerState(device, 0, D3DSAMP_ADDRESSU, &old_wrap_state[0]);
IDirect3DDevice9_GetSamplerState(device, 0, D3DSAMP_ADDRESSV, &old_wrap_state[1]);
IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
if(!indices)
{
switch (type) {
case ALLEGRO_PRIM_LINE_LIST: {
num_primitives = num_vtx / 2;
IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_LINELIST, num_primitives, vtx, stride);
break;
};
case ALLEGRO_PRIM_LINE_STRIP: {
num_primitives = num_vtx - 1;
IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_LINESTRIP, num_primitives, vtx, stride);
break;
};
case ALLEGRO_PRIM_LINE_LOOP: {
int in[2];
in[0] = 0;
in[1] = num_vtx-1;
num_primitives = num_vtx - 1;
IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_LINESTRIP, num_primitives, vtx, stride);
IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_LINELIST, 0, num_vtx, 1, in, D3DFMT_INDEX32, vtx, stride);
break;
};
case ALLEGRO_PRIM_TRIANGLE_LIST: {
num_primitives = num_vtx / 3;
IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLELIST, num_primitives, vtx, stride);
break;
};
case ALLEGRO_PRIM_TRIANGLE_STRIP: {
num_primitives = num_vtx - 2;
IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, num_primitives, vtx, stride);
break;
};
case ALLEGRO_PRIM_TRIANGLE_FAN: {
num_primitives = num_vtx - 2;
IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLEFAN, num_primitives, vtx, stride);
break;
};
case ALLEGRO_PRIM_POINT_LIST: {
num_primitives = num_vtx;
IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, num_primitives, vtx, stride);
break;
};
}
} else {
switch (type) {
case ALLEGRO_PRIM_LINE_LIST: {
num_primitives = num_vtx / 2;
IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_LINELIST, min_idx, max_idx + 1, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
break;
};
case ALLEGRO_PRIM_LINE_STRIP: {
num_primitives = num_vtx - 1;
IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_LINESTRIP, min_idx, max_idx + 1, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
break;
};
case ALLEGRO_PRIM_LINE_LOOP: {
int in[2];
num_primitives = num_vtx - 1;
IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_LINESTRIP, min_idx, max_idx + 1, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
in[0] = indices[0];
in[1] = indices[num_vtx-1];
IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_LINELIST, min_idx, max_idx + 1, 1, in, D3DFMT_INDEX32, vtx, stride);
break;
};
case ALLEGRO_PRIM_TRIANGLE_LIST: {
num_primitives = num_vtx / 3;
IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, min_idx, max_idx + 1, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
break;
};
case ALLEGRO_PRIM_TRIANGLE_STRIP: {
num_primitives = num_vtx - 2;
IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLESTRIP, min_idx, max_idx + 1, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
break;
};
case ALLEGRO_PRIM_TRIANGLE_FAN: {
num_primitives = num_vtx - 2;
IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLEFAN, min_idx, max_idx + 1, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
break;
};
case ALLEGRO_PRIM_POINT_LIST: {
/*
* D3D does not support point lists in indexed mode, so we draw them using the non-indexed mode. To gain at least a semblance
* of speed, we detect consecutive runs of vertices and draw them using a single DrawPrimitiveUP call
*/
int ii = 0;
int start_idx = indices[0];
int run_length = 0;
for(ii = 0; ii < num_vtx; ii++)
{
run_length++;
if(indices[ii] + 1 != indices[ii + 1] || ii == num_vtx - 1) {
IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, run_length, (const char*)vtx + start_idx * stride, stride);
if(ii != num_vtx - 1)
start_idx = indices[ii + 1];
run_length = 0;
}
}
break;
};
}
}
IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, old_wrap_state[0]);
IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, old_wrap_state[1]);
if(texture) {
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, old_ttf_state);
}
return num_primitives;
}
static void test_filter(IDirect3DDevice9 *device) {
HRESULT hr;
IDirect3DTexture9 *texture;
IDirect3D9 *d3d9;
DWORD passes = 0;
unsigned int i;
struct filter_tests {
DWORD magfilter, minfilter, mipfilter;
BOOL has_texture;
HRESULT result;
} tests[] = {
{ D3DTEXF_NONE, D3DTEXF_NONE, D3DTEXF_NONE, FALSE, D3DERR_UNSUPPORTEDTEXTUREFILTER },
{ D3DTEXF_POINT, D3DTEXF_NONE, D3DTEXF_NONE, FALSE, D3DERR_UNSUPPORTEDTEXTUREFILTER },
{ D3DTEXF_NONE, D3DTEXF_POINT, D3DTEXF_NONE, FALSE, D3DERR_UNSUPPORTEDTEXTUREFILTER },
{ D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_NONE, FALSE, D3D_OK },
{ D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_POINT, FALSE, D3D_OK },
{ D3DTEXF_NONE, D3DTEXF_NONE, D3DTEXF_NONE, TRUE, D3DERR_UNSUPPORTEDTEXTUREFILTER },
{ D3DTEXF_POINT, D3DTEXF_NONE, D3DTEXF_NONE, TRUE, D3DERR_UNSUPPORTEDTEXTUREFILTER },
{ D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_NONE, TRUE, D3D_OK },
{ D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_POINT, TRUE, D3D_OK },
{ D3DTEXF_NONE, D3DTEXF_NONE, D3DTEXF_NONE, TRUE, D3DERR_UNSUPPORTEDTEXTUREFILTER },
{ D3DTEXF_LINEAR, D3DTEXF_NONE, D3DTEXF_NONE, TRUE, D3DERR_UNSUPPORTEDTEXTUREFILTER },
{ D3DTEXF_LINEAR, D3DTEXF_POINT, D3DTEXF_NONE, TRUE, E_FAIL },
{ D3DTEXF_POINT, D3DTEXF_LINEAR, D3DTEXF_NONE, TRUE, E_FAIL },
{ D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_LINEAR, TRUE, E_FAIL },
};
hr = IDirect3DDevice9_GetDirect3D(device, &d3d9);
ok(hr == D3D_OK, "IDirect3DDevice9_GetDirect3D(levels = 1) returned %08x\n", hr);
hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
D3DRTYPE_TEXTURE, D3DFMT_A32B32G32R32F);
if(FAILED(hr)) {
skip("D3DFMT_A32B32G32R32F not supported\n");
goto out;
}
hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, D3DUSAGE_QUERY_FILTER,
D3DRTYPE_TEXTURE, D3DFMT_A32B32G32R32F);
if(SUCCEEDED(hr)) {
skip("D3DFMT_A32B32G32R32F supports filtering\n");
goto out;
}
hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 0, 0, D3DFMT_A32B32G32R32F,
D3DPOOL_MANAGED, &texture, 0);
ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %08x\n", hr);
/* Needed for ValidateDevice */
hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
for(i = 0; i < (sizeof(tests) / sizeof(tests[0])); i++) {
if(tests[i].has_texture) {
hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr);
} else {
hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr);
}
hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, tests[i].magfilter);
ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState returned %08x\n", hr);
hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, tests[i].minfilter);
ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState returned %08x\n", hr);
hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, tests[i].mipfilter);
ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState returned %08x\n", hr);
passes = 0xdeadbeef;
hr = IDirect3DDevice9_ValidateDevice(device, &passes);
ok(hr == tests[i].result, "ValidateDevice failed: Texture %s, min %u, mag %u, mip %u. Got %08x, expected %08x\n",
tests[i].has_texture ? "TRUE" : "FALSE", tests[i].magfilter, tests[i].minfilter,
tests[i].mipfilter, hr, tests[i].result);
if(SUCCEEDED(hr)) {
ok(passes != 0, "ValidateDevice succeeded, passes is %u\n", passes);
} else {
ok(passes == 0xdeadbeef, "ValidateDevice failed, passes is %u\n", passes);
}
}
hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture returned %#x.\n", hr);
IDirect3DTexture9_Release(texture);
out:
IDirect3D9_Release(d3d9);
}
static HRESULT WINAPI ID3DXSpriteImpl_Flush(ID3DXSprite *iface)
{
ID3DXSpriteImpl *This = impl_from_ID3DXSprite(iface);
SPRITEVERTEX *vertices;
int i, count=0, start;
TRACE("(%p)->(): relay\n", This);
if(!This->ready) return D3DERR_INVALIDCALL;
if(!This->sprite_count) return D3D_OK;
/* TODO: use of a vertex buffer here */
vertices=HeapAlloc(GetProcessHeap(), 0, sizeof(SPRITEVERTEX)*6*This->sprite_count);
for(start=0; start<This->sprite_count; start+=count,count=0) {
i=start;
while(i<This->sprite_count &&
(count==0 || This->sprites[i].texture==This->sprites[i-1].texture)) {
float spritewidth=(float)This->sprites[i].rect.right-(float)This->sprites[i].rect.left;
float spriteheight=(float)This->sprites[i].rect.bottom-(float)This->sprites[i].rect.top;
vertices[6*i ].pos.x = This->sprites[i].pos.x - This->sprites[i].center.x;
vertices[6*i ].pos.y = This->sprites[i].pos.y - This->sprites[i].center.y;
vertices[6*i ].pos.z = This->sprites[i].pos.z - This->sprites[i].center.z;
vertices[6*i+1].pos.x = spritewidth + This->sprites[i].pos.x - This->sprites[i].center.x;
vertices[6*i+1].pos.y = This->sprites[i].pos.y - This->sprites[i].center.y;
vertices[6*i+1].pos.z = This->sprites[i].pos.z - This->sprites[i].center.z;
vertices[6*i+2].pos.x = spritewidth + This->sprites[i].pos.x - This->sprites[i].center.x;
vertices[6*i+2].pos.y = spriteheight + This->sprites[i].pos.y - This->sprites[i].center.y;
vertices[6*i+2].pos.z = This->sprites[i].pos.z - This->sprites[i].center.z;
vertices[6*i+3].pos.x = This->sprites[i].pos.x - This->sprites[i].center.x;
vertices[6*i+3].pos.y = spriteheight + This->sprites[i].pos.y - This->sprites[i].center.y;
vertices[6*i+3].pos.z = This->sprites[i].pos.z - This->sprites[i].center.z;
vertices[6*i ].col = This->sprites[i].color;
vertices[6*i+1].col = This->sprites[i].color;
vertices[6*i+2].col = This->sprites[i].color;
vertices[6*i+3].col = This->sprites[i].color;
vertices[6*i ].tex.x = (float)This->sprites[i].rect.left / (float)This->sprites[i].texw;
vertices[6*i ].tex.y = (float)This->sprites[i].rect.top / (float)This->sprites[i].texh;
vertices[6*i+1].tex.x = (float)This->sprites[i].rect.right / (float)This->sprites[i].texw;
vertices[6*i+1].tex.y = (float)This->sprites[i].rect.top / (float)This->sprites[i].texh;
vertices[6*i+2].tex.x = (float)This->sprites[i].rect.right / (float)This->sprites[i].texw;
vertices[6*i+2].tex.y = (float)This->sprites[i].rect.bottom / (float)This->sprites[i].texh;
vertices[6*i+3].tex.x = (float)This->sprites[i].rect.left / (float)This->sprites[i].texw;
vertices[6*i+3].tex.y = (float)This->sprites[i].rect.bottom / (float)This->sprites[i].texh;
vertices[6*i+4]=vertices[6*i];
vertices[6*i+5]=vertices[6*i+2];
D3DXVec3TransformCoordArray(&vertices[6*i].pos, sizeof(SPRITEVERTEX),
&vertices[6*i].pos, sizeof(SPRITEVERTEX),
&This->sprites[i].transform, 6);
count++;
i++;
}
IDirect3DDevice9_SetTexture(This->device, 0, (struct IDirect3DBaseTexture9 *)This->sprites[start].texture);
IDirect3DDevice9_SetVertexDeclaration(This->device, This->vdecl);
IDirect3DDevice9_DrawPrimitiveUP(This->device, D3DPT_TRIANGLELIST, 2*count, vertices+6*start, sizeof(SPRITEVERTEX));
}
HeapFree(GetProcessHeap(), 0, vertices);
if(!(This->flags & D3DXSPRITE_DO_NOT_ADDREF_TEXTURE))
for(i=0; i<This->sprite_count; i++)
IDirect3DTexture9_Release(This->sprites[i].texture);
This->sprite_count=0;
/* Flush may be called more than once, so we don't reset This->ready here */
return D3D_OK;
}
static HRESULT WINAPI ID3DXSpriteImpl_Begin(ID3DXSprite *iface, DWORD flags)
{
ID3DXSpriteImpl *This = impl_from_ID3DXSprite(iface);
HRESULT hr;
TRACE("(%p): relay\n", This);
if(flags>D3DXSPRITE_FLAGLIMIT || This->ready) return D3DERR_INVALIDCALL;
/* TODO: Implement flags:
D3DXSPRITE_BILLBOARD: makes the sprite always face the camera
D3DXSPRITE_DONOTMODIFY_RENDERSTATE: name says it all
D3DXSPRITE_OBJECTSPACE: do not change device transforms
D3DXSPRITE_SORT_DEPTH_BACKTOFRONT: sort by position
D3DXSPRITE_SORT_DEPTH_FRONTTOBACK: sort by position
D3DXSPRITE_SORT_TEXTURE: sort by texture (so that it doesn't change too often)
*/
/* Seems like alpha blending is always enabled, regardless of D3DXSPRITE_ALPHABLEND flag */
if(flags & (D3DXSPRITE_BILLBOARD |
D3DXSPRITE_DONOTMODIFY_RENDERSTATE | D3DXSPRITE_OBJECTSPACE |
D3DXSPRITE_SORT_DEPTH_BACKTOFRONT))
FIXME("Flags unsupported: %#x\n", flags);
/* These flags should only matter to performances */
else if(flags & (D3DXSPRITE_SORT_DEPTH_FRONTTOBACK | D3DXSPRITE_SORT_TEXTURE))
TRACE("Flags unsupported: %#x\n", flags);
if(This->vdecl==NULL) {
static const D3DVERTEXELEMENT9 elements[] =
{
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
{ 0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 },
{ 0, 16, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
D3DDECL_END()
};
IDirect3DDevice9_CreateVertexDeclaration(This->device, elements, &This->vdecl);
}
if(!(flags & D3DXSPRITE_DONOTSAVESTATE)) {
if(This->stateblock==NULL) {
/* Tell our state block what it must store */
hr=IDirect3DDevice9_BeginStateBlock(This->device);
if(hr!=D3D_OK) return hr;
set_states(This);
IDirect3DDevice9_SetVertexDeclaration(This->device, This->vdecl);
IDirect3DDevice9_SetStreamSource(This->device, 0, NULL, 0, sizeof(SPRITEVERTEX));
IDirect3DDevice9_SetIndices(This->device, NULL);
IDirect3DDevice9_SetTexture(This->device, 0, NULL);
IDirect3DDevice9_EndStateBlock(This->device, &This->stateblock);
}
IDirect3DStateBlock9_Capture(This->stateblock); /* Save current state */
}
/* Apply device state */
set_states(This);
This->flags=flags;
This->ready=TRUE;
return D3D_OK;
}
static int
D3D_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
float minx, miny, maxx, maxy;
DWORD color;
Vertex vertices[4];
HRESULT result;
if (data->beginScene) {
IDirect3DDevice9_BeginScene(data->device);
data->beginScene = SDL_FALSE;
}
minx = (float) rect->x - 0.5f;
miny = (float) rect->y - 0.5f;
maxx = (float) rect->x + rect->w - 0.5f;
maxy = (float) rect->y + rect->h - 0.5f;
color = D3DCOLOR_ARGB(renderer->a, renderer->r, renderer->g, renderer->b);
vertices[0].x = minx;
vertices[0].y = miny;
vertices[0].z = 0.0f;
vertices[0].rhw = 1.0f;
vertices[0].color = color;
vertices[0].u = 0.0f;
vertices[0].v = 0.0f;
vertices[1].x = maxx;
vertices[1].y = miny;
vertices[1].z = 0.0f;
vertices[1].rhw = 1.0f;
vertices[1].color = color;
vertices[1].u = 0.0f;
vertices[1].v = 0.0f;
vertices[2].x = maxx;
vertices[2].y = maxy;
vertices[2].z = 0.0f;
vertices[2].rhw = 1.0f;
vertices[2].color = color;
vertices[2].u = 0.0f;
vertices[2].v = 0.0f;
vertices[3].x = minx;
vertices[3].y = maxy;
vertices[3].z = 0.0f;
vertices[3].rhw = 1.0f;
vertices[3].color = color;
vertices[3].u = 0.0f;
vertices[3].v = 0.0f;
D3D_SetBlendMode(data, renderer->blendMode);
result =
IDirect3DDevice9_SetTexture(data->device, 0,
(IDirect3DBaseTexture9 *) 0);
if (FAILED(result)) {
D3D_SetError("SetTexture()", result);
return -1;
}
result =
IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN, 2,
vertices, sizeof(*vertices));
if (FAILED(result)) {
D3D_SetError("DrawPrimitiveUP()", result);
return -1;
}
return 0;
}
static int
D3D_RenderCopyEx(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * srcrect, const SDL_FRect * dstrect,
const double angle, const SDL_FPoint * center, const SDL_RendererFlip flip)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
D3D_TextureData *texturedata = (D3D_TextureData *) texture->driverdata;
LPDIRECT3DPIXELSHADER9 shader = NULL;
float minx, miny, maxx, maxy;
float minu, maxu, minv, maxv;
float centerx, centery;
DWORD color;
Vertex vertices[4];
HRESULT result;
if (D3D_ActivateRenderer(renderer) < 0) {
return -1;
}
centerx = center->x;
centery = center->y;
if (flip & SDL_FLIP_HORIZONTAL) {
minx = dstrect->w - centerx - 0.5f;
maxx = -centerx - 0.5f;
}
else {
minx = -centerx - 0.5f;
maxx = dstrect->w - centerx - 0.5f;
}
if (flip & SDL_FLIP_VERTICAL) {
miny = dstrect->h - centery - 0.5f;
maxy = -centery - 0.5f;
}
else {
miny = -centery - 0.5f;
maxy = dstrect->h - centery - 0.5f;
}
minu = (float) srcrect->x / texture->w;
maxu = (float) (srcrect->x + srcrect->w) / texture->w;
minv = (float) srcrect->y / texture->h;
maxv = (float) (srcrect->y + srcrect->h) / texture->h;
color = D3DCOLOR_ARGB(texture->a, texture->r, texture->g, texture->b);
vertices[0].x = minx;
vertices[0].y = miny;
vertices[0].z = 0.0f;
vertices[0].color = color;
vertices[0].u = minu;
vertices[0].v = minv;
vertices[1].x = maxx;
vertices[1].y = miny;
vertices[1].z = 0.0f;
vertices[1].color = color;
vertices[1].u = maxu;
vertices[1].v = minv;
vertices[2].x = maxx;
vertices[2].y = maxy;
vertices[2].z = 0.0f;
vertices[2].color = color;
vertices[2].u = maxu;
vertices[2].v = maxv;
vertices[3].x = minx;
vertices[3].y = maxy;
vertices[3].z = 0.0f;
vertices[3].color = color;
vertices[3].u = minu;
vertices[3].v = maxv;
D3D_SetBlendMode(data, texture->blendMode);
// Rotate and translate
ID3DXMatrixStack_Push(data->matrixStack);
ID3DXMatrixStack_LoadIdentity(data->matrixStack);
ID3DXMatrixStack_RotateYawPitchRoll(data->matrixStack, 0.0, 0.0, (float)(M_PI * (float) angle / 180.0f));
ID3DXMatrixStack_Translate(data->matrixStack, (float)dstrect->x + centerx, (float)dstrect->y + centery, (float)0.0);
IDirect3DDevice9_SetTransform(data->device, D3DTS_VIEW, (D3DMATRIX*)ID3DXMatrixStack_GetTop(data->matrixStack));
if (texturedata->scaleMode != data->scaleMode) {
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MINFILTER,
texturedata->scaleMode);
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MAGFILTER,
texturedata->scaleMode);
data->scaleMode = texturedata->scaleMode;
}
result =
IDirect3DDevice9_SetTexture(data->device, 0, (IDirect3DBaseTexture9 *)
texturedata->texture);
if (FAILED(result)) {
D3D_SetError("SetTexture()", result);
return -1;
}
if (shader) {
result = IDirect3DDevice9_SetPixelShader(data->device, shader);
if (FAILED(result)) {
D3D_SetError("SetShader()", result);
return -1;
}
}
result =
IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN, 2,
vertices, sizeof(*vertices));
if (FAILED(result)) {
D3D_SetError("DrawPrimitiveUP()", result);
return -1;
}
if (shader) {
result = IDirect3DDevice9_SetPixelShader(data->device, NULL);
if (FAILED(result)) {
D3D_SetError("SetShader()", result);
return -1;
}
}
ID3DXMatrixStack_Pop(data->matrixStack);
ID3DXMatrixStack_Push(data->matrixStack);
ID3DXMatrixStack_LoadIdentity(data->matrixStack);
IDirect3DDevice9_SetTransform(data->device, D3DTS_VIEW, (D3DMATRIX*)ID3DXMatrixStack_GetTop(data->matrixStack));
ID3DXMatrixStack_Pop(data->matrixStack);
return 0;
}
void D3DCacheFlush(d3d_render_cache_system *pCacheSystem, d3d_render_pool_new *pPool, int numStages,
int type)
{
u_int curPacket, curChunk, numPackets;
LPDIRECT3DTEXTURE9 pTexture = NULL;
d3d_render_cache *pRenderCache = NULL;
d3d_render_packet_new *pPacket;
d3d_render_chunk_new *pChunk;
list_type list;
int i;
// call material function for this pool
if (FALSE == pPool->pMaterialFctn(pPool))
return;
for (list = pPool->renderPacketList; list != pPool->curPacketList->next; list = list->next)
{
pPacket = (d3d_render_packet_new *)list->data;
if (list == pPool->curPacketList)
numPackets = pPool->curPacket;
else
numPackets = pPool->size;
for (curPacket = 0; curPacket < numPackets; curPacket++, pPacket++)
{
// call material function for this packet
if (FALSE == pPacket->pMaterialFctn(pPacket, pCacheSystem))
continue;
for (curChunk = 0; curChunk < pPacket->curChunk; curChunk++)
{
pChunk = &pPacket->renderChunks[curChunk];
// call material function for this chunk
if (FALSE == pChunk->pMaterialFctn(pChunk))
continue;
if (pRenderCache != pChunk->pRenderCache)
{
pRenderCache = pChunk->pRenderCache;
D3DRENDER_SET_STREAMS(gpD3DDevice, pRenderCache, numStages);
}
IDirect3DDevice9_DrawIndexedPrimitive(gpD3DDevice,
(D3DPRIMITIVETYPE) type,
0,
pChunk->startIndex,
pChunk->numIndices,
pChunk->startIndex,
pChunk->numPrimitives);
gNumVertices += pChunk->numIndices;
gNumDPCalls++;
}
}
}
// now decrement reference count for these textures
for (i = 0; i < numStages; i++)
{
IDirect3DDevice9_SetTexture(gpD3DDevice, i, NULL);
}
D3DRENDER_CLEAR_STREAMS(gpD3DDevice, numStages);
}
static int
D3D_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * srcrect, const SDL_Rect * dstrect)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
D3D_TextureData *texturedata = (D3D_TextureData *) texture->driverdata;
LPDIRECT3DPIXELSHADER9 shader = NULL;
float minx, miny, maxx, maxy;
float minu, maxu, minv, maxv;
DWORD color;
Vertex vertices[4];
HRESULT result;
if (D3D_ActivateRenderer(renderer) < 0) {
return -1;
}
minx = (float) dstrect->x - 0.5f;
miny = (float) dstrect->y - 0.5f;
maxx = (float) dstrect->x + dstrect->w - 0.5f;
maxy = (float) dstrect->y + dstrect->h - 0.5f;
minu = (float) srcrect->x / texture->w;
maxu = (float) (srcrect->x + srcrect->w) / texture->w;
minv = (float) srcrect->y / texture->h;
maxv = (float) (srcrect->y + srcrect->h) / texture->h;
color = D3DCOLOR_ARGB(texture->a, texture->r, texture->g, texture->b);
vertices[0].x = minx;
vertices[0].y = miny;
vertices[0].z = 0.0f;
vertices[0].color = color;
vertices[0].u = minu;
vertices[0].v = minv;
vertices[1].x = maxx;
vertices[1].y = miny;
vertices[1].z = 0.0f;
vertices[1].color = color;
vertices[1].u = maxu;
vertices[1].v = minv;
vertices[2].x = maxx;
vertices[2].y = maxy;
vertices[2].z = 0.0f;
vertices[2].color = color;
vertices[2].u = maxu;
vertices[2].v = maxv;
vertices[3].x = minx;
vertices[3].y = maxy;
vertices[3].z = 0.0f;
vertices[3].color = color;
vertices[3].u = minu;
vertices[3].v = maxv;
D3D_SetBlendMode(data, texture->blendMode);
if (texturedata->scaleMode != data->scaleMode) {
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MINFILTER,
texturedata->scaleMode);
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MAGFILTER,
texturedata->scaleMode);
data->scaleMode = texturedata->scaleMode;
}
result =
IDirect3DDevice9_SetTexture(data->device, 0, (IDirect3DBaseTexture9 *)
texturedata->texture);
if (FAILED(result)) {
D3D_SetError("SetTexture()", result);
return -1;
}
if (shader) {
result = IDirect3DDevice9_SetPixelShader(data->device, shader);
if (FAILED(result)) {
D3D_SetError("SetShader()", result);
return -1;
}
}
result =
IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN, 2,
vertices, sizeof(*vertices));
if (FAILED(result)) {
D3D_SetError("DrawPrimitiveUP()", result);
return -1;
}
if (shader) {
result = IDirect3DDevice9_SetPixelShader(data->device, NULL);
if (FAILED(result)) {
D3D_SetError("SetShader()", result);
return -1;
}
}
return 0;
}
void JBKRender_SetTexture(JBKNativeTextureSampler sampler, JBKNativeTexture nativeTexture) {
DXCall( IDirect3DDevice9_SetTexture(gDevice, sampler, nativeTexture) );
}
/** @brief libvo Callback: Draw OSD/Subtitles,
*/
static void draw_osd(void)
{
// we can not render OSD if we lost the device e.g. because it was uncooperative
if (!priv->d3d_device)
return;
if (vo_osd_changed(0)) {
D3DLOCKED_RECT locked_rect; /**< Offscreen surface we lock in order
to copy MPlayer's frame inside it.*/
/* clear the OSD */
if (FAILED(IDirect3DTexture9_LockRect(priv->d3d_texture_system, 0,
&locked_rect, NULL, 0))) {
mp_msg(MSGT_VO,MSGL_ERR, "<vo_direct3d>OSD texture lock failed.\n");
return;
}
/* clear the whole texture to avoid issues due to interpolation */
memset(locked_rect.pBits, 0, locked_rect.Pitch * priv->osd_texture_height);
/* this unlock is used for both slice_draw path and D3DRenderFrame path */
if (FAILED(IDirect3DTexture9_UnlockRect(priv->d3d_texture_system, 0))) {
mp_msg(MSGT_VO,MSGL_ERR, "<vo_direct3d>OSD texture unlock failed.\n");
return;
}
priv->is_osd_populated = 0;
/* required for if subs are in the boarder region */
priv->is_clear_needed = 1;
vo_draw_text_ext(priv->osd_width, priv->osd_height, priv->border_x, priv->border_y,
priv->border_x, priv->border_y, priv->src_width, priv->src_height, draw_alpha);
if (!priv->device_texture_sys)
{
/* only DMA to the shadow if its required */
if (FAILED(IDirect3DDevice9_UpdateTexture(priv->d3d_device,
(IDirect3DBaseTexture9 *)priv->d3d_texture_system,
(IDirect3DBaseTexture9 *)priv->d3d_texture_osd))) {
mp_msg(MSGT_VO,MSGL_ERR, "<vo_direct3d>OSD texture transfer failed.\n");
return;
}
}
}
/* update OSD */
if (priv->is_osd_populated) {
struct_vertex osd_quad_vb[] = {
{-1.0f, 1.0f, 0.0f, 0, 0 },
{ 1.0f, 1.0f, 0.0f, 1, 0 },
{-1.0f,-1.0f, 0.0f, 0, 1 },
{ 1.0f,-1.0f, 0.0f, 1, 1 }
};
/* calculate the texture coordinates */
osd_quad_vb[1].tu =
osd_quad_vb[3].tu = (float)priv->osd_width / priv->osd_texture_width;
osd_quad_vb[2].tv =
osd_quad_vb[3].tv = (float)priv->osd_height / priv->osd_texture_height;
if (FAILED(IDirect3DDevice9_BeginScene(priv->d3d_device))) {
mp_msg(MSGT_VO,MSGL_ERR,"<vo_direct3d>BeginScene failed.\n");
return;
}
/* turn on alpha test */
IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_ALPHABLENDENABLE, TRUE);
IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_ALPHATESTENABLE, TRUE);
/* need to use a texture here (done here as we may be able to texture from system memory) */
IDirect3DDevice9_SetTexture(priv->d3d_device, 0,
(IDirect3DBaseTexture9 *)(priv->device_texture_sys
? priv->d3d_texture_system : priv->d3d_texture_osd));
IDirect3DDevice9_SetFVF(priv->d3d_device, D3DFVF_MY_VERTEX);
IDirect3DDevice9_DrawPrimitiveUP(priv->d3d_device, D3DPT_TRIANGLESTRIP, 2, osd_quad_vb, sizeof(struct_vertex));
/* turn off alpha test */
IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_ALPHATESTENABLE, FALSE);
IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_ALPHABLENDENABLE, FALSE);
if (FAILED(IDirect3DDevice9_EndScene(priv->d3d_device))) {
mp_msg(MSGT_VO,MSGL_ERR,"<vo_direct3d>EndScene failed.\n");
return;
}
}
}
int main( void )
{
LPDIRECT3DVERTEXBUFFER9 v_buffer;
sgui_window_description desc;
IDirect3DTexture9* texture;
sgui_d3d9_context* ctx;
sgui_canvas* texcanvas;
IDirect3DDevice9* dev;
sgui_widget* check2;
sgui_widget* check;
sgui_widget* butt;
sgui_window* wnd;
float a=0.0f;
VOID* pVoid;
float m[16];
sgui_init( );
/*************************** create a window **************************/
desc.parent = NULL;
desc.share = NULL;
desc.width = 640;
desc.height = 480;
desc.flags = SGUI_FIXED_SIZE|SGUI_DOUBLEBUFFERED;
desc.backend = SGUI_DIRECT3D_9;
desc.bits_per_pixel = 32;
desc.depth_bits = 16;
desc.stencil_bits = 0;
desc.samples = 0;
wnd = sgui_window_create_desc( &desc );
sgui_window_set_title( wnd, "Direct3D 9 Texture Canvas" );
sgui_window_move_center( wnd );
sgui_window_set_visible( wnd, SGUI_VISIBLE );
sgui_window_set_vsync( wnd, 1 );
/************************ createtexture canvas ************************/
texcanvas = sgui_tex_canvas_create( wnd, sgui_window_get_context( wnd ),
128, 128 );
butt = sgui_button_create( 10, 10, 60, 25, "Button", 0 );
check = sgui_checkbox_create( 10, 40, "Direct3D" );
check2 = sgui_checkbox_create( 10, 65, "Texture" );
sgui_button_set_state( check, 1 );
sgui_button_set_state( check2, 1 );
sgui_widget_add_child( &texcanvas->root, butt );
sgui_widget_add_child( &texcanvas->root, check );
sgui_widget_add_child( &texcanvas->root, check2 );
/************** connect keyboard input to texture canvas **************/
sgui_event_connect( wnd, SGUI_KEY_PRESSED_EVENT,
sgui_canvas_send_window_event, texcanvas,
SGUI_FROM_EVENT, SGUI_EVENT );
sgui_event_connect( wnd, SGUI_KEY_RELEASED_EVENT,
sgui_canvas_send_window_event, texcanvas,
SGUI_FROM_EVENT, SGUI_EVENT );
sgui_event_connect( wnd, SGUI_CHAR_EVENT,
sgui_canvas_send_window_event, texcanvas,
SGUI_FROM_EVENT, SGUI_EVENT );
/*************************** Direct3D setup ***************************/
/* get the device context, set new present parameters */
ctx = (sgui_d3d9_context*)sgui_window_get_context( wnd );
dev = ctx->device;
IDirect3DDevice9_Reset( dev, &ctx->present );
/* create a vertex buffer */
IDirect3DDevice9_CreateVertexBuffer( dev, sizeof(vertices), 0,
CUSTOMFVF, D3DPOOL_MANAGED,
&v_buffer, NULL );
/* load vertex data */
IDirect3DVertexBuffer9_Lock( v_buffer, 0, 0, (void**)&pVoid, 0 );
memcpy( pVoid, vertices, sizeof(vertices) );
IDirect3DVertexBuffer9_Unlock( v_buffer );
/* setup renderer state */
IDirect3DDevice9_SetRenderState( dev, D3DRS_CULLMODE, D3DCULL_NONE );
IDirect3DDevice9_SetRenderState( dev, D3DRS_LIGHTING, FALSE );
IDirect3DDevice9_SetRenderState( dev, D3DRS_ZENABLE, TRUE );
/* set up perspective projection matrix */
perspective( m, 45.0f, (float)desc.width/(float)desc.height,
0.1f, 100.0f );
IDirect3DDevice9_SetTransform( dev, D3DTS_PROJECTION, (D3DMATRIX*)m );
/* set up texturing, bind canvas texture to stage 0 */
texture = sgui_tex_canvas_get_texture( texcanvas );
IDirect3DDevice9_SetTexture( dev, 0, (IDirect3DBaseTexture9*)texture );
IDirect3DDevice9_SetTextureStageState( dev, 0, D3DTSS_COLOROP,
D3DTOP_BLENDTEXTUREALPHA );
IDirect3DDevice9_SetTextureStageState( dev, 0, D3DTSS_COLORARG1,
D3DTA_TEXTURE );
IDirect3DDevice9_SetTextureStageState( dev, 0, D3DTSS_COLORARG2,
D3DTA_DIFFUSE );
IDirect3DDevice9_SetTextureStageState( dev, 0, D3DTSS_ALPHAOP,
D3DTOP_DISABLE );
IDirect3DDevice9_SetSamplerState(dev,0,D3DSAMP_MINFILTER,D3DTEXF_LINEAR);
IDirect3DDevice9_SetSamplerState(dev,0,D3DSAMP_MAGFILTER,D3DTEXF_LINEAR);
/****************************** main loop *****************************/
while( sgui_main_loop_step( ) )
{
/* redraw widgets in dirty areas */
sgui_canvas_redraw_widgets( texcanvas, 1 );
/* draw scene */
IDirect3DDevice9_Clear( dev, 0, NULL,
D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,
0, 1.0f, 0 );
IDirect3DDevice9_BeginScene( dev );
transform( m, a );
IDirect3DDevice9_SetTransform( dev, D3DTS_VIEW, (D3DMATRIX*)m );
a += 0.01f;
IDirect3DDevice9_SetFVF( dev, CUSTOMFVF );
IDirect3DDevice9_SetStreamSource( dev, 0, v_buffer, 0,
sizeof(CUSTOMVERTEX) );
IDirect3DDevice9_DrawPrimitive( dev, D3DPT_TRIANGLELIST, 0, 8 );
IDirect3DDevice9_EndScene( dev );
/* swap front and back buffer */
sgui_window_swap_buffers( wnd );
}
/****************************** clean up ******************************/
sgui_canvas_destroy( texcanvas );
sgui_widget_destroy( check2 );
sgui_widget_destroy( check );
sgui_widget_destroy( butt );
IDirect3DVertexBuffer9_Release( v_buffer );
sgui_window_destroy( wnd );
sgui_deinit( );
return 0;
}
