Shader.cpp 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348
  1. #include "Shader.h"
  2. #include "Text.h"
  3. #include "Datei.h"
  4. #include "DXBuffer.h"
  5. #include <d3d11.h>
  6. #include <d3d12.h>
  7. #include <iostream>
  8. using namespace Framework;
  9. // Inhalt der Shader Klasse
  10. // Konstruktor
  11. Shader::Shader()
  12. : ReferenceCounter()
  13. {
  14. type = UNBEKANNT;
  15. constBuffers = new RCArray< DXBuffer >();
  16. }
  17. // Destruktor
  18. Shader::~Shader()
  19. {
  20. constBuffers->release();
  21. }
  22. // Löscht einen constanten Buffer
  23. // index: der Index des Buffers, der gelöscht werden soll. Buffer 0 kann nicht gelöscht werden, solange Buffer 1 noch existiert usw.
  24. bool Shader::removeConstBuffer( int index )
  25. {
  26. if( index < 0 )
  27. return 0;
  28. bool ok = 1;
  29. constBuffers->set( 0, index );
  30. return 1;
  31. }
  32. // Kopiert daten in einen constanten buffer
  33. // zD3d11Context: Das Context Objekt, das zum kopieren verwendt werden soll
  34. // data: Einen zeiger auf en byte Array der größe des Buffers
  35. // index: Der Index des Buffers
  36. // län: Die Länge der Daten in Bytes (-1 für die maximale größe des Buffers)
  37. bool Shader::füllConstBuffer( char *data, int index, int len )
  38. {
  39. if( index < 0 || index > constBuffers->getLastIndex() )
  40. return 0;
  41. DXBuffer * zB = constBuffers->z( index );
  42. if( !zB )
  43. return 0;
  44. if( len < 0 )
  45. len = zB->getElementAnzahl() * zB->getElementLength();
  46. zB->setData( data );
  47. zB->copieren( len );
  48. return 1;
  49. }
  50. // Gibt die Länge eines constanten Buffers zurück
  51. // index: Der Index des Buffers
  52. int Shader::getConstBufferLänge( int index ) const
  53. {
  54. if( index < 0 || index > constBuffers->getLastIndex() )
  55. return 0;
  56. DXBuffer * zB = constBuffers->z( index );
  57. if( !zB )
  58. return 0;
  59. return zB->getElementAnzahl() * zB->getElementLength();
  60. }
  61. // Gibt den Shadertyp zurück
  62. ShaderType Shader::getType() const
  63. {
  64. return type;
  65. }
  66. DX11Shader::DX11Shader( ID3D11Device * device, ID3D11DeviceContext * context )
  67. : Shader()
  68. {
  69. this->device = device;
  70. this->context = context;
  71. }
  72. DX11Shader::~DX11Shader()
  73. {}
  74. // erstellt ein constanten Buffer, der constante daten an den Shader übergibt
  75. // es können maximal 14 Buffer erstellt werden
  76. // zD3d11Device: Das Device, mit dem der Buffer erstellt werden soll
  77. // größe: Die größe des buffers in byte
  78. // index: Die position des Buffers im Buffer Array. Bereits vorhanderner Buffer wird ersetzt. Buffer 1 kann nicht erstellt werden, wenn Buffer 0 noch nicht erstellt wurde usw.
  79. bool DX11Shader::erstelleConstBuffer( int größe, int index )
  80. {
  81. if( index < 0 || index >= 14 )
  82. return 0;
  83. bool ok = 1;
  84. while( ( größe / 16 ) * 16 != größe ) // es sind nur vielfache von 16 als größe erlaubt
  85. größe++;
  86. while( !constBuffers->hat( index ) )
  87. constBuffers->add( 0 );
  88. constBuffers->set( new DX11Buffer( 1, device, context, D3D11_BIND_CONSTANT_BUFFER ), index );
  89. constBuffers->z( index )->setLength( größe );
  90. return 1;
  91. }
  92. // Inhalt der PixelShader Klasse
  93. // Konstruktor
  94. DX11PixelShader::DX11PixelShader( ID3D11Device * device, ID3D11DeviceContext * context )
  95. : DX11Shader( device, context )
  96. {
  97. pixelShader = 0;
  98. }
  99. // Destruktor
  100. DX11PixelShader::~DX11PixelShader()
  101. {
  102. if( pixelShader )
  103. pixelShader->Release();
  104. }
  105. // Setzt den Compilierten Shader
  106. // bytes: Die Bytes des compilierten codes
  107. // length: die Länge des bytearrays
  108. // return: true, wenn bytes gültig ist, false sonst
  109. bool DX11PixelShader::setCompiledByteArray( unsigned char *bytes, int length )
  110. {
  111. HRESULT result = device->CreatePixelShader( bytes, length, 0, &pixelShader );
  112. return result == S_OK;
  113. }
  114. // Nach dem Aufruf dieser Funktion wird dieser Shader als Pixel Shader benutzt
  115. // zD3d11Context: Das Context Objekt, mit dem der Shader verwendet werden soll
  116. void DX11PixelShader::benutzeShader()
  117. {
  118. int maxI = constBuffers->getLastIndex();
  119. for( int i = 0; i <= maxI; i++ )
  120. {
  121. if( !constBuffers->z( i ) )
  122. continue;
  123. if( !( (DX11Buffer *)constBuffers->z( i ) )->zBuffer() )
  124. constBuffers->z( i )->copieren();
  125. ID3D11Buffer * buf = ( (DX11Buffer *)constBuffers->z( i ) )->zBuffer();
  126. context->PSSetConstantBuffers( i, 1, &buf );
  127. }
  128. if( pixelShader )
  129. context->PSSetShader( pixelShader, 0, 0 );
  130. }
  131. // Inhalt der VertexShader Klasse
  132. // Konstruktor
  133. DX11VertexShader::DX11VertexShader( ID3D11Device * device, ID3D11DeviceContext * context )
  134. : DX11Shader( device, context )
  135. {
  136. vertexShader = 0;
  137. inputLayout = 0;
  138. shaderByteBuffer = 0;
  139. byteBufferSize = 0;
  140. }
  141. // Destruktor
  142. DX11VertexShader::~DX11VertexShader()
  143. {
  144. if( vertexShader )
  145. vertexShader->Release();
  146. if( inputLayout )
  147. inputLayout->Release();
  148. }
  149. // Setzt den Compilierten Shader
  150. // bytes: Die Bytes des compilierten codes
  151. // length: die Länge des bytearrays
  152. // return: true, wenn bytes gültig ist, false sonst
  153. bool DX11VertexShader::setCompiledByteArray( unsigned char *bytes, int length )
  154. {
  155. shaderByteBuffer = (unsigned char *)bytes;
  156. byteBufferSize = length;
  157. HRESULT result = device->CreateVertexShader( bytes, length, 0, &vertexShader );
  158. return result == S_OK;
  159. }
  160. // erstellt ein InputLayout für den Shader
  161. // Darf erst nach compile aufgerufen werden
  162. // zD3d11Device: Das Device, mit dem das Layout erstellt werden soll
  163. // descArray: Ein Array mit initialisierungsdaten
  164. // anz: Die Anzahl der Elemente im Array
  165. bool DX11VertexShader::erstelleInputLayout( D3D11_INPUT_ELEMENT_DESC * descArray, int anz )
  166. {
  167. if( !shaderByteBuffer )
  168. return 0;
  169. if( inputLayout )
  170. inputLayout->Release();
  171. inputLayout = 0;
  172. HRESULT res = device->CreateInputLayout( descArray, anz, shaderByteBuffer, byteBufferSize, &inputLayout );
  173. if( res == S_OK )
  174. {
  175. shaderByteBuffer = 0;
  176. byteBufferSize = 0;
  177. }
  178. return res == S_OK;
  179. }
  180. // Nach dem Aufruf dieser Funktion wird dieser Shader als Vertex Shader benutzt
  181. // zD3d11Context: Das Context Objekt, mit dem der Shader verwendet werden soll
  182. void DX11VertexShader::benutzeShader()
  183. {
  184. int maxI = constBuffers->getLastIndex();
  185. for( int i = 0; i <= maxI; i++ )
  186. {
  187. if( !constBuffers->z( i ) )
  188. continue;
  189. if( !( (DX11Buffer *)constBuffers->z( i ) )->zBuffer() )
  190. constBuffers->z( i )->copieren();
  191. ID3D11Buffer * buf = ( (DX11Buffer *)constBuffers->z( i ) )->zBuffer();
  192. context->VSSetConstantBuffers( i, 1, &buf );
  193. }
  194. if( inputLayout )
  195. context->IASetInputLayout( inputLayout );
  196. if( vertexShader )
  197. context->VSSetShader( vertexShader, 0, 0 );
  198. }
  199. DX12Shader::DX12Shader( ID3D12Device2 * device, DX12CopyCommandQueue *copy, DX12DirectCommandQueue *direct )
  200. : Shader()
  201. {
  202. shaderByteBuffer = 0;
  203. byteBufferSize = 0;
  204. this->device = device;
  205. this->copy = copy;
  206. this->direct = direct;
  207. }
  208. DX12Shader::~DX12Shader()
  209. {
  210. delete[] shaderByteBuffer;
  211. }
  212. // erstellt ein constanten Buffer, der constante daten an den Shader übergibt
  213. // es können maximal 14 Buffer erstellt werden
  214. // zD3d11Device: Das Device, mit dem der Buffer erstellt werden soll
  215. // size: Die größe des buffers in byte
  216. // index: Die position des Buffers im Buffer Array. Bereits vorhanderner Buffer wird ersetzt. Buffer 1 kann nicht erstellt werden, wenn Buffer 0 noch nicht erstellt wurde usw.
  217. bool DX12Shader::erstelleConstBuffer( int size, int index )
  218. {
  219. if( index < 0 || index >= 14 )
  220. return 0;
  221. while( ( size / 256 ) * 256 != size )
  222. size++;
  223. while( !constBuffers->hat( index ) )
  224. constBuffers->add( 0 );
  225. constBuffers->set( new DX12VertexBuffer( 1, device, copy, direct ), index );
  226. constBuffers->z( index )->setLength( size );
  227. constBuffers->z( index )->copieren();
  228. return 1;
  229. }
  230. // Setzt den Compilierten Shader
  231. // zD3d11Device: Das Device, mit welchem der Shader erstellt werden soll
  232. // bytes: Die Bytes des compilierten codes
  233. // length: die Länge des bytearrays
  234. // return: true, wenn bytes gültig ist, false sonst
  235. bool DX12Shader::setCompiledByteArray( unsigned char *bytes, int length )
  236. {
  237. delete[] shaderByteBuffer;
  238. shaderByteBuffer = new unsigned char[ length ];
  239. memcpy( shaderByteBuffer, bytes, length );
  240. byteBufferSize = length;
  241. return 1;
  242. }
  243. // Nach dem Aufruf dieser Funktion wird dieser Shader als Pixel Shader benutzt
  244. // zD3d11Context: Das Context Objekt, mit dem der Shader verwendet werden soll
  245. void DX12Shader::benutzeShader()
  246. {
  247. // not needet in DirectX 12
  248. }
  249. // gibt die compilierten bytes zurück
  250. unsigned char *DX12Shader::getCompiledShader() const
  251. {
  252. return shaderByteBuffer;
  253. }
  254. // gitbt die anzahl der compilierten bytes zurück
  255. int DX12Shader::getCompiledLength() const
  256. {
  257. return byteBufferSize;
  258. }
  259. // Erstellt den RootParameter zu einem constanten buffer
  260. // index: Der Index des Buffers
  261. // view: enthält nach dem Aufruf die position und größe des buffers im speicher
  262. void DX12Shader::getViewDesc( int index, D3D12_CONSTANT_BUFFER_VIEW_DESC &view )
  263. {
  264. DX12Buffer *zB = (DX12Buffer *)constBuffers->z( index );
  265. if( !zB )
  266. return;
  267. view.SizeInBytes = zB->getElementAnzahl() * zB->getElementLength();
  268. view.BufferLocation = zB->zBuffer()->GetGPUVirtualAddress();
  269. }
  270. DX12PixelShader::DX12PixelShader( ID3D12Device2 * device, DX12CopyCommandQueue *copy, DX12DirectCommandQueue *direct )
  271. : DX12Shader( device, copy, direct )
  272. {}
  273. // Konstruktor
  274. DX12VertexShader::DX12VertexShader( ID3D12Device2 * device, DX12CopyCommandQueue *copy, DX12DirectCommandQueue *direct )
  275. : DX12Shader( device, copy, direct )
  276. {
  277. inputLayout = 0;
  278. inputLayoutSize = 0;
  279. }
  280. // Destruktor
  281. DX12VertexShader::~DX12VertexShader()
  282. {
  283. delete[] inputLayout;
  284. }
  285. // erstellt ein InputLayout für den Shader
  286. // Darf erst nach compile aufgerufen werden
  287. // zD3d11Device: Das Device, mit dem das Layout erstellt werden soll
  288. // descArray: Ein Array mit initialisierungsdaten
  289. // anz: Die Anzahl der Elemente im Array
  290. bool DX12VertexShader::erstelleInputLayout( D3D12_INPUT_ELEMENT_DESC * descArray, int anz )
  291. {
  292. delete[] inputLayout;
  293. inputLayout = new D3D12_INPUT_ELEMENT_DESC[ anz ];
  294. memcpy( inputLayout, descArray, anz * sizeof( D3D12_INPUT_ELEMENT_DESC ) );
  295. inputLayoutSize = anz;
  296. return 1;
  297. }
  298. // Gint die Anzahl an eingabeparametern des Shaders zurück
  299. int DX12VertexShader::getInputLayoutSize() const
  300. {
  301. return inputLayoutSize;
  302. }
  303. // Gibt eine Liste mit formaten für jeden Eingabewert zurück
  304. D3D12_INPUT_ELEMENT_DESC *DX12VertexShader::zInputLayout() const
  305. {
  306. return inputLayout;
  307. }