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;
}
void JBKRender_DrawUserPrimitives(void* data, JBKVertexDataType datatype, JBKPrimitiveType primitivetype, uint32_t primitivecount) {
int32_t stride = 0;
DWORD fvf = DataTypeToFVF(datatype, &stride);
D3DPRIMITIVETYPE d3dprimtype = PrimitiveTypeToD3D(primitivetype);
SetupTextureStageStates(fvf);
DXCall( IDirect3DDevice9_SetFVF(gDevice, fvf) );
DXCall( IDirect3DDevice9_BeginScene(gDevice) );
DXCall( IDirect3DDevice9_DrawPrimitiveUP(gDevice, d3dprimtype, primitivecount, data, stride) );
DXCall( IDirect3DDevice9_EndScene(gDevice) );
}
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;
}
/** @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;
}
}
}
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;
}
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;
}
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;
}
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 _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 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 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;
}