API tools faq
paste
Guest User

Untitled

a guest
Jun 30th, 2019
66
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 15.81 KB | None | 0 0
raw download clone embed print report
  1. #ifndef NK_SDL_GLES2_H_
  2. #define NK_SDL_GLES2_H_
  3.  
  4. /*
  5.  *
  6.  *  ДОБАВИЛ ТУТ ЗУМ КОРОЧ. НАДЕШЬ ПРИМЕНЕНИЕ ЭТОЙ ПЕРЕМЕННОЙ.
  7.  */
  8. static struct nk_vec2 zoom = {2, 2};
  9.  
  10.  
  11. #include <SDL2/SDL.h>
  12. #include <SDL2/SDL_opengles2.h>
  13.  
  14.  
  15. NK_API struct nk_context*   nk_sdl_init(SDL_Window *win);
  16. NK_API void                 nk_sdl_font_stash_begin(struct nk_font_atlas **atlas);
  17. NK_API void                 nk_sdl_font_stash_end(void);
  18. NK_API int                  nk_sdl_handle_event(SDL_Event *evt);
  19. NK_API void                 nk_sdl_render(enum nk_anti_aliasing , int max_vertex_buffer, int max_element_buffer);
  20. NK_API void                 nk_sdl_shutdown(void);
  21. NK_API void                 nk_sdl_device_destroy(void);
  22. NK_API void                 nk_sdl_device_create(void);
  23.  
  24. #endif
  25.  
  26. /*
  27.  * ==============================================================
  28.  *
  29.  *                          IMPLEMENTATION
  30.  *
  31.  * ===============================================================
  32.  */
  33. #ifdef NK_SDL_GLES2_IMPLEMENTATION
  34.  
  35. #include <string.h>
  36.  
  37. struct nk_sdl_device {
  38.     struct nk_buffer cmds;
  39.     struct nk_draw_null_texture null;
  40.     GLuint vbo, ebo;
  41.     GLuint prog;
  42.     GLuint vert_shdr;
  43.     GLuint frag_shdr;
  44.     GLint attrib_pos;
  45.     GLint attrib_uv;
  46.     GLint attrib_col;
  47.     GLint uniform_tex;
  48.     GLint uniform_proj;
  49.     GLuint font_tex;
  50.     GLsizei vs;
  51.     size_t vp, vt, vc;
  52. };
  53.  
  54. struct nk_sdl_vertex {
  55.     GLfloat position[2];
  56.     GLfloat uv[2];
  57.     nk_byte col[4];
  58. };
  59.  
  60. static struct nk_sdl {
  61.     SDL_Window *win;
  62.     struct nk_sdl_device ogl;
  63.     struct nk_context ctx;
  64.     struct nk_font_atlas atlas;
  65. } sdl;
  66.  
  67.  
  68. #define NK_SHADER_VERSION "#version 100\n"
  69.  
  70.  
  71. NK_API void
  72. nk_sdl_device_create(void)
  73. {
  74.     GLint status;
  75.     static const GLchar *vertex_shader =
  76.         NK_SHADER_VERSION
  77.         "uniform mat4 ProjMtx;\n"
  78.         "attribute vec2 Position;\n"
  79.         "attribute vec2 TexCoord;\n"
  80.         "attribute vec4 Color;\n"
  81.         "varying vec2 Frag_UV;\n"
  82.         "varying vec4 Frag_Color;\n"
  83.         "void main() {\n"
  84.         "   Frag_UV = TexCoord;\n"
  85.         "   Frag_Color = Color;\n"
  86.         "   gl_Position = ProjMtx * vec4(Position.xy, 0, 1);\n"
  87.         "}\n";
  88.     static const GLchar *fragment_shader =
  89.         NK_SHADER_VERSION
  90.         "precision mediump float;\n"
  91.         "uniform sampler2D Texture;\n"
  92.         "varying vec2 Frag_UV;\n"
  93.         "varying vec4 Frag_Color;\n"
  94.         "void main(){\n"
  95.         "   gl_FragColor = Frag_Color * texture2D(Texture, Frag_UV);\n"
  96.         "}\n";
  97.  
  98.     struct nk_sdl_device *dev = &sdl.ogl;
  99.    
  100.     nk_buffer_init_default(&dev->cmds);
  101.     dev->prog = glCreateProgram();
  102.     dev->vert_shdr = glCreateShader(GL_VERTEX_SHADER);
  103.     dev->frag_shdr = glCreateShader(GL_FRAGMENT_SHADER);
  104.     glShaderSource(dev->vert_shdr, 1, &vertex_shader, 0);
  105.     glShaderSource(dev->frag_shdr, 1, &fragment_shader, 0);
  106.     glCompileShader(dev->vert_shdr);
  107.     glCompileShader(dev->frag_shdr);
  108.     glGetShaderiv(dev->vert_shdr, GL_COMPILE_STATUS, &status);
  109.     assert(status == GL_TRUE);
  110.     glGetShaderiv(dev->frag_shdr, GL_COMPILE_STATUS, &status);
  111.     assert(status == GL_TRUE);
  112.     glAttachShader(dev->prog, dev->vert_shdr);
  113.     glAttachShader(dev->prog, dev->frag_shdr);
  114.     glLinkProgram(dev->prog);
  115.     glGetProgramiv(dev->prog, GL_LINK_STATUS, &status);
  116.     assert(status == GL_TRUE);
  117.  
  118.  
  119.     dev->uniform_tex = glGetUniformLocation(dev->prog, "Texture");
  120.     dev->uniform_proj = glGetUniformLocation(dev->prog, "ProjMtx");
  121.     dev->attrib_pos = glGetAttribLocation(dev->prog, "Position");
  122.     dev->attrib_uv = glGetAttribLocation(dev->prog, "TexCoord");
  123.     dev->attrib_col = glGetAttribLocation(dev->prog, "Color");
  124.     {
  125.         dev->vs = sizeof(struct nk_sdl_vertex);
  126.         dev->vp = offsetof(struct nk_sdl_vertex, position);
  127.         dev->vt = offsetof(struct nk_sdl_vertex, uv);
  128.         dev->vc = offsetof(struct nk_sdl_vertex, col);
  129.        
  130.         /* Allocate buffers */
  131.         glGenBuffers(1, &dev->vbo);
  132.         glGenBuffers(1, &dev->ebo);
  133.     }
  134.     glBindTexture(GL_TEXTURE_2D, 0);
  135.     glBindBuffer(GL_ARRAY_BUFFER, 0);
  136.     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
  137. }
  138.  
  139. NK_INTERN void
  140. nk_sdl_device_upload_atlas(const void *image, int width, int height)
  141. {
  142.     struct nk_sdl_device *dev = &sdl.ogl;
  143.     glGenTextures(1, &dev->font_tex);
  144.     glBindTexture(GL_TEXTURE_2D, dev->font_tex);
  145.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  146.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  147.     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)width, (GLsizei)height, 0,
  148.                 GL_RGBA, GL_UNSIGNED_BYTE, image);
  149. }
  150.  
  151. NK_API void
  152. nk_sdl_device_destroy(void)
  153. {
  154.     struct nk_sdl_device *dev = &sdl.ogl;
  155.     glDetachShader(dev->prog, dev->vert_shdr);
  156.     glDetachShader(dev->prog, dev->frag_shdr);
  157.     glDeleteShader(dev->vert_shdr);
  158.     glDeleteShader(dev->frag_shdr);
  159.     glDeleteProgram(dev->prog);
  160.     glDeleteTextures(1, &dev->font_tex);
  161.     glDeleteBuffers(1, &dev->vbo);
  162.     glDeleteBuffers(1, &dev->ebo);
  163.     nk_buffer_free(&dev->cmds);
  164. }
  165.  
  166. NK_API void
  167. nk_sdl_render(enum nk_anti_aliasing AA, int max_vertex_buffer, int max_element_buffer)
  168. {
  169.     struct nk_sdl_device *dev = &sdl.ogl;
  170.     int width, height;
  171.     int display_width, display_height;
  172.     struct nk_vec2 scale;
  173.     GLfloat ortho[4][4] = {
  174.         {2.0f, 0.0f, 0.0f, 0.0f},
  175.         {0.0f,-2.0f, 0.0f, 0.0f},
  176.         {0.0f, 0.0f,-1.0f, 0.0f},
  177.         {-1.0f,1.0f, 0.0f, 1.0f},
  178.     };
  179.     SDL_GetWindowSize(sdl.win, &width, &height);
  180.     SDL_GL_GetDrawableSize(sdl.win, &display_width, &display_height);
  181.     width *= zoom.x;
  182.     height *= zoom.y;
  183.  
  184.     ortho[0][0] /= (GLfloat)width;
  185.     ortho[1][1] /= (GLfloat)height;
  186.  
  187.     scale.x = (float)display_width/(float)width;
  188.     scale.y = (float)display_height/(float)height;
  189.  
  190.     /* setup global state */
  191.     glViewport(0,0,display_width,display_height);
  192.     glEnable(GL_BLEND);
  193.     glBlendEquation(GL_FUNC_ADD);
  194.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  195.     glDisable(GL_CULL_FACE);
  196.     glDisable(GL_DEPTH_TEST);
  197.     glEnable(GL_SCISSOR_TEST);
  198.     glActiveTexture(GL_TEXTURE0);
  199.  
  200.     /* setup program */
  201.     glUseProgram(dev->prog);
  202.     glUniform1i(dev->uniform_tex, 0);
  203.     glUniformMatrix4fv(dev->uniform_proj, 1, GL_FALSE, &ortho[0][0]);
  204.     {
  205.         /* convert from command queue into draw list and draw to screen */
  206.         const struct nk_draw_command *cmd;
  207.         void *vertices, *elements;
  208.         const nk_draw_index *offset = NULL;
  209.  
  210.         /* Bind buffers */
  211.         glBindBuffer(GL_ARRAY_BUFFER, dev->vbo);
  212.         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, dev->ebo);
  213.        
  214.         {
  215.             /* buffer setup */
  216.             glEnableVertexAttribArray((GLuint)dev->attrib_pos);
  217.             glEnableVertexAttribArray((GLuint)dev->attrib_uv);
  218.             glEnableVertexAttribArray((GLuint)dev->attrib_col);
  219.  
  220.             glVertexAttribPointer((GLuint)dev->attrib_pos, 2, GL_FLOAT, GL_FALSE, dev->vs, (void*)dev->vp);
  221.             glVertexAttribPointer((GLuint)dev->attrib_uv, 2, GL_FLOAT, GL_FALSE, dev->vs, (void*)dev->vt);
  222.             glVertexAttribPointer((GLuint)dev->attrib_col, 4, GL_UNSIGNED_BYTE, GL_TRUE, dev->vs, (void*)dev->vc);
  223.         }
  224.  
  225.         glBufferData(GL_ARRAY_BUFFER, max_vertex_buffer, NULL, GL_STREAM_DRAW);
  226.         glBufferData(GL_ELEMENT_ARRAY_BUFFER, max_element_buffer, NULL, GL_STREAM_DRAW);
  227.  
  228.         /* load vertices/elements directly into vertex/element buffer */
  229.         vertices = malloc((size_t)max_vertex_buffer);
  230.         elements = malloc((size_t)max_element_buffer);
  231.         {
  232.             /* fill convert configuration */
  233.             struct nk_convert_config config;
  234.             static const struct nk_draw_vertex_layout_element vertex_layout[] = {
  235.                 {NK_VERTEX_POSITION, NK_FORMAT_FLOAT, NK_OFFSETOF(struct nk_sdl_vertex, position)},
  236.                 {NK_VERTEX_TEXCOORD, NK_FORMAT_FLOAT, NK_OFFSETOF(struct nk_sdl_vertex, uv)},
  237.                 {NK_VERTEX_COLOR, NK_FORMAT_R8G8B8A8, NK_OFFSETOF(struct nk_sdl_vertex, col)},
  238.                 {NK_VERTEX_LAYOUT_END}
  239.             };
  240.             NK_MEMSET(&config, 0, sizeof(config));
  241.             config.vertex_layout = vertex_layout;
  242.             config.vertex_size = sizeof(struct nk_sdl_vertex);
  243.             config.vertex_alignment = NK_ALIGNOF(struct nk_sdl_vertex);
  244.             config.null = dev->null;
  245.             config.circle_segment_count = 22;
  246.             config.curve_segment_count = 22;
  247.             config.arc_segment_count = 22;
  248.             config.global_alpha = 1.0f;
  249.             config.shape_AA = AA;
  250.             config.line_AA = AA;
  251.  
  252.             /* setup buffers to load vertices and elements */
  253.             {struct nk_buffer vbuf, ebuf;
  254.             nk_buffer_init_fixed(&vbuf, vertices, (nk_size)max_vertex_buffer);
  255.             nk_buffer_init_fixed(&ebuf, elements, (nk_size)max_element_buffer);
  256.             nk_convert(&sdl.ctx, &dev->cmds, &vbuf, &ebuf, &config);}
  257.         }
  258.         glBufferSubData(GL_ARRAY_BUFFER, 0, (size_t)max_vertex_buffer, vertices);
  259.         glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, (size_t)max_element_buffer, elements);
  260.         free(vertices);
  261.         free(elements);
  262.  
  263.         /* iterate over and execute each draw command */
  264.         nk_draw_foreach(cmd, &sdl.ctx, &dev->cmds) {
  265.             if (!cmd->elem_count) continue;
  266.             glBindTexture(GL_TEXTURE_2D, (GLuint)cmd->texture.id);
  267.             glScissor((GLint)(cmd->clip_rect.x * scale.x),
  268.                 (GLint)((height - (GLint)(cmd->clip_rect.y + cmd->clip_rect.h)) * scale.y),
  269.                 (GLint)(cmd->clip_rect.w * scale.x),
  270.                 (GLint)(cmd->clip_rect.h * scale.y));
  271.             glDrawElements(GL_TRIANGLES, (GLsizei)cmd->elem_count, GL_UNSIGNED_SHORT, offset);
  272.             offset += cmd->elem_count;
  273.         }
  274.         nk_clear(&sdl.ctx);
  275.     }
  276.  
  277.     glUseProgram(0);
  278.     glBindBuffer(GL_ARRAY_BUFFER, 0);
  279.     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
  280.  
  281.     glDisable(GL_BLEND);
  282.     glDisable(GL_SCISSOR_TEST);
  283. }
  284.  
  285. static void
  286. nk_sdl_clipboard_paste(nk_handle usr, struct nk_text_edit *edit)
  287. {
  288.     const char *text = SDL_GetClipboardText();
  289.     if (text) nk_textedit_paste(edit, text, nk_strlen(text));
  290.     (void)usr;
  291. }
  292.  
  293. static void
  294. nk_sdl_clipboard_copy(nk_handle usr, const char *text, int len)
  295. {
  296.     char *str = 0;
  297.     (void)usr;
  298.     if (!len) return;
  299.     str = (char*)malloc((size_t)len+1);
  300.     if (!str) return;
  301.     memcpy(str, text, (size_t)len);
  302.     str[len] = '\0';
  303.     SDL_SetClipboardText(str);
  304.     free(str);
  305. }
  306.  
  307. NK_API struct nk_context*
  308. nk_sdl_init(SDL_Window *win)
  309. {
  310.     sdl.win = win;
  311.     nk_init_default(&sdl.ctx, 0);
  312.     sdl.ctx.clip.copy = nk_sdl_clipboard_copy;
  313.     sdl.ctx.clip.paste = nk_sdl_clipboard_paste;
  314.     sdl.ctx.clip.userdata = nk_handle_ptr(0);
  315.     nk_sdl_device_create();
  316.     return &sdl.ctx;
  317. }
  318.  
  319. NK_API void
  320. nk_sdl_font_stash_begin(struct nk_font_atlas **atlas)
  321. {
  322.     nk_font_atlas_init_default(&sdl.atlas);
  323.     nk_font_atlas_begin(&sdl.atlas);
  324.     *atlas = &sdl.atlas;
  325. }
  326.  
  327. NK_API void
  328. nk_sdl_font_stash_end(void)
  329. {
  330.     const void *image; int w, h;
  331.     image = nk_font_atlas_bake(&sdl.atlas, &w, &h, NK_FONT_ATLAS_RGBA32);
  332.     nk_sdl_device_upload_atlas(image, w, h);
  333.     nk_font_atlas_end(&sdl.atlas, nk_handle_id((int)sdl.ogl.font_tex), &sdl.ogl.null);
  334.     if (sdl.atlas.default_font)
  335.         nk_style_set_font(&sdl.ctx, &sdl.atlas.default_font->handle);
  336.  
  337. }
  338.  
  339. NK_API int
  340. nk_sdl_handle_event(SDL_Event *evt)
  341. {
  342.     struct nk_context *ctx = &sdl.ctx;
  343.     if (evt->type == SDL_KEYUP || evt->type == SDL_KEYDOWN) {
  344.         /* key events */
  345.         int down = evt->type == SDL_KEYDOWN;
  346.         const Uint8* state = SDL_GetKeyboardState(0);
  347.         SDL_Keycode sym = evt->key.keysym.sym;
  348.         if (sym == SDLK_RSHIFT || sym == SDLK_LSHIFT)
  349.             nk_input_key(ctx, NK_KEY_SHIFT, down);
  350.         else if (sym == SDLK_DELETE)
  351.             nk_input_key(ctx, NK_KEY_DEL, down);
  352.         else if (sym == SDLK_RETURN)
  353.             nk_input_key(ctx, NK_KEY_ENTER, down);
  354.         else if (sym == SDLK_TAB)
  355.             nk_input_key(ctx, NK_KEY_TAB, down);
  356.         else if (sym == SDLK_BACKSPACE)
  357.             nk_input_key(ctx, NK_KEY_BACKSPACE, down);
  358.         else if (sym == SDLK_HOME) {
  359.             nk_input_key(ctx, NK_KEY_TEXT_START, down);
  360.             nk_input_key(ctx, NK_KEY_SCROLL_START, down);
  361.         } else if (sym == SDLK_END) {
  362.             nk_input_key(ctx, NK_KEY_TEXT_END, down);
  363.             nk_input_key(ctx, NK_KEY_SCROLL_END, down);
  364.         } else if (sym == SDLK_PAGEDOWN) {
  365.             nk_input_key(ctx, NK_KEY_SCROLL_DOWN, down);
  366.         } else if (sym == SDLK_PAGEUP) {
  367.             nk_input_key(ctx, NK_KEY_SCROLL_UP, down);
  368.         } else if (sym == SDLK_z)
  369.             nk_input_key(ctx, NK_KEY_TEXT_UNDO, down && state[SDL_SCANCODE_LCTRL]);
  370.         else if (sym == SDLK_r)
  371.             nk_input_key(ctx, NK_KEY_TEXT_REDO, down && state[SDL_SCANCODE_LCTRL]);
  372.         else if (sym == SDLK_c)
  373.             nk_input_key(ctx, NK_KEY_COPY, down && state[SDL_SCANCODE_LCTRL]);
  374.         else if (sym == SDLK_v)
  375.             nk_input_key(ctx, NK_KEY_PASTE, down && state[SDL_SCANCODE_LCTRL]);
  376.         else if (sym == SDLK_x)
  377.             nk_input_key(ctx, NK_KEY_CUT, down && state[SDL_SCANCODE_LCTRL]);
  378.         else if (sym == SDLK_b)
  379.             nk_input_key(ctx, NK_KEY_TEXT_LINE_START, down && state[SDL_SCANCODE_LCTRL]);
  380.         else if (sym == SDLK_e)
  381.             nk_input_key(ctx, NK_KEY_TEXT_LINE_END, down && state[SDL_SCANCODE_LCTRL]);
  382.         else if (sym == SDLK_UP)
  383.             nk_input_key(ctx, NK_KEY_UP, down);
  384.         else if (sym == SDLK_DOWN)
  385.             nk_input_key(ctx, NK_KEY_DOWN, down);
  386.         else if (sym == SDLK_LEFT) {
  387.             if (state[SDL_SCANCODE_LCTRL])
  388.                 nk_input_key(ctx, NK_KEY_TEXT_WORD_LEFT, down);
  389.             else nk_input_key(ctx, NK_KEY_LEFT, down);
  390.         } else if (sym == SDLK_RIGHT) {
  391.             if (state[SDL_SCANCODE_LCTRL])
  392.                 nk_input_key(ctx, NK_KEY_TEXT_WORD_RIGHT, down);
  393.             else nk_input_key(ctx, NK_KEY_RIGHT, down);
  394.         } else return 0;
  395.         return 1;
  396.     } else if (evt->type == SDL_MOUSEBUTTONDOWN || evt->type == SDL_MOUSEBUTTONUP) {
  397.         /* mouse button */
  398.         int down = evt->type == SDL_MOUSEBUTTONDOWN;
  399.         const int x = evt->button.x * zoom.x, y = evt->button.y * zoom.y;
  400.         if (evt->button.button == SDL_BUTTON_LEFT) {
  401.             if (evt->button.clicks > 1)
  402.                 nk_input_button(ctx, NK_BUTTON_DOUBLE, x, y, down);
  403.             nk_input_button(ctx, NK_BUTTON_LEFT, x, y, down);
  404.         } else if (evt->button.button == SDL_BUTTON_MIDDLE)
  405.             nk_input_button(ctx, NK_BUTTON_MIDDLE, x, y, down);
  406.         else if (evt->button.button == SDL_BUTTON_RIGHT)
  407.             nk_input_button(ctx, NK_BUTTON_RIGHT, x, y, down);
  408.         return 1;
  409.     } else if (evt->type == SDL_MOUSEMOTION) {
  410.         /* mouse motion */
  411.         if (ctx->input.mouse.grabbed) {
  412.             int x = (int)ctx->input.mouse.prev.x * zoom.x, y = (int)ctx->input.mouse.prev.y * zoom.y;
  413.             nk_input_motion(ctx, x + evt->motion.xrel * zoom.x, y + evt->motion.yrel * zoom.y);
  414.         } else nk_input_motion(ctx, evt->motion.x * zoom.x, evt->motion.y * zoom.y);
  415.         return 1;
  416.     } else if (evt->type == SDL_TEXTINPUT) {
  417.         /* text input */
  418.         nk_glyph glyph;
  419.         memcpy(glyph, evt->text.text, NK_UTF_SIZE);
  420.         nk_input_glyph(ctx, glyph);
  421.         return 1;
  422.     } else if (evt->type == SDL_MOUSEWHEEL) {
  423.         /* mouse wheel */
  424.         nk_input_scroll(ctx,nk_vec2((float)evt->wheel.x,(float)evt->wheel.y));
  425.         return 1;
  426.     }
  427.     return 0;
  428. }
  429.  
  430. NK_API
  431. void nk_sdl_shutdown(void)
  432. {
  433.     nk_font_atlas_clear(&sdl.atlas);
  434.     nk_free(&sdl.ctx);
  435.     nk_sdl_device_destroy();
  436.     memset(&sdl, 0, sizeof(sdl));
  437. }
  438.  
  439. #endif
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!