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; }