Shader.cpp 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370
  1. #include "Shader.h"
  2. #include "Text.h"
  3. #include "Datei.h"
  4. #include <d3d11.h>
  5. #include <D3Dcompiler.h>
  6. #include <iostream>
  7. using namespace Framework;
  8. // Inhalt der Shader Klasse
  9. // Konstruktor
  10. Shader::Shader()
  11. {
  12. shader = new Text();
  13. shaderBuffer = 0;
  14. type = UNBEKANNT;
  15. for( int i = 0; i < 14; i++ )
  16. {
  17. constBuffers[ i ] = 0;
  18. buffLen[ i ] = 0;
  19. }
  20. buffAnz = 0;
  21. ref = 1;
  22. }
  23. // Destruktor
  24. Shader::~Shader()
  25. {
  26. shader->release();
  27. if( shaderBuffer )
  28. shaderBuffer->Release();
  29. for( int i = 0; i < 14; i++ )
  30. {
  31. if( constBuffers[ i ] )
  32. constBuffers[ i ]->Release();
  33. }
  34. }
  35. // Lähdt den Shader Quellcode aus einer Textdatei
  36. // pfad: Der Pfad zur Datei
  37. // return: true, wenn der Shader erfolgreich geladen wurde
  38. bool Shader::ladeAusDatei( const char* pfad )
  39. {
  40. Datei d;
  41. d.setDatei( pfad );
  42. __int64 gr = d.getSize();
  43. if( gr > 10 * 1024 )
  44. return 0; // Datei zu groß für Shader Quellcode
  45. shader->fillText( ' ', (int)gr );
  46. if( !d.open( Datei::Style::lesen ) )
  47. return 0;
  48. d.lese( shader->getText(), (int)gr );
  49. d.close();
  50. return 1;
  51. }
  52. // Setzt den Shader Quellcode
  53. // zCode: Der Quellcode des Shaders
  54. void Shader::setShaderCode( Text * zCode )
  55. {
  56. shader->setText( zCode->getText() );
  57. }
  58. // Compiliert den Shader Quellcode
  59. // zD3d11Device: Das Device, mit welchem der Shader erstellt werden soll
  60. // einstiegsFunktion: Der Name der Funktion, die als erstes aufgerufen werden soll
  61. // type: Der Typ und die Version des Shaders. Beispiel: 'vs_5_0' für Vertexshader, 'ps_5_0' für Pixelshader.
  62. // return: true, wenn der Quellcode keine Fehler enthällt
  63. bool Shader::compile( ID3D11Device * zD3d11Device, const char* einstiegsFunktion, const char* type )
  64. {
  65. ID3D10Blob* errorMessage = 0;
  66. unsigned int flag = D3D10_SHADER_ENABLE_STRICTNESS;
  67. #ifdef _DEBUG
  68. flag |= D3D10_SHADER_DEBUG;
  69. #endif
  70. if( shaderBuffer )
  71. shaderBuffer->Release();
  72. HRESULT result = D3DCompile( shader->getText(), shader->getLength(), 0, 0, 0, einstiegsFunktion, type, flag, 0, &shaderBuffer, &errorMessage );
  73. if( errorMessage )
  74. {
  75. char* err = (char*)errorMessage->GetBufferPointer();
  76. std::cout << err;
  77. errorMessage->Release();
  78. }
  79. return result == S_OK;
  80. }
  81. // Nach dem Aufruf dieser Funktion wird dieser Shader als Pixel Shader benutzt
  82. // zD3d11Context: Das Context Objekt, mit dem der Shader verwendet werden soll
  83. void Shader::benutzeShader( ID3D11DeviceContext * zD3d11Context )
  84. {}
  85. // erstellt ein constanten Buffer, der constante daten an den Shader übergibt
  86. // es können maximal 14 Buffer erstellt werden
  87. // zD3d11Device: Das Device, mit dem der Buffer erstellt werden soll
  88. // größe: Die größe des buffers in byte
  89. // 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.
  90. bool Shader::erstelleConstBuffer( ID3D11Device * zD3d11Device, int größe, int index )
  91. {
  92. if( index < 0 || index >= 14 )
  93. return 0;
  94. bool ok = 1;
  95. for( int i = 0; i < index; i++ )
  96. ok &= constBuffers[ index ] != 0;
  97. if( !ok )
  98. return 0;
  99. D3D11_BUFFER_DESC bufferDesc;
  100. bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
  101. bufferDesc.ByteWidth = größe;
  102. bufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
  103. bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
  104. bufferDesc.MiscFlags = 0;
  105. bufferDesc.StructureByteStride = 0;
  106. if( constBuffers[ index ] )
  107. {
  108. constBuffers[ index ]->Release();
  109. constBuffers[ index ] = 0;
  110. buffLen[ index ] = 0;
  111. }
  112. HRESULT res = zD3d11Device->CreateBuffer( &bufferDesc, 0, &constBuffers[ index ] );
  113. if( res == S_OK )
  114. buffLen[ index ] = größe;
  115. for( buffAnz = 0; buffAnz < 14 && constBuffers[ buffAnz ]; buffAnz++ );
  116. return res == S_OK;
  117. }
  118. // Löscht einen constanten Buffer
  119. // index: der Index des Buffers, der gelöscht werden soll. Buffer 0 kann nicht gelöscht werden, solange Buffer 1 noch existiert usw.
  120. bool Shader::removeConstBuffer( int index )
  121. {
  122. if( index < 0 || index >= 14 )
  123. return 0;
  124. bool ok = 1;
  125. for( int i = 13; i > index; i-- )
  126. ok &= constBuffers[ i ] == 0;
  127. if( !ok )
  128. return 0;
  129. if( constBuffers[ index ] )
  130. {
  131. constBuffers[ index ]->Release();
  132. constBuffers[ index ] = 0;
  133. buffLen[ index ] = 0;
  134. }
  135. for( buffAnz = 0; buffAnz < 14 && constBuffers[ buffAnz ]; buffAnz++ );
  136. return 1;
  137. }
  138. // Kopiert daten in einen constanten buffer
  139. // zD3d11Context: Das Context Objekt, das zum kopieren verwendt werden soll
  140. // data: Einen zeiger auf en byte Array der größe des Buffers
  141. // index: Der Index des Buffers
  142. // län: Die Länge der Daten in Bytes (-1 für die maximale größe des Buffers)
  143. bool Shader::füllConstBuffer( ID3D11DeviceContext * zD3d11Context, char* data, int index, int län )
  144. {
  145. if( index < 0 || index >= 14 )
  146. return 0;
  147. if( !constBuffers[ index ] )
  148. return 0;
  149. if( län < 0 )
  150. län = buffLen[ index ];
  151. D3D11_MAPPED_SUBRESOURCE mappedResource;
  152. HRESULT res = zD3d11Context->Map( constBuffers[ index ], 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource );
  153. if( res != S_OK )
  154. return 0;
  155. memcpy( mappedResource.pData, data, län );
  156. zD3d11Context->Unmap( constBuffers[ index ], 0 );
  157. return 1;
  158. }
  159. // Gibt die Länge eines constanten Buffers zurück
  160. // index: Der Index des Buffers
  161. int Shader::getConstBufferLänge( int index ) const
  162. {
  163. if( index < 0 || index >= 14 )
  164. return 0;
  165. return buffLen[ index ];
  166. }
  167. // Gibt den Shadertyp zurück
  168. ShaderType Shader::getType() const
  169. {
  170. return type;
  171. }
  172. // Erhöht den Reference Counter um 1
  173. // Return: Ein zeiger auf diesen Shader
  174. Shader* Shader::getThis()
  175. {
  176. ref++;
  177. return this;
  178. }
  179. // Verringert den Reference Counter und löscht den Shader, falls der Refeence Counter auf 0 ist
  180. // Return: 0
  181. Shader* Shader::release()
  182. {
  183. ref--;
  184. if( !ref )
  185. delete this;
  186. return 0;
  187. }
  188. // Inhalt der PixelShader Klasse
  189. // Konstruktor
  190. PixelShader::PixelShader()
  191. : Shader()
  192. {
  193. pixelShader = 0;
  194. }
  195. // Destruktor
  196. PixelShader::~PixelShader()
  197. {
  198. if( pixelShader )
  199. pixelShader->Release();
  200. }
  201. // Compiliert den Shader Quellcode
  202. // zD3d11Device: Das Device, mit welchem der Shader erstellt werden soll
  203. // einstiegsFunktion: Der Name der Funktion, die als erstes aufgerufen werden soll
  204. // type: Der die Version des Shaders. Beispiel: '5_0', '4_0'
  205. // return: true, wenn kein Fehler aufgetreten ist
  206. bool PixelShader::compile( ID3D11Device * zD3d11Device, const char* einstiegsFunktion, const char* version )
  207. {
  208. Text v = "ps_";
  209. v += version;
  210. if( !__super::compile( zD3d11Device, einstiegsFunktion, v ) )
  211. return 0;
  212. if( pixelShader )
  213. pixelShader->Release();
  214. pixelShader = 0;
  215. HRESULT result = zD3d11Device->CreatePixelShader( shaderBuffer->GetBufferPointer(), shaderBuffer->GetBufferSize(), 0, &pixelShader );
  216. shaderBuffer->Release();
  217. shaderBuffer = 0;
  218. return result == S_OK;
  219. }
  220. // Setzt den Compilierten Shader
  221. // bytes: Die Bytes des compilierten codes
  222. // length: die Länge des bytearrays
  223. // return: true, wenn bytes gültig ist, false sonst
  224. bool PixelShader::setCompiledByteArray( ID3D11Device * zD3d11Device, unsigned char* bytes, int length )
  225. {
  226. HRESULT result = zD3d11Device->CreatePixelShader( bytes, length, 0, &pixelShader );
  227. return result == S_OK;
  228. }
  229. // Nach dem Aufruf dieser Funktion wird dieser Shader als Pixel Shader benutzt
  230. // zD3d11Context: Das Context Objekt, mit dem der Shader verwendet werden soll
  231. void PixelShader::benutzeShader( ID3D11DeviceContext * zD3d11Context )
  232. {
  233. if( buffAnz )
  234. zD3d11Context->PSSetConstantBuffers( 0, buffAnz, constBuffers );
  235. if( pixelShader )
  236. zD3d11Context->PSSetShader( pixelShader, 0, 0 );
  237. }
  238. // Verringert den Reference Counter und löscht den Shader, falls der Refeence Counter auf 0 ist
  239. // Return: 0
  240. Shader * PixelShader::release()
  241. {
  242. ref--;
  243. if( !ref )
  244. delete this;
  245. return 0;
  246. }
  247. // Inhalt der VertexShader Klasse
  248. // Konstruktor
  249. VertexShader::VertexShader()
  250. : Shader()
  251. {
  252. vertexShader = 0;
  253. inputLayout = 0;
  254. shaderByteBuffer = 0;
  255. byteBufferSize = 0;
  256. }
  257. // Destruktor
  258. VertexShader::~VertexShader()
  259. {
  260. if( vertexShader )
  261. vertexShader->Release();
  262. if( inputLayout )
  263. inputLayout->Release();
  264. }
  265. // Compiliert den Shader Quellcode
  266. // zD3d11Device: Das Device, mit welchem der Shader erstellt werden soll
  267. // einstiegsFunktion: Der Name der Funktion, die als erstes aufgerufen werden soll
  268. // type: Der die Version des Shaders. Beispiel: '5_0', '4_0'
  269. // return: true, wenn kein Fehler aufgetreten ist
  270. bool VertexShader::compile( ID3D11Device * zD3d11Device, const char* einstiegsFunktion, const char* version )
  271. {
  272. Text v = "vs_";
  273. v += version;
  274. if( !__super::compile( zD3d11Device, einstiegsFunktion, v ) )
  275. return 0;
  276. if( vertexShader )
  277. vertexShader->Release();
  278. vertexShader = 0;
  279. HRESULT result = zD3d11Device->CreateVertexShader( shaderBuffer->GetBufferPointer(), shaderBuffer->GetBufferSize(), 0, &vertexShader );
  280. return result == S_OK;
  281. }
  282. // Setzt den Compilierten Shader
  283. // bytes: Die Bytes des compilierten codes
  284. // length: die Länge des bytearrays
  285. // return: true, wenn bytes gültig ist, false sonst
  286. bool VertexShader::setCompiledByteArray( ID3D11Device * zD3d11Device, unsigned char* bytes, int length )
  287. {
  288. shaderByteBuffer = (unsigned char*)bytes;
  289. byteBufferSize = length;
  290. HRESULT result = zD3d11Device->CreateVertexShader( bytes, length, 0, &vertexShader );
  291. return result == S_OK;
  292. }
  293. // erstellt ein InputLayout für den Shader
  294. // Darf erst nach compile aufgerufen werden
  295. // zD3d11Device: Das Device, mit dem das Layout erstellt werden soll
  296. // descArray: Ein Array mit initialisierungsdaten
  297. // anz: Die Anzahl der Elemente im Array
  298. bool VertexShader::erstelleInputLayout( ID3D11Device * zD3d11Device, D3D11_INPUT_ELEMENT_DESC * descArray, int anz )
  299. {
  300. if( !shaderBuffer && !shaderByteBuffer )
  301. return 0;
  302. if( inputLayout )
  303. inputLayout->Release();
  304. inputLayout = 0;
  305. HRESULT res = zD3d11Device->CreateInputLayout( descArray, anz, shaderBuffer ? shaderBuffer->GetBufferPointer() : shaderByteBuffer, shaderBuffer ? shaderBuffer->GetBufferSize() : byteBufferSize, &inputLayout );
  306. if( res == S_OK )
  307. {
  308. if( shaderBuffer )
  309. {
  310. shaderBuffer->Release();
  311. shaderBuffer = 0;
  312. }
  313. else
  314. {
  315. shaderByteBuffer = 0;
  316. byteBufferSize = 0;
  317. }
  318. }
  319. return res == S_OK;
  320. }
  321. // Nach dem Aufruf dieser Funktion wird dieser Shader als Vertex Shader benutzt
  322. // zD3d11Context: Das Context Objekt, mit dem der Shader verwendet werden soll
  323. void VertexShader::benutzeShader( ID3D11DeviceContext * zD3d11Context )
  324. {
  325. if( buffAnz )
  326. zD3d11Context->VSSetConstantBuffers( 0, buffAnz, constBuffers );
  327. if( inputLayout )
  328. zD3d11Context->IASetInputLayout( inputLayout );
  329. if( vertexShader )
  330. zD3d11Context->VSSetShader( vertexShader, 0, 0 );
  331. }
  332. // Verringert den Reference Counter und löscht den Shader, falls der Refeence Counter auf 0 ist
  333. // Return: 0
  334. Shader * VertexShader::release()
  335. {
  336. ref--;
  337. if( !ref )
  338. delete this;
  339. return 0;
  340. }