自学教程：C++ D3D_SetError函数代码示例

static intD3D_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture){    D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;    D3D_TextureData *texturedata;    HRESULT result;    D3D_ActivateRenderer(renderer);    /* Release the previous render target if it wasn't the default one */    if (data->currentRenderTarget != NULL) {        IDirect3DSurface9_Release(data->currentRenderTarget);        data->currentRenderTarget = NULL;    }    if (texture == NULL) {        IDirect3DDevice9_SetRenderTarget(data->device, 0, data->defaultRenderTarget);        return 0;    }    texturedata = (D3D_TextureData *) texture->driverdata;    result = IDirect3DTexture9_GetSurfaceLevel(texturedata->texture, 0, &data->currentRenderTarget);    if(FAILED(result)) {        D3D_SetError("GetSurfaceLevel()", result);        return -1;    }    result = IDirect3DDevice9_SetRenderTarget(data->device, 0, data->currentRenderTarget);    if(FAILED(result)) {        D3D_SetError("SetRenderTarget()", result);        return -1;    }    return 0;}

static intD3D_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,                     Uint32 format, void * pixels, int pitch){    D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;    D3DSURFACE_DESC desc;    LPDIRECT3DSURFACE9 backBuffer;    LPDIRECT3DSURFACE9 surface;    RECT d3drect;    D3DLOCKED_RECT locked;    HRESULT result;    result = IDirect3DDevice9_GetBackBuffer(data->device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backBuffer);    if (FAILED(result)) {        return D3D_SetError("GetBackBuffer()", result);    }    result = IDirect3DSurface9_GetDesc(backBuffer, &desc);    if (FAILED(result)) {        IDirect3DSurface9_Release(backBuffer);        return D3D_SetError("GetDesc()", result);    }    result = IDirect3DDevice9_CreateOffscreenPlainSurface(data->device, desc.Width, desc.Height, desc.Format, D3DPOOL_SYSTEMMEM, &surface, NULL);    if (FAILED(result)) {        IDirect3DSurface9_Release(backBuffer);        return D3D_SetError("CreateOffscreenPlainSurface()", result);    }    result = IDirect3DDevice9_GetRenderTargetData(data->device, backBuffer, surface);    if (FAILED(result)) {        IDirect3DSurface9_Release(surface);        IDirect3DSurface9_Release(backBuffer);        return D3D_SetError("GetRenderTargetData()", result);    }    d3drect.left = rect->x;    d3drect.right = rect->x + rect->w;    d3drect.top = rect->y;    d3drect.bottom = rect->y + rect->h;    result = IDirect3DSurface9_LockRect(surface, &locked, &d3drect, D3DLOCK_READONLY);    if (FAILED(result)) {        IDirect3DSurface9_Release(surface);        IDirect3DSurface9_Release(backBuffer);        return D3D_SetError("LockRect()", result);    }    SDL_ConvertPixels(rect->w, rect->h,                      D3DFMTToPixelFormat(desc.Format), locked.pBits, locked.Pitch,                      format, pixels, pitch);    IDirect3DSurface9_UnlockRect(surface);    IDirect3DSurface9_Release(surface);    IDirect3DSurface9_Release(backBuffer);    return 0;}

static intD3D_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 intD3D_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 intD3D_UpdateClipRect(SDL_Renderer * renderer){    const SDL_Rect *rect = &renderer->clip_rect;    D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;    RECT r;    HRESULT result;    if (!SDL_RectEmpty(rect)) {        IDirect3DDevice9_SetRenderState(data->device, D3DRS_SCISSORTESTENABLE, TRUE);        r.left = rect->x;        r.top = rect->y;        r.right = rect->w + rect->w;        r.bottom = rect->y + rect->h;        result = IDirect3DDevice9_SetScissorRect(data->device, &r);        if (result != D3D_OK) {            D3D_SetError("SetScissor()", result);            return -1;        }    } else {        IDirect3DDevice9_SetRenderState(data->device, D3DRS_SCISSORTESTENABLE, FALSE);    }    return 0;}

static intD3D_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,                const SDL_Rect * rect, int markDirty, void **pixels,                int *pitch){    D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;    if (data->yuv) {        return SDL_SW_LockYUVTexture(data->yuv, rect, markDirty, pixels,                                     pitch);    } else {        RECT d3drect;        D3DLOCKED_RECT locked;        HRESULT result;        d3drect.left = rect->x;        d3drect.right = rect->x + rect->w;        d3drect.top = rect->y;        d3drect.bottom = rect->y + rect->h;        result =            IDirect3DTexture9_LockRect(data->texture, 0, &locked, &d3drect,                                       markDirty ? 0 :                                       D3DLOCK_NO_DIRTY_UPDATE);        if (FAILED(result)) {            D3D_SetError("LockRect()", result);            return -1;        }        *pixels = locked.pBits;        *pitch = locked.Pitch;        return 0;    }}

static intD3D_Reset(SDL_Renderer * renderer){    D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;    HRESULT result;    /* Release the default render target before reset */    if (data->defaultRenderTarget) {        IDirect3DSurface9_Release(data->defaultRenderTarget);        data->defaultRenderTarget = NULL;    }    result = IDirect3DDevice9_Reset(data->device, &data->pparams);    if (FAILED(result)) {        if (result == D3DERR_DEVICELOST) {            /* Don't worry about it, we'll reset later... */            return 0;        } else {            return D3D_SetError("Reset()", result);        }    }    IDirect3DDevice9_SetVertexShader(data->device, NULL);    IDirect3DDevice9_SetFVF(data->device,                            D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);    IDirect3DDevice9_SetRenderState(data->device, D3DRS_CULLMODE,                                    D3DCULL_NONE);    IDirect3DDevice9_SetRenderState(data->device, D3DRS_LIGHTING, FALSE);    IDirect3DDevice9_GetRenderTarget(data->device, 0, &data->defaultRenderTarget);    return 0;}

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

static intD3D_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,                  const SDL_Rect * rect, const void *pixels, int pitch){    D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;    D3D_RenderData *renderdata = (D3D_RenderData *) renderer->driverdata;    RECT d3drect;    D3DLOCKED_RECT locked;    const Uint8 *src;    Uint8 *dst;    int row, length;    HRESULT result;#ifdef USE_DYNAMIC_TEXTURE    if (texture->access == SDL_TEXTUREACCESS_STREAMING &&        rect->x == 0 && rect->y == 0 &&        rect->w == texture->w && rect->h == texture->h) {        result = IDirect3DTexture9_LockRect(data->texture, 0, &locked, NULL, D3DLOCK_DISCARD);    } else#endif    {        d3drect.left = rect->x;        d3drect.right = rect->x + rect->w;        d3drect.top = rect->y;        d3drect.bottom = rect->y + rect->h;        result = IDirect3DTexture9_LockRect(data->texture, 0, &locked, &d3drect, 0);    }    if (FAILED(result)) {        D3D_SetError("LockRect()", result);        return -1;    }    src = pixels;    dst = locked.pBits;    length = rect->w * SDL_BYTESPERPIXEL(texture->format);    if (length == pitch && length == locked.Pitch) {        SDL_memcpy(dst, src, length*rect->h);    } else {        for (row = 0; row < rect->h; ++row) {            SDL_memcpy(dst, src, length);            src += pitch;            dst += locked.Pitch;        }    }    IDirect3DTexture9_UnlockRect(data->texture, 0);    return 0;}

static intD3D_RenderClear(SDL_Renderer * renderer){    D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;    DWORD color;    HRESULT result;    if (D3D_ActivateRenderer(renderer) < 0) {        return -1;    }    color = D3DCOLOR_ARGB(renderer->a, renderer->r, renderer->g, renderer->b);    /* Don't reset the viewport if we don't have to! */    if (!renderer->viewport.x && !renderer->viewport.y &&        renderer->viewport.w == data->pparams.BackBufferWidth &&        renderer->viewport.h == data->pparams.BackBufferHeight) {        result = IDirect3DDevice9_Clear(data->device, 0, NULL, D3DCLEAR_TARGET, color, 0.0f, 0);    } else {        D3DVIEWPORT9 viewport;        /* Clear is defined to clear the entire render target */        viewport.X = 0;        viewport.Y = 0;        viewport.Width = data->pparams.BackBufferWidth;        viewport.Height = data->pparams.BackBufferHeight;        viewport.MinZ = 0.0f;        viewport.MaxZ = 1.0f;        IDirect3DDevice9_SetViewport(data->device, &viewport);        result = IDirect3DDevice9_Clear(data->device, 0, NULL, D3DCLEAR_TARGET, color, 0.0f, 0);        /* Reset the viewport */        viewport.X = renderer->viewport.x;        viewport.Y = renderer->viewport.y;        viewport.Width = renderer->viewport.w;        viewport.Height = renderer->viewport.h;        viewport.MinZ = 0.0f;        viewport.MaxZ = 1.0f;        IDirect3DDevice9_SetViewport(data->device, &viewport);    }    if (FAILED(result)) {        D3D_SetError("Clear()", result);        return -1;    }    return 0;}

static intD3D_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture){    D3D_RenderData *renderdata = (D3D_RenderData *) renderer->driverdata;    SDL_Window *window = renderer->window;    SDL_VideoDisplay *display = window->display;    Uint32 display_format = display->current_mode.format;    D3D_TextureData *data;    HRESULT result;    data = (D3D_TextureData *) SDL_calloc(1, sizeof(*data));    if (!data) {        SDL_OutOfMemory();        return -1;    }    texture->driverdata = data;    if (SDL_ISPIXELFORMAT_FOURCC(texture->format) &&        (texture->format != SDL_PIXELFORMAT_YUY2 ||         !D3D_IsTextureFormatAvailable(renderdata->d3d, renderdata->adapter,                                       display_format, texture->format))        && (texture->format != SDL_PIXELFORMAT_YVYU            || !D3D_IsTextureFormatAvailable(renderdata->d3d, renderdata->adapter,                                             display_format, texture->format))) {        data->yuv =            SDL_SW_CreateYUVTexture(texture->format, texture->w, texture->h);        if (!data->yuv) {            return -1;        }        data->format = display->current_mode.format;    } else {        data->format = texture->format;    }    result =        IDirect3DDevice9_CreateTexture(renderdata->device, texture->w,                                       texture->h, 1, 0,                                       PixelFormatToD3DFMT(data->format),                                       D3DPOOL_SDL, &data->texture, NULL);    if (FAILED(result)) {        D3D_SetError("CreateTexture()", result);        return -1;    }    return 0;}

static intD3D_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture){    D3D_RenderData *renderdata = (D3D_RenderData *) renderer->driverdata;    SDL_Window *window = renderer->window;    D3DFORMAT display_format = renderdata->pparams.BackBufferFormat;    D3D_TextureData *data;    D3DPOOL pool;    DWORD usage;    HRESULT result;    data = (D3D_TextureData *) SDL_calloc(1, sizeof(*data));    if (!data) {        SDL_OutOfMemory();        return -1;    }    data->scaleMode = GetScaleQuality();    texture->driverdata = data;#ifdef USE_DYNAMIC_TEXTURE    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {        pool = D3DPOOL_DEFAULT;        usage = D3DUSAGE_DYNAMIC;    } else#endif    if (texture->access == SDL_TEXTUREACCESS_TARGET) {        /* D3DPOOL_MANAGED does not work with D3DUSAGE_RENDERTARGET */        pool = D3DPOOL_DEFAULT;        usage = D3DUSAGE_RENDERTARGET;    } else {        pool = D3DPOOL_MANAGED;        usage = 0;    }    result =        IDirect3DDevice9_CreateTexture(renderdata->device, texture->w,                                       texture->h, 1, usage,                                       PixelFormatToD3DFMT(texture->format),                                       pool, &data->texture, NULL);    if (FAILED(result)) {        D3D_SetError("CreateTexture()", result);        return -1;    }    return 0;}

static intD3D_ActivateRenderer(SDL_Renderer * renderer){    D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;    HRESULT result;    if (data->updateSize) {        SDL_Window *window = renderer->window;        int w, h;        SDL_GetWindowSize(window, &w, &h);        data->pparams.BackBufferWidth = w;        data->pparams.BackBufferHeight = h;        if (SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN) {            data->pparams.BackBufferFormat =                PixelFormatToD3DFMT(SDL_GetWindowPixelFormat(window));        } else {            data->pparams.BackBufferFormat = D3DFMT_UNKNOWN;        }        if (D3D_Reset(renderer) < 0) {            return -1;        }        D3D_UpdateViewport(renderer);        data->updateSize = SDL_FALSE;    }    if (data->beginScene) {        result = IDirect3DDevice9_BeginScene(data->device);        if (result == D3DERR_DEVICELOST) {            if (D3D_Reset(renderer) < 0) {                return -1;            }            result = IDirect3DDevice9_BeginScene(data->device);        }        if (FAILED(result)) {            D3D_SetError("BeginScene()", result);            return -1;        }        data->beginScene = SDL_FALSE;    }    return 0;}

static intD3D_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,                const SDL_Rect * rect, void **pixels, int *pitch){    D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;    RECT d3drect;    D3DLOCKED_RECT locked;    HRESULT result;    d3drect.left = rect->x;    d3drect.right = rect->x + rect->w;    d3drect.top = rect->y;    d3drect.bottom = rect->y + rect->h;    result = IDirect3DTexture9_LockRect(data->texture, 0, &locked, &d3drect, 0);    if (FAILED(result)) {        return D3D_SetError("LockRect()", result);    }    *pixels = locked.pBits;    *pitch = locked.Pitch;    return 0;}

static intD3D_Reset(SDL_Renderer * renderer){    D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;    HRESULT result;    result = IDirect3DDevice9_Reset(data->device, &data->pparams);    if (FAILED(result)) {        if (result == D3DERR_DEVICELOST) {            /* Don't worry about it, we'll reset later... */            return 0;        } else {            D3D_SetError("Reset()", result);            return -1;        }    }    IDirect3DDevice9_SetVertexShader(data->device, NULL);    IDirect3DDevice9_SetFVF(data->device,                            D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1);    IDirect3DDevice9_SetRenderState(data->device, D3DRS_CULLMODE,                                    D3DCULL_NONE);    IDirect3DDevice9_SetRenderState(data->device, D3DRS_LIGHTING, FALSE);    return 0;}

static voidD3D_RenderPresent(SDL_Renderer * renderer){    D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;    HRESULT result;    if (!data->beginScene) {        IDirect3DDevice9_EndScene(data->device);        data->beginScene = SDL_TRUE;    }    result = IDirect3DDevice9_TestCooperativeLevel(data->device);    if (result == D3DERR_DEVICELOST) {        /* We'll reset later */        return;    }    if (result == D3DERR_DEVICENOTRESET) {        D3D_Reset(renderer);    }    result = IDirect3DDevice9_Present(data->device, NULL, NULL, NULL, NULL);    if (FAILED(result)) {        D3D_SetError("Present()", result);    }}

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

//.........这里部分代码省略.........    }    pparams.BackBufferCount = 1;    pparams.SwapEffect = D3DSWAPEFFECT_DISCARD;    if (window_flags & SDL_WINDOW_FULLSCREEN) {        pparams.Windowed = FALSE;        pparams.FullScreen_RefreshRateInHz =            fullscreen_mode.refresh_rate;    } else {        pparams.Windowed = TRUE;        pparams.FullScreen_RefreshRateInHz = 0;    }    if (flags & SDL_RENDERER_PRESENTVSYNC) {        pparams.PresentationInterval = D3DPRESENT_INTERVAL_ONE;    } else {        pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;    }    /* FIXME: Which adapter? */    data->adapter = D3DADAPTER_DEFAULT;    IDirect3D9_GetDeviceCaps(data->d3d, data->adapter, D3DDEVTYPE_HAL, &caps);    result = IDirect3D9_CreateDevice(data->d3d, data->adapter,                                     D3DDEVTYPE_HAL,                                     pparams.hDeviceWindow,                                     D3DCREATE_FPU_PRESERVE | ((caps.                                      DevCaps &                                      D3DDEVCAPS_HWTRANSFORMANDLIGHT) ?                                     D3DCREATE_HARDWARE_VERTEXPROCESSING :                                     D3DCREATE_SOFTWARE_VERTEXPROCESSING),                                     &pparams, &data->device);    if (FAILED(result)) {        D3D_DestroyRenderer(renderer);        D3D_SetError("CreateDevice()", result);        return NULL;    }    data->beginScene = SDL_TRUE;    data->scaleMode = D3DTEXF_FORCE_DWORD;    /* Get presentation parameters to fill info */    result = IDirect3DDevice9_GetSwapChain(data->device, 0, &chain);    if (FAILED(result)) {        D3D_DestroyRenderer(renderer);        D3D_SetError("GetSwapChain()", result);        return NULL;    }    result = IDirect3DSwapChain9_GetPresentParameters(chain, &pparams);    if (FAILED(result)) {        IDirect3DSwapChain9_Release(chain);        D3D_DestroyRenderer(renderer);        D3D_SetError("GetPresentParameters()", result);        return NULL;    }    IDirect3DSwapChain9_Release(chain);    if (pparams.PresentationInterval == D3DPRESENT_INTERVAL_ONE) {        renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;    }    data->pparams = pparams;    IDirect3DDevice9_GetDeviceCaps(data->device, &caps);    renderer->info.max_texture_width = caps.MaxTextureWidth;    renderer->info.max_texture_height = caps.MaxTextureHeight;    if (caps.NumSimultaneousRTs >= 2) {        renderer->info.flags |= SDL_RENDERER_TARGETTEXTURE;    }

static intD3D_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 intD3D_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) {//.........这里部分代码省略.........

static intD3D_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,                  const SDL_Rect * rect, const void *pixels, int pitch){    D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;    D3D_RenderData *renderdata = (D3D_RenderData *) renderer->driverdata;    if (data->yuv) {        if (SDL_SW_UpdateYUVTexture(data->yuv, rect, pixels, pitch) < 0) {            return -1;        }        UpdateYUVTextureData(texture);        return 0;    } else {#ifdef SDL_MEMORY_POOL_DEFAULT        IDirect3DTexture9 *temp;        RECT d3drect;        D3DLOCKED_RECT locked;        const Uint8 *src;        Uint8 *dst;        int row, length;        HRESULT result;        result =            IDirect3DDevice9_CreateTexture(renderdata->device, texture->w,                                           texture->h, 1, 0,                                           PixelFormatToD3DFMT(texture->                                                               format),                                           D3DPOOL_SYSTEMMEM, &temp, NULL);        if (FAILED(result)) {            D3D_SetError("CreateTexture()", result);            return -1;        }        d3drect.left = rect->x;        d3drect.right = rect->x + rect->w;        d3drect.top = rect->y;        d3drect.bottom = rect->y + rect->h;        result = IDirect3DTexture9_LockRect(temp, 0, &locked, &d3drect, 0);        if (FAILED(result)) {            IDirect3DTexture9_Release(temp);            D3D_SetError("LockRect()", result);            return -1;        }        src = pixels;        dst = locked.pBits;        length = rect->w * SDL_BYTESPERPIXEL(texture->format);        for (row = 0; row < rect->h; ++row) {            SDL_memcpy(dst, src, length);            src += pitch;            dst += locked.Pitch;        }        IDirect3DTexture9_UnlockRect(temp, 0);        result =            IDirect3DDevice9_UpdateTexture(renderdata->device,                                           (IDirect3DBaseTexture9 *) temp,                                           (IDirect3DBaseTexture9 *)                                           data->texture);        IDirect3DTexture9_Release(temp);        if (FAILED(result)) {            D3D_SetError("UpdateTexture()", result);            return -1;        }#else        RECT d3drect;        D3DLOCKED_RECT locked;        const Uint8 *src;        Uint8 *dst;        int row, length;        HRESULT result;        d3drect.left = rect->x;        d3drect.right = rect->x + rect->w;        d3drect.top = rect->y;        d3drect.bottom = rect->y + rect->h;        result =            IDirect3DTexture9_LockRect(data->texture, 0, &locked, &d3drect,                                       0);        if (FAILED(result)) {            D3D_SetError("LockRect()", result);            return -1;        }        src = pixels;        dst = locked.pBits;        length = rect->w * SDL_BYTESPERPIXEL(texture->format);        for (row = 0; row < rect->h; ++row) {            SDL_memcpy(dst, src, length);            src += pitch;            dst += locked.Pitch;        }        IDirect3DTexture9_UnlockRect(data->texture, 0);#endif // SDL_MEMORY_POOL_DEFAULT        return 0;    }//.........这里部分代码省略.........

static intD3D_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 intD3D_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)) {//.........这里部分代码省略.........

//.........这里部分代码省略.........    } else {        pparams.BackBufferCount = 1;        pparams.SwapEffect = D3DSWAPEFFECT_DISCARD;    }    if (window->flags & SDL_WINDOW_FULLSCREEN) {        pparams.Windowed = FALSE;        pparams.FullScreen_RefreshRateInHz =            window->fullscreen_mode.refresh_rate;    } else {        pparams.Windowed = TRUE;        pparams.FullScreen_RefreshRateInHz = 0;    }    if (flags & SDL_RENDERER_PRESENTVSYNC) {        pparams.PresentationInterval = D3DPRESENT_INTERVAL_ONE;    } else {        pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;    }    data->adapter = D3D_FindAdapter(videodata->d3d, display);    IDirect3D9_GetDeviceCaps(videodata->d3d, data->adapter,                             D3DDEVTYPE_HAL, &caps);    result = IDirect3D9_CreateDevice(videodata->d3d, data->adapter,                                     D3DDEVTYPE_HAL,                                     windowdata->hwnd,                                     (caps.                                      DevCaps &                                      D3DDEVCAPS_HWTRANSFORMANDLIGHT) ?                                     D3DCREATE_HARDWARE_VERTEXPROCESSING :                                     D3DCREATE_SOFTWARE_VERTEXPROCESSING,                                     &pparams, &data->device);    if (FAILED(result)) {        D3D_DestroyRenderer(renderer);        D3D_SetError("CreateDevice()", result);        return NULL;    }    data->beginScene = SDL_TRUE;    /* Get presentation parameters to fill info */    result = IDirect3DDevice9_GetSwapChain(data->device, 0, &chain);    if (FAILED(result)) {        D3D_DestroyRenderer(renderer);        D3D_SetError("GetSwapChain()", result);        return NULL;    }    result = IDirect3DSwapChain9_GetPresentParameters(chain, &pparams);    if (FAILED(result)) {        IDirect3DSwapChain9_Release(chain);        D3D_DestroyRenderer(renderer);        D3D_SetError("GetPresentParameters()", result);        return NULL;    }    IDirect3DSwapChain9_Release(chain);    switch (pparams.SwapEffect) {    case D3DSWAPEFFECT_COPY:        renderer->info.flags |= SDL_RENDERER_PRESENTCOPY;        break;    case D3DSWAPEFFECT_FLIP:        switch (pparams.BackBufferCount) {        case 2:            renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2;            break;        case 3:            renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3;            break;        }

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

//.........这里部分代码省略.........        pparams.SwapEffect = D3DSWAPEFFECT_COPY;    } else {        pparams.BackBufferCount = 1;        pparams.SwapEffect = D3DSWAPEFFECT_DISCARD;    }    if (window->flags & SDL_WINDOW_FULLSCREEN) {        pparams.Windowed = FALSE;        pparams.FullScreen_RefreshRateInHz =            display->fullscreen_mode.refresh_rate;    } else {        pparams.Windowed = TRUE;        pparams.FullScreen_RefreshRateInHz = 0;    }    if (flags & SDL_RENDERER_PRESENTVSYNC) {        pparams.PresentationInterval = D3DPRESENT_INTERVAL_ONE;    } else {        pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;    }    IDirect3D9_GetDeviceCaps(videodata->d3d, D3DADAPTER_DEFAULT,                             D3DDEVTYPE_HAL, &caps);    result = IDirect3D9_CreateDevice(videodata->d3d, D3DADAPTER_DEFAULT,        /* FIXME */                                     D3DDEVTYPE_HAL,                                     windowdata->hwnd,                                     (caps.                                      DevCaps &                                      D3DDEVCAPS_HWTRANSFORMANDLIGHT) ?                                     D3DCREATE_HARDWARE_VERTEXPROCESSING :                                     D3DCREATE_SOFTWARE_VERTEXPROCESSING,                                     &pparams, &data->device);    if (FAILED(result)) {        D3D_DestroyRenderer(renderer);        D3D_SetError("CreateDevice()", result);        return NULL;    }    data->beginScene = SDL_TRUE;    /* Get presentation parameters to fill info */    result = IDirect3DDevice9_GetSwapChain(data->device, 0, &chain);    if (FAILED(result)) {        D3D_DestroyRenderer(renderer);        D3D_SetError("GetSwapChain()", result);        return NULL;    }    result = IDirect3DSwapChain9_GetPresentParameters(chain, &pparams);    if (FAILED(result)) {        IDirect3DSwapChain9_Release(chain);        D3D_DestroyRenderer(renderer);        D3D_SetError("GetPresentParameters()", result);        return NULL;    }    IDirect3DSwapChain9_Release(chain);    switch (pparams.SwapEffect) {    case D3DSWAPEFFECT_COPY:        renderer->info.flags |= SDL_RENDERER_PRESENTCOPY;        break;    case D3DSWAPEFFECT_FLIP:        switch (pparams.BackBufferCount) {        case 2:            renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2;            break;        case 3:            renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3;            break;        }