The Tor Browser / file comparison

comparison: gfx/angle/src/libGLESv2/renderer/TextureStorage11.cpp

gfx/angle/src/libGLESv2/renderer/TextureStorage11.cpp

branch
TOR_BUG_9701
changeset 3
141e0f1194b1
equal deleted inserted replaced
-1:000000000000 0:61df8b02acf1
1 #include "precompiled.h"
2 //
3 // Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
4 // Use of this source code is governed by a BSD-style license that can be
5 // found in the LICENSE file.
6 //
7
8 // TextureStorage11.cpp: Implements the abstract rx::TextureStorage11 class and its concrete derived
9 // classes TextureStorage11_2D and TextureStorage11_Cube, which act as the interface to the D3D11 texture.
10
11 #include "libGLESv2/renderer/TextureStorage11.h"
12
13 #include "libGLESv2/renderer/Renderer11.h"
14 #include "libGLESv2/renderer/RenderTarget11.h"
15 #include "libGLESv2/renderer/SwapChain11.h"
16 #include "libGLESv2/renderer/renderer11_utils.h"
17
18 #include "libGLESv2/utilities.h"
19 #include "libGLESv2/main.h"
20
21 namespace rx
22 {
23
24 TextureStorage11::TextureStorage11(Renderer *renderer, UINT bindFlags)
25 : mBindFlags(bindFlags),
26 mLodOffset(0),
27 mMipLevels(0),
28 mTexture(NULL),
29 mTextureFormat(DXGI_FORMAT_UNKNOWN),
30 mShaderResourceFormat(DXGI_FORMAT_UNKNOWN),
31 mRenderTargetFormat(DXGI_FORMAT_UNKNOWN),
32 mDepthStencilFormat(DXGI_FORMAT_UNKNOWN),
33 mSRV(NULL),
34 mTextureWidth(0),
35 mTextureHeight(0)
36 {
37 mRenderer = Renderer11::makeRenderer11(renderer);
38 }
39
40 TextureStorage11::~TextureStorage11()
41 {
42 }
43
44 TextureStorage11 *TextureStorage11::makeTextureStorage11(TextureStorage *storage)
45 {
46 ASSERT(HAS_DYNAMIC_TYPE(TextureStorage11*, storage));
47 return static_cast<TextureStorage11*>(storage);
48 }
49
50 DWORD TextureStorage11::GetTextureBindFlags(DXGI_FORMAT format, GLenum glusage, bool forceRenderable)
51 {
52 UINT bindFlags = D3D11_BIND_SHADER_RESOURCE;
53
54 if (d3d11::IsDepthStencilFormat(format))
55 {
56 bindFlags |= D3D11_BIND_DEPTH_STENCIL;
57 }
58 else if(forceRenderable || (TextureStorage11::IsTextureFormatRenderable(format) && (glusage == GL_FRAMEBUFFER_ATTACHMENT_ANGLE)))
59 {
60 bindFlags |= D3D11_BIND_RENDER_TARGET;
61 }
62 return bindFlags;
63 }
64
65 bool TextureStorage11::IsTextureFormatRenderable(DXGI_FORMAT format)
66 {
67 switch(format)
68 {
69 case DXGI_FORMAT_R8G8B8A8_UNORM:
70 case DXGI_FORMAT_A8_UNORM:
71 case DXGI_FORMAT_R32G32B32A32_FLOAT:
72 case DXGI_FORMAT_R16G16B16A16_FLOAT:
73 case DXGI_FORMAT_B8G8R8A8_UNORM:
74 case DXGI_FORMAT_R8_UNORM:
75 case DXGI_FORMAT_R8G8_UNORM:
76 case DXGI_FORMAT_R16_FLOAT:
77 case DXGI_FORMAT_R16G16_FLOAT:
78 return true;
79 case DXGI_FORMAT_BC1_UNORM:
80 case DXGI_FORMAT_BC2_UNORM:
81 case DXGI_FORMAT_BC3_UNORM:
82 case DXGI_FORMAT_R32G32B32_FLOAT: // not renderable on all devices
83 return false;
84 default:
85 UNREACHABLE();
86 return false;
87 }
88 }
89
90 UINT TextureStorage11::getBindFlags() const
91 {
92 return mBindFlags;
93 }
94
95 ID3D11Texture2D *TextureStorage11::getBaseTexture() const
96 {
97 return mTexture;
98 }
99
100 int TextureStorage11::getLodOffset() const
101 {
102 return mLodOffset;
103 }
104
105 bool TextureStorage11::isRenderTarget() const
106 {
107 return (mBindFlags & (D3D11_BIND_RENDER_TARGET | D3D11_BIND_DEPTH_STENCIL)) != 0;
108 }
109
110 bool TextureStorage11::isManaged() const
111 {
112 return false;
113 }
114
115 int TextureStorage11::levelCount()
116 {
117 int levels = 0;
118 if (getBaseTexture())
119 {
120 levels = mMipLevels - getLodOffset();
121 }
122 return levels;
123 }
124
125 UINT TextureStorage11::getSubresourceIndex(int level, int faceIndex)
126 {
127 UINT index = 0;
128 if (getBaseTexture())
129 {
130 index = D3D11CalcSubresource(level, faceIndex, mMipLevels);
131 }
132 return index;
133 }
134
135 bool TextureStorage11::updateSubresourceLevel(ID3D11Texture2D *srcTexture, unsigned int sourceSubresource,
136 int level, int face, GLint xoffset, GLint yoffset,
137 GLsizei width, GLsizei height)
138 {
139 if (srcTexture)
140 {
141 // Round up the width and height to the nearest multiple of dimension alignment
142 unsigned int dimensionAlignment = d3d11::GetTextureFormatDimensionAlignment(mTextureFormat);
143 width = width + dimensionAlignment - 1 - (width - 1) % dimensionAlignment;
144 height = height + dimensionAlignment - 1 - (height - 1) % dimensionAlignment;
145
146 D3D11_BOX srcBox;
147 srcBox.left = xoffset;
148 srcBox.top = yoffset;
149 srcBox.right = xoffset + width;
150 srcBox.bottom = yoffset + height;
151 srcBox.front = 0;
152 srcBox.back = 1;
153
154 ID3D11DeviceContext *context = mRenderer->getDeviceContext();
155
156 ASSERT(getBaseTexture());
157 context->CopySubresourceRegion(getBaseTexture(), getSubresourceIndex(level + mLodOffset, face),
158 xoffset, yoffset, 0, srcTexture, sourceSubresource, &srcBox);
159 return true;
160 }
161
162 return false;
163 }
164
165 void TextureStorage11::generateMipmapLayer(RenderTarget11 *source, RenderTarget11 *dest)
166 {
167 if (source && dest)
168 {
169 ID3D11ShaderResourceView *sourceSRV = source->getShaderResourceView();
170 ID3D11RenderTargetView *destRTV = dest->getRenderTargetView();
171
172 if (sourceSRV && destRTV)
173 {
174 gl::Rectangle sourceArea;
175 sourceArea.x = 0;
176 sourceArea.y = 0;
177 sourceArea.width = source->getWidth();
178 sourceArea.height = source->getHeight();
179
180 gl::Rectangle destArea;
181 destArea.x = 0;
182 destArea.y = 0;
183 destArea.width = dest->getWidth();
184 destArea.height = dest->getHeight();
185
186 mRenderer->copyTexture(sourceSRV, sourceArea, source->getWidth(), source->getHeight(),
187 destRTV, destArea, dest->getWidth(), dest->getHeight(),
188 GL_RGBA);
189 }
190 }
191 }
192
193 TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, SwapChain11 *swapchain)
194 : TextureStorage11(renderer, D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE)
195 {
196 mTexture = swapchain->getOffscreenTexture();
197 mSRV = swapchain->getRenderTargetShaderResource();
198
199 for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
200 {
201 mRenderTarget[i] = NULL;
202 }
203
204 D3D11_TEXTURE2D_DESC texDesc;
205 mTexture->GetDesc(&texDesc);
206 mMipLevels = texDesc.MipLevels;
207 mTextureFormat = texDesc.Format;
208 mTextureWidth = texDesc.Width;
209 mTextureHeight = texDesc.Height;
210
211 D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
212 mSRV->GetDesc(&srvDesc);
213 mShaderResourceFormat = srvDesc.Format;
214
215 ID3D11RenderTargetView* offscreenRTV = swapchain->getRenderTarget();
216 D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
217 offscreenRTV->GetDesc(&rtvDesc);
218 mRenderTargetFormat = rtvDesc.Format;
219 offscreenRTV->Release();
220
221 mDepthStencilFormat = DXGI_FORMAT_UNKNOWN;
222 }
223
224 TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, GLsizei width, GLsizei height)
225 : TextureStorage11(renderer, GetTextureBindFlags(gl_d3d11::ConvertTextureFormat(internalformat), usage, forceRenderable))
226 {
227 for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
228 {
229 mRenderTarget[i] = NULL;
230 }
231
232 DXGI_FORMAT convertedFormat = gl_d3d11::ConvertTextureFormat(internalformat);
233 if (d3d11::IsDepthStencilFormat(convertedFormat))
234 {
235 mTextureFormat = d3d11::GetDepthTextureFormat(convertedFormat);
236 mShaderResourceFormat = d3d11::GetDepthShaderResourceFormat(convertedFormat);
237 mDepthStencilFormat = convertedFormat;
238 mRenderTargetFormat = DXGI_FORMAT_UNKNOWN;
239 }
240 else
241 {
242 mTextureFormat = convertedFormat;
243 mShaderResourceFormat = convertedFormat;
244 mDepthStencilFormat = DXGI_FORMAT_UNKNOWN;
245 mRenderTargetFormat = convertedFormat;
246 }
247
248 // if the width or height is not positive this should be treated as an incomplete texture
249 // we handle that here by skipping the d3d texture creation
250 if (width > 0 && height > 0)
251 {
252 // adjust size if needed for compressed textures
253 gl::MakeValidSize(false, gl::IsCompressed(internalformat), &width, &height, &mLodOffset);
254
255 ID3D11Device *device = mRenderer->getDevice();
256
257 D3D11_TEXTURE2D_DESC desc;
258 desc.Width = width; // Compressed texture size constraints?
259 desc.Height = height;
260 desc.MipLevels = (levels > 0) ? levels + mLodOffset : 0;
261 desc.ArraySize = 1;
262 desc.Format = mTextureFormat;
263 desc.SampleDesc.Count = 1;
264 desc.SampleDesc.Quality = 0;
265 desc.Usage = D3D11_USAGE_DEFAULT;
266 desc.BindFlags = getBindFlags();
267 desc.CPUAccessFlags = 0;
268 desc.MiscFlags = 0;
269
270 HRESULT result = device->CreateTexture2D(&desc, NULL, &mTexture);
271
272 // this can happen from windows TDR
273 if (d3d11::isDeviceLostError(result))
274 {
275 mRenderer->notifyDeviceLost();
276 gl::error(GL_OUT_OF_MEMORY);
277 }
278 else if (FAILED(result))
279 {
280 ASSERT(result == E_OUTOFMEMORY);
281 ERR("Creating image failed.");
282 gl::error(GL_OUT_OF_MEMORY);
283 }
284 else
285 {
286 mTexture->GetDesc(&desc);
287 mMipLevels = desc.MipLevels;
288 mTextureWidth = desc.Width;
289 mTextureHeight = desc.Height;
290 }
291 }
292 }
293
294 TextureStorage11_2D::~TextureStorage11_2D()
295 {
296 if (mTexture)
297 {
298 mTexture->Release();
299 mTexture = NULL;
300 }
301
302 if (mSRV)
303 {
304 mSRV->Release();
305 mSRV = NULL;
306 }
307
308 for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
309 {
310 delete mRenderTarget[i];
311 mRenderTarget[i] = NULL;
312 }
313 }
314
315 TextureStorage11_2D *TextureStorage11_2D::makeTextureStorage11_2D(TextureStorage *storage)
316 {
317 ASSERT(HAS_DYNAMIC_TYPE(TextureStorage11_2D*, storage));
318 return static_cast<TextureStorage11_2D*>(storage);
319 }
320
321 RenderTarget *TextureStorage11_2D::getRenderTarget(int level)
322 {
323 if (level >= 0 && level < static_cast<int>(mMipLevels))
324 {
325 if (!mRenderTarget[level])
326 {
327 ID3D11Device *device = mRenderer->getDevice();
328 HRESULT result;
329
330 D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
331 srvDesc.Format = mShaderResourceFormat;
332 srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
333 srvDesc.Texture2D.MostDetailedMip = level;
334 srvDesc.Texture2D.MipLevels = 1;
335
336 ID3D11ShaderResourceView *srv;
337 result = device->CreateShaderResourceView(mTexture, &srvDesc, &srv);
338
339 if (result == E_OUTOFMEMORY)
340 {
341 return gl::error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
342 }
343 ASSERT(SUCCEEDED(result));
344
345 if (mRenderTargetFormat != DXGI_FORMAT_UNKNOWN)
346 {
347 D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
348 rtvDesc.Format = mRenderTargetFormat;
349 rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
350 rtvDesc.Texture2D.MipSlice = level;
351
352 ID3D11RenderTargetView *rtv;
353 result = device->CreateRenderTargetView(mTexture, &rtvDesc, &rtv);
354
355 if (result == E_OUTOFMEMORY)
356 {
357 srv->Release();
358 return gl::error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
359 }
360 ASSERT(SUCCEEDED(result));
361
362 // RenderTarget11 expects to be the owner of the resources it is given but TextureStorage11
363 // also needs to keep a reference to the texture.
364 mTexture->AddRef();
365
366 mRenderTarget[level] = new RenderTarget11(mRenderer, rtv, mTexture, srv,
367 std::max(mTextureWidth >> level, 1U),
368 std::max(mTextureHeight >> level, 1U));
369 }
370 else if (mDepthStencilFormat != DXGI_FORMAT_UNKNOWN)
371 {
372 D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc;
373 dsvDesc.Format = mDepthStencilFormat;
374 dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
375 dsvDesc.Texture2D.MipSlice = level;
376 dsvDesc.Flags = 0;
377
378 ID3D11DepthStencilView *dsv;
379 result = device->CreateDepthStencilView(mTexture, &dsvDesc, &dsv);
380
381 if (result == E_OUTOFMEMORY)
382 {
383 srv->Release();
384 return gl::error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
385 }
386 ASSERT(SUCCEEDED(result));
387
388 // RenderTarget11 expects to be the owner of the resources it is given but TextureStorage11
389 // also needs to keep a reference to the texture.
390 mTexture->AddRef();
391
392 mRenderTarget[level] = new RenderTarget11(mRenderer, dsv, mTexture, srv,
393 std::max(mTextureWidth >> level, 1U),
394 std::max(mTextureHeight >> level, 1U));
395 }
396 else
397 {
398 UNREACHABLE();
399 }
400 }
401
402 return mRenderTarget[level];
403 }
404 else
405 {
406 return NULL;
407 }
408 }
409
410 ID3D11ShaderResourceView *TextureStorage11_2D::getSRV()
411 {
412 if (!mSRV)
413 {
414 ID3D11Device *device = mRenderer->getDevice();
415
416 D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
417 srvDesc.Format = mShaderResourceFormat;
418 srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
419 srvDesc.Texture2D.MipLevels = (mMipLevels == 0 ? -1 : mMipLevels);
420 srvDesc.Texture2D.MostDetailedMip = 0;
421
422 HRESULT result = device->CreateShaderResourceView(mTexture, &srvDesc, &mSRV);
423
424 if (result == E_OUTOFMEMORY)
425 {
426 return gl::error(GL_OUT_OF_MEMORY, static_cast<ID3D11ShaderResourceView*>(NULL));
427 }
428 ASSERT(SUCCEEDED(result));
429 }
430
431 return mSRV;
432 }
433
434 void TextureStorage11_2D::generateMipmap(int level)
435 {
436 RenderTarget11 *source = RenderTarget11::makeRenderTarget11(getRenderTarget(level - 1));
437 RenderTarget11 *dest = RenderTarget11::makeRenderTarget11(getRenderTarget(level));
438
439 generateMipmapLayer(source, dest);
440 }
441
442 TextureStorage11_Cube::TextureStorage11_Cube(Renderer *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, int size)
443 : TextureStorage11(renderer, GetTextureBindFlags(gl_d3d11::ConvertTextureFormat(internalformat), usage, forceRenderable))
444 {
445 for (unsigned int i = 0; i < 6; i++)
446 {
447 for (unsigned int j = 0; j < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; j++)
448 {
449 mRenderTarget[i][j] = NULL;
450 }
451 }
452
453 DXGI_FORMAT convertedFormat = gl_d3d11::ConvertTextureFormat(internalformat);
454 if (d3d11::IsDepthStencilFormat(convertedFormat))
455 {
456 mTextureFormat = d3d11::GetDepthTextureFormat(convertedFormat);
457 mShaderResourceFormat = d3d11::GetDepthShaderResourceFormat(convertedFormat);
458 mDepthStencilFormat = convertedFormat;
459 mRenderTargetFormat = DXGI_FORMAT_UNKNOWN;
460 }
461 else
462 {
463 mTextureFormat = convertedFormat;
464 mShaderResourceFormat = convertedFormat;
465 mDepthStencilFormat = DXGI_FORMAT_UNKNOWN;
466 mRenderTargetFormat = convertedFormat;
467 }
468
469 // if the size is not positive this should be treated as an incomplete texture
470 // we handle that here by skipping the d3d texture creation
471 if (size > 0)
472 {
473 // adjust size if needed for compressed textures
474 int height = size;
475 gl::MakeValidSize(false, gl::IsCompressed(internalformat), &size, &height, &mLodOffset);
476
477 ID3D11Device *device = mRenderer->getDevice();
478
479 D3D11_TEXTURE2D_DESC desc;
480 desc.Width = size;
481 desc.Height = size;
482 desc.MipLevels = (levels > 0) ? levels + mLodOffset : 0;
483 desc.ArraySize = 6;
484 desc.Format = mTextureFormat;
485 desc.SampleDesc.Count = 1;
486 desc.SampleDesc.Quality = 0;
487 desc.Usage = D3D11_USAGE_DEFAULT;
488 desc.BindFlags = getBindFlags();
489 desc.CPUAccessFlags = 0;
490 desc.MiscFlags = D3D11_RESOURCE_MISC_TEXTURECUBE;
491
492 HRESULT result = device->CreateTexture2D(&desc, NULL, &mTexture);
493
494 if (FAILED(result))
495 {
496 ASSERT(result == E_OUTOFMEMORY);
497 ERR("Creating image failed.");
498 gl::error(GL_OUT_OF_MEMORY);
499 }
500 else
501 {
502 mTexture->GetDesc(&desc);
503 mMipLevels = desc.MipLevels;
504 mTextureWidth = desc.Width;
505 mTextureHeight = desc.Height;
506 }
507 }
508 }
509
510 TextureStorage11_Cube::~TextureStorage11_Cube()
511 {
512 if (mTexture)
513 {
514 mTexture->Release();
515 mTexture = NULL;
516 }
517
518 if (mSRV)
519 {
520 mSRV->Release();
521 mSRV = NULL;
522 }
523
524 for (unsigned int i = 0; i < 6; i++)
525 {
526 for (unsigned int j = 0; j < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; j++)
527 {
528 delete mRenderTarget[i][j];
529 mRenderTarget[i][j] = NULL;
530 }
531 }
532 }
533
534 TextureStorage11_Cube *TextureStorage11_Cube::makeTextureStorage11_Cube(TextureStorage *storage)
535 {
536 ASSERT(HAS_DYNAMIC_TYPE(TextureStorage11_Cube*, storage));
537 return static_cast<TextureStorage11_Cube*>(storage);
538 }
539
540 RenderTarget *TextureStorage11_Cube::getRenderTarget(GLenum faceTarget, int level)
541 {
542 unsigned int faceIdx = gl::TextureCubeMap::faceIndex(faceTarget);
543 if (level >= 0 && level < static_cast<int>(mMipLevels))
544 {
545 if (!mRenderTarget[faceIdx][level])
546 {
547 ID3D11Device *device = mRenderer->getDevice();
548 HRESULT result;
549
550 D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
551 srvDesc.Format = mShaderResourceFormat;
552 srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE;
553 srvDesc.Texture2DArray.MostDetailedMip = level;
554 srvDesc.Texture2DArray.MipLevels = 1;
555 srvDesc.Texture2DArray.FirstArraySlice = faceIdx;
556 srvDesc.Texture2DArray.ArraySize = 1;
557
558 ID3D11ShaderResourceView *srv;
559 result = device->CreateShaderResourceView(mTexture, &srvDesc, &srv);
560
561 if (result == E_OUTOFMEMORY)
562 {
563 return gl::error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
564 }
565 ASSERT(SUCCEEDED(result));
566
567 if (mRenderTargetFormat != DXGI_FORMAT_UNKNOWN)
568 {
569 D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
570 rtvDesc.Format = mRenderTargetFormat;
571 rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY;
572 rtvDesc.Texture2DArray.MipSlice = level;
573 rtvDesc.Texture2DArray.FirstArraySlice = faceIdx;
574 rtvDesc.Texture2DArray.ArraySize = 1;
575
576 ID3D11RenderTargetView *rtv;
577 result = device->CreateRenderTargetView(mTexture, &rtvDesc, &rtv);
578
579 if (result == E_OUTOFMEMORY)
580 {
581 srv->Release();
582 return gl::error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
583 }
584 ASSERT(SUCCEEDED(result));
585
586 // RenderTarget11 expects to be the owner of the resources it is given but TextureStorage11
587 // also needs to keep a reference to the texture.
588 mTexture->AddRef();
589
590 mRenderTarget[faceIdx][level] = new RenderTarget11(mRenderer, rtv, mTexture, srv,
591 std::max(mTextureWidth >> level, 1U),
592 std::max(mTextureHeight >> level, 1U));
593 }
594 else if (mDepthStencilFormat != DXGI_FORMAT_UNKNOWN)
595 {
596 D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc;
597 dsvDesc.Format = mRenderTargetFormat;
598 dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY;
599 dsvDesc.Texture2DArray.MipSlice = level;
600 dsvDesc.Texture2DArray.FirstArraySlice = faceIdx;
601 dsvDesc.Texture2DArray.ArraySize = 1;
602
603 ID3D11DepthStencilView *dsv;
604 result = device->CreateDepthStencilView(mTexture, &dsvDesc, &dsv);
605
606 if (result == E_OUTOFMEMORY)
607 {
608 srv->Release();
609 return gl::error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
610 }
611 ASSERT(SUCCEEDED(result));
612
613 // RenderTarget11 expects to be the owner of the resources it is given but TextureStorage11
614 // also needs to keep a reference to the texture.
615 mTexture->AddRef();
616
617 mRenderTarget[faceIdx][level] = new RenderTarget11(mRenderer, dsv, mTexture, srv,
618 std::max(mTextureWidth >> level, 1U),
619 std::max(mTextureHeight >> level, 1U));
620 }
621 else
622 {
623 UNREACHABLE();
624 }
625 }
626
627 return mRenderTarget[faceIdx][level];
628 }
629 else
630 {
631 return NULL;
632 }
633 }
634
635 ID3D11ShaderResourceView *TextureStorage11_Cube::getSRV()
636 {
637 if (!mSRV)
638 {
639 ID3D11Device *device = mRenderer->getDevice();
640
641 D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
642 srvDesc.Format = mShaderResourceFormat;
643 srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE;
644 srvDesc.TextureCube.MipLevels = (mMipLevels == 0 ? -1 : mMipLevels);
645 srvDesc.TextureCube.MostDetailedMip = 0;
646
647 HRESULT result = device->CreateShaderResourceView(mTexture, &srvDesc, &mSRV);
648
649 if (result == E_OUTOFMEMORY)
650 {
651 return gl::error(GL_OUT_OF_MEMORY, static_cast<ID3D11ShaderResourceView*>(NULL));
652 }
653 ASSERT(SUCCEEDED(result));
654 }
655
656 return mSRV;
657 }
658
659 void TextureStorage11_Cube::generateMipmap(int face, int level)
660 {
661 RenderTarget11 *source = RenderTarget11::makeRenderTarget11(getRenderTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level - 1));
662 RenderTarget11 *dest = RenderTarget11::makeRenderTarget11(getRenderTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level));
663
664 generateMipmapLayer(source, dest);
665 }
666
667 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial