GL.cpp 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417
  1. #include "GL/glew.h"
  2. #include <type_traits>
  3. #include "utils/Array.h"
  4. #include "utils/Logger.h"
  5. #include "wrapper/GL.h"
  6. static_assert(std::is_same<GL::Shader, GLuint>::value,
  7. "shader has invalid type");
  8. static_assert(std::is_same<GL::Program, GLuint>::value, "p has invalid type");
  9. static_assert(std::is_same<char, GLchar>::value, "char has invalid type");
  10. static_assert(std::is_same<int, GLint>::value, "int has invalid type");
  11. static_assert(std::is_same<float, GLfloat>::value, "float has invalid type");
  12. static_assert(std::is_same<GL::ShaderType, GLenum>::value,
  13. "shader type has invalid type");
  14. static_assert(std::is_same<GL::Texture, GLuint>::value,
  15. "texture has invalid type");
  16. static_assert(std::is_same<GL::Framebuffer, GLuint>::value,
  17. "framebuffer has invalid type");
  18. static_assert(std::is_same<GL::ColorAttachment, GLenum>::value,
  19. "color attachment has invalid type");
  20. static_assert(std::is_same<GL::VertexArray, GLuint>::value,
  21. "vertex array has invalid type");
  22. static_assert(std::is_same<GL::Buffer, GLuint>::value,
  23. "buffer has invalid type");
  24. GL::ShaderType GL::NO_SHADER = 0;
  25. GL::ShaderType GL::VERTEX_SHADER = GL_VERTEX_SHADER;
  26. GL::ShaderType GL::FRAGMENT_SHADER = GL_FRAGMENT_SHADER;
  27. GL::ShaderType GL::GEOMETRY_SHADER = GL_GEOMETRY_SHADER;
  28. GL::ShaderType GL::TESSELATION_CONTROL_SHADER = GL_TESS_CONTROL_SHADER;
  29. GL::ShaderType GL::TESSELATION_EVALUATION_SHADER = GL_TESS_EVALUATION_SHADER;
  30. GL::Attribute::Attribute(int count, int size, int type, bool normalized)
  31. : count(count), size(size), type(type), normalized(normalized) {
  32. }
  33. GL::Attribute GL::Attribute::newFloat(int count) {
  34. return GL::Attribute(count, sizeof(float), GL_FLOAT, false);
  35. }
  36. GL::Attribute GL::Attribute::newColor(int count) {
  37. return GL::Attribute(count, sizeof(unsigned char), GL_UNSIGNED_BYTE, true);
  38. }
  39. GL::Attribute GL::Attribute::newDummy() {
  40. return GL::Attribute(0, 0, -1, false);
  41. }
  42. bool GL::Attribute::isDummy() const {
  43. return type == -1;
  44. }
  45. int GL::Attribute::getSize() const {
  46. return count * size;
  47. }
  48. GL::TextureFormat::TextureFormat(int internalformat, int format, int type)
  49. : internalformat(internalformat), format(format), type(type) {
  50. }
  51. GL::TextureFormat GL::TextureFormat::color8(int channels) {
  52. switch(channels) {
  53. case 1: return TextureFormat(GL_RED, GL_RED, GL_UNSIGNED_BYTE);
  54. case 2: return TextureFormat(GL_RG, GL_RG, GL_UNSIGNED_BYTE);
  55. case 3: return TextureFormat(GL_RGB, GL_RGB, GL_UNSIGNED_BYTE);
  56. case 4: return TextureFormat(GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE);
  57. }
  58. LOG_ERROR(StringBuffer<50>(channels).append(
  59. " is not a valid amount of channels"));
  60. return unknown();
  61. }
  62. GL::TextureFormat GL::TextureFormat::float16(int channels) {
  63. switch(channels) {
  64. case 1: return TextureFormat(GL_R16F, GL_RED, GL_FLOAT);
  65. case 2: return TextureFormat(GL_RG16F, GL_RG, GL_FLOAT);
  66. case 3: return TextureFormat(GL_RGB16F, GL_RGB, GL_FLOAT);
  67. case 4: return TextureFormat(GL_RGBA16F, GL_RGBA, GL_FLOAT);
  68. }
  69. LOG_ERROR(StringBuffer<50>(channels).append(
  70. " is not a valid amount of channels"));
  71. return unknown();
  72. }
  73. GL::TextureFormat GL::TextureFormat::float32(int channels) {
  74. switch(channels) {
  75. case 1: return TextureFormat(GL_R32F, GL_RED, GL_FLOAT);
  76. case 2: return TextureFormat(GL_RG32F, GL_RG, GL_FLOAT);
  77. case 3: return TextureFormat(GL_RGB32F, GL_RGB, GL_FLOAT);
  78. case 4: return TextureFormat(GL_RGBA32F, GL_RGBA, GL_FLOAT);
  79. }
  80. LOG_ERROR(StringBuffer<50>(channels).append(
  81. " is not a valid amount of channels"));
  82. return unknown();
  83. }
  84. GL::TextureFormat GL::TextureFormat::depth16() {
  85. return TextureFormat(GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_FLOAT);
  86. }
  87. GL::TextureFormat GL::TextureFormat::depth32() {
  88. return TextureFormat(GL_DEPTH_COMPONENT32, GL_DEPTH_COMPONENT, GL_FLOAT);
  89. }
  90. GL::TextureFormat GL::TextureFormat::unknown() {
  91. return TextureFormat(-1, -1, -1);
  92. }
  93. bool GL::printError(const char* message) {
  94. GLenum error = glGetError();
  95. if(error != GL_NO_ERROR) {
  96. (void)message;
  97. LOG_ERROR(StringBuffer<100>(message).append(": ").append(error));
  98. return true;
  99. }
  100. return false;
  101. }
  102. Error GL::getError(const char* message) {
  103. GLenum error = glGetError();
  104. if(error != GL_NO_ERROR) {
  105. Error e = {message};
  106. e.message.append(": ").append(error);
  107. return e;
  108. }
  109. return {};
  110. }
  111. void GL::enableDepthTesting() {
  112. glEnable(GL_DEPTH_TEST);
  113. }
  114. void GL::disableDepthTesting() {
  115. glDisable(GL_DEPTH_TEST);
  116. }
  117. void GL::bindMainFramebuffer() {
  118. glBindFramebuffer(GL_FRAMEBUFFER, 0);
  119. }
  120. void GL::clear() {
  121. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  122. }
  123. void GL::enableBlending() {
  124. glEnable(GL_BLEND);
  125. glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  126. glBlendEquation(GL_FUNC_ADD);
  127. }
  128. void GL::disableBlending() {
  129. glDisable(GL_BLEND);
  130. }
  131. void GL::setViewport(int width, int height) {
  132. glViewport(0, 0, width, height);
  133. }
  134. void GL::vertexAttribPointer(int index, const Attribute& a, int stride,
  135. int offset) {
  136. glVertexAttribPointer(index, a.count, a.type, a.normalized, stride,
  137. static_cast<char*>(0) + offset);
  138. glEnableVertexAttribArray(index);
  139. }
  140. GL::Program GL::createProgram() {
  141. return glCreateProgram();
  142. }
  143. void GL::attachShader(Program p, Shader s) {
  144. glAttachShader(p, s);
  145. }
  146. void GL::linkProgram(Program p) {
  147. glLinkProgram(p);
  148. }
  149. Error GL::getLinkerError(Program p) {
  150. GLint linked;
  151. glGetProgramiv(p, GL_LINK_STATUS, &linked);
  152. if(!linked) {
  153. Array<char, 256> log;
  154. glGetProgramInfoLog(p, log.getLength(), nullptr, log.begin());
  155. Error e = {"linker log: "};
  156. e.message.append(static_cast<const char*>(log.begin()));
  157. return e;
  158. }
  159. return {};
  160. }
  161. void GL::deleteShader(Shader s) {
  162. if(s != 0) {
  163. glDeleteShader(s);
  164. }
  165. }
  166. void GL::deleteProgram(Program p) {
  167. if(p != 0) {
  168. glDeleteProgram(p);
  169. }
  170. }
  171. GL::Shader GL::createShader(ShaderType type) {
  172. return glCreateShader(type);
  173. }
  174. void GL::compileShader(Shader s, const char* code) {
  175. glShaderSource(s, 1, &code, nullptr);
  176. glCompileShader(s);
  177. }
  178. Error GL::getCompileError(Shader s) {
  179. GLint compiled;
  180. glGetShaderiv(s, GL_COMPILE_STATUS, &compiled);
  181. if(!compiled) {
  182. Array<char, 256> log;
  183. glGetShaderInfoLog(s, log.getLength(), nullptr, log.begin());
  184. Error e = {"compiler log: "};
  185. e.message.append(static_cast<const char*>(log.begin()));
  186. return e;
  187. }
  188. return {};
  189. }
  190. void GL::useProgram(Program p) {
  191. glUseProgram(p);
  192. }
  193. void GL::setMatrix(Program p, const char* name, const float* data) {
  194. glUniformMatrix4fv(glGetUniformLocation(p, name), 1, GL_TRUE, data);
  195. }
  196. void GL::setInt(Program p, const char* name, int data) {
  197. glUniform1i(glGetUniformLocation(p, name), data);
  198. }
  199. void GL::setFloat(Program p, const char* name, float data) {
  200. glUniform1f(glGetUniformLocation(p, name), data);
  201. }
  202. void GL::set2Float(Program p, const char* name, const float* data) {
  203. glUniform2fv(glGetUniformLocation(p, name), 1, data);
  204. }
  205. void GL::set3Float(Program p, const char* name, const float* data) {
  206. glUniform3fv(glGetUniformLocation(p, name), 1, data);
  207. }
  208. void GL::set4Float(Program p, const char* name, const float* data) {
  209. glUniform4fv(glGetUniformLocation(p, name), 1, data);
  210. }
  211. void GL::texImage2D(const TextureFormat& tf, int width, int height,
  212. const void* data, int level) {
  213. glTexImage2D(GL_TEXTURE_2D, level, tf.internalformat, width, height, 0,
  214. tf.format, tf.type, data);
  215. }
  216. GL::Texture GL::genTexture() {
  217. Texture t;
  218. glGenTextures(1, &t);
  219. return t;
  220. }
  221. void GL::deleteTexture(Texture t) {
  222. if(t != 0) {
  223. glDeleteTextures(1, &t);
  224. }
  225. }
  226. void GL::setNearFilter2D() {
  227. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  228. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  229. }
  230. void GL::setMipMapNearFilter2D() {
  231. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
  232. GL_NEAREST_MIPMAP_LINEAR);
  233. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  234. }
  235. void GL::setLinearFilter2D() {
  236. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  237. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  238. }
  239. void GL::setMipMapLinearFilter2D() {
  240. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
  241. GL_LINEAR_MIPMAP_LINEAR);
  242. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  243. }
  244. void GL::setClampWrap2D() {
  245. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
  246. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
  247. }
  248. void GL::setRepeatWrap2D() {
  249. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  250. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  251. }
  252. void GL::bindTexture2D(Texture t) {
  253. glBindTexture(GL_TEXTURE_2D, t);
  254. }
  255. void GL::activeTexture(int index) {
  256. glActiveTexture(GL_TEXTURE0 + index);
  257. }
  258. void GL::generateMipmap2D(int maxLevels) {
  259. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
  260. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, maxLevels);
  261. glGenerateMipmap(GL_TEXTURE_2D);
  262. }
  263. void GL::deleteFramebuffers(Framebuffer fb) {
  264. if(fb != 0) {
  265. glDeleteFramebuffers(1, &fb);
  266. }
  267. }
  268. GL::Framebuffer GL::genFramebuffer() {
  269. Framebuffer fb;
  270. glGenFramebuffers(1, &fb);
  271. return fb;
  272. }
  273. void GL::bindFramebuffer(Framebuffer fb) {
  274. glBindFramebuffer(GL_FRAMEBUFFER, fb);
  275. }
  276. void GL::framebufferDepthTexture2D(Texture t) {
  277. glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D,
  278. t, 0);
  279. }
  280. GL::ColorAttachment GL::framebufferColorTexture2D(Texture t, int index) {
  281. GLenum c = GL_COLOR_ATTACHMENT0 + index;
  282. glFramebufferTexture2D(GL_FRAMEBUFFER, c, GL_TEXTURE_2D, t, 0);
  283. return c;
  284. }
  285. void GL::drawBuffers(int length, ColorAttachment* c) {
  286. glDrawBuffers(length, c);
  287. }
  288. Error GL::getFramebufferError() {
  289. GLenum error = glCheckFramebufferStatus(GL_FRAMEBUFFER);
  290. if(error != GL_FRAMEBUFFER_COMPLETE) {
  291. Error e = {"framebuffer error: "};
  292. e.message.append(error);
  293. return e;
  294. }
  295. return {};
  296. }
  297. GL::VertexArray GL::genVertexArray() {
  298. VertexArray va;
  299. glGenVertexArrays(1, &va);
  300. return va;
  301. }
  302. GL::Buffer GL::genBuffer() {
  303. Buffer b;
  304. glGenBuffers(1, &b);
  305. return b;
  306. }
  307. void GL::deleteBuffer(Buffer b) {
  308. if(b != 0) {
  309. glDeleteBuffers(1, &b);
  310. }
  311. }
  312. void GL::deleteVertexArray(VertexArray va) {
  313. if(va != 0) {
  314. glDeleteVertexArrays(1, &va);
  315. }
  316. }
  317. void GL::bindVertexArray(VertexArray va) {
  318. glBindVertexArray(va);
  319. }
  320. void GL::bindBuffer(Buffer b) {
  321. glBindBuffer(GL_ARRAY_BUFFER, b);
  322. }
  323. void GL::bufferDataStatic(int size, const void* data) {
  324. glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW);
  325. }
  326. void GL::bufferDataStream(int size, const void* data) {
  327. glBufferData(GL_ARRAY_BUFFER, size, data, GL_STREAM_DRAW);
  328. }
  329. void GL::bufferDataDynamic(int size, const void* data) {
  330. glBufferData(GL_ARRAY_BUFFER, size, data, GL_DYNAMIC_DRAW);
  331. }
  332. void GL::bufferSubData(int offset, int size, const void* data) {
  333. glBufferSubData(GL_ARRAY_BUFFER, offset, size, data);
  334. }
  335. void GL::drawTriangles(int offset, int vertices) {
  336. glDrawArrays(GL_TRIANGLES, offset, vertices);
  337. }
  338. void GL::drawTriangleStrip(int offset, int vertices) {
  339. glDrawArrays(GL_TRIANGLE_STRIP, offset, vertices);
  340. }
  341. void GL::drawPoints(int offset, int vertices) {
  342. glDrawArrays(GL_POINTS, offset, vertices);
  343. }