SDL_Renderer *
D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_VideoDisplay *display = window->display;
SDL_VideoData *videodata = (SDL_VideoData *) display->device->driverdata;
SDL_WindowData *windowdata = (SDL_WindowData *) window->driverdata;
SDL_Renderer *renderer;
D3D_RenderData *data;
HRESULT result;
D3DPRESENT_PARAMETERS pparams;
IDirect3DSwapChain9 *chain;
D3DCAPS9 caps;
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
data = (D3D_RenderData *) SDL_calloc(1, sizeof(*data));
if (!data) {
D3D_DestroyRenderer(renderer);
SDL_OutOfMemory();
return NULL;
}
data->d3d = videodata->d3d;
videodata->render = RENDER_D3D;
renderer->DisplayModeChanged = D3D_DisplayModeChanged;
renderer->CreateTexture = D3D_CreateTexture;
renderer->QueryTexturePixels = D3D_QueryTexturePixels;
renderer->SetTexturePalette = D3D_SetTexturePalette;
renderer->GetTexturePalette = D3D_GetTexturePalette;
renderer->SetTextureColorMod = D3D_SetTextureColorMod;
renderer->SetTextureAlphaMod = D3D_SetTextureAlphaMod;
renderer->SetTextureBlendMode = D3D_SetTextureBlendMode;
renderer->SetTextureScaleMode = D3D_SetTextureScaleMode;
renderer->UpdateTexture = D3D_UpdateTexture;
renderer->LockTexture = D3D_LockTexture;
renderer->UnlockTexture = D3D_UnlockTexture;
renderer->DirtyTexture = D3D_DirtyTexture;
renderer->RenderDrawPoints = D3D_RenderDrawPoints;
renderer->RenderDrawLines = D3D_RenderDrawLines;
renderer->RenderDrawRects = D3D_RenderDrawRects;
renderer->RenderFillRects = D3D_RenderFillRects;
renderer->RenderCopy = D3D_RenderCopy;
renderer->RenderReadPixels = D3D_RenderReadPixels;
renderer->RenderWritePixels = D3D_RenderWritePixels;
renderer->RenderPresent = D3D_RenderPresent;
renderer->DestroyTexture = D3D_DestroyTexture;
renderer->DestroyRenderer = D3D_DestroyRenderer;
renderer->info = D3D_RenderDriver.info;
renderer->window = window;
renderer->driverdata = data;
renderer->info.flags = SDL_RENDERER_ACCELERATED;
SDL_zero(pparams);
pparams.BackBufferWidth = window->w;
pparams.BackBufferHeight = window->h;
if (window->flags & SDL_WINDOW_FULLSCREEN) {
pparams.BackBufferFormat =
PixelFormatToD3DFMT(window->fullscreen_mode.format);
} else {
pparams.BackBufferFormat = D3DFMT_UNKNOWN;
}
if (flags & SDL_RENDERER_PRESENTFLIP2) {
pparams.BackBufferCount = 2;
pparams.SwapEffect = D3DSWAPEFFECT_FLIP;
} else if (flags & SDL_RENDERER_PRESENTFLIP3) {
pparams.BackBufferCount = 3;
pparams.SwapEffect = D3DSWAPEFFECT_FLIP;
} else if (flags & SDL_RENDERER_PRESENTCOPY) {
pparams.BackBufferCount = 1;
pparams.SwapEffect = D3DSWAPEFFECT_COPY;
} 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;
}
break;
case D3DSWAPEFFECT_DISCARD:
renderer->info.flags |= SDL_RENDERER_PRESENTDISCARD;
break;
}
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;
/* Set up parameters for rendering */
IDirect3DDevice9_SetVertexShader(data->device, NULL);
IDirect3DDevice9_SetFVF(data->device,
D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_ZENABLE, D3DZB_FALSE);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_CULLMODE,
D3DCULL_NONE);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_LIGHTING, FALSE);
/* Enable color modulation by diffuse color */
IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_COLOROP,
D3DTOP_MODULATE);
IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_COLORARG1,
D3DTA_TEXTURE);
IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_COLORARG2,
D3DTA_DIFFUSE);
/* Enable alpha modulation by diffuse alpha */
IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_ALPHAOP,
D3DTOP_MODULATE);
IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_ALPHAARG1,
D3DTA_TEXTURE);
IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_ALPHAARG2,
D3DTA_DIFFUSE);
/* Disable second texture stage, since we're done */
IDirect3DDevice9_SetTextureStageState(data->device, 1, D3DTSS_COLOROP,
D3DTOP_DISABLE);
IDirect3DDevice9_SetTextureStageState(data->device, 1, D3DTSS_ALPHAOP,
D3DTOP_DISABLE);
{
#ifdef ASSEMBLE_SHADER
const char *shader_text =
"ps_1_1\n"
"def c0, 0, 0, 0, 0.496\n"
"def c1, 0, 0, 0, 1\n"
"def c2, 0, 0, 0, -1\n"
"tex t0\n"
"mul r1, t0, v0\n"
"add r0, r1, c0\n"
"cnd r0, r0.a, c1, c2\n"
"add r0, r0, r1\n";
LPD3DXBUFFER pCode; // buffer with the assembled shader code
LPD3DXBUFFER pErrorMsgs; // buffer with error messages
LPDWORD shader_data;
DWORD shader_size;
result = D3DXAssembleShader( shader_text, SDL_strlen(shader_text), NULL, NULL, 0, &pCode, &pErrorMsgs );
if (FAILED(result)) {
D3D_SetError("D3DXAssembleShader()", result);
}
shader_data = (DWORD*)pCode->lpVtbl->GetBufferPointer(pCode);
shader_size = pCode->lpVtbl->GetBufferSize(pCode);
#else
const DWORD shader_data[] = {
0xffff0101,0x00000051,0xa00f0000,0x00000000,0x00000000,0x00000000,
0x3efdf3b6,0x00000051,0xa00f0001,0x00000000,0x00000000,0x00000000,
0x3f800000,0x00000051,0xa00f0002,0x00000000,0x00000000,0x00000000,
0xbf800000,0x00000042,0xb00f0000,0x00000005,0x800f0001,0xb0e40000,
0x90e40000,0x00000002,0x800f0000,0x80e40001,0xa0e40000,0x00000050,
0x800f0000,0x80ff0000,0xa0e40001,0xa0e40002,0x00000002,0x800f0000,
0x80e40000,0x80e40001,0x0000ffff
};
#endif
result = IDirect3DDevice9_CreatePixelShader(data->device, shader_data, &data->ps_mask);
if (FAILED(result)) {
D3D_SetError("CreatePixelShader()", result);
}
}
return renderer;
}
static void createShadersD3D9()
{
static HMODULE d3dx9_handle = 0;
LPD3DXBUFFER vShaderBuffer = NULL;
LPD3DXBUFFER pShaderBuffer = NULL;
LPD3DXBUFFER errBuf = NULL;
HRESULT hr;
HRESULT (__stdcall * d3dx_assemble_shader)(LPCSTR pSrcData, UINT SrcDataLen, CONST D3DXMACRO* pDefines,
LPD3DXINCLUDE pInclude, DWORD Flags, LPD3DXBUFFER* ppShader,
LPD3DXBUFFER* ppErrorMsgs);
d3dx9_handle = LoadLibraryA("d3dx9_30.dll");
if (!d3dx9_handle) {
fprintf(stderr, "Could not load d3dx9_30.dll\n");
return;
}
d3dx_assemble_shader = (void *)GetProcAddress(d3dx9_handle, "D3DXAssembleShader");
if (!d3dx_assemble_shader) {
fprintf(stderr, "Could not get address of D3DXAssembleShader\n");
goto cleanup;
}
/* Assemble the vertex shader into bytecode and create it */
hr = d3dx_assemble_shader(basicVertexShaderSourceD3D9, strlen(basicVertexShaderSourceD3D9), NULL, NULL, 0, &vShaderBuffer, &errBuf);
if (FAILED(hr)) {
fprintf(stderr, "Vertex shader assembly failed\n");
if (errBuf) {
fprintf(stderr, "error: %s\n", (const char*)ID3DXBuffer_GetBufferPointer(errBuf));
ID3DXBuffer_Release(errBuf);
errBuf = NULL;
}
goto cleanup;
}
hr = IDirect3DDevice9_CreateVertexShader(gDevicePtr, ID3DXBuffer_GetBufferPointer(vShaderBuffer), &gVShaderPtr);
if (FAILED(hr)) {
fprintf(stderr, "Vertex shader creation failed\n");
goto cleanup;
}
/* Assemble the pixel shader into bytecode and create it */
hr = d3dx_assemble_shader(basicPixelShaderSourceD3D9, strlen(basicPixelShaderSourceD3D9), NULL, NULL, 0, &pShaderBuffer, &errBuf);
if (FAILED(hr)) {
fprintf(stderr, "Pixel shader assembly failed\n");
if (errBuf) {
fprintf(stderr, "error: %s\n", (const char*)ID3DXBuffer_GetBufferPointer(errBuf));
ID3DXBuffer_Release(errBuf);
errBuf = NULL;
}
goto cleanup;
}
hr = IDirect3DDevice9_CreatePixelShader(gDevicePtr, ID3DXBuffer_GetBufferPointer(pShaderBuffer), &gPShaderPtr);
if (FAILED(hr)) {
fprintf(stderr, "Pixel shader creation failed\n");
goto cleanup;
}
return;
cleanup:
if (vShaderBuffer)
ID3DXBuffer_Release(vShaderBuffer);
if (pShaderBuffer)
ID3DXBuffer_Release(pShaderBuffer);
FreeLibrary(d3dx9_handle);
}
