pandory500/SDL-mirror
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

WinRT: moved texture management code from SDL_winrtrenderer to the D3D 11.1 SDL_Renderer backend

Browse source
This commit is contained in:
David Ludwig 2013-02-09 18:58:13 -05:00
parent 43c3909acd
commit ba872e50c7
4 changed files with 254 additions and 154 deletions
Download patch file Download diff file Expand all files Collapse all files

232
src/render/direct3d11/SDL_render_d3d11.cpp
View file

@ -53,32 +53,32 @@ using namespace Windows::UI::Core;
static SDL_Renderer *D3D11_CreateRenderer(SDL_Window * window, Uint32 flags); static SDL_Renderer *D3D11_CreateRenderer(SDL_Window * window, Uint32 flags);
static void D3D11_WindowEvent(SDL_Renderer * renderer, static void D3D11_WindowEvent(SDL_Renderer * renderer,
const SDL_WindowEvent *event); const SDL_WindowEvent *event);
//static int D3D11_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture); static int D3D11_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
//static int D3D11_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture, static int D3D11_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
// const SDL_Rect * rect, const void *pixels, const SDL_Rect * rect, const void *pixels,
// int pitch); int pitch);
//static int D3D11_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture, //static int D3D11_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
// const SDL_Rect * rect, void **pixels, int *pitch); // const SDL_Rect * rect, void **pixels, int *pitch);
//static void D3D11_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture); //static void D3D11_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture);
//static int D3D11_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture); //static int D3D11_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture);
static int D3D11_UpdateViewport(SDL_Renderer * renderer); static int D3D11_UpdateViewport(SDL_Renderer * renderer);
//static int D3D11_RenderClear(SDL_Renderer * renderer); static int D3D11_RenderClear(SDL_Renderer * renderer);
//static int D3D11_RenderDrawPoints(SDL_Renderer * renderer, //static int D3D11_RenderDrawPoints(SDL_Renderer * renderer,
// const SDL_FPoint * points, int count); // const SDL_FPoint * points, int count);
//static int D3D11_RenderDrawLines(SDL_Renderer * renderer, //static int D3D11_RenderDrawLines(SDL_Renderer * renderer,
// const SDL_FPoint * points, int count); // const SDL_FPoint * points, int count);
//static int D3D11_RenderFillRects(SDL_Renderer * renderer, //static int D3D11_RenderFillRects(SDL_Renderer * renderer,
// const SDL_FRect * rects, int count); // const SDL_FRect * rects, int count);
//static int D3D11_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, static int D3D11_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
// const SDL_Rect * srcrect, const SDL_FRect * dstrect); const SDL_Rect * srcrect, const SDL_FRect * dstrect);
//static int D3D11_RenderCopyEx(SDL_Renderer * renderer, SDL_Texture * texture, //static int D3D11_RenderCopyEx(SDL_Renderer * renderer, SDL_Texture * texture,
// const SDL_Rect * srcrect, const SDL_FRect * dstrect, // const SDL_Rect * srcrect, const SDL_FRect * dstrect,
// const double angle, const SDL_FPoint * center, const SDL_RendererFlip flip); // const double angle, const SDL_FPoint * center, const SDL_RendererFlip flip);
//static int D3D11_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect, //static int D3D11_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
// Uint32 format, void * pixels, int pitch); // Uint32 format, void * pixels, int pitch);
static void D3D11_RenderPresent(SDL_Renderer * renderer); static void D3D11_RenderPresent(SDL_Renderer * renderer);
//static void D3D11_DestroyTexture(SDL_Renderer * renderer, static void D3D11_DestroyTexture(SDL_Renderer * renderer,
// SDL_Texture * texture); SDL_Texture * texture);
static void D3D11_DestroyRenderer(SDL_Renderer * renderer); static void D3D11_DestroyRenderer(SDL_Renderer * renderer);
/* Direct3D 11.1 Internal Functions */ /* Direct3D 11.1 Internal Functions */
@ -91,10 +91,10 @@ extern "C" {
SDL_RenderDriver D3D11_RenderDriver = { SDL_RenderDriver D3D11_RenderDriver = {
D3D11_CreateRenderer, D3D11_CreateRenderer,
{ {
"direct3d", "direct3d 11.1",
(SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE), (SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE),
1, 1,
{SDL_PIXELFORMAT_ARGB8888}, {SDL_PIXELFORMAT_RGB888},
0, 0,
0} 0}
}; };
@ -132,21 +132,21 @@ D3D11_CreateRenderer(SDL_Window * window, Uint32 flags)
data->renderTargetSize = XMFLOAT2(0, 0); data->renderTargetSize = XMFLOAT2(0, 0);
renderer->WindowEvent = D3D11_WindowEvent; renderer->WindowEvent = D3D11_WindowEvent;
//renderer->CreateTexture = D3D11_CreateTexture; renderer->CreateTexture = D3D11_CreateTexture;
//renderer->UpdateTexture = D3D11_UpdateTexture; renderer->UpdateTexture = D3D11_UpdateTexture;
//renderer->LockTexture = D3D11_LockTexture; //renderer->LockTexture = D3D11_LockTexture;
//renderer->UnlockTexture = D3D11_UnlockTexture; //renderer->UnlockTexture = D3D11_UnlockTexture;
//renderer->SetRenderTarget = D3D11_SetRenderTarget; //renderer->SetRenderTarget = D3D11_SetRenderTarget;
renderer->UpdateViewport = D3D11_UpdateViewport; renderer->UpdateViewport = D3D11_UpdateViewport;
//renderer->RenderClear = D3D11_RenderClear; renderer->RenderClear = D3D11_RenderClear;
//renderer->RenderDrawPoints = D3D11_RenderDrawPoints; //renderer->RenderDrawPoints = D3D11_RenderDrawPoints;
//renderer->RenderDrawLines = D3D11_RenderDrawLines; //renderer->RenderDrawLines = D3D11_RenderDrawLines;
//renderer->RenderFillRects = D3D11_RenderFillRects; //renderer->RenderFillRects = D3D11_RenderFillRects;
//renderer->RenderCopy = D3D11_RenderCopy; renderer->RenderCopy = D3D11_RenderCopy;
//renderer->RenderCopyEx = D3D11_RenderCopyEx; //renderer->RenderCopyEx = D3D11_RenderCopyEx;
//renderer->RenderReadPixels = D3D11_RenderReadPixels; //renderer->RenderReadPixels = D3D11_RenderReadPixels;
renderer->RenderPresent = D3D11_RenderPresent; renderer->RenderPresent = D3D11_RenderPresent;
//renderer->DestroyTexture = D3D11_DestroyTexture; renderer->DestroyTexture = D3D11_DestroyTexture;
renderer->DestroyRenderer = D3D11_DestroyRenderer; renderer->DestroyRenderer = D3D11_DestroyRenderer;
renderer->info = D3D11_RenderDriver.info; renderer->info = D3D11_RenderDriver.info;
renderer->info.flags = SDL_RENDERER_ACCELERATED; renderer->info.flags = SDL_RENDERER_ACCELERATED;
@ -166,6 +166,8 @@ D3D11_CreateRenderer(SDL_Window * window, Uint32 flags)
return NULL; return NULL;
} }
// TODO, WinRT: fill in renderer->info.texture_formats where appropriate
return renderer; return renderer;
} }
@ -720,12 +722,210 @@ D3D11_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
} }
} }
static int
D3D11_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->driverdata;
D3D11_TextureData *textureData;
HRESULT result;
textureData = new D3D11_TextureData;
if (!textureData) {
SDL_OutOfMemory();
return -1;
}
textureData->pixelFormat = SDL_AllocFormat(texture->format);
texture->driverdata = textureData;
const int pixelSizeInBytes = textureData->pixelFormat->BytesPerPixel;
D3D11_TEXTURE2D_DESC textureDesc = {0};
textureDesc.Width = texture->w;
textureDesc.Height = texture->h;
textureDesc.MipLevels = 1;
textureDesc.ArraySize = 1;
textureDesc.Format = DXGI_FORMAT_B8G8R8X8_UNORM;
textureDesc.SampleDesc.Count = 1;
textureDesc.SampleDesc.Quality = 0;
textureDesc.Usage = D3D11_USAGE_DYNAMIC;
textureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
textureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
textureDesc.MiscFlags = 0;
const int numPixels = textureDesc.Width * textureDesc.Height;
std::vector<uint8> initialTexturePixels(numPixels * pixelSizeInBytes, 0x00);
// Fill the texture with a non-black color, for debugging purposes:
//for (int i = 0; i < (numPixels * pixelSizeInBytes); i += pixelSizeInBytes) {
// initialTexturePixels[i+0] = 0xff;
// initialTexturePixels[i+1] = 0xff;
// initialTexturePixels[i+2] = 0x00;
// initialTexturePixels[i+3] = 0xff;
//}
D3D11_SUBRESOURCE_DATA initialTextureData = {0};
initialTextureData.pSysMem = (void *)&(initialTexturePixels[0]);
initialTextureData.SysMemPitch = textureDesc.Width * pixelSizeInBytes;
initialTextureData.SysMemSlicePitch = numPixels * pixelSizeInBytes;
result = rendererData->d3dDevice->CreateTexture2D(
&textureDesc,
&initialTextureData,
&textureData->mainTexture
);
if (FAILED(result)) {
D3D11_DestroyTexture(renderer, texture);
WIN_SetErrorFromHRESULT(__FUNCTION__, result);
return -1;
}
D3D11_SHADER_RESOURCE_VIEW_DESC resourceViewDesc;
resourceViewDesc.Format = textureDesc.Format;
resourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
resourceViewDesc.Texture2D.MostDetailedMip = 0;
resourceViewDesc.Texture2D.MipLevels = textureDesc.MipLevels;
result = rendererData->d3dDevice->CreateShaderResourceView(
textureData->mainTexture.Get(),
&resourceViewDesc,
&textureData->mainTextureResourceView
);
if (FAILED(result)) {
D3D11_DestroyTexture(renderer, texture);
WIN_SetErrorFromHRESULT(__FUNCTION__, result);
return -1;
}
return 0;
}
static void
D3D11_DestroyTexture(SDL_Renderer * renderer,
SDL_Texture * texture)
{
D3D11_TextureData *textureData = (D3D11_TextureData *) texture->driverdata;
if (textureData) {
if (textureData->pixelFormat) {
SDL_FreeFormat(textureData->pixelFormat);
textureData->pixelFormat = NULL;
}
delete textureData;
texture = NULL;
texture->driverdata = NULL;
}
}
static int
D3D11_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels,
int pitch)
{
D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->driverdata;
D3D11_TextureData *textureData = (D3D11_TextureData *) texture->driverdata;
HRESULT result = S_OK;
D3D11_MAPPED_SUBRESOURCE textureMemory = {0};
result = rendererData->d3dContext->Map(
textureData->mainTexture.Get(),
0,
D3D11_MAP_WRITE_DISCARD,
0,
&textureMemory
);
if (FAILED(result)) {
WIN_SetErrorFromHRESULT(__FUNCTION__, result);
return -1;
}
// Copy pixel data to the locked texture's memory:
for (int y = 0; y < rect->h; ++y) {
memcpy(
((Uint8 *)textureMemory.pData) + (textureMemory.RowPitch * y),
((Uint8 *)pixels) + (pitch * y),
pitch
);
}
// Clean up a bit, then commit the texture's memory back to Direct3D:
rendererData->d3dContext->Unmap(
textureData->mainTexture.Get(),
0);
return 0;
}
static int static int
D3D11_UpdateViewport(SDL_Renderer * renderer) D3D11_UpdateViewport(SDL_Renderer * renderer)
{ {
return 0; return 0;
} }
static int
D3D11_RenderClear(SDL_Renderer * renderer)
{
D3D11_RenderData *data = (D3D11_RenderData *) renderer->driverdata;
const float colorRGBA[] = {
renderer->r,
renderer->g,
renderer->b,
renderer->a
};
data->d3dContext->ClearRenderTargetView(
data->renderTargetView.Get(),
colorRGBA
);
return 0;
}
static int D3D11_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * srcrect, const SDL_FRect * dstrect)
{
D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->driverdata;
D3D11_TextureData *textureData = (D3D11_TextureData *) texture->driverdata;
//HRESULT result = S_OK;
rendererData->d3dContext->OMSetRenderTargets(
1,
rendererData->renderTargetView.GetAddressOf(),
nullptr
);
UINT stride = sizeof(VertexPositionColor);
UINT offset = 0;
rendererData->d3dContext->IASetVertexBuffers(
0,
1,
rendererData->vertexBuffer.GetAddressOf(),
&stride,
&offset
);
rendererData->d3dContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
rendererData->d3dContext->IASetInputLayout(rendererData->inputLayout.Get());
rendererData->d3dContext->VSSetShader(
rendererData->vertexShader.Get(),
nullptr,
0
);
rendererData->d3dContext->PSSetShader(
rendererData->pixelShader.Get(),
nullptr,
0
);
rendererData->d3dContext->PSSetShaderResources(0, 1, textureData->mainTextureResourceView.GetAddressOf());
rendererData->d3dContext->PSSetSamplers(0, 1, rendererData->mainSampler.GetAddressOf());
rendererData->d3dContext->Draw(4, 0);
return 0;
}
static void static void
D3D11_RenderPresent(SDL_Renderer * renderer) D3D11_RenderPresent(SDL_Renderer * renderer)
{ {

5
src/render/direct3d11/SDL_render_d3d11_cpp.h
View file

@ -34,8 +34,6 @@ typedef struct
Microsoft::WRL::ComPtr<ID3D11Buffer> vertexBuffer; Microsoft::WRL::ComPtr<ID3D11Buffer> vertexBuffer;
Microsoft::WRL::ComPtr<ID3D11VertexShader> vertexShader; Microsoft::WRL::ComPtr<ID3D11VertexShader> vertexShader;
Microsoft::WRL::ComPtr<ID3D11PixelShader> pixelShader; Microsoft::WRL::ComPtr<ID3D11PixelShader> pixelShader;
Microsoft::WRL::ComPtr<ID3D11Texture2D> mainTexture;
Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> mainTextureResourceView;
Microsoft::WRL::ComPtr<ID3D11SamplerState> mainSampler; Microsoft::WRL::ComPtr<ID3D11SamplerState> mainSampler;
D3D_FEATURE_LEVEL featureLevel; D3D_FEATURE_LEVEL featureLevel;
unsigned int vertexCount; unsigned int vertexCount;
@ -52,6 +50,9 @@ typedef struct
typedef struct typedef struct
{ {
Microsoft::WRL::ComPtr<ID3D11Texture2D> mainTexture;
Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> mainTextureResourceView;
SDL_PixelFormat * pixelFormat;
} D3D11_TextureData; } D3D11_TextureData;
struct VertexPositionColor struct VertexPositionColor

169
src/video/windowsrt/SDL_winrtrenderer.cpp
View file

@ -7,6 +7,7 @@
extern "C" { extern "C" {
#include "SDL_syswm.h" #include "SDL_syswm.h"
#include "../../core/windows/SDL_windows.h"
} }
using namespace DirectX; using namespace DirectX;
@ -18,167 +19,65 @@ using namespace Windows::Graphics::Display;
// Constructor. // Constructor.
SDL_winrtrenderer::SDL_winrtrenderer() : SDL_winrtrenderer::SDL_winrtrenderer() :
m_mainTextureHelperSurface(NULL),
m_sdlRenderer(NULL), m_sdlRenderer(NULL),
m_sdlRendererData(NULL) m_sdlRendererData(NULL),
m_mainTexture(NULL)
{ {
} }
SDL_winrtrenderer::~SDL_winrtrenderer() SDL_winrtrenderer::~SDL_winrtrenderer()
{ {
if (m_mainTextureHelperSurface) { if (m_mainTexture) {
SDL_FreeSurface(m_mainTextureHelperSurface); SDL_DestroyTexture(m_mainTexture);
m_mainTextureHelperSurface = NULL; m_mainTexture = NULL;
} }
} }
void SDL_winrtrenderer::ResizeMainTexture(int w, int h) void SDL_winrtrenderer::ResizeMainTexture(int w, int h)
{ {
const int pixelSizeInBytes = 4; if (m_mainTexture) {
SDL_DestroyTexture(m_mainTexture);
D3D11_TEXTURE2D_DESC textureDesc = {0}; m_mainTexture = NULL;
textureDesc.Width = w;
textureDesc.Height = h;
textureDesc.MipLevels = 1;
textureDesc.ArraySize = 1;
textureDesc.Format = DXGI_FORMAT_B8G8R8X8_UNORM;
textureDesc.SampleDesc.Count = 1;
textureDesc.SampleDesc.Quality = 0;
textureDesc.Usage = D3D11_USAGE_DYNAMIC;
textureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
textureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
textureDesc.MiscFlags = 0;
const int numPixels = textureDesc.Width * textureDesc.Height;
std::vector<uint8> initialTexturePixels(numPixels * pixelSizeInBytes, 0x00);
// Fill the texture with a non-black color, for debugging purposes:
//for (int i = 0; i < (numPixels * pixelSizeInBytes); i += pixelSizeInBytes) {
// initialTexturePixels[i+0] = 0xff;
// initialTexturePixels[i+1] = 0xff;
// initialTexturePixels[i+2] = 0x00;
// initialTexturePixels[i+3] = 0xff;
//}
D3D11_SUBRESOURCE_DATA initialTextureData = {0};
initialTextureData.pSysMem = (void *)&(initialTexturePixels[0]);
initialTextureData.SysMemPitch = textureDesc.Width * pixelSizeInBytes;
initialTextureData.SysMemSlicePitch = numPixels * pixelSizeInBytes;
DX::ThrowIfFailed(
m_sdlRendererData->d3dDevice->CreateTexture2D(
&textureDesc,
&initialTextureData,
&m_sdlRendererData->mainTexture
)
);
if (m_mainTextureHelperSurface) {
SDL_FreeSurface(m_mainTextureHelperSurface);
m_mainTextureHelperSurface = NULL;
}
m_mainTextureHelperSurface = SDL_CreateRGBSurfaceFrom(
NULL,
textureDesc.Width, textureDesc.Height,
(pixelSizeInBytes * 8),
0, // Use an nil pitch for now. This'll be filled in when updating the texture.
0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000); // TODO, WinRT: calculate masks given the Direct3D-defined pixel format of the texture
if (m_mainTextureHelperSurface == NULL) {
DX::ThrowIfFailed(E_FAIL); // TODO, WinRT: generate a better error here, taking into account who's calling this function.
} }
D3D11_SHADER_RESOURCE_VIEW_DESC resourceViewDesc; m_mainTexture = SDL_CreateTexture(m_sdlRenderer, SDL_PIXELFORMAT_RGB888, SDL_TEXTUREACCESS_TARGET, w, h);
resourceViewDesc.Format = textureDesc.Format; }
resourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
resourceViewDesc.Texture2D.MostDetailedMip = 0; static inline Platform::Exception ^
resourceViewDesc.Texture2D.MipLevels = textureDesc.MipLevels; WINRT_CreateExceptionWithSDLError()
DX::ThrowIfFailed( {
m_sdlRendererData->d3dDevice->CreateShaderResourceView( wchar_t * sdlErrorMessage = WIN_UTF8ToString(SDL_GetError());
m_sdlRendererData->mainTexture.Get(), Platform::String ^ errorMessage = ref new Platform::String(sdlErrorMessage);
&resourceViewDesc, SDL_free(sdlErrorMessage);
&m_sdlRendererData->mainTextureResourceView) throw ref new Platform::FailureException(errorMessage);
);
} }
void SDL_winrtrenderer::Render(SDL_Surface * surface, SDL_Rect * rects, int numrects) void SDL_winrtrenderer::Render(SDL_Surface * surface, SDL_Rect * rects, int numrects)
{ {
const float blackColor[] = { 0.0f, 0.0f, 0.0f, 0.0f }; D3D11_TextureData * textureData = (D3D11_TextureData *)m_mainTexture->driverdata;
m_sdlRendererData->d3dContext->ClearRenderTargetView(
m_sdlRendererData->renderTargetView.Get(), SDL_SetRenderDrawColor(m_sdlRenderer, 0, 0, 0, 0);
blackColor if (SDL_RenderClear(m_sdlRenderer) != 0) {
); throw WINRT_CreateExceptionWithSDLError();
}
// Only draw the screen once it is loaded (some loading is asynchronous). // Only draw the screen once it is loaded (some loading is asynchronous).
if (!m_sdlRendererData->loadingComplete) if (!m_sdlRendererData->loadingComplete) {
{
return; return;
} }
if (!m_sdlRendererData->mainTextureResourceView) if (!textureData->mainTextureResourceView) {
{
return; return;
} }
// Update the main texture (for SDL usage). Start by mapping the SDL // Update the main texture (for SDL usage).
// window's main texture to CPU-accessible memory:
D3D11_MAPPED_SUBRESOURCE textureMemory = {0};
DX::ThrowIfFailed(
m_sdlRendererData->d3dContext->Map(
m_sdlRendererData->mainTexture.Get(),
0,
D3D11_MAP_WRITE_DISCARD,
0,
&textureMemory)
);
// Copy pixel data to the locked texture's memory:
m_mainTextureHelperSurface->pixels = textureMemory.pData;
m_mainTextureHelperSurface->pitch = textureMemory.RowPitch;
SDL_BlitSurface(surface, NULL, m_mainTextureHelperSurface, NULL);
// TODO, WinRT: only update the requested rects (passed to SDL_UpdateWindowSurface), rather than everything // TODO, WinRT: only update the requested rects (passed to SDL_UpdateWindowSurface), rather than everything
if (SDL_UpdateTexture(m_mainTexture, NULL, surface->pixels, surface->pitch) != 0) {
throw WINRT_CreateExceptionWithSDLError();
}
// Clean up a bit, then commit the texture's memory back to Direct3D: if (SDL_RenderCopy(m_sdlRenderer, m_mainTexture, NULL, NULL) != 0) {
m_mainTextureHelperSurface->pixels = NULL; throw WINRT_CreateExceptionWithSDLError();
m_mainTextureHelperSurface->pitch = 0; }
m_sdlRendererData->d3dContext->Unmap(
m_sdlRendererData->mainTexture.Get(),
0);
m_sdlRendererData->d3dContext->OMSetRenderTargets(
1,
m_sdlRendererData->renderTargetView.GetAddressOf(),
nullptr
);
UINT stride = sizeof(VertexPositionColor);
UINT offset = 0;
m_sdlRendererData->d3dContext->IASetVertexBuffers(
0,
1,
m_sdlRendererData->vertexBuffer.GetAddressOf(),
&stride,
&offset
);
m_sdlRendererData->d3dContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
m_sdlRendererData->d3dContext->IASetInputLayout(m_sdlRendererData->inputLayout.Get());
m_sdlRendererData->d3dContext->VSSetShader(
m_sdlRendererData->vertexShader.Get(),
nullptr,
0
);
m_sdlRendererData->d3dContext->PSSetShader(
m_sdlRendererData->pixelShader.Get(),
nullptr,
0
);
m_sdlRendererData->d3dContext->PSSetShaderResources(0, 1, m_sdlRendererData->mainTextureResourceView.GetAddressOf());
m_sdlRendererData->d3dContext->PSSetSamplers(0, 1, m_sdlRendererData->mainSampler.GetAddressOf());
m_sdlRendererData->d3dContext->Draw(4, 0);
} }
// Method to deliver the final image to the display. // Method to deliver the final image to the display.

2
src/video/windowsrt/SDL_winrtrenderer.h
View file

@ -29,5 +29,5 @@ internal:
protected private: protected private:
// UpdateWindowSurface helper objects // UpdateWindowSurface helper objects
SDL_Surface * m_mainTextureHelperSurface; SDL_Texture * m_mainTexture;
}; };